From 90463b001c3827d74973d6c2beb55945e71d1cb3 Mon Sep 17 00:00:00 2001 From: Michael Benfield Date: Thu, 16 Jan 2025 10:08:19 -0800 Subject: [PATCH] Constant propagation and folding. --- Cargo.lock | 3 +- compiler/ast/src/common/identifier.rs | 2 +- compiler/ast/src/expressions/err.rs | 2 +- compiler/ast/src/expressions/mod.rs | 6 + compiler/ast/src/expressions/unary.rs | 10 +- compiler/ast/src/functions/mod.rs | 2 +- compiler/ast/src/functions/variant.rs | 3 +- compiler/ast/src/program/program_scope.rs | 3 + compiler/ast/src/statement/assign.rs | 2 +- compiler/ast/src/statement/block.rs | 2 +- compiler/ast/src/statement/const_.rs | 6 +- compiler/ast/src/statement/definition/mod.rs | 5 +- compiler/compiler/src/compiler.rs | 69 +- .../tests/integration/utilities/mod.rs | 6 +- compiler/passes/Cargo.toml | 3 + .../passes/src/common/symbol_table/mod.rs | 19 + .../const_propagate_expression.rs | 303 +++++ .../const_propagate_program.rs | 45 + .../const_propagate_statement.rs | 169 +++ .../src/const_propagation/const_propagator.rs | 121 ++ compiler/passes/src/const_propagation/mod.rs | 57 + compiler/passes/src/lib.rs | 3 + .../passes/src/loop_unrolling/duplicate.rs | 85 ++ compiler/passes/src/loop_unrolling/mod.rs | 21 +- .../src/loop_unrolling/unroll_expression.rs | 30 +- .../src/loop_unrolling/unroll_program.rs | 32 +- .../src/loop_unrolling/unroll_statement.rs | 161 +-- .../passes/src/loop_unrolling/unroller.rs | 59 +- .../rename_statement.rs | 5 +- .../src/type_checking/check_statements.rs | 55 +- compiler/passes/src/type_checking/checker.rs | 4 +- compiler/passes/src/type_checking/mod.rs | 6 +- compiler/span/src/symbol.rs | 6 + errors/src/errors/compiler/compiler_errors.rs | 21 + .../loop_unroller/loop_unroller_errors.rs | 1 + errors/src/errors/loop_unroller/mod.rs | 3 +- .../static_analyzer/static_analyzer_error.rs | 28 + .../errors/type_checker/type_checker_error.rs | 2 + errors/src/lib.rs | 2 +- interpreter/Cargo.toml | 6 - interpreter/src/core_functions.rs | 1153 +++++++++++++++++ interpreter/src/cursor.rs | 466 ++++--- interpreter/src/cursor_aleo.rs | 4 +- interpreter/src/lib.rs | 7 + interpreter/src/test/runner.rs | 6 +- interpreter/src/value.rs | 28 +- .../array/access_array_with_loop_counter.out | 2 +- .../array/array_variable_access_fail.out | 7 +- .../compiler/const_prop/big_const_prop.out | 8 + .../const_prop/compile_time_const_fail.out | 19 + .../compiler/const_prop/core_functions.out | 26 + .../const_prop/evaluate_const_fail.out | 8 + .../compiler/const_prop/loop_bounds_fail.out | 8 + .../compiler/const_prop/some_loop_bounds.out | 21 + .../compiler/const_prop/tuples.out | 8 + .../constants/const_tuple_declaration.out | 2 +- .../constants/const_type_error_fail.out | 5 - .../compiler/constants/constant_finalize.out | 2 +- .../constants/constant_loop_bound.out | 2 +- .../compiler/constants/loop_unrolling.out | 2 +- .../unroll_loop_with_tuple_definition.out | 2 +- .../algorithms/bhp1024_commit_to_group.out | 2 +- .../algorithms/bhp1024_hash_to_address.out | 2 +- .../core/algorithms/bhp1024_hash_to_field.out | 2 +- .../core/algorithms/bhp1024_hash_to_group.out | 2 +- .../algorithms/bhp1024_hash_to_scalar.out | 2 +- .../algorithms/bhp256_commit_to_group.out | 2 +- .../algorithms/bhp256_hash_to_address.out | 2 +- .../core/algorithms/bhp256_hash_to_field.out | 2 +- .../core/algorithms/bhp256_hash_to_group.out | 2 +- .../core/algorithms/bhp256_hash_to_scalar.out | 2 +- .../algorithms/bhp512_commit_to_group.out | 2 +- .../algorithms/bhp512_hash_to_address.out | 2 +- .../core/algorithms/bhp512_hash_to_field.out | 2 +- .../core/algorithms/bhp512_hash_to_group.out | 2 +- .../core/algorithms/bhp512_hash_to_scalar.out | 2 +- .../algorithms/bhp768_commit_to_group.out | 2 +- .../algorithms/bhp768_hash_to_address.out | 2 +- .../core/algorithms/bhp768_hash_to_field.out | 2 +- .../core/algorithms/bhp768_hash_to_group.out | 2 +- .../core/algorithms/bhp768_hash_to_scalar.out | 2 +- .../integers/bhp1024/bhp1024_hash_to_i128.out | 2 +- .../integers/bhp1024/bhp1024_hash_to_i16.out | 2 +- .../integers/bhp1024/bhp1024_hash_to_i32.out | 2 +- .../integers/bhp1024/bhp1024_hash_to_i64.out | 2 +- .../integers/bhp1024/bhp1024_hash_to_i8.out | 2 +- .../integers/bhp1024/bhp1024_hash_to_u128.out | 2 +- .../integers/bhp1024/bhp1024_hash_to_u16.out | 2 +- .../integers/bhp1024/bhp1024_hash_to_u32.out | 2 +- .../integers/bhp1024/bhp1024_hash_to_u64.out | 2 +- .../integers/bhp1024/bhp1024_hash_to_u8.out | 2 +- .../integers/bhp256/bhp256_hash_to_i128.out | 2 +- .../integers/bhp256/bhp256_hash_to_i16.out | 2 +- .../integers/bhp256/bhp256_hash_to_i32.out | 2 +- .../integers/bhp256/bhp256_hash_to_i64.out | 2 +- .../integers/bhp256/bhp256_hash_to_i8.out | 2 +- .../integers/bhp256/bhp256_hash_to_u128.out | 2 +- .../integers/bhp256/bhp256_hash_to_u16.out | 2 +- .../integers/bhp256/bhp256_hash_to_u32.out | 2 +- .../integers/bhp256/bhp256_hash_to_u64.out | 2 +- .../integers/bhp256/bhp256_hash_to_u8.out | 2 +- .../integers/bhp512/bhp512_hash_to_i128.out | 2 +- .../integers/bhp512/bhp512_hash_to_i16.out | 2 +- .../integers/bhp512/bhp512_hash_to_i32.out | 2 +- .../integers/bhp512/bhp512_hash_to_i64.out | 2 +- .../integers/bhp512/bhp512_hash_to_i8.out | 2 +- .../integers/bhp512/bhp512_hash_to_u128.out | 2 +- .../integers/bhp512/bhp512_hash_to_u16.out | 2 +- .../integers/bhp512/bhp512_hash_to_u32.out | 2 +- .../integers/bhp512/bhp512_hash_to_u64.out | 2 +- .../integers/bhp512/bhp512_hash_to_u8.out | 2 +- .../integers/bhp768/bhp768_hash_to_i128.out | 2 +- .../integers/bhp768/bhp768_hash_to_i16.out | 2 +- .../integers/bhp768/bhp768_hash_to_i32.out | 2 +- .../integers/bhp768/bhp768_hash_to_i64.out | 2 +- .../integers/bhp768/bhp768_hash_to_i8.out | 2 +- .../integers/bhp768/bhp768_hash_to_u128.out | 2 +- .../integers/bhp768/bhp768_hash_to_u16.out | 2 +- .../integers/bhp768/bhp768_hash_to_u32.out | 2 +- .../integers/bhp768/bhp768_hash_to_u64.out | 2 +- .../integers/bhp768/bhp768_hash_to_u8.out | 2 +- .../keccak256/keccak256_hash_to_i128.out | 2 +- .../keccak256/keccak256_hash_to_i16.out | 2 +- .../keccak256/keccak256_hash_to_i32.out | 2 +- .../keccak256/keccak256_hash_to_i64.out | 2 +- .../keccak256/keccak256_hash_to_i8.out | 2 +- .../keccak256/keccak256_hash_to_u128.out | 2 +- .../keccak256/keccak256_hash_to_u16.out | 2 +- .../keccak256/keccak256_hash_to_u32.out | 2 +- .../keccak256/keccak256_hash_to_u64.out | 2 +- .../keccak256/keccak256_hash_to_u8.out | 2 +- .../keccak384/keccak384_hash_to_i128.out | 2 +- .../keccak384/keccak384_hash_to_i16.out | 2 +- .../keccak384/keccak384_hash_to_i32.out | 2 +- .../keccak384/keccak384_hash_to_i64.out | 2 +- .../keccak384/keccak384_hash_to_i8.out | 2 +- .../keccak384/keccak384_hash_to_u128.out | 2 +- .../keccak384/keccak384_hash_to_u16.out | 2 +- .../keccak384/keccak384_hash_to_u32.out | 2 +- .../keccak384/keccak384_hash_to_u64.out | 2 +- .../keccak384/keccak384_hash_to_u8.out | 2 +- .../keccak512/keccak512_hash_to_i128.out | 2 +- .../keccak512/keccak512_hash_to_i16.out | 2 +- .../keccak512/keccak512_hash_to_i32.out | 2 +- .../keccak512/keccak512_hash_to_i64.out | 2 +- .../keccak512/keccak512_hash_to_i8.out | 2 +- .../keccak512/keccak512_hash_to_u128.out | 2 +- .../keccak512/keccak512_hash_to_u16.out | 2 +- .../keccak512/keccak512_hash_to_u32.out | 2 +- .../keccak512/keccak512_hash_to_u64.out | 2 +- .../keccak512/keccak512_hash_to_u8.out | 2 +- .../poseidon2/poseidon2_hash_to_i128.out | 2 +- .../poseidon2/poseidon2_hash_to_i16.out | 2 +- .../poseidon2/poseidon2_hash_to_i32.out | 2 +- .../poseidon2/poseidon2_hash_to_i64.out | 2 +- .../poseidon2/poseidon2_hash_to_i8.out | 2 +- .../poseidon2/poseidon2_hash_to_u128.out | 2 +- .../poseidon2/poseidon2_hash_to_u16.out | 2 +- .../poseidon2/poseidon2_hash_to_u32.out | 2 +- .../poseidon2/poseidon2_hash_to_u64.out | 2 +- .../poseidon2/poseidon2_hash_to_u8.out | 2 +- .../poseidon4/poseidon4_hash_to_i128.out | 2 +- .../poseidon4/poseidon4_hash_to_i16.out | 2 +- .../poseidon4/poseidon4_hash_to_i32.out | 2 +- .../poseidon4/poseidon4_hash_to_i64.out | 2 +- .../poseidon4/poseidon4_hash_to_i8.out | 2 +- .../poseidon4/poseidon4_hash_to_u128.out | 2 +- .../poseidon4/poseidon4_hash_to_u16.out | 2 +- .../poseidon4/poseidon4_hash_to_u32.out | 2 +- .../poseidon4/poseidon4_hash_to_u64.out | 2 +- .../poseidon4/poseidon4_hash_to_u8.out | 2 +- .../poseidon8/poseidon8_hash_to_i128.out | 2 +- .../poseidon8/poseidon8_hash_to_i16.out | 2 +- .../poseidon8/poseidon8_hash_to_i32.out | 2 +- .../poseidon8/poseidon8_hash_to_i64.out | 2 +- .../poseidon8/poseidon8_hash_to_i8.out | 2 +- .../poseidon8/poseidon8_hash_to_u128.out | 2 +- .../poseidon8/poseidon8_hash_to_u16.out | 2 +- .../poseidon8/poseidon8_hash_to_u32.out | 2 +- .../poseidon8/poseidon8_hash_to_u64.out | 2 +- .../poseidon8/poseidon8_hash_to_u8.out | 2 +- .../sha3_256/sha3_256_hash_to_i128.out | 2 +- .../sha3_256/sha3_256_hash_to_i16.out | 2 +- .../sha3_256/sha3_256_hash_to_i32.out | 2 +- .../sha3_256/sha3_256_hash_to_i64.out | 2 +- .../integers/sha3_256/sha3_256_hash_to_i8.out | 2 +- .../sha3_256/sha3_256_hash_to_u128.out | 2 +- .../sha3_256/sha3_256_hash_to_u16.out | 2 +- .../sha3_256/sha3_256_hash_to_u32.out | 2 +- .../sha3_256/sha3_256_hash_to_u64.out | 2 +- .../integers/sha3_256/sha3_256_hash_to_u8.out | 2 +- .../sha3_384/sha3_384_hash_to_i128.out | 2 +- .../sha3_384/sha3_384_hash_to_i16.out | 2 +- .../sha3_384/sha3_384_hash_to_i32.out | 2 +- .../sha3_384/sha3_384_hash_to_i64.out | 2 +- .../integers/sha3_384/sha3_384_hash_to_i8.out | 2 +- .../sha3_384/sha3_384_hash_to_u128.out | 2 +- .../sha3_384/sha3_384_hash_to_u16.out | 2 +- .../sha3_384/sha3_384_hash_to_u32.out | 2 +- .../sha3_384/sha3_384_hash_to_u64.out | 2 +- .../integers/sha3_384/sha3_384_hash_to_u8.out | 2 +- .../sha3_512/sha3_512_hash_to_i128.out | 2 +- .../sha3_512/sha3_512_hash_to_i16.out | 2 +- .../sha3_512/sha3_512_hash_to_i32.out | 2 +- .../sha3_512/sha3_512_hash_to_i64.out | 2 +- .../integers/sha3_512/sha3_512_hash_to_i8.out | 2 +- .../sha3_512/sha3_512_hash_to_u128.out | 2 +- .../sha3_512/sha3_512_hash_to_u16.out | 2 +- .../sha3_512/sha3_512_hash_to_u32.out | 2 +- .../sha3_512/sha3_512_hash_to_u64.out | 2 +- .../integers/sha3_512/sha3_512_hash_to_u8.out | 2 +- .../algorithms/keccak256_hash_to_address.out | 2 +- .../algorithms/keccak256_hash_to_field.out | 2 +- .../algorithms/keccak256_hash_to_group.out | 2 +- .../algorithms/keccak256_hash_to_scalar.out | 2 +- .../algorithms/keccak384_hash_to_address.out | 2 +- .../algorithms/keccak384_hash_to_field.out | 2 +- .../algorithms/keccak384_hash_to_group.out | 2 +- .../algorithms/keccak384_hash_to_scalar.out | 2 +- .../algorithms/keccak512_hash_to_address.out | 2 +- .../algorithms/keccak512_hash_to_field.out | 2 +- .../algorithms/keccak512_hash_to_group.out | 2 +- .../algorithms/keccak512_hash_to_scalar.out | 2 +- .../algorithms/poseidon2_hash_to_address.out | 2 +- .../algorithms/poseidon2_hash_to_field.out | 2 +- .../algorithms/poseidon2_hash_to_group.out | 2 +- .../algorithms/poseidon2_hash_to_scalar.out | 2 +- .../algorithms/poseidon4_hash_to_address.out | 2 +- .../algorithms/poseidon4_hash_to_field.out | 2 +- .../algorithms/poseidon4_hash_to_group.out | 2 +- .../algorithms/poseidon4_hash_to_scalar.out | 2 +- .../algorithms/poseidon8_hash_to_address.out | 2 +- .../algorithms/poseidon8_hash_to_field.out | 2 +- .../algorithms/poseidon8_hash_to_group.out | 2 +- .../algorithms/poseidon8_hash_to_scalar.out | 2 +- .../algorithms/sha3_256_hash_to_address.out | 2 +- .../algorithms/sha3_256_hash_to_field.out | 2 +- .../algorithms/sha3_256_hash_to_group.out | 2 +- .../algorithms/sha3_256_hash_to_scalar.out | 2 +- .../algorithms/sha3_384_hash_to_address.out | 2 +- .../algorithms/sha3_384_hash_to_field.out | 2 +- .../algorithms/sha3_384_hash_to_group.out | 2 +- .../algorithms/sha3_384_hash_to_scalar.out | 2 +- .../algorithms/sha3_512_hash_to_address.out | 2 +- .../algorithms/sha3_512_hash_to_field.out | 2 +- .../algorithms/sha3_512_hash_to_group.out | 2 +- .../algorithms/sha3_512_hash_to_scalar.out | 2 +- .../compiler/core/constants/group_gen.out | 4 +- .../compiler/examples/basic_bank.out | 2 +- .../compiler/examples/fibonacci.out | 2 +- .../expectations/compiler/examples/groups.out | 4 +- .../compiler/examples/interest.out | 628 +++++---- .../compiler/examples/ntzloops.out | 2 +- .../compiler/examples/ntzsearchtree.out | 233 ++-- .../compiler/examples/twoadicity.out | 2 +- tests/expectations/compiler/field/field.out | 2 +- .../helper_function_with_interface.out | 6 +- ...ction_any_number_of_inputs_and_outputs.out | 5 +- tests/expectations/compiler/group/ternary.out | 11 +- .../compiler/group/to_x_coordinate.out | 2 +- .../compiler/group/to_y_coordinate.out | 2 +- .../compiler/mappings/max_mappings.out | 5 +- .../compiler/statements/iteration_basic.out | 2 +- .../compiler/statements/iteration_nested.out | 2 +- .../loop_non_literal_bound_fail.out | 5 +- .../statements/underscore_for_loop.out | 2 +- .../compiler/tuple/tuple_in_assignment.out | 5 +- .../compiler/tuple/tuple_in_definition.out | 5 +- .../compiler/tuple/tuple_in_loop.out | 2 +- tests/expectations/execution/array_sum.out | 2 +- tests/expectations/execution/counter.out | 14 +- tests/test-framework/benches/leo_compiler.rs | 68 +- .../compiler/const_prop/big_const_prop.leo | 20 + .../const_prop/compile_time_const_fail.leo | 16 + .../compiler/const_prop/core_functions.leo | 29 + .../const_prop/evaluate_const_fail.leo | 24 + .../compiler/const_prop/loop_bounds_fail.leo | 24 + .../compiler/const_prop/some_loop_bounds.leo | 24 + tests/tests/compiler/const_prop/tuples.leo | 16 + .../compiler/constants/loop_unrolling.leo | 2 +- 280 files changed, 3414 insertions(+), 1284 deletions(-) create mode 100644 compiler/passes/src/const_propagation/const_propagate_expression.rs create mode 100644 compiler/passes/src/const_propagation/const_propagate_program.rs create mode 100644 compiler/passes/src/const_propagation/const_propagate_statement.rs create mode 100644 compiler/passes/src/const_propagation/const_propagator.rs create mode 100644 compiler/passes/src/const_propagation/mod.rs create mode 100644 compiler/passes/src/loop_unrolling/duplicate.rs create mode 100644 interpreter/src/core_functions.rs create mode 100644 tests/expectations/compiler/const_prop/big_const_prop.out create mode 100644 tests/expectations/compiler/const_prop/compile_time_const_fail.out create mode 100644 tests/expectations/compiler/const_prop/core_functions.out create mode 100644 tests/expectations/compiler/const_prop/evaluate_const_fail.out create mode 100644 tests/expectations/compiler/const_prop/loop_bounds_fail.out create mode 100644 tests/expectations/compiler/const_prop/some_loop_bounds.out create mode 100644 tests/expectations/compiler/const_prop/tuples.out create mode 100644 tests/tests/compiler/const_prop/big_const_prop.leo create mode 100644 tests/tests/compiler/const_prop/compile_time_const_fail.leo create mode 100644 tests/tests/compiler/const_prop/core_functions.leo create mode 100644 tests/tests/compiler/const_prop/evaluate_const_fail.leo create mode 100644 tests/tests/compiler/const_prop/loop_bounds_fail.leo create mode 100644 tests/tests/compiler/const_prop/some_loop_bounds.leo create mode 100644 tests/tests/compiler/const_prop/tuples.leo diff --git a/Cargo.lock b/Cargo.lock index 35cb30c7d2..bd4c4f9873 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1667,9 +1667,7 @@ dependencies = [ "indexmap 2.6.0", "leo-ast", "leo-errors", - "leo-package", "leo-parser", - "leo-passes", "leo-span", "leo-test-framework", "rand", @@ -1760,6 +1758,7 @@ dependencies = [ "itertools 0.13.0", "leo-ast", "leo-errors", + "leo-interpreter", "leo-span", "num-traits", "serde", diff --git a/compiler/ast/src/common/identifier.rs b/compiler/ast/src/common/identifier.rs index 0e44b17ada..7d6e1b064e 100644 --- a/compiler/ast/src/common/identifier.rs +++ b/compiler/ast/src/common/identifier.rs @@ -41,7 +41,7 @@ use std::{ /// Attention - When adding or removing fields from this struct, /// please remember to update its Serialize and Deserialize implementation /// to reflect the new struct instantiation. -#[derive(Clone, Copy)] +#[derive(Clone, Copy, Default)] pub struct Identifier { /// The symbol that the user wrote, e.g., `foo`. pub name: Symbol, diff --git a/compiler/ast/src/expressions/err.rs b/compiler/ast/src/expressions/err.rs index 5f6d95af5a..1bbd5cb185 100644 --- a/compiler/ast/src/expressions/err.rs +++ b/compiler/ast/src/expressions/err.rs @@ -17,7 +17,7 @@ use super::*; /// Represents a syntactically invalid expression. -#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +#[derive(Debug, Default, Clone, PartialEq, Eq, Serialize, Deserialize)] pub struct ErrExpression { /// The span of the invalid expression. pub span: Span, diff --git a/compiler/ast/src/expressions/mod.rs b/compiler/ast/src/expressions/mod.rs index da3a846651..a79925c23e 100644 --- a/compiler/ast/src/expressions/mod.rs +++ b/compiler/ast/src/expressions/mod.rs @@ -93,6 +93,12 @@ pub enum Expression { Unit(UnitExpression), } +impl Default for Expression { + fn default() -> Self { + Expression::Err(Default::default()) + } +} + impl Node for Expression { fn span(&self) -> Span { use Expression::*; diff --git a/compiler/ast/src/expressions/unary.rs b/compiler/ast/src/expressions/unary.rs index 6223ad5551..779b06cfc2 100644 --- a/compiler/ast/src/expressions/unary.rs +++ b/compiler/ast/src/expressions/unary.rs @@ -60,7 +60,7 @@ impl UnaryOperation { }) } - /// Represents the opera.tor as a string. + /// Represents the operator as a string. fn as_str(self) -> &'static str { match self { Self::Abs => "abs", @@ -77,6 +77,12 @@ impl UnaryOperation { } } +impl fmt::Display for UnaryOperation { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "{}", self.as_str()) + } +} + /// An unary expression applying an operator to an inner expression. #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] pub struct UnaryExpression { @@ -92,7 +98,7 @@ pub struct UnaryExpression { impl fmt::Display for UnaryExpression { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}{}", self.op.as_str(), self.receiver) + write!(f, "({}).{}()", self.receiver, self.op) } } diff --git a/compiler/ast/src/functions/mod.rs b/compiler/ast/src/functions/mod.rs index f0b9f9622d..d98e58e4ea 100644 --- a/compiler/ast/src/functions/mod.rs +++ b/compiler/ast/src/functions/mod.rs @@ -39,7 +39,7 @@ use serde::{Deserialize, Serialize}; use std::fmt; /// A function definition. -#[derive(Clone, Serialize, Deserialize)] +#[derive(Clone, Default, Serialize, Deserialize)] pub struct Function { /// Annotations on the function. pub annotations: Vec, diff --git a/compiler/ast/src/functions/variant.rs b/compiler/ast/src/functions/variant.rs index eb2851456f..ddf6bd220c 100644 --- a/compiler/ast/src/functions/variant.rs +++ b/compiler/ast/src/functions/variant.rs @@ -22,8 +22,9 @@ use serde::{Deserialize, Serialize}; /// A regular function is not permitted to manipulate records. /// An asynchronous function contains on-chain operations. /// An inline function is directly copied at the call site. -#[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq)] +#[derive(Copy, Clone, Debug, Default, Serialize, Deserialize, PartialEq, Eq)] pub enum Variant { + #[default] Inline, Function, Transition, diff --git a/compiler/ast/src/program/program_scope.rs b/compiler/ast/src/program/program_scope.rs index 75d9dd4c4e..021e6dd39e 100644 --- a/compiler/ast/src/program/program_scope.rs +++ b/compiler/ast/src/program/program_scope.rs @@ -59,6 +59,9 @@ impl From for ProgramScope { impl fmt::Display for ProgramScope { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { writeln!(f, "program {} {{", self.program_id)?; + for (_, const_decl) in self.consts.iter() { + writeln!(f, " {const_decl}")?; + } for (_, struct_) in self.structs.iter() { writeln!(f, " {struct_}")?; } diff --git a/compiler/ast/src/statement/assign.rs b/compiler/ast/src/statement/assign.rs index 1262754bfe..131ad3cfb6 100644 --- a/compiler/ast/src/statement/assign.rs +++ b/compiler/ast/src/statement/assign.rs @@ -37,7 +37,7 @@ pub struct AssignStatement { impl fmt::Display for AssignStatement { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{} = {};", self.place, self.value) + write!(f, "{} = {}", self.place, self.value) } } diff --git a/compiler/ast/src/statement/block.rs b/compiler/ast/src/statement/block.rs index 37d5711ff2..f69d6af4f4 100644 --- a/compiler/ast/src/statement/block.rs +++ b/compiler/ast/src/statement/block.rs @@ -37,7 +37,7 @@ impl fmt::Display for Block { if self.statements.is_empty() { writeln!(f, "\t")?; } else { - self.statements.iter().try_for_each(|statement| writeln!(f, "\t{statement}"))?; + self.statements.iter().try_for_each(|statement| writeln!(f, "\t{statement};"))?; } write!(f, "}}") } diff --git a/compiler/ast/src/statement/const_.rs b/compiler/ast/src/statement/const_.rs index 162034e38a..78a411e138 100644 --- a/compiler/ast/src/statement/const_.rs +++ b/compiler/ast/src/statement/const_.rs @@ -21,7 +21,7 @@ use serde::{Deserialize, Serialize}; use std::fmt; /// A constant declaration statement. -#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)] +#[derive(Clone, Default, PartialEq, Eq, Serialize, Deserialize, Debug)] pub struct ConstDeclaration { /// The place to assign to. As opposed to `DefinitionStatement`, this can only be an identifier pub place: Identifier, @@ -37,9 +37,7 @@ pub struct ConstDeclaration { impl fmt::Display for ConstDeclaration { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{}", self.place)?; - write!(f, ": {}", self.type_)?; - write!(f, " = {};", self.value) + write!(f, "const {}: {} = {}", self.place, self.type_, self.value) } } diff --git a/compiler/ast/src/statement/definition/mod.rs b/compiler/ast/src/statement/definition/mod.rs index e06f029c22..abdeff3ada 100644 --- a/compiler/ast/src/statement/definition/mod.rs +++ b/compiler/ast/src/statement/definition/mod.rs @@ -42,10 +42,7 @@ pub struct DefinitionStatement { impl fmt::Display for DefinitionStatement { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "{} ", self.declaration_type)?; - write!(f, "{}", self.place)?; - write!(f, ": {}", self.type_)?; - write!(f, " = {};", self.value) + write!(f, "{} {}: {} = {}", self.declaration_type, self.place, self.type_, self.value) } } diff --git a/compiler/compiler/src/compiler.rs b/compiler/compiler/src/compiler.rs index c505c43510..4e4c7bed17 100644 --- a/compiler/compiler/src/compiler.rs +++ b/compiler/compiler/src/compiler.rs @@ -150,14 +150,14 @@ impl<'a, N: Network> Compiler<'a, N> { } /// Runs the type checker pass. - pub fn type_checker_pass(&'a self, symbol_table: SymbolTable) -> Result<(SymbolTable, StructGraph, CallGraph)> { - let (symbol_table, struct_graph, call_graph) = + pub fn type_checker_pass(&'a self, symbol_table: &mut SymbolTable) -> Result<(StructGraph, CallGraph)> { + let (struct_graph, call_graph) = TypeChecker::do_pass((&self.ast, self.handler, symbol_table, &self.type_table, NetworkLimits { max_array_elements: N::MAX_ARRAY_ELEMENTS, max_mappings: N::MAX_MAPPINGS, max_functions: N::MAX_FUNCTIONS, }))?; - Ok((symbol_table, struct_graph, call_graph)) + Ok((struct_graph, call_graph)) } /// Runs the static analysis pass. @@ -172,22 +172,64 @@ impl<'a, N: Network> Compiler<'a, N> { )) } + /// Run const propagation and loop unrolling until we hit a fixed point or find an error. + pub fn const_propagation_and_unroll_loop(&mut self, symbol_table: &mut SymbolTable) -> Result<()> { + loop { + let loop_unroll_output = self.loop_unrolling_pass(symbol_table)?; + + let const_prop_output = self.const_propagation_pass(symbol_table)?; + + if !const_prop_output.changed && !loop_unroll_output.loop_unrolled { + // We've got a fixed point, so see if we have any errors. + if let Some(not_evaluated_span) = const_prop_output.const_not_evaluated { + return Err(CompilerError::const_not_evaluated(not_evaluated_span).into()); + } + + if let Some(not_evaluated_span) = const_prop_output.array_index_not_evaluated { + return Err(CompilerError::array_index_not_evaluated(not_evaluated_span).into()); + } + + if let Some(not_unrolled_span) = loop_unroll_output.loop_not_unrolled { + return Err(CompilerError::loop_bounds_not_evaluated(not_unrolled_span).into()); + } + + if self.compiler_options.output.unrolled_ast { + self.write_ast_to_json("unrolled_ast.json")?; + } + + return Ok(()); + } + } + } + + /// Runs the const propagation pass. + pub fn const_propagation_pass(&mut self, symbol_table: &mut SymbolTable) -> Result { + let (ast, output) = ConstPropagator::do_pass(( + std::mem::take(&mut self.ast), + self.handler, + symbol_table, + &self.type_table, + &self.node_builder, + ))?; + + self.ast = ast; + + Ok(output) + } + /// Runs the loop unrolling pass. - pub fn loop_unrolling_pass(&mut self, symbol_table: SymbolTable) -> Result { - let (ast, symbol_table) = Unroller::do_pass(( + pub fn loop_unrolling_pass(&mut self, symbol_table: &mut SymbolTable) -> Result { + let (ast, output) = Unroller::do_pass(( std::mem::take(&mut self.ast), self.handler, &self.node_builder, symbol_table, &self.type_table, ))?; - self.ast = ast; - if self.compiler_options.output.unrolled_ast { - self.write_ast_to_json("unrolled_ast.json")?; - } + self.ast = ast; - Ok(symbol_table) + Ok(output) } /// Runs the static single assignment pass. @@ -283,14 +325,13 @@ impl<'a, N: Network> Compiler<'a, N> { /// Runs the compiler stages. pub fn compiler_stages(&mut self) -> Result<(SymbolTable, StructGraph, CallGraph)> { - let st = self.symbol_table_pass()?; + let mut st = self.symbol_table_pass()?; - let (st, struct_graph, call_graph) = self.type_checker_pass(st)?; + let (struct_graph, call_graph) = self.type_checker_pass(&mut st)?; self.static_analysis_pass(&st)?; - // TODO: Make this pass optional. - let st = self.loop_unrolling_pass(st)?; + self.const_propagation_and_unroll_loop(&mut st)?; self.static_single_assignment_pass(&st)?; diff --git a/compiler/compiler/tests/integration/utilities/mod.rs b/compiler/compiler/tests/integration/utilities/mod.rs index 81db34cb1a..7028914cbe 100644 --- a/compiler/compiler/tests/integration/utilities/mod.rs +++ b/compiler/compiler/tests/integration/utilities/mod.rs @@ -251,17 +251,17 @@ pub fn temp_dir() -> PathBuf { pub fn compile_and_process<'a>(parsed: &'a mut Compiler<'a, CurrentNetwork>) -> Result { parsed.add_import_stubs()?; - let st = parsed.symbol_table_pass()?; + let mut st = parsed.symbol_table_pass()?; CheckUniqueNodeIds::new().visit_program(&parsed.ast.ast); - let (st, struct_graph, call_graph) = parsed.type_checker_pass(st)?; + let (struct_graph, call_graph) = parsed.type_checker_pass(&mut st)?; parsed.static_analysis_pass(&st)?; CheckUniqueNodeIds::new().visit_program(&parsed.ast.ast); - let st = parsed.loop_unrolling_pass(st)?; + parsed.const_propagation_and_unroll_loop(&mut st)?; parsed.static_single_assignment_pass(&st)?; diff --git a/compiler/passes/Cargo.toml b/compiler/passes/Cargo.toml index 824e883739..bb36b99aec 100644 --- a/compiler/passes/Cargo.toml +++ b/compiler/passes/Cargo.toml @@ -30,6 +30,9 @@ workspace = true [dependencies.leo-errors] workspace = true +[dependencies.leo-interpreter] +workspace = true + [dependencies.leo-span] workspace = true diff --git a/compiler/passes/src/common/symbol_table/mod.rs b/compiler/passes/src/common/symbol_table/mod.rs index 6b46c8b37a..cac303ff5b 100644 --- a/compiler/passes/src/common/symbol_table/mod.rs +++ b/compiler/passes/src/common/symbol_table/mod.rs @@ -82,6 +82,12 @@ impl LocalTable { })), } } + + fn dup(&self, new_id: NodeID) -> Self { + let mut inner = self.inner.borrow().clone(); + inner.id = new_id; + LocalTable { inner: Rc::new(RefCell::new(inner)) } + } } impl SymbolTable { @@ -139,10 +145,23 @@ impl SymbolTable { self.local = id.map(|id| { let parent = self.local.as_ref().map(|table| table.inner.borrow().id); let new_local_table = self.all_locals.entry(id).or_insert_with(|| LocalTable::new(id, parent)); + assert_eq!(parent, new_local_table.inner.borrow().parent, "Entered scopes out of order."); new_local_table.clone() }); } + /// Enter the new scope with id `new_id`, duplicating its local symbol table from the scope at `old_id`. + /// + /// This is useful for a pass like loop unrolling, in which the loop body must be duplicated multiple times. + pub fn enter_scope_duped(&mut self, new_id: NodeID, old_id: NodeID) { + let old_local_table = self.all_locals.get(&old_id).expect("Must have an old scope to dup from."); + let new_local_table = old_local_table.dup(new_id); + let parent = self.local.as_ref().map(|table| table.inner.borrow().id); + new_local_table.inner.borrow_mut().parent = parent; + self.all_locals.insert(new_id, new_local_table.clone()); + self.local = Some(new_local_table); + } + /// Enther the parent scope of the current scope (or the global scope if there is no local parent scope). pub fn enter_parent(&mut self) { let parent: Option = self.local.as_ref().and_then(|table| table.inner.borrow().parent); diff --git a/compiler/passes/src/const_propagation/const_propagate_expression.rs b/compiler/passes/src/const_propagation/const_propagate_expression.rs new file mode 100644 index 0000000000..bbda287f00 --- /dev/null +++ b/compiler/passes/src/const_propagation/const_propagate_expression.rs @@ -0,0 +1,303 @@ +// Copyright (C) 2019-2024 Aleo Systems Inc. +// This file is part of the Leo library. + +// The Leo library is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// The Leo library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with the Leo library. If not, see . + +use leo_ast::{ + AccessExpression, + CoreFunction, + Expression, + ExpressionReconstructor, + Node, + StructExpression, + TernaryExpression, +}; +use leo_errors::StaticAnalyzerError; +use leo_interpreter::Value; +use leo_span::sym; + +use crate::ConstPropagator; + +use super::const_propagator::value_to_expression; + +impl ExpressionReconstructor for ConstPropagator<'_> { + type AdditionalOutput = Option; + + fn reconstruct_expression(&mut self, input: Expression) -> (Expression, Self::AdditionalOutput) { + let old_id = input.id(); + let (new_expr, opt_value) = match input { + Expression::Access(access) => self.reconstruct_access(access), + Expression::Array(array) => self.reconstruct_array(array), + Expression::Binary(binary) => self.reconstruct_binary(binary), + Expression::Call(call) => self.reconstruct_call(call), + Expression::Cast(cast) => self.reconstruct_cast(cast), + Expression::Struct(struct_) => self.reconstruct_struct_init(struct_), + Expression::Err(err) => self.reconstruct_err(err), + Expression::Identifier(identifier) => self.reconstruct_identifier(identifier), + Expression::Literal(value) => self.reconstruct_literal(value), + Expression::Locator(locator) => self.reconstruct_locator(locator), + Expression::Ternary(ternary) => self.reconstruct_ternary(ternary), + Expression::Tuple(tuple) => self.reconstruct_tuple(tuple), + Expression::Unary(unary) => self.reconstruct_unary(unary), + Expression::Unit(unit) => self.reconstruct_unit(unit), + }; + + if old_id != new_expr.id() { + self.changed = true; + let old_type = + self.type_table.get(&old_id).expect("Type checking guarantees that all expressions have a type."); + self.type_table.insert(new_expr.id(), old_type); + } + + (new_expr, opt_value) + } + + fn reconstruct_struct_init(&mut self, mut input: StructExpression) -> (Expression, Self::AdditionalOutput) { + for member in input.members.iter_mut() { + if let Some(expr) = std::mem::take(&mut member.expression) { + member.expression = Some(self.reconstruct_expression(expr).0); + } + } + (Expression::Struct(input), Default::default()) + } + + fn reconstruct_ternary(&mut self, mut input: TernaryExpression) -> (Expression, Self::AdditionalOutput) { + let (cond, cond_value) = self.reconstruct_expression(*input.condition); + + match cond_value { + Some(Value::Bool(true)) => self.reconstruct_expression(*input.if_true), + Some(Value::Bool(false)) => self.reconstruct_expression(*input.if_false), + _ => { + *input.condition = cond; + *input.if_true = self.reconstruct_expression(*input.if_true).0; + *input.if_false = self.reconstruct_expression(*input.if_false).0; + (Expression::Ternary(input), None) + } + } + } + + fn reconstruct_access(&mut self, input: leo_ast::AccessExpression) -> (Expression, Self::AdditionalOutput) { + match input { + leo_ast::AccessExpression::Array(array) => self.reconstruct_array_access(array), + leo_ast::AccessExpression::AssociatedConstant(constant) => self.reconstruct_associated_constant(constant), + leo_ast::AccessExpression::AssociatedFunction(function) => self.reconstruct_associated_function(function), + leo_ast::AccessExpression::Member(member) => self.reconstruct_member_access(member), + leo_ast::AccessExpression::Tuple(tuple) => self.reconstruct_tuple_access(tuple), + } + } + + fn reconstruct_array_access(&mut self, mut input: leo_ast::ArrayAccess) -> (Expression, Self::AdditionalOutput) { + *input.array = self.reconstruct_expression(*input.array).0; + let (index_expr, opt_value) = self.reconstruct_expression(*input.index); + if opt_value.is_none() { + self.array_index_not_evaluated = Some(index_expr.span()); + } + *input.index = index_expr; + (Expression::Access(leo_ast::AccessExpression::Array(input)), None) + } + + fn reconstruct_associated_constant( + &mut self, + input: leo_ast::AssociatedConstant, + ) -> (Expression, Self::AdditionalOutput) { + // Currently there is only one associated constant. + let generator = Value::generator(); + let expr = value_to_expression(&generator, input.span(), self.node_builder); + (expr, Some(generator)) + } + + fn reconstruct_associated_function( + &mut self, + mut input: leo_ast::AssociatedFunction, + ) -> (Expression, Self::AdditionalOutput) { + let mut values = Vec::new(); + for argument in input.arguments.iter_mut() { + let (new_argument, opt_value) = self.reconstruct_expression(std::mem::take(argument)); + *argument = new_argument; + if let Some(value) = opt_value { + values.push(value); + } + } + + if values.len() == input.arguments.len() && !matches!(input.variant.name, sym::CheatCode | sym::Mapping) { + // We've evaluated every argument, and this function isn't a cheat code or mapping + // operation, so maybe we can compute the result at compile time. + let core_function = CoreFunction::from_symbols(input.variant.name, input.name.name) + .expect("Type checking guarantees this is valid."); + + values.reverse(); + + match leo_interpreter::evaluate_core_function(&mut values, core_function, &[], input.span()) { + Ok(Some(value)) => { + // Successful evaluation. + let expr = value_to_expression(&value, input.span(), self.node_builder); + return (expr, Some(value)); + } + Ok(None) => + // No errors, but we were unable to evaluate. + {} + Err(err) => { + self.emit_err(StaticAnalyzerError::compile_core_function(err, input.span())); + } + } + } + + (Expression::Access(AccessExpression::AssociatedFunction(input)), Default::default()) + } + + fn reconstruct_member_access(&mut self, mut input: leo_ast::MemberAccess) -> (Expression, Self::AdditionalOutput) { + *input.inner = self.reconstruct_expression(*input.inner).0; + (Expression::Access(leo_ast::AccessExpression::Member(input)), None) + } + + fn reconstruct_tuple_access(&mut self, input: leo_ast::TupleAccess) -> (Expression, Self::AdditionalOutput) { + ( + Expression::Access(leo_ast::AccessExpression::Tuple(leo_ast::TupleAccess { + tuple: Box::new(self.reconstruct_expression(*input.tuple).0), + index: input.index, + span: input.span, + id: input.id, + })), + None, + ) + } + + fn reconstruct_array(&mut self, mut input: leo_ast::ArrayExpression) -> (Expression, Self::AdditionalOutput) { + input.elements.iter_mut().for_each(|element| { + *element = self.reconstruct_expression(std::mem::take(element)).0; + }); + (Expression::Array(input), None) + } + + fn reconstruct_binary(&mut self, mut input: leo_ast::BinaryExpression) -> (Expression, Self::AdditionalOutput) { + let span = input.span(); + + let (lhs_expr, lhs_opt_value) = self.reconstruct_expression(*input.left); + let (rhs_expr, rhs_opt_value) = self.reconstruct_expression(*input.right); + + if let (Some(lhs_value), Some(rhs_value)) = (lhs_opt_value, rhs_opt_value) { + // We were able to evaluate both operands, so we can evaluate this expression. + match leo_interpreter::evaluate_binary(span, input.op, &lhs_value, &rhs_value) { + Ok(new_value) => { + let new_expr = value_to_expression(&new_value, span, self.node_builder); + return (new_expr, Some(new_value)); + } + Err(err) => self + .emit_err(StaticAnalyzerError::compile_time_binary_op(lhs_value, rhs_value, input.op, err, span)), + } + } + + *input.left = lhs_expr; + *input.right = rhs_expr; + + (Expression::Binary(input), None) + } + + fn reconstruct_call(&mut self, mut input: leo_ast::CallExpression) -> (Expression, Self::AdditionalOutput) { + input.arguments.iter_mut().for_each(|arg| { + *arg = self.reconstruct_expression(std::mem::take(arg)).0; + }); + (Expression::Call(input), Default::default()) + } + + fn reconstruct_cast(&mut self, mut input: leo_ast::CastExpression) -> (Expression, Self::AdditionalOutput) { + let span = input.span(); + + let (expr, opt_value) = self.reconstruct_expression(*input.expression); + + if let Some(value) = opt_value { + if let Some(cast_value) = value.cast(&input.type_) { + let expr = value_to_expression(&cast_value, span, self.node_builder); + return (expr, Some(cast_value)); + } else { + self.emit_err(StaticAnalyzerError::compile_time_cast(value, &input.type_, span)); + } + } + *input.expression = expr; + (Expression::Cast(input), None) + } + + fn reconstruct_err(&mut self, _input: leo_ast::ErrExpression) -> (Expression, Self::AdditionalOutput) { + panic!("`ErrExpression`s should not be in the AST at this phase of compilation.") + } + + fn reconstruct_identifier(&mut self, input: leo_ast::Identifier) -> (Expression, Self::AdditionalOutput) { + println!("LOOKING UP {}", input.name); + if format!("{}", input.name) == "BIG_NUMBER" { + // println!("TABLE {:#?}", self.symbol_table); + } + // Substitute the identifier with the constant value if it is a constant that's been evaluated. + if let Some(expression) = self.symbol_table.lookup_const(self.program, input.name) { + println!("FOUND"); + let (expression, opt_value) = self.reconstruct_expression(expression); + if opt_value.is_some() { + return (expression, opt_value); + } + } + + (Expression::Identifier(input), None) + } + + fn reconstruct_literal(&mut self, input: leo_ast::Literal) -> (Expression, Self::AdditionalOutput) { + if let leo_ast::Literal::Group(boxed_gl) = &input { + if matches!(&**boxed_gl, leo_ast::GroupLiteral::Tuple(..)) { + // YYY - I don't know how to handle this. + return (Expression::Literal(input), None); + } + } + let value = leo_interpreter::literal_to_value(&input).expect("Should work"); + (Expression::Literal(input), Some(value)) + } + + fn reconstruct_locator(&mut self, input: leo_ast::LocatorExpression) -> (Expression, Self::AdditionalOutput) { + (Expression::Locator(input), Default::default()) + } + + fn reconstruct_tuple(&mut self, mut input: leo_ast::TupleExpression) -> (Expression, Self::AdditionalOutput) { + let mut values = Vec::with_capacity(input.elements.len()); + for expr in input.elements.iter_mut() { + let (new_expr, opt_value) = self.reconstruct_expression(std::mem::take(expr)); + *expr = new_expr; + if let Some(value) = opt_value { + values.push(value); + } + } + + let opt_value = if values.len() == input.elements.len() { Some(Value::Tuple(values)) } else { None }; + + (Expression::Tuple(input), opt_value) + } + + fn reconstruct_unary(&mut self, mut input: leo_ast::UnaryExpression) -> (Expression, Self::AdditionalOutput) { + let (expr, opt_value) = self.reconstruct_expression(*input.receiver); + let span = input.span; + + if let Some(value) = opt_value { + // We were able to evaluate the operand, so we can evaluate the expression. + match leo_interpreter::evaluate_unary(span, input.op, &value) { + Ok(new_value) => { + let new_expr = value_to_expression(&new_value, span, self.node_builder); + return (new_expr, Some(new_value)); + } + Err(err) => self.emit_err(StaticAnalyzerError::compile_time_unary_op(value, input.op, err, span)), + } + } + *input.receiver = expr; + (Expression::Unary(input), None) + } + + fn reconstruct_unit(&mut self, input: leo_ast::UnitExpression) -> (Expression, Self::AdditionalOutput) { + (Expression::Unit(input), None) + } +} diff --git a/compiler/passes/src/const_propagation/const_propagate_program.rs b/compiler/passes/src/const_propagation/const_propagate_program.rs new file mode 100644 index 0000000000..6a112baa97 --- /dev/null +++ b/compiler/passes/src/const_propagation/const_propagate_program.rs @@ -0,0 +1,45 @@ +// Copyright (C) 2019-2024 Aleo Systems Inc. +// This file is part of the Leo library. + +// The Leo library is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// The Leo library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with the Leo library. If not, see . + +use crate::ConstPropagator; + +use leo_ast::{Function, Node, ProgramReconstructor, ProgramScope, Statement, StatementReconstructor as _}; + +impl ProgramReconstructor for ConstPropagator<'_> { + fn reconstruct_program_scope(&mut self, mut input: ProgramScope) -> ProgramScope { + self.program = input.program_id.name.name; + + for (_sym, c) in input.consts.iter_mut() { + let Statement::Const(declaration) = self.reconstruct_const(std::mem::take(c)).0 else { + panic!("`reconstruct_const` always returns `Statement::Const`"); + }; + *c = declaration; + } + + for (_sym, f) in input.functions.iter_mut() { + *f = self.reconstruct_function(std::mem::take(f)); + } + + input + } + + fn reconstruct_function(&mut self, mut function: Function) -> Function { + self.in_scope(function.id(), |slf| { + function.block = slf.reconstruct_block(function.block).0; + function + }) + } +} diff --git a/compiler/passes/src/const_propagation/const_propagate_statement.rs b/compiler/passes/src/const_propagation/const_propagate_statement.rs new file mode 100644 index 0000000000..908adc43f8 --- /dev/null +++ b/compiler/passes/src/const_propagation/const_propagate_statement.rs @@ -0,0 +1,169 @@ +// Copyright (C) 2019-2024 Aleo Systems Inc. +// This file is part of the Leo library. + +// The Leo library is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// The Leo library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with the Leo library. If not, see . + +use crate::ConstPropagator; + +use leo_ast::{ + AssertStatement, + AssertVariant, + AssignStatement, + Block, + ConditionalStatement, + ConsoleStatement, + ConstDeclaration, + DeclarationType, + DefinitionStatement, + Expression, + ExpressionReconstructor, + ExpressionStatement, + IterationStatement, + Node, + ReturnStatement, + Statement, + StatementReconstructor, +}; + +fn empty_statement() -> Statement { + Statement::Block(Block { statements: Vec::new(), span: Default::default(), id: Default::default() }) +} + +fn is_empty_statement(stmt: &Statement) -> bool { + let Statement::Block(block) = stmt else { + return false; + }; + block.statements.is_empty() +} + +impl StatementReconstructor for ConstPropagator<'_> { + fn reconstruct_assert(&mut self, mut input: AssertStatement) -> (Statement, Self::AdditionalOutput) { + // It would seem natural to catch assert triggers at compile time, but this may be + // difficult due to control flow. + input.variant = match input.variant { + AssertVariant::Assert(expr) => AssertVariant::Assert(self.reconstruct_expression(expr).0), + + AssertVariant::AssertEq(lhs, rhs) => { + AssertVariant::AssertEq(self.reconstruct_expression(lhs).0, self.reconstruct_expression(rhs).0) + } + + AssertVariant::AssertNeq(lhs, rhs) => { + AssertVariant::AssertNeq(self.reconstruct_expression(lhs).0, self.reconstruct_expression(rhs).0) + } + }; + + (Statement::Assert(input), None) + } + + fn reconstruct_assign(&mut self, mut assign: AssignStatement) -> (Statement, Self::AdditionalOutput) { + assign.value = self.reconstruct_expression(assign.value).0; + (Statement::Assign(Box::new(assign)), None) + } + + fn reconstruct_block(&mut self, mut block: Block) -> (Block, Self::AdditionalOutput) { + self.in_scope(block.id(), |slf| { + block.statements.retain_mut(|statement| { + let bogus_statement = empty_statement(); + let this_statement = std::mem::replace(statement, bogus_statement); + *statement = slf.reconstruct_statement(this_statement).0; + !is_empty_statement(statement) + }); + (block, None) + }) + } + + fn reconstruct_conditional( + &mut self, + mut conditional: ConditionalStatement, + ) -> (Statement, Self::AdditionalOutput) { + conditional.condition = self.reconstruct_expression(conditional.condition).0; + conditional.then = self.reconstruct_block(conditional.then).0; + if let Some(mut otherwise) = conditional.otherwise { + *otherwise = self.reconstruct_statement(*otherwise).0; + conditional.otherwise = Some(otherwise); + } + + (Statement::Conditional(conditional), None) + } + + fn reconstruct_console(&mut self, _: ConsoleStatement) -> (Statement, Self::AdditionalOutput) { + unreachable!("`ConsoleStatement`s should not be in the AST at this phase of compilation.") + } + + fn reconstruct_const(&mut self, mut input: ConstDeclaration) -> (Statement, Self::AdditionalOutput) { + let span = input.span(); + + let (expr, opt_value) = self.reconstruct_expression(input.value); + + if opt_value.is_some() { + self.symbol_table.insert_const(self.program, input.place.name, expr.clone()); + } else { + self.const_not_evaluated = Some(span); + } + + input.value = expr; + + (Statement::Const(input), None) + } + + fn reconstruct_definition(&mut self, mut definition: DefinitionStatement) -> (Statement, Self::AdditionalOutput) { + let span = definition.span(); + + let (expr, opt_value) = self.reconstruct_expression(definition.value); + + if definition.declaration_type == DeclarationType::Const { + if opt_value.is_some() { + let Expression::Identifier(id) = &definition.place else { + panic!("Const definitions always have identifiers as the place."); + }; + self.symbol_table.insert_const(self.program, id.name, expr.clone()); + } else { + self.const_not_evaluated = Some(span); + } + } + + definition.value = expr; + + (Statement::Definition(definition), None) + } + + fn reconstruct_expression_statement( + &mut self, + mut input: ExpressionStatement, + ) -> (Statement, Self::AdditionalOutput) { + input.expression = self.reconstruct_expression(input.expression).0; + + if matches!(&input.expression, Expression::Unit(..) | Expression::Literal(..)) { + // We were able to evaluate this at compile time, but we need to get rid of this statement as + // we can't have expression statements that aren't calls. + (empty_statement(), Default::default()) + } else { + (Statement::Expression(input), Default::default()) + } + } + + fn reconstruct_iteration(&mut self, mut iteration: IterationStatement) -> (Statement, Self::AdditionalOutput) { + iteration.start = self.reconstruct_expression(iteration.start).0; + iteration.stop = self.reconstruct_expression(iteration.stop).0; + self.in_scope(iteration.id(), |slf| { + iteration.block = slf.reconstruct_block(iteration.block).0; + (Statement::Iteration(Box::new(iteration)), None) + }) + } + + fn reconstruct_return(&mut self, mut input: ReturnStatement) -> (Statement, Self::AdditionalOutput) { + input.expression = self.reconstruct_expression(input.expression).0; + (Statement::Return(input), Default::default()) + } +} diff --git a/compiler/passes/src/const_propagation/const_propagator.rs b/compiler/passes/src/const_propagation/const_propagator.rs new file mode 100644 index 0000000000..418b0a35ed --- /dev/null +++ b/compiler/passes/src/const_propagation/const_propagator.rs @@ -0,0 +1,121 @@ +// Copyright (C) 2019-2024 Aleo Systems Inc. +// This file is part of the Leo library. + +// The Leo library is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// The Leo library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with the Leo library. If not, see . + +use crate::{SymbolTable, TypeTable}; + +use leo_ast::{Expression, IntegerType, Literal, NodeBuilder, NodeID, TupleExpression}; +use leo_errors::{StaticAnalyzerError, emitter::Handler}; +use leo_interpreter::Value; +use leo_span::{Span, Symbol}; + +/// A pass to perform const propagation and folding. +/// +/// This pass should be used in conjunction with the Unroller so that +/// loop bounds and consts in loop bodies can be evaluated. +pub struct ConstPropagator<'a> { + /// The symbol table associated with the program. + pub(crate) symbol_table: &'a mut SymbolTable, + /// A mapping between node IDs and their types. + pub(crate) type_table: &'a TypeTable, + /// A counter used to generate unique node IDs. + pub(crate) node_builder: &'a NodeBuilder, + /// The error handler. + pub(crate) handler: &'a Handler, + /// The program name. + pub(crate) program: Symbol, + /// Have we actually modified the progam at all? + pub(crate) changed: bool, + /// The RHS of a const declaration we were not able to evaluate. + pub(crate) const_not_evaluated: Option, + /// An array index which was not able to be evaluated. + pub(crate) array_index_not_evaluated: Option, +} + +impl<'a> ConstPropagator<'a> { + pub(crate) fn new( + handler: &'a Handler, + symbol_table: &'a mut SymbolTable, + type_table: &'a TypeTable, + node_builder: &'a NodeBuilder, + ) -> Self { + Self { + handler, + symbol_table, + type_table, + node_builder, + program: Symbol::intern(""), + changed: false, + const_not_evaluated: None, + array_index_not_evaluated: None, + } + } + + /// Enter the symbol table's scope `id`, execute `func`, and then return to the parent scope. + pub(crate) fn in_scope(&mut self, id: NodeID, func: impl FnOnce(&mut Self) -> T) -> T { + self.symbol_table.enter_scope(Some(id)); + let result = func(self); + self.symbol_table.enter_parent(); + result + } + + /// Emit a `StaticAnalyzerError`. + pub(crate) fn emit_err(&self, err: StaticAnalyzerError) { + self.handler.emit_err(err); + } +} + +pub(crate) fn value_to_expression(value: &Value, span: Span, node_builder: &NodeBuilder) -> Expression { + use Value::*; + let id = node_builder.next_id(); + + match value { + Unit => Expression::Unit(leo_ast::UnitExpression { span, id }), + Bool(x) => Expression::Literal(Literal::Boolean(*x, span, id)), + U8(x) => Expression::Literal(Literal::Integer(IntegerType::U8, format!("{x}"), span, id)), + U16(x) => Expression::Literal(Literal::Integer(IntegerType::U16, format!("{x}"), span, id)), + U32(x) => Expression::Literal(Literal::Integer(IntegerType::U32, format!("{x}"), span, id)), + U64(x) => Expression::Literal(Literal::Integer(IntegerType::U64, format!("{x}"), span, id)), + U128(x) => Expression::Literal(Literal::Integer(IntegerType::U128, format!("{x}"), span, id)), + I8(x) => Expression::Literal(Literal::Integer(IntegerType::I8, format!("{x}"), span, id)), + I16(x) => Expression::Literal(Literal::Integer(IntegerType::I16, format!("{x}"), span, id)), + I32(x) => Expression::Literal(Literal::Integer(IntegerType::I32, format!("{x}"), span, id)), + I64(x) => Expression::Literal(Literal::Integer(IntegerType::I64, format!("{x}"), span, id)), + I128(x) => Expression::Literal(Literal::Integer(IntegerType::I128, format!("{x}"), span, id)), + Group(x) => { + let mut s = format!("{x}"); + // Strip off the `group` suffix. + s.truncate(s.len() - 5); + Expression::Literal(Literal::Group(Box::new(leo_ast::GroupLiteral::Single(s, span, id)))) + } + Field(x) => { + let mut s = format!("{x}"); + // Strip off the `field` suffix. + s.truncate(s.len() - 5); + Expression::Literal(Literal::Field(s, span, id)) + } + Scalar(x) => { + let mut s = format!("{x}"); + // Strip off the `scalar` suffix. + s.truncate(s.len() - 6); + Expression::Literal(Literal::Scalar(s, span, id)) + } + Tuple(x) => { + let elements = x.iter().map(|val| value_to_expression(val, span, node_builder)).collect(); + Expression::Tuple(TupleExpression { elements, span, id }) + } + _ => panic!("Can only evaluate literals and tuples."), + } +} diff --git a/compiler/passes/src/const_propagation/mod.rs b/compiler/passes/src/const_propagation/mod.rs new file mode 100644 index 0000000000..5ee40f9fc4 --- /dev/null +++ b/compiler/passes/src/const_propagation/mod.rs @@ -0,0 +1,57 @@ +// Copyright (C) 2019-2024 Aleo Systems Inc. +// This file is part of the Leo library. + +// The Leo library is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// The Leo library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with the Leo library. If not, see . + +use crate::{Pass, SymbolTable, TypeTable}; + +use leo_ast::{Ast, NodeBuilder, ProgramReconstructor as _}; +use leo_errors::{Result, emitter::Handler}; +use leo_span::Span; + +mod const_propagate_expression; + +mod const_propagate_program; + +mod const_propagate_statement; + +mod const_propagator; + +pub use const_propagator::ConstPropagator; + +pub struct ConstPropagatorOutput { + /// Something about the program was actually changed during the pass. + pub changed: bool, + /// A const declaration whose RHS was not able to be evaluated. + pub const_not_evaluated: Option, + /// An array index which was not able to be evaluated. + pub array_index_not_evaluated: Option, +} + +impl<'a> Pass for ConstPropagator<'a> { + type Input = (Ast, &'a Handler, &'a mut SymbolTable, &'a TypeTable, &'a NodeBuilder); + type Output = Result<(Ast, ConstPropagatorOutput)>; + + fn do_pass((ast, handler, symbol_table, type_table, node_builder): Self::Input) -> Self::Output { + let mut reconstructor = ConstPropagator::new(handler, symbol_table, type_table, node_builder); + let program = reconstructor.reconstruct_program(ast.into_repr()); + handler.last_err().map_err(|e| *e)?; + + Ok((Ast::new(program), ConstPropagatorOutput { + changed: reconstructor.changed, + const_not_evaluated: reconstructor.const_not_evaluated, + array_index_not_evaluated: reconstructor.array_index_not_evaluated, + })) + } +} diff --git a/compiler/passes/src/lib.rs b/compiler/passes/src/lib.rs index ffab8e5dc7..5564ca7b7b 100644 --- a/compiler/passes/src/lib.rs +++ b/compiler/passes/src/lib.rs @@ -26,6 +26,9 @@ pub use code_generation::*; pub mod common; pub use common::*; +mod const_propagation; +pub use const_propagation::*; + pub mod dead_code_elimination; pub use dead_code_elimination::*; diff --git a/compiler/passes/src/loop_unrolling/duplicate.rs b/compiler/passes/src/loop_unrolling/duplicate.rs new file mode 100644 index 0000000000..e9953e3f2e --- /dev/null +++ b/compiler/passes/src/loop_unrolling/duplicate.rs @@ -0,0 +1,85 @@ +// Copyright (C) 2019-2024 Aleo Systems Inc. +// This file is part of the Leo library. + +// The Leo library is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// The Leo library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with the Leo library. If not, see . + +use leo_ast::{Block, ExpressionReconstructor, Statement, StatementReconstructor, *}; + +use crate::SymbolTable; + +/// Duplicate this block, recursively giving new `NodeID`s into scopes, and duplicating the new scopes +/// in the `SymbolTable`. +pub fn duplicate(block: Block, symbol_table: &mut SymbolTable, node_builder: &NodeBuilder) -> Block { + Duplicator { symbol_table, node_builder }.reconstruct_block(block).0 +} + +struct Duplicator<'a> { + symbol_table: &'a mut SymbolTable, + node_builder: &'a NodeBuilder, +} + +impl Duplicator<'_> { + fn in_scope_duped(&mut self, new_id: NodeID, old_id: NodeID, func: impl FnOnce(&mut Self) -> T) -> T { + self.symbol_table.enter_scope_duped(new_id, old_id); + let result = func(self); + self.symbol_table.enter_parent(); + result + } +} + +impl ExpressionReconstructor for Duplicator<'_> { + type AdditionalOutput = (); +} + +impl StatementReconstructor for Duplicator<'_> { + fn reconstruct_statement(&mut self, input: Statement) -> (Statement, Self::AdditionalOutput) { + match input { + Statement::Block(stmt) => { + let (stmt, output) = self.reconstruct_block(stmt); + (Statement::Block(stmt), output) + } + Statement::Conditional(stmt) => self.reconstruct_conditional(stmt), + Statement::Iteration(stmt) => self.reconstruct_iteration(*stmt), + stmt => (stmt, Default::default()), + } + } + + fn reconstruct_block(&mut self, mut input: Block) -> (Block, Self::AdditionalOutput) { + let next_id = self.node_builder.next_id(); + self.in_scope_duped(next_id, input.id(), |slf| { + input.id = next_id; + input.statements = input.statements.into_iter().map(|stmt| slf.reconstruct_statement(stmt).0).collect(); + (input, Default::default()) + }) + } + + fn reconstruct_conditional(&mut self, mut input: ConditionalStatement) -> (Statement, Self::AdditionalOutput) { + input.then = self.reconstruct_block(input.then).0; + if let Some(mut otherwise) = input.otherwise { + *otherwise = self.reconstruct_statement(*otherwise).0; + input.otherwise = Some(otherwise); + } + + (Statement::Conditional(input), Default::default()) + } + + fn reconstruct_iteration(&mut self, mut input: IterationStatement) -> (Statement, Self::AdditionalOutput) { + let next_id = self.node_builder.next_id(); + self.in_scope_duped(next_id, input.id(), |slf| { + input.id = next_id; + input.block = slf.reconstruct_block(input.block).0; + (Statement::Iteration(Box::new(input)), Default::default()) + }) + } +} diff --git a/compiler/passes/src/loop_unrolling/mod.rs b/compiler/passes/src/loop_unrolling/mod.rs index ccfe1de887..41088166c0 100644 --- a/compiler/passes/src/loop_unrolling/mod.rs +++ b/compiler/passes/src/loop_unrolling/mod.rs @@ -17,6 +17,8 @@ mod range_iterator; pub(crate) use range_iterator::*; +mod duplicate; + pub mod unroller; pub use unroller::*; @@ -30,16 +32,29 @@ use crate::{Pass, SymbolTable, TypeTable}; use leo_ast::{Ast, NodeBuilder, ProgramReconstructor}; use leo_errors::{Result, emitter::Handler}; +use leo_span::Span; + +pub struct UnrollerOutput { + pub loop_encountered: bool, + + pub loop_not_unrolled: Option, + + pub loop_unrolled: bool, +} impl<'a> Pass for Unroller<'a> { - type Input = (Ast, &'a Handler, &'a NodeBuilder, SymbolTable, &'a TypeTable); - type Output = Result<(Ast, SymbolTable)>; + type Input = (Ast, &'a Handler, &'a NodeBuilder, &'a mut SymbolTable, &'a TypeTable); + type Output = Result<(Ast, UnrollerOutput)>; fn do_pass((ast, handler, node_builder, symbol_table, tt): Self::Input) -> Self::Output { let mut reconstructor = Self::new(symbol_table, tt, handler, node_builder); let program = reconstructor.reconstruct_program(ast.into_repr()); handler.last_err().map_err(|e| *e)?; - Ok((Ast::new(program), reconstructor.symbol_table)) + Ok((Ast::new(program), UnrollerOutput { + loop_encountered: reconstructor.loop_encountered, + loop_not_unrolled: reconstructor.loop_not_unrolled, + loop_unrolled: reconstructor.loop_unrolled, + })) } } diff --git a/compiler/passes/src/loop_unrolling/unroll_expression.rs b/compiler/passes/src/loop_unrolling/unroll_expression.rs index 0dab3f2856..d7e293b476 100644 --- a/compiler/passes/src/loop_unrolling/unroll_expression.rs +++ b/compiler/passes/src/loop_unrolling/unroll_expression.rs @@ -15,37 +15,9 @@ // along with the Leo library. If not, see . use leo_ast::*; -use leo_errors::LoopUnrollerError; use crate::Unroller; impl ExpressionReconstructor for Unroller<'_> { - type AdditionalOutput = bool; - - fn reconstruct_array_access(&mut self, input: ArrayAccess) -> (Expression, Self::AdditionalOutput) { - // Reconstruct the index. - let index = self.reconstruct_expression(*input.index).0; - // If the index is not a literal, then emit an error. - if !matches!(index, Expression::Literal(_)) { - self.emit_err(LoopUnrollerError::variable_array_access(input.span)); - } - - ( - Expression::Access(AccessExpression::Array(ArrayAccess { - array: Box::new(self.reconstruct_expression(*input.array).0), - index: Box::new(index), - span: input.span, - id: input.id, - })), - Default::default(), - ) - } - - fn reconstruct_identifier(&mut self, input: Identifier) -> (Expression, Self::AdditionalOutput) { - // Substitute the identifier with the constant value if it is a constant. - if let Some(expr) = self.symbol_table.lookup_const(self.current_program.unwrap(), input.name) { - return (expr, Default::default()); - } - (Expression::Identifier(input), Default::default()) - } + type AdditionalOutput = (); } diff --git a/compiler/passes/src/loop_unrolling/unroll_program.rs b/compiler/passes/src/loop_unrolling/unroll_program.rs index e5e587d81e..8deef311b1 100644 --- a/compiler/passes/src/loop_unrolling/unroll_program.rs +++ b/compiler/passes/src/loop_unrolling/unroll_program.rs @@ -33,36 +33,18 @@ impl ProgramReconstructor for Unroller<'_> { } } - fn reconstruct_program_scope(&mut self, input: ProgramScope) -> ProgramScope { + fn reconstruct_program_scope(&mut self, mut input: ProgramScope) -> ProgramScope { // Set the current program. self.current_program = Some(input.program_id.name.name); - // Don't need to reconstructed consts, just need to add them to constant propagation table - input.consts.into_iter().for_each(|(_, c)| { - self.reconstruct_const(c); - }); - // Reconstruct the program scope - ProgramScope { - program_id: input.program_id, - structs: input.structs, - mappings: input.mappings, - functions: input.functions.into_iter().map(|(i, f)| (i, self.reconstruct_function(f))).collect(), - consts: Vec::new(), - span: input.span, - } + input.functions = input.functions.into_iter().map(|(i, f)| (i, self.reconstruct_function(f))).collect(); + input } // Reconstruct the function body, entering the associated scopes as needed. - fn reconstruct_function(&mut self, function: Function) -> Function { - self.in_scope(function.id(), |slf| Function { - annotations: function.annotations, - variant: function.variant, - identifier: function.identifier, - input: function.input, - output: function.output, - output_type: function.output_type, - block: slf.reconstruct_block(function.block).0, - span: function.span, - id: function.id, + fn reconstruct_function(&mut self, mut function: Function) -> Function { + self.in_scope(function.id(), |slf| { + function.block = slf.reconstruct_block(function.block).0; + function }) } } diff --git a/compiler/passes/src/loop_unrolling/unroll_statement.rs b/compiler/passes/src/loop_unrolling/unroll_statement.rs index f7009a1f8a..a35cbd579e 100644 --- a/compiler/passes/src/loop_unrolling/unroll_statement.rs +++ b/compiler/passes/src/loop_unrolling/unroll_statement.rs @@ -14,141 +14,48 @@ // You should have received a copy of the GNU General Public License // along with the Leo library. If not, see . -use itertools::Itertools; use leo_ast::{Expression::Literal, Type::Integer, *}; use leo_errors::loop_unroller::LoopUnrollerError; -use leo_span::{Span, Symbol}; -use crate::{VariableSymbol, VariableType, unroller::Unroller}; +use crate::unroller::Unroller; impl StatementReconstructor for Unroller<'_> { - fn reconstruct_block(&mut self, input: Block) -> (Block, Self::AdditionalOutput) { - let id = if self.is_unrolling { self.node_builder.next_id() } else { input.id }; - - self.in_scope(id, |slf| { - // Filter out the statements that have additional output = true - let filtered_statements: Vec<_> = input - .statements - .into_iter() - .filter_map(|s| { - let (reconstructed_statement, additional_output) = slf.reconstruct_statement(s); - if additional_output { - None // Exclude this statement from the block since it is a constant variable definition - } else { - Some(reconstructed_statement) - } - }) - .collect(); - - let block = Block { statements: filtered_statements, span: input.span, id: input.id }; - - (block, Default::default()) + fn reconstruct_block(&mut self, mut input: Block) -> (Block, Self::AdditionalOutput) { + self.in_scope(input.id(), |slf| { + input.statements = input.statements.into_iter().map(|stmt| slf.reconstruct_statement(stmt).0).collect(); + + (input, Default::default()) }) } fn reconstruct_const(&mut self, input: ConstDeclaration) -> (Statement, Self::AdditionalOutput) { - // Reconstruct the RHS expression to allow for constant propagation - let reconstructed_value_expression = self.reconstruct_expression(input.value.clone()).0; - - // Add to symbol table. - self.symbol_table.insert_const( - self.current_program.unwrap(), - input.place.name, - reconstructed_value_expression.clone(), - ); - - ( - Statement::Const(ConstDeclaration { - place: input.place, - type_: input.type_, - value: reconstructed_value_expression, - span: input.span, - id: input.id, - }), - true, - ) + (Statement::Const(input), Default::default()) } fn reconstruct_definition(&mut self, input: DefinitionStatement) -> (Statement, Self::AdditionalOutput) { - if !self.is_unrolling { - return ( - Statement::Definition(DefinitionStatement { - declaration_type: input.declaration_type, - place: input.place, - type_: input.type_, - value: self.reconstruct_expression(input.value).0, - span: input.span, - id: input.id, - }), - Default::default(), - ); - } + (Statement::Definition(input), Default::default()) + } - // Helper function to add variables to symbol table - let mut insert_variable = |symbol: Symbol, type_: Type, span: Span| { - if let Err(err) = self.symbol_table.insert_variable(self.current_program.unwrap(), symbol, VariableSymbol { - type_: type_.clone(), - span, - declaration: VariableType::Mut, - }) { - self.handler.emit_err(err); - } - }; + fn reconstruct_iteration(&mut self, input: IterationStatement) -> (Statement, Self::AdditionalOutput) { + self.loop_encountered = true; - // If we are unrolling a loop, then we need to repopulate the symbol table. - match &input.place { - Expression::Identifier(identifier) => { - insert_variable(identifier.name, input.type_.clone(), input.span); - } - Expression::Tuple(tuple_expression) => { - let tuple_type = match input.type_ { - Type::Tuple(ref tuple_type) => tuple_type, - _ => unreachable!( - "Type checking guarantees that if the lhs is a tuple, its associated type is also a tuple." - ), - }; - tuple_expression.elements.iter().zip_eq(tuple_type.elements().iter()).for_each(|(expression, _type_)| { - let identifier = match expression { - Expression::Identifier(identifier) => identifier, - _ => unreachable!("Type checking guarantees that if the lhs is a tuple, all of its elements are identifiers.") - }; - insert_variable(identifier.name, input.type_.clone(), input.span); - }); - } - _ => unreachable!( - "Type checking guarantees that the lhs of a `DefinitionStatement` is either an identifier or tuple." - ), - } + // There's no need to reconstruct the bound expressions - they must be constants + // which can be evaluated through constant propagation. - // Reconstruct the expression and return - ( - Statement::Definition(DefinitionStatement { - declaration_type: input.declaration_type, - place: input.place, - type_: input.type_, - value: self.reconstruct_expression(input.value).0, - span: input.span, - id: self.node_builder.next_id(), - }), - Default::default(), - ) - } + let Literal(start_lit) = &input.start else { + self.loop_not_unrolled = Some(input.start.span()); + return (Statement::Iteration(Box::new(input)), Default::default()); + }; - fn reconstruct_iteration(&mut self, input: IterationStatement) -> (Statement, Self::AdditionalOutput) { - // Reconstruct the bound expressions - let (new_start, _) = self.reconstruct_expression(input.start); - let (new_stop, _) = self.reconstruct_expression(input.stop); - - // Convert into values - match (new_start.clone(), new_stop.clone()) { - (Literal(start_lit), Literal(stop_lit)) => { - input.start_value.replace(Some(Value::try_from(&start_lit).unwrap())); - input.stop_value.replace(Some(Value::try_from(&stop_lit).unwrap())); - } - _ => unreachable!("Type checking guarantees that the loop bounds are literals."), + let Literal(stop_lit) = &input.stop else { + self.loop_not_unrolled = Some(input.stop.span()); + return (Statement::Iteration(Box::new(input)), Default::default()); }; - // Ensure loop bounds are increasing. This cannot be done in the type checker because constant propagation occurs in this pass. + input.start_value.replace(Some(Value::try_from(start_lit).unwrap())); + input.stop_value.replace(Some(Value::try_from(stop_lit).unwrap())); + + // Ensure loop bounds are increasing. This cannot be done in the type checker because constant propagation must happen first. if match (input.type_.clone(), input.start_value.borrow().as_ref(), input.stop_value.borrow().as_ref()) { (Integer(IntegerType::I8), Some(Value::I8(lower_bound, _)), Some(Value::I8(upper_bound, _))) => { lower_bound >= upper_bound @@ -182,23 +89,11 @@ impl StatementReconstructor for Unroller<'_> { } _ => unreachable!("Type checking guarantees that the loop bounds have same type as loop variable."), } { - self.emit_err(LoopUnrollerError::loop_range_decreasing(new_stop.span())); + self.emit_err(LoopUnrollerError::loop_range_decreasing(input.stop.span())); } - ( - self.unroll_iteration_statement::(IterationStatement { - variable: input.variable, - type_: input.type_, - start: new_start, - stop: new_stop, - start_value: input.start_value.clone(), - stop_value: input.stop_value.clone(), - inclusive: false, - block: input.block, - span: input.span, - id: input.id, - }), - Default::default(), - ) + self.loop_unrolled = true; + + (self.unroll_iteration_statement::(input), Default::default()) } } diff --git a/compiler/passes/src/loop_unrolling/unroller.rs b/compiler/passes/src/loop_unrolling/unroller.rs index 04ec7a30e5..3d6a17d404 100644 --- a/compiler/passes/src/loop_unrolling/unroller.rs +++ b/compiler/passes/src/loop_unrolling/unroller.rs @@ -19,6 +19,7 @@ use leo_ast::{ Expression, IterationStatement, Literal, + Node, NodeBuilder, NodeID, Statement, @@ -28,13 +29,13 @@ use leo_ast::{ }; use leo_errors::{emitter::Handler, loop_unroller::LoopUnrollerError}; -use leo_span::Symbol; +use leo_span::{Span, Symbol}; use crate::{Clusivity, LoopBound, RangeIterator, SymbolTable, TypeTable}; pub struct Unroller<'a> { /// The symbol table for the function being processed. - pub(crate) symbol_table: SymbolTable, + pub(crate) symbol_table: &'a mut SymbolTable, /// A mapping from node IDs to their types. pub(crate) type_table: &'a TypeTable, /// An error handler used for any errors found during unrolling. @@ -45,16 +46,32 @@ pub struct Unroller<'a> { pub(crate) is_unrolling: bool, /// The current program name. pub(crate) current_program: Option, + + pub(crate) loop_encountered: bool, + + pub(crate) loop_not_unrolled: Option, + + pub(crate) loop_unrolled: bool, } impl<'a> Unroller<'a> { pub(crate) fn new( - symbol_table: SymbolTable, + symbol_table: &'a mut SymbolTable, type_table: &'a TypeTable, handler: &'a Handler, node_builder: &'a NodeBuilder, ) -> Self { - Self { symbol_table, type_table, handler, node_builder, is_unrolling: false, current_program: None } + Self { + symbol_table, + type_table, + handler, + node_builder, + is_unrolling: false, + current_program: None, + loop_encountered: false, + loop_not_unrolled: None, + loop_unrolled: false, + } } pub(crate) fn in_scope(&mut self, id: NodeID, func: impl FnOnce(&mut Self) -> T) -> T { @@ -125,45 +142,33 @@ impl<'a> Unroller<'a> { // Update the type table. self.type_table.insert(const_id, input.type_.clone()); - let block_id = self.node_builder.next_id(); + let outer_block_id = self.node_builder.next_id(); // Reconstruct `iteration_count` as a `Literal`. let Type::Integer(integer_type) = &input.type_ else { unreachable!("Type checking enforces that the iteration variable is of integer type"); }; - self.in_scope(block_id, |slf| { - let prior_is_unrolling = slf.is_unrolling; - slf.is_unrolling = true; - + self.in_scope(outer_block_id, |slf| { let value = Literal::Integer(*integer_type, iteration_count.to_string(), Default::default(), const_id); - // Add the loop variable as a constant for the current scope + // Add the loop variable as a constant for the current scope. slf.symbol_table.insert_const( slf.current_program.unwrap(), input.variable.name, - Expression::Literal(value.clone()), + Expression::Literal(value), ); - // Reconstruct the statements in the loop body. - let statements: Vec<_> = input - .block - .statements - .clone() - .into_iter() - .filter_map(|s| { - let (reconstructed_statement, additional_output) = slf.reconstruct_statement(s); - if additional_output { - None // Exclude this statement from the block since it is a constant variable definition - } else { - Some(reconstructed_statement) - } - }) - .collect(); + let duplicated_body = super::duplicate::duplicate(input.block.clone(), slf.symbol_table, slf.node_builder); + + let prior_is_unrolling = slf.is_unrolling; + slf.is_unrolling = true; + + let result = Statement::Block(slf.reconstruct_block(duplicated_body).0); slf.is_unrolling = prior_is_unrolling; - Statement::Block(Block { statements, span: input.block.span, id: block_id }) + Statement::Block(Block { statements: vec![result], span: input.span(), id: outer_block_id }) }) } } diff --git a/compiler/passes/src/static_single_assignment/rename_statement.rs b/compiler/passes/src/static_single_assignment/rename_statement.rs index 4defd35824..fa5620422f 100644 --- a/compiler/passes/src/static_single_assignment/rename_statement.rs +++ b/compiler/passes/src/static_single_assignment/rename_statement.rs @@ -237,7 +237,8 @@ impl StatementConsumer for StaticSingleAssigner<'_> { } fn consume_const(&mut self, _: ConstDeclaration) -> Self::Output { - unreachable!("Loop unrolling pass removes all constant declaration statements in the program.") + // Constants have been propagated everywhere by this point, so we no longer need const declarations. + Default::default() } /// Consumes the `DefinitionStatement` into an `AssignStatement`, renaming the left-hand-side as appropriate. @@ -370,7 +371,7 @@ impl StatementConsumer for StaticSingleAssigner<'_> { })) } - _ => unreachable!("Type checking guarantees that expression statements are always function calls."), + _ => panic!("Type checking guarantees that expression statements are always function calls."), } statements diff --git a/compiler/passes/src/type_checking/check_statements.rs b/compiler/passes/src/type_checking/check_statements.rs index dbb0097128..216eba5cd5 100644 --- a/compiler/passes/src/type_checking/check_statements.rs +++ b/compiler/passes/src/type_checking/check_statements.rs @@ -166,22 +166,6 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> { _ => (), // Do nothing } - // Enforce that Constant variables have literal expressions on right-hand side - match &input.value { - Expression::Literal(_) => (), - Expression::Tuple(tuple_expression) => match tuple_expression.elements.len() { - 0 | 1 => unreachable!("Parsing guarantees that tuple types have at least two elements."), - _ => { - if tuple_expression.elements.iter().any(|expr| !matches!(expr, Expression::Literal(_))) { - self.emit_err(TypeCheckerError::const_declaration_must_be_literal_or_tuple_of_literals( - input.span, - )) - } - } - }, - _ => self.emit_err(TypeCheckerError::const_declaration_must_be_literal_or_tuple_of_literals(input.span())), - } - // Check the expression on the right-hand side. self.visit_expression(&input.value, &Some(input.type_.clone())); @@ -225,7 +209,7 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> { // Insert the variables into the symbol table. match &input.place { Expression::Identifier(identifier) => { - self.insert_variable(Some(inferred_type.clone()), identifier, input.type_.clone(), identifier.span) + self.insert_variable(Some(inferred_type.clone()), identifier, input.type_.clone(), identifier.span); } Expression::Tuple(tuple_expression) => { let tuple_type = match &input.type_ { @@ -306,46 +290,9 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> { slf.scope_state.has_called_finalize = prior_has_finalize; }); - // Check that the literal is valid. self.visit_expression(&input.start, &Some(input.type_.clone())); - // If `input.start` is a valid literal, instantiate it as a value. - match &input.start { - Expression::Literal(literal) => { - // Note that this check is needed because the pass attempts to make progress, even though the literal may be invalid. - if let Ok(value) = Value::try_from(literal) { - input.start_value.replace(Some(value)); - } - } - Expression::Identifier(id) => { - if let Some(var) = self.symbol_table.lookup_variable(self.scope_state.program_name.unwrap(), id.name) { - if VariableType::Const != var.declaration { - self.emit_err(TypeCheckerError::loop_bound_must_be_literal_or_const(id.span)); - } - } - } - _ => self.emit_err(TypeCheckerError::loop_bound_must_be_literal_or_const(input.start.span())), - } - self.visit_expression(&input.stop, &Some(input.type_.clone())); - - // If `input.stop` is a valid literal, instantiate it as a value. - match &input.stop { - Expression::Literal(literal) => { - // Note that this check is needed because the pass attempts to make progress, even though the literal may be invalid. - if let Ok(value) = Value::try_from(literal) { - input.stop_value.replace(Some(value)); - } - } - Expression::Identifier(id) => { - if let Some(var) = self.symbol_table.lookup_variable(self.scope_state.program_name.unwrap(), id.name) { - if VariableType::Const != var.declaration { - self.emit_err(TypeCheckerError::loop_bound_must_be_literal_or_const(id.span)); - } - } - } - _ => self.emit_err(TypeCheckerError::loop_bound_must_be_literal_or_const(input.stop.span())), - } } fn visit_return(&mut self, input: &'a ReturnStatement) { diff --git a/compiler/passes/src/type_checking/checker.rs b/compiler/passes/src/type_checking/checker.rs index 3b81da2e12..b65ef64198 100644 --- a/compiler/passes/src/type_checking/checker.rs +++ b/compiler/passes/src/type_checking/checker.rs @@ -40,7 +40,7 @@ pub struct NetworkLimits { pub struct TypeChecker<'a> { /// The symbol table for the program. - pub(crate) symbol_table: SymbolTable, + pub(crate) symbol_table: &'a mut SymbolTable, /// A mapping from node IDs to their types. pub(crate) type_table: &'a TypeTable, /// A dependency graph of the structs in program. @@ -66,7 +66,7 @@ pub struct TypeChecker<'a> { impl<'a> TypeChecker<'a> { /// Returns a new type checker given a symbol table and error handler. pub fn new( - symbol_table: SymbolTable, + symbol_table: &'a mut SymbolTable, type_table: &'a TypeTable, handler: &'a Handler, limits: NetworkLimits, diff --git a/compiler/passes/src/type_checking/mod.rs b/compiler/passes/src/type_checking/mod.rs index 5e3118faa8..80b5ac1350 100644 --- a/compiler/passes/src/type_checking/mod.rs +++ b/compiler/passes/src/type_checking/mod.rs @@ -32,8 +32,8 @@ use leo_ast::{Ast, ProgramVisitor}; use leo_errors::{Result, emitter::Handler}; impl<'a> Pass for TypeChecker<'a> { - type Input = (&'a Ast, &'a Handler, SymbolTable, &'a TypeTable, NetworkLimits); - type Output = Result<(SymbolTable, StructGraph, CallGraph)>; + type Input = (&'a Ast, &'a Handler, &'a mut SymbolTable, &'a TypeTable, NetworkLimits); + type Output = Result<(StructGraph, CallGraph)>; fn do_pass((ast, handler, symbol_table, type_table, limits): Self::Input) -> Self::Output { let mut visitor = TypeChecker::new(symbol_table, type_table, handler, limits); @@ -43,6 +43,6 @@ impl<'a> Pass for TypeChecker<'a> { // Remove unused structs from the struct graph. // This prevents unused struct definitions from being included in the generated bytecode. visitor.struct_graph.retain_nodes(&visitor.used_structs); - Ok((visitor.symbol_table, visitor.struct_graph, visitor.call_graph)) + Ok((visitor.struct_graph, visitor.call_graph)) } } diff --git a/compiler/span/src/symbol.rs b/compiler/span/src/symbol.rs index bd22d4704b..ef95c6be2a 100644 --- a/compiler/span/src/symbol.rs +++ b/compiler/span/src/symbol.rs @@ -292,6 +292,12 @@ pub struct Symbol( NonZeroU32, ); +impl Default for Symbol { + fn default() -> Self { + Symbol(NonZeroU32::MIN) + } +} + impl Symbol { /// Returns the corresponding `Symbol` for the given `index`. pub const fn new(index: u32) -> Self { diff --git a/errors/src/errors/compiler/compiler_errors.rs b/errors/src/errors/compiler/compiler_errors.rs index e92adfd80c..5f78f33ccb 100644 --- a/errors/src/errors/compiler/compiler_errors.rs +++ b/errors/src/errors/compiler/compiler_errors.rs @@ -77,4 +77,25 @@ create_messages!( msg: format!("`{main_program_name}` imports `{dependency_name}.aleo`, but `{dependency_name}.aleo` is not found in program manifest. Use `leo add --help` for more information on how to add a dependency."), help: None, } + + @formatted + const_not_evaluated { + args: (), + msg: "The value of this const could not be determined at compile time.".to_string(), + help: None, + } + + @formatted + loop_bounds_not_evaluated { + args: (), + msg: "This loop bound could not be determined at compile time.".to_string(), + help: None, + } + + @formatted + array_index_not_evaluated { + args: (), + msg: "This array index could not be determined at compile time.".to_string(), + help: None, + } ); diff --git a/errors/src/errors/loop_unroller/loop_unroller_errors.rs b/errors/src/errors/loop_unroller/loop_unroller_errors.rs index c99172def4..f4d4e4646d 100644 --- a/errors/src/errors/loop_unroller/loop_unroller_errors.rs +++ b/errors/src/errors/loop_unroller/loop_unroller_errors.rs @@ -30,6 +30,7 @@ create_messages!( help: None, } + // TODO This error is unused. Remove it in a future version. @formatted variable_array_access { args: (), diff --git a/errors/src/errors/loop_unroller/mod.rs b/errors/src/errors/loop_unroller/mod.rs index b12ed03ea2..880a49c9bd 100644 --- a/errors/src/errors/loop_unroller/mod.rs +++ b/errors/src/errors/loop_unroller/mod.rs @@ -14,6 +14,7 @@ // You should have received a copy of the GNU General Public License // along with the Leo library. If not, see . -/// This module contains the Input error definitions. +//! This module contains the loop unroller error definitions. + pub mod loop_unroller_errors; pub use self::loop_unroller_errors::*; diff --git a/errors/src/errors/static_analyzer/static_analyzer_error.rs b/errors/src/errors/static_analyzer/static_analyzer_error.rs index 20f5817d44..b336f6c92c 100644 --- a/errors/src/errors/static_analyzer/static_analyzer_error.rs +++ b/errors/src/errors/static_analyzer/static_analyzer_error.rs @@ -66,4 +66,32 @@ create_messages!( msg: "A future may not be used in this way".to_string(), help: Some("Futures should be created, assigned to a variable, and consumed without being moved or reassigned.".to_string()), } + + @formatted + compile_time_unary_op { + args: (value: impl Display, op: impl Display, err: impl Display), + msg: format!("Unary operation `{value}.{op}()` failed at compile time: {err}."), + help: None, + } + + @formatted + compile_time_binary_op { + args: (value_lhs: impl Display, value_rhs: impl Display, op: impl Display, err: impl Display), + msg: format!("Binary operation `{value_lhs} {op} {value_rhs}` failed at compile time: {err}."), + help: None, + } + + @formatted + compile_time_cast { + args: (value: impl Display, type_: impl Display), + msg: format!("Compile time cast failure: `{value} as {type_}`."), + help: None, + } + + @formatted + compile_core_function { + args: (err: impl Display), + msg: format!("Error during compile time evaluation of this core function: {err}."), + help: None, + } ); diff --git a/errors/src/errors/type_checker/type_checker_error.rs b/errors/src/errors/type_checker/type_checker_error.rs index decbb0fe36..045966bc07 100644 --- a/errors/src/errors/type_checker/type_checker_error.rs +++ b/errors/src/errors/type_checker/type_checker_error.rs @@ -587,6 +587,7 @@ create_messages!( help: None, } + // TODO This error is unused. Remove it in a future version. @formatted const_declaration_must_be_literal_or_tuple_of_literals { args: (), @@ -594,6 +595,7 @@ create_messages!( help: None, } + // TODO This error is unused. Remove it in a future version. @formatted loop_bound_must_be_literal_or_const { args: (), diff --git a/errors/src/lib.rs b/errors/src/lib.rs index 521784f345..57dfd2d7d2 100644 --- a/errors/src/lib.rs +++ b/errors/src/lib.rs @@ -15,7 +15,7 @@ // along with the Leo library. If not, see . #![forbid(unsafe_code)] -#![deny(clippy::all, clippy::missing_docs_in_private_items)] +#![deny(clippy::all)] #![doc = include_str!("../README.md")] #[macro_use] diff --git a/interpreter/Cargo.toml b/interpreter/Cargo.toml index 0e45902f41..e73ca49f9d 100644 --- a/interpreter/Cargo.toml +++ b/interpreter/Cargo.toml @@ -30,15 +30,9 @@ version = "1.0.0" [dependencies.leo-ast] workspace = true -[dependencies.leo-passes] -workspace = true - [dependencies.leo-errors] workspace = true -[dependencies.leo-package] -workspace = true - [dependencies.leo-parser] workspace = true diff --git a/interpreter/src/core_functions.rs b/interpreter/src/core_functions.rs new file mode 100644 index 0000000000..6337c46fae --- /dev/null +++ b/interpreter/src/core_functions.rs @@ -0,0 +1,1153 @@ +// Copyright (C) 2019-2024 Aleo Systems Inc. +// This file is part of the Leo library. + +// The Leo library is free software: you can redistribute it and/or modify +// it under the terms of the GNU General Public License as published by +// the Free Software Foundation, either version 3 of the License, or +// (at your option) any later version. + +// The Leo library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the +// GNU General Public License for more details. + +// You should have received a copy of the GNU General Public License +// along with the Leo library. If not, see . + +use super::*; + +use leo_ast::{CoreFunction, Expression}; +use leo_errors::Result; +use leo_span::{Span, Symbol}; + +use snarkvm::prelude::{CastLossy as _, Network as _, TestnetV0, ToBits}; + +use rand::Rng as _; +use rand_chacha::ChaCha20Rng; + +pub trait CoreFunctionHelper { + fn pop_value_impl(&mut self) -> Option; + + fn pop_value(&mut self) -> Result { + match self.pop_value_impl() { + Some(v) => Ok(v), + None => { + Err(InterpreterHalt::new("value expected - this may be a bug in the Leo interpreter".to_string()) + .into()) + } + } + } + + fn set_block_height(&mut self, _height: u32) {} + + fn lookup_mapping(&self, _program: Option, _name: Symbol) -> Option<&HashMap> { + None + } + + fn lookup_mapping_mut(&mut self, _program: Option, _name: Symbol) -> Option<&mut HashMap> { + None + } + + fn rng(&mut self) -> Option<&mut ChaCha20Rng> { + None + } +} + +impl CoreFunctionHelper for Vec { + fn pop_value_impl(&mut self) -> Option { + self.pop() + } +} + +pub fn evaluate_core_function( + helper: &mut dyn CoreFunctionHelper, + core_function: CoreFunction, + arguments: &[Expression], + span: Span, +) -> Result> { + macro_rules! apply { + ($func: expr, $value: ident, $to: ident) => {{ + let v = helper.pop_value()?; + let bits = v.$to(); + Value::$value($func(&bits).expect_tc(span)?) + }}; + } + + macro_rules! apply_cast { + ($func: expr, $value: ident, $to: ident) => {{ + let v = helper.pop_value()?; + let bits = v.$to(); + let group = $func(&bits).expect_tc(span)?; + let x = group.to_x_coordinate(); + Value::$value(x.cast_lossy()) + }}; + } + + macro_rules! apply_cast_int { + ($func: expr, $value: ident, $int_ty: ident, $to: ident) => {{ + let v = helper.pop_value()?; + let bits = v.$to(); + let group = $func(&bits).expect_tc(span)?; + let x = group.to_x_coordinate(); + let bits = x.to_bits_le(); + let mut result: $int_ty = 0; + for bit in 0..std::cmp::min($int_ty::BITS as usize, bits.len()) { + let setbit = (if bits[bit] { 1 } else { 0 }) << bit; + result |= setbit; + } + Value::$value(result) + }}; + } + + macro_rules! apply_cast2 { + ($func: expr, $value: ident) => {{ + let Value::Scalar(randomizer) = helper.pop_value()? else { + tc_fail!(); + }; + let v = helper.pop_value()?; + let bits = v.to_bits_le(); + let group = $func(&bits, &randomizer).expect_tc(span)?; + let x = group.to_x_coordinate(); + Value::$value(x.cast_lossy()) + }}; + } + + macro_rules! maybe_gen { + () => { + if let Some(rng) = helper.rng() { + rng.gen() + } else { + return Ok(None); + } + }; + } + + let value = match core_function { + CoreFunction::BHP256CommitToAddress => { + apply_cast2!(TestnetV0::commit_to_group_bhp256, Address) + } + CoreFunction::BHP256CommitToField => { + apply_cast2!(TestnetV0::commit_to_group_bhp256, Field) + } + CoreFunction::BHP256CommitToGroup => { + apply_cast2!(TestnetV0::commit_to_group_bhp256, Group) + } + CoreFunction::BHP256HashToAddress => { + apply_cast!(TestnetV0::hash_to_group_bhp256, Address, to_bits_le) + } + CoreFunction::BHP256HashToField => apply!(TestnetV0::hash_bhp256, Field, to_bits_le), + CoreFunction::BHP256HashToGroup => apply!(TestnetV0::hash_to_group_bhp256, Group, to_bits_le), + CoreFunction::BHP256HashToI8 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp256, I8, i8, to_bits_le) + } + CoreFunction::BHP256HashToI16 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp256, I16, i16, to_bits_le) + } + CoreFunction::BHP256HashToI32 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp256, I32, i32, to_bits_le) + } + CoreFunction::BHP256HashToI64 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp256, I64, i64, to_bits_le) + } + CoreFunction::BHP256HashToI128 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp256, I128, i128, to_bits_le) + } + CoreFunction::BHP256HashToU8 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp256, U8, u8, to_bits_le) + } + CoreFunction::BHP256HashToU16 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp256, U16, u16, to_bits_le) + } + CoreFunction::BHP256HashToU32 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp256, U32, u32, to_bits_le) + } + CoreFunction::BHP256HashToU64 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp256, U64, u64, to_bits_le) + } + CoreFunction::BHP256HashToU128 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp256, U128, u128, to_bits_le) + } + CoreFunction::BHP256HashToScalar => { + apply_cast!(TestnetV0::hash_to_group_bhp256, Scalar, to_bits_le) + } + CoreFunction::BHP512CommitToAddress => { + apply_cast2!(TestnetV0::commit_to_group_bhp512, Address) + } + CoreFunction::BHP512CommitToField => { + apply_cast2!(TestnetV0::commit_to_group_bhp512, Field) + } + CoreFunction::BHP512CommitToGroup => { + apply_cast2!(TestnetV0::commit_to_group_bhp512, Group) + } + CoreFunction::BHP512HashToAddress => { + apply_cast!(TestnetV0::hash_to_group_bhp512, Address, to_bits_le) + } + CoreFunction::BHP512HashToField => apply!(TestnetV0::hash_bhp512, Field, to_bits_le), + CoreFunction::BHP512HashToGroup => apply!(TestnetV0::hash_to_group_bhp512, Group, to_bits_le), + CoreFunction::BHP512HashToI8 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp512, I8, i8, to_bits_le) + } + CoreFunction::BHP512HashToI16 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp512, I16, i16, to_bits_le) + } + CoreFunction::BHP512HashToI32 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp512, I32, i32, to_bits_le) + } + CoreFunction::BHP512HashToI64 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp512, I64, i64, to_bits_le) + } + CoreFunction::BHP512HashToI128 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp512, I128, i128, to_bits_le) + } + CoreFunction::BHP512HashToU8 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp512, U8, u8, to_bits_le) + } + CoreFunction::BHP512HashToU16 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp512, U16, u16, to_bits_le) + } + CoreFunction::BHP512HashToU32 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp512, U32, u32, to_bits_le) + } + CoreFunction::BHP512HashToU64 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp512, U64, u64, to_bits_le) + } + CoreFunction::BHP512HashToU128 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp512, U128, u128, to_bits_le) + } + CoreFunction::BHP512HashToScalar => { + apply_cast!(TestnetV0::hash_to_group_bhp512, Scalar, to_bits_le) + } + CoreFunction::BHP768CommitToAddress => { + apply_cast2!(TestnetV0::commit_to_group_bhp768, Address) + } + CoreFunction::BHP768CommitToField => { + apply_cast2!(TestnetV0::commit_to_group_bhp768, Field) + } + CoreFunction::BHP768CommitToGroup => { + apply_cast2!(TestnetV0::commit_to_group_bhp768, Group) + } + CoreFunction::BHP768HashToAddress => { + apply_cast!(TestnetV0::hash_to_group_bhp768, Address, to_bits_le) + } + CoreFunction::BHP768HashToField => apply!(TestnetV0::hash_bhp768, Field, to_bits_le), + CoreFunction::BHP768HashToGroup => apply!(TestnetV0::hash_to_group_bhp768, Group, to_bits_le), + CoreFunction::BHP768HashToI8 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp768, I8, i8, to_bits_le) + } + CoreFunction::BHP768HashToI16 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp768, I16, i16, to_bits_le) + } + CoreFunction::BHP768HashToI32 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp768, I32, i32, to_bits_le) + } + CoreFunction::BHP768HashToI64 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp768, I64, i64, to_bits_le) + } + CoreFunction::BHP768HashToI128 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp768, I128, i128, to_bits_le) + } + CoreFunction::BHP768HashToU8 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp768, U8, u8, to_bits_le) + } + CoreFunction::BHP768HashToU16 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp768, U16, u16, to_bits_le) + } + CoreFunction::BHP768HashToU32 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp768, U32, u32, to_bits_le) + } + CoreFunction::BHP768HashToU64 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp768, U64, u64, to_bits_le) + } + CoreFunction::BHP768HashToU128 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp768, U128, u128, to_bits_le) + } + CoreFunction::BHP768HashToScalar => { + apply_cast!(TestnetV0::hash_to_group_bhp768, Scalar, to_bits_le) + } + CoreFunction::BHP1024CommitToAddress => { + apply_cast2!(TestnetV0::commit_to_group_bhp1024, Address) + } + CoreFunction::BHP1024CommitToField => { + apply_cast2!(TestnetV0::commit_to_group_bhp1024, Field) + } + CoreFunction::BHP1024CommitToGroup => { + apply_cast2!(TestnetV0::commit_to_group_bhp1024, Group) + } + CoreFunction::BHP1024HashToAddress => { + apply_cast!(TestnetV0::hash_to_group_bhp1024, Address, to_bits_le) + } + CoreFunction::BHP1024HashToField => apply!(TestnetV0::hash_bhp1024, Field, to_bits_le), + CoreFunction::BHP1024HashToGroup => apply!(TestnetV0::hash_to_group_bhp1024, Group, to_bits_le), + CoreFunction::BHP1024HashToI8 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp1024, I8, i8, to_bits_le) + } + CoreFunction::BHP1024HashToI16 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp1024, I16, i16, to_bits_le) + } + CoreFunction::BHP1024HashToI32 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp1024, I32, i32, to_bits_le) + } + CoreFunction::BHP1024HashToI64 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp1024, I64, i64, to_bits_le) + } + CoreFunction::BHP1024HashToI128 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp1024, I128, i128, to_bits_le) + } + CoreFunction::BHP1024HashToU8 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp1024, U8, u8, to_bits_le) + } + CoreFunction::BHP1024HashToU16 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp1024, U16, u16, to_bits_le) + } + CoreFunction::BHP1024HashToU32 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp1024, U32, u32, to_bits_le) + } + CoreFunction::BHP1024HashToU64 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp1024, U64, u64, to_bits_le) + } + CoreFunction::BHP1024HashToU128 => { + apply_cast_int!(TestnetV0::hash_to_group_bhp1024, U128, u128, to_bits_le) + } + CoreFunction::BHP1024HashToScalar => { + apply_cast!(TestnetV0::hash_to_group_bhp1024, Scalar, to_bits_le) + } + CoreFunction::Keccak256HashToAddress => apply_cast!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_keccak256(v).expect_tc(span)?), + Address, + to_bits_le + ), + CoreFunction::Keccak256HashToField => apply_cast!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_keccak256(v).expect_tc(span)?), + Field, + to_bits_le + ), + CoreFunction::Keccak256HashToGroup => { + apply!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_keccak256(v).expect_tc(span)?), + Group, + to_bits_le + ) + } + CoreFunction::Keccak256HashToI8 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_keccak256(v).expect_tc(span)?), + I8, + i8, + to_bits_le + ), + CoreFunction::Keccak256HashToI16 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_keccak256(v).expect_tc(span)?), + I16, + i16, + to_bits_le + ), + + CoreFunction::Keccak256HashToI32 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_keccak256(v).expect_tc(span)?), + I32, + i32, + to_bits_le + ), + CoreFunction::Keccak256HashToI64 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_keccak256(v).expect_tc(span)?), + I64, + i64, + to_bits_le + ), + CoreFunction::Keccak256HashToI128 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_keccak256(v).expect_tc(span)?), + I128, + i128, + to_bits_le + ), + CoreFunction::Keccak256HashToU8 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_keccak256(v).expect_tc(span)?), + U8, + u8, + to_bits_le + ), + CoreFunction::Keccak256HashToU16 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_keccak256(v).expect_tc(span)?), + U16, + u16, + to_bits_le + ), + CoreFunction::Keccak256HashToU32 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_keccak256(v).expect_tc(span)?), + U32, + u32, + to_bits_le + ), + CoreFunction::Keccak256HashToU64 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_keccak256(v).expect_tc(span)?), + U64, + u64, + to_bits_le + ), + CoreFunction::Keccak256HashToU128 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_keccak256(v).expect_tc(span)?), + U128, + u128, + to_bits_le + ), + CoreFunction::Keccak256HashToScalar => apply_cast!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_keccak256(v).expect_tc(span)?), + Scalar, + to_bits_le + ), + CoreFunction::Keccak384HashToAddress => apply_cast!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak384(v).expect_tc(span)?), + Address, + to_bits_le + ), + CoreFunction::Keccak384HashToField => apply_cast!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak384(v).expect_tc(span)?), + Field, + to_bits_le + ), + CoreFunction::Keccak384HashToGroup => { + apply!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak384(v).expect_tc(span)?), + Group, + to_bits_le + ) + } + CoreFunction::Keccak384HashToI8 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak384(v).expect_tc(span)?), + I8, + i8, + to_bits_le + ), + CoreFunction::Keccak384HashToI16 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak384(v).expect_tc(span)?), + I16, + i16, + to_bits_le + ), + CoreFunction::Keccak384HashToI32 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak384(v).expect_tc(span)?), + I32, + i32, + to_bits_le + ), + CoreFunction::Keccak384HashToI64 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak384(v).expect_tc(span)?), + I64, + i64, + to_bits_le + ), + CoreFunction::Keccak384HashToI128 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak384(v).expect_tc(span)?), + I128, + i128, + to_bits_le + ), + CoreFunction::Keccak384HashToU8 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak384(v).expect_tc(span)?), + U8, + u8, + to_bits_le + ), + CoreFunction::Keccak384HashToU16 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak384(v).expect_tc(span)?), + U16, + u16, + to_bits_le + ), + CoreFunction::Keccak384HashToU32 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak384(v).expect_tc(span)?), + U32, + u32, + to_bits_le + ), + CoreFunction::Keccak384HashToU64 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak384(v).expect_tc(span)?), + U64, + u64, + to_bits_le + ), + CoreFunction::Keccak384HashToU128 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak384(v).expect_tc(span)?), + U128, + u128, + to_bits_le + ), + CoreFunction::Keccak384HashToScalar => apply_cast!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak384(v).expect_tc(span)?), + Scalar, + to_bits_le + ), + CoreFunction::Keccak512HashToAddress => apply_cast!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak512(v).expect_tc(span)?), + Address, + to_bits_le + ), + CoreFunction::Keccak512HashToField => apply_cast!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak512(v).expect_tc(span)?), + Field, + to_bits_le + ), + CoreFunction::Keccak512HashToGroup => { + apply!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak512(v).expect_tc(span)?), + Group, + to_bits_le + ) + } + CoreFunction::Keccak512HashToI8 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak512(v).expect_tc(span)?), + I8, + i8, + to_bits_le + ), + CoreFunction::Keccak512HashToI16 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak512(v).expect_tc(span)?), + I16, + i16, + to_bits_le + ), + CoreFunction::Keccak512HashToI32 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak512(v).expect_tc(span)?), + I32, + i32, + to_bits_le + ), + CoreFunction::Keccak512HashToI64 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak512(v).expect_tc(span)?), + I64, + i64, + to_bits_le + ), + CoreFunction::Keccak512HashToI128 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak512(v).expect_tc(span)?), + I128, + i128, + to_bits_le + ), + CoreFunction::Keccak512HashToU8 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak512(v).expect_tc(span)?), + U8, + u8, + to_bits_le + ), + CoreFunction::Keccak512HashToU16 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak512(v).expect_tc(span)?), + U16, + u16, + to_bits_le + ), + CoreFunction::Keccak512HashToU32 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak512(v).expect_tc(span)?), + U32, + u32, + to_bits_le + ), + CoreFunction::Keccak512HashToU64 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak512(v).expect_tc(span)?), + U64, + u64, + to_bits_le + ), + CoreFunction::Keccak512HashToU128 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak512(v).expect_tc(span)?), + U128, + u128, + to_bits_le + ), + CoreFunction::Keccak512HashToScalar => apply_cast!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_keccak512(v).expect_tc(span)?), + Scalar, + to_bits_le + ), + CoreFunction::Pedersen64CommitToAddress => { + apply_cast2!(TestnetV0::commit_to_group_ped64, Address) + } + CoreFunction::Pedersen64CommitToField => { + apply_cast2!(TestnetV0::commit_to_group_ped64, Field) + } + CoreFunction::Pedersen64CommitToGroup => { + apply_cast2!(TestnetV0::commit_to_group_ped64, Group) + } + CoreFunction::Pedersen64HashToAddress => { + apply_cast!(TestnetV0::hash_to_group_ped64, Address, to_bits_le) + } + CoreFunction::Pedersen64HashToField => apply!(TestnetV0::hash_ped64, Field, to_bits_le), + CoreFunction::Pedersen64HashToGroup => apply!(TestnetV0::hash_to_group_ped64, Group, to_bits_le), + CoreFunction::Pedersen64HashToI8 => { + apply_cast_int!(TestnetV0::hash_to_group_ped64, I8, i8, to_bits_le) + } + CoreFunction::Pedersen64HashToI16 => { + apply_cast_int!(TestnetV0::hash_to_group_ped64, I16, i16, to_bits_le) + } + CoreFunction::Pedersen64HashToI32 => { + apply_cast_int!(TestnetV0::hash_to_group_ped64, I32, i32, to_bits_le) + } + CoreFunction::Pedersen64HashToI64 => { + apply_cast_int!(TestnetV0::hash_to_group_ped64, I64, i64, to_bits_le) + } + CoreFunction::Pedersen64HashToI128 => { + apply_cast_int!(TestnetV0::hash_to_group_ped64, I128, i128, to_bits_le) + } + CoreFunction::Pedersen64HashToU8 => { + apply_cast_int!(TestnetV0::hash_to_group_ped64, U8, u8, to_bits_le) + } + CoreFunction::Pedersen64HashToU16 => { + apply_cast_int!(TestnetV0::hash_to_group_ped64, U16, u16, to_bits_le) + } + CoreFunction::Pedersen64HashToU32 => { + apply_cast_int!(TestnetV0::hash_to_group_ped64, U32, u32, to_bits_le) + } + CoreFunction::Pedersen64HashToU64 => { + apply_cast_int!(TestnetV0::hash_to_group_ped64, U64, u64, to_bits_le) + } + CoreFunction::Pedersen64HashToU128 => { + apply_cast_int!(TestnetV0::hash_to_group_ped64, U128, u128, to_bits_le) + } + CoreFunction::Pedersen64HashToScalar => { + apply_cast!(TestnetV0::hash_to_group_ped64, Scalar, to_bits_le) + } + CoreFunction::Pedersen128HashToAddress => { + apply_cast!(TestnetV0::hash_to_group_ped128, Address, to_bits_le) + } + CoreFunction::Pedersen128HashToField => { + apply_cast!(TestnetV0::hash_to_group_ped128, Field, to_bits_le) + } + CoreFunction::Pedersen128HashToGroup => { + apply_cast!(TestnetV0::hash_to_group_ped128, Group, to_bits_le) + } + CoreFunction::Pedersen128HashToI8 => { + apply_cast_int!(TestnetV0::hash_to_group_ped128, I8, i8, to_bits_le) + } + CoreFunction::Pedersen128HashToI16 => { + apply_cast_int!(TestnetV0::hash_to_group_ped64, I16, i16, to_bits_le) + } + CoreFunction::Pedersen128HashToI32 => { + apply_cast_int!(TestnetV0::hash_to_group_ped128, I32, i32, to_bits_le) + } + CoreFunction::Pedersen128HashToI64 => { + apply_cast_int!(TestnetV0::hash_to_group_ped64, I64, i64, to_bits_le) + } + CoreFunction::Pedersen128HashToI128 => { + apply_cast_int!(TestnetV0::hash_to_group_ped128, I128, i128, to_bits_le) + } + CoreFunction::Pedersen128HashToU8 => { + apply_cast_int!(TestnetV0::hash_to_group_ped128, U8, u8, to_bits_le) + } + CoreFunction::Pedersen128HashToU16 => { + apply_cast_int!(TestnetV0::hash_to_group_ped64, U16, u16, to_bits_le) + } + CoreFunction::Pedersen128HashToU32 => { + apply_cast_int!(TestnetV0::hash_to_group_ped128, U32, u32, to_bits_le) + } + CoreFunction::Pedersen128HashToU64 => { + apply_cast_int!(TestnetV0::hash_to_group_ped64, U64, u64, to_bits_le) + } + CoreFunction::Pedersen128HashToU128 => { + apply_cast_int!(TestnetV0::hash_to_group_ped128, U128, u128, to_bits_le) + } + CoreFunction::Pedersen128HashToScalar => { + apply_cast!(TestnetV0::hash_to_group_ped128, Scalar, to_bits_le) + } + CoreFunction::Pedersen128CommitToAddress => { + apply_cast2!(TestnetV0::commit_to_group_ped128, Address) + } + CoreFunction::Pedersen128CommitToField => { + apply_cast2!(TestnetV0::commit_to_group_ped128, Field) + } + CoreFunction::Pedersen128CommitToGroup => { + apply_cast2!(TestnetV0::commit_to_group_ped128, Group) + } + CoreFunction::Poseidon2HashToAddress => { + apply_cast!(TestnetV0::hash_to_group_psd2, Address, to_fields) + } + CoreFunction::Poseidon2HashToField => { + apply!(TestnetV0::hash_psd2, Field, to_fields) + } + CoreFunction::Poseidon2HashToGroup => { + apply_cast!(TestnetV0::hash_to_group_psd2, Group, to_fields) + } + CoreFunction::Poseidon2HashToI8 => { + apply_cast_int!(TestnetV0::hash_to_group_psd2, I8, i8, to_fields) + } + CoreFunction::Poseidon2HashToI16 => { + apply_cast_int!(TestnetV0::hash_to_group_psd2, I16, i16, to_fields) + } + CoreFunction::Poseidon2HashToI32 => { + apply_cast_int!(TestnetV0::hash_to_group_psd2, I32, i32, to_fields) + } + CoreFunction::Poseidon2HashToI64 => { + apply_cast_int!(TestnetV0::hash_to_group_psd2, I64, i64, to_fields) + } + CoreFunction::Poseidon2HashToI128 => { + apply_cast_int!(TestnetV0::hash_to_group_psd2, I128, i128, to_fields) + } + CoreFunction::Poseidon2HashToU8 => { + apply_cast_int!(TestnetV0::hash_to_group_psd2, U8, u8, to_fields) + } + CoreFunction::Poseidon2HashToU16 => { + apply_cast_int!(TestnetV0::hash_to_group_psd2, U16, u16, to_fields) + } + CoreFunction::Poseidon2HashToU32 => { + apply_cast_int!(TestnetV0::hash_to_group_psd2, U32, u32, to_fields) + } + CoreFunction::Poseidon2HashToU64 => { + apply_cast_int!(TestnetV0::hash_to_group_psd2, U64, u64, to_fields) + } + CoreFunction::Poseidon2HashToU128 => { + apply_cast_int!(TestnetV0::hash_to_group_psd2, U128, u128, to_fields) + } + CoreFunction::Poseidon2HashToScalar => { + apply_cast!(TestnetV0::hash_to_group_psd4, Scalar, to_fields) + } + CoreFunction::Poseidon4HashToAddress => { + apply_cast!(TestnetV0::hash_to_group_psd4, Address, to_fields) + } + CoreFunction::Poseidon4HashToField => { + apply!(TestnetV0::hash_psd4, Field, to_fields) + } + CoreFunction::Poseidon4HashToGroup => { + apply_cast!(TestnetV0::hash_to_group_psd4, Group, to_fields) + } + CoreFunction::Poseidon4HashToI8 => { + apply_cast_int!(TestnetV0::hash_to_group_psd4, I8, i8, to_fields) + } + CoreFunction::Poseidon4HashToI16 => { + apply_cast_int!(TestnetV0::hash_to_group_psd4, I16, i16, to_fields) + } + CoreFunction::Poseidon4HashToI32 => { + apply_cast_int!(TestnetV0::hash_to_group_psd4, I32, i32, to_fields) + } + CoreFunction::Poseidon4HashToI64 => { + apply_cast_int!(TestnetV0::hash_to_group_psd4, I64, i64, to_fields) + } + CoreFunction::Poseidon4HashToI128 => { + apply_cast_int!(TestnetV0::hash_to_group_psd4, I128, i128, to_fields) + } + CoreFunction::Poseidon4HashToU8 => { + apply_cast_int!(TestnetV0::hash_to_group_psd4, U8, u8, to_fields) + } + CoreFunction::Poseidon4HashToU16 => { + apply_cast_int!(TestnetV0::hash_to_group_psd4, U16, u16, to_fields) + } + CoreFunction::Poseidon4HashToU32 => { + apply_cast_int!(TestnetV0::hash_to_group_psd4, U32, u32, to_fields) + } + CoreFunction::Poseidon4HashToU64 => { + apply_cast_int!(TestnetV0::hash_to_group_psd4, U64, u64, to_fields) + } + CoreFunction::Poseidon4HashToU128 => { + apply_cast_int!(TestnetV0::hash_to_group_psd4, U128, u128, to_fields) + } + CoreFunction::Poseidon4HashToScalar => { + apply_cast!(TestnetV0::hash_to_group_psd4, Scalar, to_fields) + } + CoreFunction::Poseidon8HashToAddress => { + apply_cast!(TestnetV0::hash_to_group_psd8, Address, to_fields) + } + CoreFunction::Poseidon8HashToField => { + apply!(TestnetV0::hash_psd8, Field, to_fields) + } + CoreFunction::Poseidon8HashToGroup => { + apply_cast!(TestnetV0::hash_to_group_psd8, Group, to_fields) + } + CoreFunction::Poseidon8HashToI8 => { + apply_cast_int!(TestnetV0::hash_to_group_psd8, I8, i8, to_fields) + } + CoreFunction::Poseidon8HashToI16 => { + apply_cast_int!(TestnetV0::hash_to_group_psd8, I16, i16, to_fields) + } + CoreFunction::Poseidon8HashToI32 => { + apply_cast_int!(TestnetV0::hash_to_group_psd8, I32, i32, to_fields) + } + CoreFunction::Poseidon8HashToI64 => { + apply_cast_int!(TestnetV0::hash_to_group_psd8, I64, i64, to_fields) + } + CoreFunction::Poseidon8HashToI128 => { + apply_cast_int!(TestnetV0::hash_to_group_psd8, I128, i128, to_fields) + } + CoreFunction::Poseidon8HashToU8 => { + apply_cast_int!(TestnetV0::hash_to_group_psd8, U8, u8, to_fields) + } + CoreFunction::Poseidon8HashToU16 => { + apply_cast_int!(TestnetV0::hash_to_group_psd8, U16, u16, to_fields) + } + CoreFunction::Poseidon8HashToU32 => { + apply_cast_int!(TestnetV0::hash_to_group_psd8, U32, u32, to_fields) + } + CoreFunction::Poseidon8HashToU64 => { + apply_cast_int!(TestnetV0::hash_to_group_psd8, U64, u64, to_fields) + } + CoreFunction::Poseidon8HashToU128 => { + apply_cast_int!(TestnetV0::hash_to_group_psd8, U128, u128, to_fields) + } + CoreFunction::Poseidon8HashToScalar => { + apply_cast!(TestnetV0::hash_to_group_psd8, Scalar, to_fields) + } + CoreFunction::SHA3_256HashToAddress => apply_cast!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_sha3_256(v).expect_tc(span)?), + Address, + to_bits_le + ), + CoreFunction::SHA3_256HashToField => apply_cast!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_sha3_256(v).expect_tc(span)?), + Field, + to_bits_le + ), + CoreFunction::SHA3_256HashToGroup => apply_cast!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_sha3_256(v).expect_tc(span)?), + Group, + to_bits_le + ), + CoreFunction::SHA3_256HashToI8 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_sha3_256(v).expect_tc(span)?), + I8, + i8, + to_bits_le + ), + CoreFunction::SHA3_256HashToI16 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_sha3_256(v).expect_tc(span)?), + I16, + i16, + to_bits_le + ), + CoreFunction::SHA3_256HashToI32 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_sha3_256(v).expect_tc(span)?), + I32, + i32, + to_bits_le + ), + CoreFunction::SHA3_256HashToI64 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_sha3_256(v).expect_tc(span)?), + I64, + i64, + to_bits_le + ), + CoreFunction::SHA3_256HashToI128 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_sha3_256(v).expect_tc(span)?), + I128, + i128, + to_bits_le + ), + CoreFunction::SHA3_256HashToU8 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_sha3_256(v).expect_tc(span)?), + U8, + u8, + to_bits_le + ), + CoreFunction::SHA3_256HashToU16 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_sha3_256(v).expect_tc(span)?), + U16, + u16, + to_bits_le + ), + CoreFunction::SHA3_256HashToU32 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_sha3_256(v).expect_tc(span)?), + U32, + u32, + to_bits_le + ), + CoreFunction::SHA3_256HashToU64 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_sha3_256(v).expect_tc(span)?), + U64, + u64, + to_bits_le + ), + CoreFunction::SHA3_256HashToU128 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_sha3_256(v).expect_tc(span)?), + U128, + u128, + to_bits_le + ), + CoreFunction::SHA3_256HashToScalar => apply_cast!( + |v| TestnetV0::hash_to_group_bhp256(&TestnetV0::hash_sha3_256(v).expect_tc(span)?), + Scalar, + to_bits_le + ), + CoreFunction::SHA3_384HashToAddress => apply_cast!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_384(v).expect_tc(span)?), + Address, + to_bits_le + ), + CoreFunction::SHA3_384HashToField => apply_cast!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_384(v).expect_tc(span)?), + Field, + to_bits_le + ), + CoreFunction::SHA3_384HashToGroup => apply_cast!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_384(v).expect_tc(span)?), + Group, + to_bits_le + ), + CoreFunction::SHA3_384HashToI8 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_384(v).expect_tc(span)?), + I8, + i8, + to_bits_le + ), + CoreFunction::SHA3_384HashToI16 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_384(v).expect_tc(span)?), + I16, + i16, + to_bits_le + ), + CoreFunction::SHA3_384HashToI32 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_384(v).expect_tc(span)?), + I32, + i32, + to_bits_le + ), + CoreFunction::SHA3_384HashToI64 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_384(v).expect_tc(span)?), + I64, + i64, + to_bits_le + ), + CoreFunction::SHA3_384HashToI128 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_384(v).expect_tc(span)?), + I128, + i128, + to_bits_le + ), + CoreFunction::SHA3_384HashToU8 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_384(v).expect_tc(span)?), + U8, + u8, + to_bits_le + ), + CoreFunction::SHA3_384HashToU16 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_384(v).expect_tc(span)?), + U16, + u16, + to_bits_le + ), + CoreFunction::SHA3_384HashToU32 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_384(v).expect_tc(span)?), + U32, + u32, + to_bits_le + ), + CoreFunction::SHA3_384HashToU64 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_384(v).expect_tc(span)?), + U64, + u64, + to_bits_le + ), + CoreFunction::SHA3_384HashToU128 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_384(v).expect_tc(span)?), + U128, + u128, + to_bits_le + ), + CoreFunction::SHA3_384HashToScalar => apply_cast!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_384(v).expect_tc(span)?), + Scalar, + to_bits_le + ), + CoreFunction::SHA3_512HashToAddress => apply_cast!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_512(v).expect_tc(span)?), + Address, + to_bits_le + ), + CoreFunction::SHA3_512HashToField => apply_cast!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_512(v).expect_tc(span)?), + Field, + to_bits_le + ), + CoreFunction::SHA3_512HashToGroup => apply_cast!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_512(v).expect_tc(span)?), + Group, + to_bits_le + ), + CoreFunction::SHA3_512HashToI8 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_512(v).expect_tc(span)?), + I8, + i8, + to_bits_le + ), + CoreFunction::SHA3_512HashToI16 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_512(v).expect_tc(span)?), + I16, + i16, + to_bits_le + ), + CoreFunction::SHA3_512HashToI32 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_512(v).expect_tc(span)?), + I32, + i32, + to_bits_le + ), + CoreFunction::SHA3_512HashToI64 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_512(v).expect_tc(span)?), + I64, + i64, + to_bits_le + ), + CoreFunction::SHA3_512HashToI128 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_512(v).expect_tc(span)?), + I128, + i128, + to_bits_le + ), + CoreFunction::SHA3_512HashToU8 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_512(v).expect_tc(span)?), + U8, + u8, + to_bits_le + ), + CoreFunction::SHA3_512HashToU16 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_512(v).expect_tc(span)?), + U16, + u16, + to_bits_le + ), + CoreFunction::SHA3_512HashToU32 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_512(v).expect_tc(span)?), + U32, + u32, + to_bits_le + ), + CoreFunction::SHA3_512HashToU64 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_512(v).expect_tc(span)?), + U64, + u64, + to_bits_le + ), + CoreFunction::SHA3_512HashToU128 => apply_cast_int!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_512(v).expect_tc(span)?), + U128, + u128, + to_bits_le + ), + CoreFunction::SHA3_512HashToScalar => apply_cast!( + |v| TestnetV0::hash_to_group_bhp512(&TestnetV0::hash_sha3_512(v).expect_tc(span)?), + Scalar, + to_bits_le + ), + CoreFunction::GroupToXCoordinate => { + let Value::Group(g) = helper.pop_value()? else { + tc_fail!(); + }; + Value::Field(g.to_x_coordinate()) + } + CoreFunction::GroupToYCoordinate => { + let Value::Group(g) = helper.pop_value()? else { + tc_fail!(); + }; + Value::Field(g.to_y_coordinate()) + } + CoreFunction::ChaChaRandAddress => Value::Address(maybe_gen!()), + CoreFunction::ChaChaRandBool => Value::Bool(maybe_gen!()), + CoreFunction::ChaChaRandField => Value::Field(maybe_gen!()), + CoreFunction::ChaChaRandGroup => Value::Group(maybe_gen!()), + CoreFunction::ChaChaRandI8 => Value::I8(maybe_gen!()), + CoreFunction::ChaChaRandI16 => Value::I16(maybe_gen!()), + CoreFunction::ChaChaRandI32 => Value::I32(maybe_gen!()), + CoreFunction::ChaChaRandI64 => Value::I64(maybe_gen!()), + CoreFunction::ChaChaRandI128 => Value::I128(maybe_gen!()), + CoreFunction::ChaChaRandU8 => Value::U8(maybe_gen!()), + CoreFunction::ChaChaRandU16 => Value::U16(maybe_gen!()), + CoreFunction::ChaChaRandU32 => Value::U32(maybe_gen!()), + CoreFunction::ChaChaRandU64 => Value::U64(maybe_gen!()), + CoreFunction::ChaChaRandU128 => Value::U128(maybe_gen!()), + CoreFunction::ChaChaRandScalar => Value::Scalar(maybe_gen!()), + CoreFunction::CheatCodePrintMapping => { + let (program, name) = match &arguments[0] { + Expression::Identifier(id) => (None, id.name), + Expression::Locator(locator) => (Some(locator.program.name.name), locator.name), + _ => tc_fail!(), + }; + if let Some(mapping) = helper.lookup_mapping(program, name) { + // TODO: What is the appropriate way to print this to the console. + // Print the name of the mapping. + println!( + "Mapping: {}", + if let Some(program) = program { format!("{}/{}", program, name) } else { name.to_string() } + ); + // Print the contents of the mapping. + for (key, value) in mapping { + println!(" {} -> {}", key, value); + } + } else { + tc_fail!(); + } + Value::Unit + } + CoreFunction::CheatCodeSetBlockHeight => { + let Value::U32(height) = helper.pop_value()? else { + tc_fail!(); + }; + helper.set_block_height(height); + Value::Unit + } + CoreFunction::MappingGet => { + let key = helper.pop_value().expect_tc(span)?; + let (program, name) = match &arguments[0] { + Expression::Identifier(id) => (None, id.name), + Expression::Locator(locator) => (Some(locator.program.name.name), locator.name), + _ => tc_fail!(), + }; + match helper.lookup_mapping(program, name).and_then(|mapping| mapping.get(&key)) { + Some(v) => v.clone(), + None => halt!(span, "map lookup failure"), + } + } + CoreFunction::MappingGetOrUse => { + let use_value = helper.pop_value().expect_tc(span)?; + let key = helper.pop_value().expect_tc(span)?; + let (program, name) = match &arguments[0] { + Expression::Identifier(id) => (None, id.name), + Expression::Locator(locator) => (Some(locator.program.name.name), locator.name), + _ => tc_fail!(), + }; + match helper.lookup_mapping(program, name).and_then(|mapping| mapping.get(&key)) { + Some(v) => v.clone(), + None => use_value, + } + } + CoreFunction::MappingSet => { + let value = helper.pop_value()?; + let key = helper.pop_value()?; + let (program, name) = match &arguments[0] { + Expression::Identifier(id) => (None, id.name), + Expression::Locator(locator) => (Some(locator.program.name.name), locator.name), + _ => tc_fail!(), + }; + if let Some(mapping) = helper.lookup_mapping_mut(program, name) { + mapping.insert(key, value); + } else { + tc_fail!(); + } + Value::Unit + } + CoreFunction::MappingRemove => { + let key = helper.pop_value()?; + let (program, name) = match &arguments[0] { + Expression::Identifier(id) => (None, id.name), + Expression::Locator(locator) => (Some(locator.program.name.name), locator.name), + _ => tc_fail!(), + }; + if let Some(mapping) = helper.lookup_mapping_mut(program, name) { + mapping.remove(&key); + } else { + tc_fail!(); + } + Value::Unit + } + CoreFunction::MappingContains => { + let key = helper.pop_value()?; + let (program, name) = match &arguments[0] { + Expression::Identifier(id) => (None, id.name), + Expression::Locator(locator) => (Some(locator.program.name.name), locator.name), + _ => tc_fail!(), + }; + if let Some(mapping) = helper.lookup_mapping_mut(program, name) { + Value::Bool(mapping.contains_key(&key)) + } else { + tc_fail!(); + } + } + CoreFunction::SignatureVerify => todo!(), + CoreFunction::FutureAwait => panic!("await must be handled elsewhere"), + }; + + Ok(Some(value)) +} diff --git a/interpreter/src/cursor.rs b/interpreter/src/cursor.rs index 624e7dd209..02e1144732 100644 --- a/interpreter/src/cursor.rs +++ b/interpreter/src/cursor.rs @@ -24,6 +24,7 @@ use leo_ast::{ CoreConstant, CoreFunction, Expression, + FromStrRadix as _, Function, GroupLiteral, IntegerType, @@ -267,6 +268,28 @@ pub struct Cursor<'a> { pub program: Option, } +impl CoreFunctionHelper for Cursor<'_> { + fn pop_value_impl(&mut self) -> Option { + self.values.pop() + } + + fn set_block_height(&mut self, height: u32) { + self.block_height = height; + } + + fn lookup_mapping(&self, program: Option, name: Symbol) -> Option<&HashMap> { + Cursor::lookup_mapping(self, program, name) + } + + fn lookup_mapping_mut(&mut self, program: Option, name: Symbol) -> Option<&mut HashMap> { + Cursor::lookup_mapping_mut(self, program, name) + } + + fn rng(&mut self) -> Option<&mut ChaCha20Rng> { + Some(&mut self.rng) + } +} + impl<'a> Cursor<'a> { /// `really_async` indicates we should really delay execution of async function calls until the user runs them. pub fn new(really_async: bool, signer: SvmAddress, block_height: u32) -> Self { @@ -724,13 +747,25 @@ impl<'a> Cursor<'a> { let span = function.span(); - let value = self.evaluate_core_function(core_function.clone(), &function.arguments, span)?; - if let CoreFunction::FutureAwait = core_function { + let value = self.pop_value()?; + let Value::Future(future) = value else { + halt!(span, "Invalid value for await: {value}"); + }; + for async_execution in future.0 { + self.values.extend(async_execution.arguments.into_iter()); + self.frames.push(Frame { + step: 0, + element: Element::DelayedCall(async_execution.function), + user_initiated: false, + }); + } // For an await, we have one extra step - first we must evaluate the delayed call. None } else { - Some(value) + let value = crate::evaluate_core_function(self, core_function.clone(), &function.arguments, span)?; + assert!(value.is_some()); + value } } Expression::Access(AccessExpression::AssociatedFunction(function)) if step == 2 => { @@ -772,7 +807,7 @@ impl<'a> Cursor<'a> { Expression::Binary(binary) if step == 1 => { let rhs = self.pop_value()?; let lhs = self.pop_value()?; - Some(evaluate_binary(binary.span, binary.op, lhs, rhs)?) + Some(evaluate_binary(binary.span, binary.op, &lhs, &rhs)?) } Expression::Call(call) if step == 0 => { call.arguments.iter().rev().for_each(push!()); @@ -821,34 +856,7 @@ impl<'a> Cursor<'a> { Expression::Identifier(identifier) if step == 0 => { Some(self.lookup(identifier.name).expect_tc(identifier.span())?) } - Expression::Literal(literal) if step == 0 => Some(match literal { - Literal::Boolean(b, ..) => Value::Bool(*b), - Literal::Integer(IntegerType::U8, s, ..) => Value::U8(s.parse().expect_tc(literal.span())?), - Literal::Integer(IntegerType::U16, s, ..) => Value::U16(s.parse().expect_tc(literal.span())?), - Literal::Integer(IntegerType::U32, s, ..) => Value::U32(s.parse().expect_tc(literal.span())?), - Literal::Integer(IntegerType::U64, s, ..) => Value::U64(s.parse().expect_tc(literal.span())?), - Literal::Integer(IntegerType::U128, s, ..) => Value::U128(s.parse().expect_tc(literal.span())?), - Literal::Integer(IntegerType::I8, s, ..) => Value::I8(s.parse().expect_tc(literal.span())?), - Literal::Integer(IntegerType::I16, s, ..) => Value::I16(s.parse().expect_tc(literal.span())?), - Literal::Integer(IntegerType::I32, s, ..) => Value::I32(s.parse().expect_tc(literal.span())?), - Literal::Integer(IntegerType::I64, s, ..) => Value::I64(s.parse().expect_tc(literal.span())?), - Literal::Integer(IntegerType::I128, s, ..) => Value::I128(s.parse().expect_tc(literal.span())?), - Literal::Field(s, ..) => Value::Field(format!("{s}field").parse().expect_tc(literal.span())?), - Literal::Group(group_literal) => match &**group_literal { - GroupLiteral::Single(s, ..) => Value::Group(format!("{s}group").parse().expect_tc(literal.span())?), - GroupLiteral::Tuple(_group_tuple) => todo!(), - }, - Literal::Address(s, ..) => { - if s.ends_with(".aleo") { - let program_id = ProgramID::from_str(s)?; - Value::Address(program_id.to_address()?) - } else { - Value::Address(s.parse().expect_tc(literal.span())?) - } - } - Literal::Scalar(s, ..) => Value::Scalar(format!("{s}scalar").parse().expect_tc(literal.span())?), - Literal::String(..) => tc_fail!(), - }), + Expression::Literal(literal) if step == 0 => Some(literal_to_value(literal)?), Expression::Locator(_locator) => todo!(), Expression::Struct(struct_) if step == 0 => { struct_.members.iter().flat_map(|init| init.expression.as_ref()).for_each(push!()); @@ -907,7 +915,7 @@ impl<'a> Cursor<'a> { } Expression::Unary(unary) if step == 1 => { let value = self.pop_value()?; - Some(evaluate_unary(unary.span, unary.op, value)?) + Some(evaluate_unary(unary.span, unary.op, &value)?) } Expression::Unit(_) if step == 0 => Some(Value::Unit), x => unreachable!("Unexpected expression {x}"), @@ -2209,23 +2217,23 @@ pub struct StepResult { } /// Evaluate a binary operation. -pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) -> Result { +pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: &Value, rhs: &Value) -> Result { let value = match op { BinaryOperation::Add => { let Some(value) = (match (lhs, rhs) { - (Value::U8(x), Value::U8(y)) => x.checked_add(y).map(Value::U8), - (Value::U16(x), Value::U16(y)) => x.checked_add(y).map(Value::U16), - (Value::U32(x), Value::U32(y)) => x.checked_add(y).map(Value::U32), - (Value::U64(x), Value::U64(y)) => x.checked_add(y).map(Value::U64), - (Value::U128(x), Value::U128(y)) => x.checked_add(y).map(Value::U128), - (Value::I8(x), Value::I8(y)) => x.checked_add(y).map(Value::I8), - (Value::I16(x), Value::I16(y)) => x.checked_add(y).map(Value::I16), - (Value::I32(x), Value::I32(y)) => x.checked_add(y).map(Value::I32), - (Value::I64(x), Value::I64(y)) => x.checked_add(y).map(Value::I64), - (Value::I128(x), Value::I128(y)) => x.checked_add(y).map(Value::I128), - (Value::Group(x), Value::Group(y)) => Some(Value::Group(x + y)), - (Value::Field(x), Value::Field(y)) => Some(Value::Field(x + y)), - (Value::Scalar(x), Value::Scalar(y)) => Some(Value::Scalar(x + y)), + (Value::U8(x), Value::U8(y)) => x.checked_add(*y).map(Value::U8), + (Value::U16(x), Value::U16(y)) => x.checked_add(*y).map(Value::U16), + (Value::U32(x), Value::U32(y)) => x.checked_add(*y).map(Value::U32), + (Value::U64(x), Value::U64(y)) => x.checked_add(*y).map(Value::U64), + (Value::U128(x), Value::U128(y)) => x.checked_add(*y).map(Value::U128), + (Value::I8(x), Value::I8(y)) => x.checked_add(*y).map(Value::I8), + (Value::I16(x), Value::I16(y)) => x.checked_add(*y).map(Value::I16), + (Value::I32(x), Value::I32(y)) => x.checked_add(*y).map(Value::I32), + (Value::I64(x), Value::I64(y)) => x.checked_add(*y).map(Value::I64), + (Value::I128(x), Value::I128(y)) => x.checked_add(*y).map(Value::I128), + (Value::Group(x), Value::Group(y)) => Some(Value::Group(*x + *y)), + (Value::Field(x), Value::Field(y)) => Some(Value::Field(*x + *y)), + (Value::Scalar(x), Value::Scalar(y)) => Some(Value::Scalar(*x + *y)), _ => halt!(span, "Type error"), }) else { halt!(span, "add overflow"); @@ -2233,20 +2241,20 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) value } BinaryOperation::AddWrapped => match (lhs, rhs) { - (Value::U8(x), Value::U8(y)) => Value::U8(x.wrapping_add(y)), - (Value::U16(x), Value::U16(y)) => Value::U16(x.wrapping_add(y)), - (Value::U32(x), Value::U32(y)) => Value::U32(x.wrapping_add(y)), - (Value::U64(x), Value::U64(y)) => Value::U64(x.wrapping_add(y)), - (Value::U128(x), Value::U128(y)) => Value::U128(x.wrapping_add(y)), - (Value::I8(x), Value::I8(y)) => Value::I8(x.wrapping_add(y)), - (Value::I16(x), Value::I16(y)) => Value::I16(x.wrapping_add(y)), - (Value::I32(x), Value::I32(y)) => Value::I32(x.wrapping_add(y)), - (Value::I64(x), Value::I64(y)) => Value::I64(x.wrapping_add(y)), - (Value::I128(x), Value::I128(y)) => Value::I128(x.wrapping_add(y)), + (Value::U8(x), Value::U8(y)) => Value::U8(x.wrapping_add(*y)), + (Value::U16(x), Value::U16(y)) => Value::U16(x.wrapping_add(*y)), + (Value::U32(x), Value::U32(y)) => Value::U32(x.wrapping_add(*y)), + (Value::U64(x), Value::U64(y)) => Value::U64(x.wrapping_add(*y)), + (Value::U128(x), Value::U128(y)) => Value::U128(x.wrapping_add(*y)), + (Value::I8(x), Value::I8(y)) => Value::I8(x.wrapping_add(*y)), + (Value::I16(x), Value::I16(y)) => Value::I16(x.wrapping_add(*y)), + (Value::I32(x), Value::I32(y)) => Value::I32(x.wrapping_add(*y)), + (Value::I64(x), Value::I64(y)) => Value::I64(x.wrapping_add(*y)), + (Value::I128(x), Value::I128(y)) => Value::I128(x.wrapping_add(*y)), _ => halt!(span, "Type error"), }, BinaryOperation::And => match (lhs, rhs) { - (Value::Bool(x), Value::Bool(y)) => Value::Bool(x && y), + (Value::Bool(x), Value::Bool(y)) => Value::Bool(*x && *y), _ => halt!(span, "Type error"), }, BinaryOperation::BitwiseAnd => match (lhs, rhs) { @@ -2265,17 +2273,17 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) }, BinaryOperation::Div => { let Some(value) = (match (lhs, rhs) { - (Value::U8(x), Value::U8(y)) => x.checked_div(y).map(Value::U8), - (Value::U16(x), Value::U16(y)) => x.checked_div(y).map(Value::U16), - (Value::U32(x), Value::U32(y)) => x.checked_div(y).map(Value::U32), - (Value::U64(x), Value::U64(y)) => x.checked_div(y).map(Value::U64), - (Value::U128(x), Value::U128(y)) => x.checked_div(y).map(Value::U128), - (Value::I8(x), Value::I8(y)) => x.checked_div(y).map(Value::I8), - (Value::I16(x), Value::I16(y)) => x.checked_div(y).map(Value::I16), - (Value::I32(x), Value::I32(y)) => x.checked_div(y).map(Value::I32), - (Value::I64(x), Value::I64(y)) => x.checked_div(y).map(Value::I64), - (Value::I128(x), Value::I128(y)) => x.checked_div(y).map(Value::I128), - (Value::Field(x), Value::Field(y)) => y.inverse().map(|y| Value::Field(x * y)).ok(), + (Value::U8(x), Value::U8(y)) => x.checked_div(*y).map(Value::U8), + (Value::U16(x), Value::U16(y)) => x.checked_div(*y).map(Value::U16), + (Value::U32(x), Value::U32(y)) => x.checked_div(*y).map(Value::U32), + (Value::U64(x), Value::U64(y)) => x.checked_div(*y).map(Value::U64), + (Value::U128(x), Value::U128(y)) => x.checked_div(*y).map(Value::U128), + (Value::I8(x), Value::I8(y)) => x.checked_div(*y).map(Value::I8), + (Value::I16(x), Value::I16(y)) => x.checked_div(*y).map(Value::I16), + (Value::I32(x), Value::I32(y)) => x.checked_div(*y).map(Value::I32), + (Value::I64(x), Value::I64(y)) => x.checked_div(*y).map(Value::I64), + (Value::I128(x), Value::I128(y)) => x.checked_div(*y).map(Value::I128), + (Value::Field(x), Value::Field(y)) => y.inverse().map(|y| Value::Field(*x * y)).ok(), _ => halt!(span, "Type error"), }) else { halt!(span, "div overflow"); @@ -2293,35 +2301,35 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) | (Value::I32(_), Value::I32(0)) | (Value::I64(_), Value::I64(0)) | (Value::I128(_), Value::I128(0)) => halt!(span, "divide by 0"), - (Value::U8(x), Value::U8(y)) => Value::U8(x.wrapping_div(y)), - (Value::U16(x), Value::U16(y)) => Value::U16(x.wrapping_div(y)), - (Value::U32(x), Value::U32(y)) => Value::U32(x.wrapping_div(y)), - (Value::U64(x), Value::U64(y)) => Value::U64(x.wrapping_div(y)), - (Value::U128(x), Value::U128(y)) => Value::U128(x.wrapping_div(y)), - (Value::I8(x), Value::I8(y)) => Value::I8(x.wrapping_div(y)), - (Value::I16(x), Value::I16(y)) => Value::I16(x.wrapping_div(y)), - (Value::I32(x), Value::I32(y)) => Value::I32(x.wrapping_div(y)), - (Value::I64(x), Value::I64(y)) => Value::I64(x.wrapping_div(y)), - (Value::I128(x), Value::I128(y)) => Value::I128(x.wrapping_div(y)), + (Value::U8(x), Value::U8(y)) => Value::U8(x.wrapping_div(*y)), + (Value::U16(x), Value::U16(y)) => Value::U16(x.wrapping_div(*y)), + (Value::U32(x), Value::U32(y)) => Value::U32(x.wrapping_div(*y)), + (Value::U64(x), Value::U64(y)) => Value::U64(x.wrapping_div(*y)), + (Value::U128(x), Value::U128(y)) => Value::U128(x.wrapping_div(*y)), + (Value::I8(x), Value::I8(y)) => Value::I8(x.wrapping_div(*y)), + (Value::I16(x), Value::I16(y)) => Value::I16(x.wrapping_div(*y)), + (Value::I32(x), Value::I32(y)) => Value::I32(x.wrapping_div(*y)), + (Value::I64(x), Value::I64(y)) => Value::I64(x.wrapping_div(*y)), + (Value::I128(x), Value::I128(y)) => Value::I128(x.wrapping_div(*y)), _ => halt!(span, "Type error"), }, - BinaryOperation::Eq => Value::Bool(lhs.eq(&rhs)?), - BinaryOperation::Gte => Value::Bool(lhs.gte(&rhs)?), - BinaryOperation::Gt => Value::Bool(lhs.gt(&rhs)?), - BinaryOperation::Lte => Value::Bool(lhs.lte(&rhs)?), - BinaryOperation::Lt => Value::Bool(lhs.lt(&rhs)?), + BinaryOperation::Eq => Value::Bool(lhs.eq(rhs)?), + BinaryOperation::Gte => Value::Bool(lhs.gte(rhs)?), + BinaryOperation::Gt => Value::Bool(lhs.gt(rhs)?), + BinaryOperation::Lte => Value::Bool(lhs.lte(rhs)?), + BinaryOperation::Lt => Value::Bool(lhs.lt(rhs)?), BinaryOperation::Mod => { let Some(value) = (match (lhs, rhs) { - (Value::U8(x), Value::U8(y)) => x.checked_rem(y).map(Value::U8), - (Value::U16(x), Value::U16(y)) => x.checked_rem(y).map(Value::U16), - (Value::U32(x), Value::U32(y)) => x.checked_rem(y).map(Value::U32), - (Value::U64(x), Value::U64(y)) => x.checked_rem(y).map(Value::U64), - (Value::U128(x), Value::U128(y)) => x.checked_rem(y).map(Value::U128), - (Value::I8(x), Value::I8(y)) => x.checked_rem(y).map(Value::I8), - (Value::I16(x), Value::I16(y)) => x.checked_rem(y).map(Value::I16), - (Value::I32(x), Value::I32(y)) => x.checked_rem(y).map(Value::I32), - (Value::I64(x), Value::I64(y)) => x.checked_rem(y).map(Value::I64), - (Value::I128(x), Value::I128(y)) => x.checked_rem(y).map(Value::I128), + (Value::U8(x), Value::U8(y)) => x.checked_rem(*y).map(Value::U8), + (Value::U16(x), Value::U16(y)) => x.checked_rem(*y).map(Value::U16), + (Value::U32(x), Value::U32(y)) => x.checked_rem(*y).map(Value::U32), + (Value::U64(x), Value::U64(y)) => x.checked_rem(*y).map(Value::U64), + (Value::U128(x), Value::U128(y)) => x.checked_rem(*y).map(Value::U128), + (Value::I8(x), Value::I8(y)) => x.checked_rem(*y).map(Value::I8), + (Value::I16(x), Value::I16(y)) => x.checked_rem(*y).map(Value::I16), + (Value::I32(x), Value::I32(y)) => x.checked_rem(*y).map(Value::I32), + (Value::I64(x), Value::I64(y)) => x.checked_rem(*y).map(Value::I64), + (Value::I128(x), Value::I128(y)) => x.checked_rem(*y).map(Value::I128), _ => halt!(span, "Type error"), }) else { halt!(span, "mod overflow"); @@ -2330,19 +2338,19 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) } BinaryOperation::Mul => { let Some(value) = (match (lhs, rhs) { - (Value::U8(x), Value::U8(y)) => x.checked_mul(y).map(Value::U8), - (Value::U16(x), Value::U16(y)) => x.checked_mul(y).map(Value::U16), - (Value::U32(x), Value::U32(y)) => x.checked_mul(y).map(Value::U32), - (Value::U64(x), Value::U64(y)) => x.checked_mul(y).map(Value::U64), - (Value::U128(x), Value::U128(y)) => x.checked_mul(y).map(Value::U128), - (Value::I8(x), Value::I8(y)) => x.checked_mul(y).map(Value::I8), - (Value::I16(x), Value::I16(y)) => x.checked_mul(y).map(Value::I16), - (Value::I32(x), Value::I32(y)) => x.checked_mul(y).map(Value::I32), - (Value::I64(x), Value::I64(y)) => x.checked_mul(y).map(Value::I64), - (Value::I128(x), Value::I128(y)) => x.checked_mul(y).map(Value::I128), - (Value::Field(x), Value::Field(y)) => Some(Value::Field(x * y)), - (Value::Group(x), Value::Scalar(y)) => Some(Value::Group(x * y)), - (Value::Scalar(x), Value::Group(y)) => Some(Value::Group(x * y)), + (Value::U8(x), Value::U8(y)) => x.checked_mul(*y).map(Value::U8), + (Value::U16(x), Value::U16(y)) => x.checked_mul(*y).map(Value::U16), + (Value::U32(x), Value::U32(y)) => x.checked_mul(*y).map(Value::U32), + (Value::U64(x), Value::U64(y)) => x.checked_mul(*y).map(Value::U64), + (Value::U128(x), Value::U128(y)) => x.checked_mul(*y).map(Value::U128), + (Value::I8(x), Value::I8(y)) => x.checked_mul(*y).map(Value::I8), + (Value::I16(x), Value::I16(y)) => x.checked_mul(*y).map(Value::I16), + (Value::I32(x), Value::I32(y)) => x.checked_mul(*y).map(Value::I32), + (Value::I64(x), Value::I64(y)) => x.checked_mul(*y).map(Value::I64), + (Value::I128(x), Value::I128(y)) => x.checked_mul(*y).map(Value::I128), + (Value::Field(x), Value::Field(y)) => Some(Value::Field(*x * *y)), + (Value::Group(x), Value::Scalar(y)) => Some(Value::Group(*x * *y)), + (Value::Scalar(x), Value::Group(y)) => Some(Value::Group(*x * *y)), _ => halt!(span, "Type error"), }) else { halt!(span, "mul overflow"); @@ -2350,17 +2358,16 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) value } BinaryOperation::MulWrapped => match (lhs, rhs) { - (Value::U8(x), Value::U8(y)) => Value::U8(x.wrapping_mul(y)), - (Value::U16(x), Value::U16(y)) => Value::U16(x.wrapping_mul(y)), - (Value::U32(x), Value::U32(y)) => Value::U32(x.wrapping_mul(y)), - (Value::U64(x), Value::U64(y)) => Value::U64(x.wrapping_mul(y)), - (Value::U128(x), Value::U128(y)) => Value::U128(x.wrapping_mul(y)), - (Value::I8(x), Value::I8(y)) => Value::I8(x.wrapping_mul(y)), - (Value::I16(x), Value::I16(y)) => Value::I16(x.wrapping_mul(y)), - (Value::I32(x), Value::I32(y)) => Value::I32(x.wrapping_mul(y)), - (Value::I64(x), Value::I64(y)) => Value::I64(x.wrapping_mul(y)), - (Value::I128(x), Value::I128(y)) => Value::I128(x.wrapping_mul(y)), - (Value::Field(_), Value::Field(_)) => todo!(), + (Value::U8(x), Value::U8(y)) => Value::U8(x.wrapping_mul(*y)), + (Value::U16(x), Value::U16(y)) => Value::U16(x.wrapping_mul(*y)), + (Value::U32(x), Value::U32(y)) => Value::U32(x.wrapping_mul(*y)), + (Value::U64(x), Value::U64(y)) => Value::U64(x.wrapping_mul(*y)), + (Value::U128(x), Value::U128(y)) => Value::U128(x.wrapping_mul(*y)), + (Value::I8(x), Value::I8(y)) => Value::I8(x.wrapping_mul(*y)), + (Value::I16(x), Value::I16(y)) => Value::I16(x.wrapping_mul(*y)), + (Value::I32(x), Value::I32(y)) => Value::I32(x.wrapping_mul(*y)), + (Value::I64(x), Value::I64(y)) => Value::I64(x.wrapping_mul(*y)), + (Value::I128(x), Value::I128(y)) => Value::I128(x.wrapping_mul(*y)), _ => halt!(span, "Type error"), }, @@ -2368,7 +2375,7 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) (Value::Bool(x), Value::Bool(y)) => Value::Bool(!(x & y)), _ => halt!(span, "Type error"), }, - BinaryOperation::Neq => Value::Bool(lhs.neq(&rhs)?), + BinaryOperation::Neq => Value::Bool(lhs.neq(rhs)?), BinaryOperation::Nor => match (lhs, rhs) { (Value::Bool(x), Value::Bool(y)) => Value::Bool(!(x | y)), _ => halt!(span, "Type error"), @@ -2396,9 +2403,9 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) Value::Field(x.pow(y)) } else { let rhs: u32 = match rhs { - Value::U8(y) => y.into(), - Value::U16(y) => y.into(), - Value::U32(y) => y, + Value::U8(y) => (*y).into(), + Value::U16(y) => (*y).into(), + Value::U32(y) => *y, _ => tc_fail!(), }; @@ -2422,9 +2429,9 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) } BinaryOperation::PowWrapped => { let rhs: u32 = match rhs { - Value::U8(y) => y.into(), - Value::U16(y) => y.into(), - Value::U32(y) => y, + Value::U8(y) => (*y).into(), + Value::U16(y) => (*y).into(), + Value::U32(y) => *y, _ => halt!(span, "Type error"), }; @@ -2444,16 +2451,16 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) } BinaryOperation::Rem => { let Some(value) = (match (lhs, rhs) { - (Value::U8(x), Value::U8(y)) => x.checked_rem(y).map(Value::U8), - (Value::U16(x), Value::U16(y)) => x.checked_rem(y).map(Value::U16), - (Value::U32(x), Value::U32(y)) => x.checked_rem(y).map(Value::U32), - (Value::U64(x), Value::U64(y)) => x.checked_rem(y).map(Value::U64), - (Value::U128(x), Value::U128(y)) => x.checked_rem(y).map(Value::U128), - (Value::I8(x), Value::I8(y)) => x.checked_rem(y).map(Value::I8), - (Value::I16(x), Value::I16(y)) => x.checked_rem(y).map(Value::I16), - (Value::I32(x), Value::I32(y)) => x.checked_rem(y).map(Value::I32), - (Value::I64(x), Value::I64(y)) => x.checked_rem(y).map(Value::I64), - (Value::I128(x), Value::I128(y)) => x.checked_rem(y).map(Value::I128), + (Value::U8(x), Value::U8(y)) => x.checked_rem(*y).map(Value::U8), + (Value::U16(x), Value::U16(y)) => x.checked_rem(*y).map(Value::U16), + (Value::U32(x), Value::U32(y)) => x.checked_rem(*y).map(Value::U32), + (Value::U64(x), Value::U64(y)) => x.checked_rem(*y).map(Value::U64), + (Value::U128(x), Value::U128(y)) => x.checked_rem(*y).map(Value::U128), + (Value::I8(x), Value::I8(y)) => x.checked_rem(*y).map(Value::I8), + (Value::I16(x), Value::I16(y)) => x.checked_rem(*y).map(Value::I16), + (Value::I32(x), Value::I32(y)) => x.checked_rem(*y).map(Value::I32), + (Value::I64(x), Value::I64(y)) => x.checked_rem(*y).map(Value::I64), + (Value::I128(x), Value::I128(y)) => x.checked_rem(*y).map(Value::I128), _ => halt!(span, "Type error"), }) else { halt!(span, "rem error"); @@ -2471,23 +2478,23 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) | (Value::I32(_), Value::I32(0)) | (Value::I64(_), Value::I64(0)) | (Value::I128(_), Value::I128(0)) => halt!(span, "rem by 0"), - (Value::U8(x), Value::U8(y)) => Value::U8(x.wrapping_rem(y)), - (Value::U16(x), Value::U16(y)) => Value::U16(x.wrapping_rem(y)), - (Value::U32(x), Value::U32(y)) => Value::U32(x.wrapping_rem(y)), - (Value::U64(x), Value::U64(y)) => Value::U64(x.wrapping_rem(y)), - (Value::U128(x), Value::U128(y)) => Value::U128(x.wrapping_rem(y)), - (Value::I8(x), Value::I8(y)) => Value::I8(x.wrapping_rem(y)), - (Value::I16(x), Value::I16(y)) => Value::I16(x.wrapping_rem(y)), - (Value::I32(x), Value::I32(y)) => Value::I32(x.wrapping_rem(y)), - (Value::I64(x), Value::I64(y)) => Value::I64(x.wrapping_rem(y)), - (Value::I128(x), Value::I128(y)) => Value::I128(x.wrapping_rem(y)), + (Value::U8(x), Value::U8(y)) => Value::U8(x.wrapping_rem(*y)), + (Value::U16(x), Value::U16(y)) => Value::U16(x.wrapping_rem(*y)), + (Value::U32(x), Value::U32(y)) => Value::U32(x.wrapping_rem(*y)), + (Value::U64(x), Value::U64(y)) => Value::U64(x.wrapping_rem(*y)), + (Value::U128(x), Value::U128(y)) => Value::U128(x.wrapping_rem(*y)), + (Value::I8(x), Value::I8(y)) => Value::I8(x.wrapping_rem(*y)), + (Value::I16(x), Value::I16(y)) => Value::I16(x.wrapping_rem(*y)), + (Value::I32(x), Value::I32(y)) => Value::I32(x.wrapping_rem(*y)), + (Value::I64(x), Value::I64(y)) => Value::I64(x.wrapping_rem(*y)), + (Value::I128(x), Value::I128(y)) => Value::I128(x.wrapping_rem(*y)), _ => halt!(span, "Type error"), }, BinaryOperation::Shl => { let rhs: u32 = match rhs { - Value::U8(y) => y.into(), - Value::U16(y) => y.into(), - Value::U32(y) => y, + Value::U8(y) => (*y).into(), + Value::U16(y) => (*y).into(), + Value::U32(y) => *y, _ => halt!(span, "Type error"), }; match lhs { @@ -2511,9 +2518,9 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) BinaryOperation::ShlWrapped => { let rhs: u32 = match rhs { - Value::U8(y) => y.into(), - Value::U16(y) => y.into(), - Value::U32(y) => y, + Value::U8(y) => (*y).into(), + Value::U16(y) => (*y).into(), + Value::U32(y) => *y, _ => halt!(span, "Type error"), }; match lhs { @@ -2533,9 +2540,9 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) BinaryOperation::Shr => { let rhs: u32 = match rhs { - Value::U8(y) => y.into(), - Value::U16(y) => y.into(), - Value::U32(y) => y, + Value::U8(y) => (*y).into(), + Value::U16(y) => (*y).into(), + Value::U32(y) => *y, _ => halt!(span, "Type error"), }; @@ -2553,9 +2560,9 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) BinaryOperation::ShrWrapped => { let rhs: u32 = match rhs { - Value::U8(y) => y.into(), - Value::U16(y) => y.into(), - Value::U32(y) => y, + Value::U8(y) => (*y).into(), + Value::U16(y) => (*y).into(), + Value::U32(y) => *y, _ => halt!(span, "Type error"), }; @@ -2576,18 +2583,18 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) BinaryOperation::Sub => { let Some(value) = (match (lhs, rhs) { - (Value::U8(x), Value::U8(y)) => x.checked_sub(y).map(Value::U8), - (Value::U16(x), Value::U16(y)) => x.checked_sub(y).map(Value::U16), - (Value::U32(x), Value::U32(y)) => x.checked_sub(y).map(Value::U32), - (Value::U64(x), Value::U64(y)) => x.checked_sub(y).map(Value::U64), - (Value::U128(x), Value::U128(y)) => x.checked_sub(y).map(Value::U128), - (Value::I8(x), Value::I8(y)) => x.checked_sub(y).map(Value::I8), - (Value::I16(x), Value::I16(y)) => x.checked_sub(y).map(Value::I16), - (Value::I32(x), Value::I32(y)) => x.checked_sub(y).map(Value::I32), - (Value::I64(x), Value::I64(y)) => x.checked_sub(y).map(Value::I64), - (Value::I128(x), Value::I128(y)) => x.checked_sub(y).map(Value::I128), - (Value::Group(x), Value::Group(y)) => Some(Value::Group(x - y)), - (Value::Field(x), Value::Field(y)) => Some(Value::Field(x - y)), + (Value::U8(x), Value::U8(y)) => x.checked_sub(*y).map(Value::U8), + (Value::U16(x), Value::U16(y)) => x.checked_sub(*y).map(Value::U16), + (Value::U32(x), Value::U32(y)) => x.checked_sub(*y).map(Value::U32), + (Value::U64(x), Value::U64(y)) => x.checked_sub(*y).map(Value::U64), + (Value::U128(x), Value::U128(y)) => x.checked_sub(*y).map(Value::U128), + (Value::I8(x), Value::I8(y)) => x.checked_sub(*y).map(Value::I8), + (Value::I16(x), Value::I16(y)) => x.checked_sub(*y).map(Value::I16), + (Value::I32(x), Value::I32(y)) => x.checked_sub(*y).map(Value::I32), + (Value::I64(x), Value::I64(y)) => x.checked_sub(*y).map(Value::I64), + (Value::I128(x), Value::I128(y)) => x.checked_sub(*y).map(Value::I128), + (Value::Group(x), Value::Group(y)) => Some(Value::Group(*x - *y)), + (Value::Field(x), Value::Field(y)) => Some(Value::Field(*x - *y)), _ => halt!(span, "Type error"), }) else { halt!(span, "sub overflow"); @@ -2596,31 +2603,31 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) } BinaryOperation::SubWrapped => match (lhs, rhs) { - (Value::U8(x), Value::U8(y)) => Value::U8(x.wrapping_sub(y)), - (Value::U16(x), Value::U16(y)) => Value::U16(x.wrapping_sub(y)), - (Value::U32(x), Value::U32(y)) => Value::U32(x.wrapping_sub(y)), - (Value::U64(x), Value::U64(y)) => Value::U64(x.wrapping_sub(y)), - (Value::U128(x), Value::U128(y)) => Value::U128(x.wrapping_sub(y)), - (Value::I8(x), Value::I8(y)) => Value::I8(x.wrapping_sub(y)), - (Value::I16(x), Value::I16(y)) => Value::I16(x.wrapping_sub(y)), - (Value::I32(x), Value::I32(y)) => Value::I32(x.wrapping_sub(y)), - (Value::I64(x), Value::I64(y)) => Value::I64(x.wrapping_sub(y)), - (Value::I128(x), Value::I128(y)) => Value::I128(x.wrapping_sub(y)), + (Value::U8(x), Value::U8(y)) => Value::U8(x.wrapping_sub(*y)), + (Value::U16(x), Value::U16(y)) => Value::U16(x.wrapping_sub(*y)), + (Value::U32(x), Value::U32(y)) => Value::U32(x.wrapping_sub(*y)), + (Value::U64(x), Value::U64(y)) => Value::U64(x.wrapping_sub(*y)), + (Value::U128(x), Value::U128(y)) => Value::U128(x.wrapping_sub(*y)), + (Value::I8(x), Value::I8(y)) => Value::I8(x.wrapping_sub(*y)), + (Value::I16(x), Value::I16(y)) => Value::I16(x.wrapping_sub(*y)), + (Value::I32(x), Value::I32(y)) => Value::I32(x.wrapping_sub(*y)), + (Value::I64(x), Value::I64(y)) => Value::I64(x.wrapping_sub(*y)), + (Value::I128(x), Value::I128(y)) => Value::I128(x.wrapping_sub(*y)), _ => halt!(span, "Type error"), }, BinaryOperation::Xor => match (lhs, rhs) { - (Value::Bool(x), Value::Bool(y)) => Value::Bool(x ^ y), - (Value::U8(x), Value::U8(y)) => Value::U8(x ^ y), - (Value::U16(x), Value::U16(y)) => Value::U16(x ^ y), - (Value::U32(x), Value::U32(y)) => Value::U32(x ^ y), - (Value::U64(x), Value::U64(y)) => Value::U64(x ^ y), - (Value::U128(x), Value::U128(y)) => Value::U128(x ^ y), - (Value::I8(x), Value::I8(y)) => Value::I8(x ^ y), - (Value::I16(x), Value::I16(y)) => Value::I16(x ^ y), - (Value::I32(x), Value::I32(y)) => Value::I32(x ^ y), - (Value::I64(x), Value::I64(y)) => Value::I64(x ^ y), - (Value::I128(x), Value::I128(y)) => Value::I128(x ^ y), + (Value::Bool(x), Value::Bool(y)) => Value::Bool(*x ^ *y), + (Value::U8(x), Value::U8(y)) => Value::U8(*x ^ *y), + (Value::U16(x), Value::U16(y)) => Value::U16(*x ^ *y), + (Value::U32(x), Value::U32(y)) => Value::U32(*x ^ *y), + (Value::U64(x), Value::U64(y)) => Value::U64(*x ^ *y), + (Value::U128(x), Value::U128(y)) => Value::U128(*x ^ *y), + (Value::I8(x), Value::I8(y)) => Value::I8(*x ^ *y), + (Value::I16(x), Value::I16(y)) => Value::I16(*x ^ *y), + (Value::I32(x), Value::I32(y)) => Value::I32(*x ^ *y), + (Value::I64(x), Value::I64(y)) => Value::I64(*x ^ *y), + (Value::I128(x), Value::I128(y)) => Value::I128(*x ^ *y), _ => halt!(span, "Type error"), }, }; @@ -2628,39 +2635,39 @@ pub fn evaluate_binary(span: Span, op: BinaryOperation, lhs: Value, rhs: Value) } /// Evaluate a unary operation. -pub fn evaluate_unary(span: Span, op: UnaryOperation, value: Value) -> Result { +pub fn evaluate_unary(span: Span, op: UnaryOperation, value: &Value) -> Result { let value_result = match op { UnaryOperation::Abs => match value { Value::I8(x) => { - if x == i8::MIN { + if *x == i8::MIN { halt!(span, "abs overflow"); } else { Value::I8(x.abs()) } } Value::I16(x) => { - if x == i16::MIN { + if *x == i16::MIN { halt!(span, "abs overflow"); } else { Value::I16(x.abs()) } } Value::I32(x) => { - if x == i32::MIN { + if *x == i32::MIN { halt!(span, "abs overflow"); } else { Value::I32(x.abs()) } } Value::I64(x) => { - if x == i64::MIN { + if *x == i64::MIN { halt!(span, "abs overflow"); } else { Value::I64(x.abs()) } } Value::I128(x) => { - if x == i128::MIN { + if *x == i128::MIN { halt!(span, "abs overflow"); } else { Value::I128(x.abs()) @@ -2711,8 +2718,8 @@ pub fn evaluate_unary(span: Span, op: UnaryOperation, value: Value) -> Result halt!(span, "negation overflow"), Some(y) => Value::I128(y), }, - Value::Group(x) => Value::Group(-x), - Value::Field(x) => Value::Field(-x), + Value::Group(x) => Value::Group(-*x), + Value::Field(x) => Value::Field(-*x), _ => halt!(span, "Type error"), }, UnaryOperation::Not => match value { @@ -2754,3 +2761,66 @@ pub fn evaluate_unary(span: Span, op: UnaryOperation, value: Value) -> Result Result { + let value = match literal { + Literal::Boolean(b, ..) => Value::Bool(*b), + Literal::Integer(IntegerType::U8, s, ..) => { + let s = s.replace("_", ""); + Value::U8(u8::from_str_by_radix(&s).expect("Parsing guarantees this works.")) + } + Literal::Integer(IntegerType::U16, s, ..) => { + let s = s.replace("_", ""); + Value::U16(u16::from_str_by_radix(&s).expect("Parsing guarantees this works.")) + } + Literal::Integer(IntegerType::U32, s, ..) => { + let s = s.replace("_", ""); + Value::U32(u32::from_str_by_radix(&s).expect("Parsing guarantees this works.")) + } + Literal::Integer(IntegerType::U64, s, ..) => { + let s = s.replace("_", ""); + Value::U64(u64::from_str_by_radix(&s).expect("Parsing guarantees this works.")) + } + Literal::Integer(IntegerType::U128, s, ..) => { + let s = s.replace("_", ""); + Value::U128(u128::from_str_by_radix(&s).expect("Parsing guarantees this works.")) + } + Literal::Integer(IntegerType::I8, s, ..) => { + let s = s.replace("_", ""); + Value::I8(i8::from_str_by_radix(&s).expect("Parsing guarantees this works.")) + } + Literal::Integer(IntegerType::I16, s, ..) => { + let s = s.replace("_", ""); + Value::I16(i16::from_str_by_radix(&s).expect("Parsing guarantees this works.")) + } + Literal::Integer(IntegerType::I32, s, ..) => { + let s = s.replace("_", ""); + Value::I32(i32::from_str_by_radix(&s).expect("Parsing guarantees this works.")) + } + Literal::Integer(IntegerType::I64, s, ..) => { + let s = s.replace("_", ""); + Value::I64(i64::from_str_by_radix(&s).expect("Parsing guarantees this works.")) + } + Literal::Integer(IntegerType::I128, s, ..) => { + let s = s.replace("_", ""); + Value::I128(i128::from_str_by_radix(&s).expect("Parsing guarantees this works.")) + } + Literal::Field(s, ..) => Value::Field(format!("{s}field").parse().expect_tc(literal.span())?), + Literal::Group(group_literal) => match &**group_literal { + GroupLiteral::Single(s, ..) => Value::Group(format!("{s}group").parse().expect_tc(literal.span())?), + GroupLiteral::Tuple(_group_tuple) => todo!(), + }, + Literal::Address(s, ..) => { + if s.ends_with(".aleo") { + let program_id = ProgramID::from_str(s)?; + Value::Address(program_id.to_address()?) + } else { + Value::Address(s.parse().expect_tc(literal.span())?) + } + } + Literal::Scalar(s, ..) => Value::Scalar(format!("{s}scalar").parse().expect_tc(literal.span())?), + Literal::String(..) => tc_fail!(), + }; + + Ok(value) +} diff --git a/interpreter/src/cursor_aleo.rs b/interpreter/src/cursor_aleo.rs index 506117dc36..59fd07b3dc 100644 --- a/interpreter/src/cursor_aleo.rs +++ b/interpreter/src/cursor_aleo.rs @@ -199,7 +199,7 @@ impl Cursor<'_> { macro_rules! unary { ($svm_op: expr, $op: ident) => {{ let operand = self.operand_value(&$svm_op.operands()[0]); - let value = evaluate_unary(Default::default(), UnaryOperation::$op, operand)?; + let value = evaluate_unary(Default::default(), UnaryOperation::$op, &operand)?; self.increment_instruction_index(); (value, $svm_op.destinations()[0].clone()) }}; @@ -209,7 +209,7 @@ impl Cursor<'_> { ($svm_op: expr, $op: ident) => {{ let operand0 = self.operand_value(&$svm_op.operands()[0]); let operand1 = self.operand_value(&$svm_op.operands()[1]); - let value = evaluate_binary(Default::default(), BinaryOperation::$op, operand0, operand1)?; + let value = evaluate_binary(Default::default(), BinaryOperation::$op, &operand0, &operand1)?; self.increment_instruction_index(); (value, $svm_op.destinations()[0].clone()) }}; diff --git a/interpreter/src/lib.rs b/interpreter/src/lib.rs index cdbd9d6ac6..10448bddc7 100644 --- a/interpreter/src/lib.rs +++ b/interpreter/src/lib.rs @@ -33,9 +33,14 @@ mod test; mod util; use util::*; +mod core_functions; +pub use core_functions::{CoreFunctionHelper, evaluate_core_function}; + mod cursor; use cursor::*; +pub use cursor::{evaluate_binary, evaluate_unary, literal_to_value}; + mod interpreter; use interpreter::*; @@ -44,6 +49,8 @@ mod cursor_aleo; mod value; use value::*; +pub use value::Value; + mod ui; use ui::Ui; diff --git a/interpreter/src/test/runner.rs b/interpreter/src/test/runner.rs index 98fde3ebfb..497c72fa72 100644 --- a/interpreter/src/test/runner.rs +++ b/interpreter/src/test/runner.rs @@ -25,6 +25,8 @@ use std::{fs, path::PathBuf, str::FromStr as _}; pub struct LeoNamespace; +pub static TEST_PRIVATE_KEY: &str = "APrivateKey1zkp8CZNn3yeCseEtxuVPbDCwSyhGW6yZKUYKfgXmcpoGPWH"; + impl Namespace for LeoNamespace { fn parse_type(&self) -> ParseType { ParseType::Whole @@ -66,7 +68,7 @@ fn run_leo_test(test: Test) -> Result { fs::write(&filename, &test.content).map_err(|e| format!("{e}"))?; let private_key: PrivateKey = - PrivateKey::from_str(leo_package::TEST_PRIVATE_KEY).expect("should be able to parse private key"); + PrivateKey::from_str(TEST_PRIVATE_KEY).expect("should be able to parse private key"); let address = Address::try_from(&private_key).expect("should be able to create address"); let empty: [&PathBuf; 0] = []; let mut interpreter = Interpreter::new([filename].iter(), empty, address, 0).map_err(|e| format!("{e}"))?; @@ -86,7 +88,7 @@ fn run_aleo_test(test: Test) -> Result { fs::write(&filename, &test.content).map_err(|e| format!("{e}"))?; let private_key: PrivateKey = - PrivateKey::from_str(leo_package::TEST_PRIVATE_KEY).expect("should be able to parse private key"); + PrivateKey::from_str(TEST_PRIVATE_KEY).expect("should be able to parse private key"); let address = Address::try_from(&private_key).expect("should be able to create address"); let empty: [&PathBuf; 0] = []; let mut interpreter = Interpreter::new(empty, [filename].iter(), address, 0).map_err(|e| format!("{e}"))?; diff --git a/interpreter/src/value.rs b/interpreter/src/value.rs index 954de329e7..2ad2ff5fb8 100644 --- a/interpreter/src/value.rs +++ b/interpreter/src/value.rs @@ -389,22 +389,22 @@ impl Value { } /// Convert to the given type if possible under Aleo casting rules. - pub fn cast(self, cast_type: &Type) -> Option { + pub fn cast(&self, cast_type: &Type) -> Option { match self { - Value::Bool(b) => really_cast(SvmBoolean::new(b), cast_type), - Value::U8(x) => really_cast(SvmInteger::new(x), cast_type), - Value::U16(x) => really_cast(SvmInteger::new(x), cast_type), - Value::U32(x) => really_cast(SvmInteger::new(x), cast_type), - Value::U64(x) => really_cast(SvmInteger::new(x), cast_type), - Value::U128(x) => really_cast(SvmInteger::new(x), cast_type), - Value::I8(x) => really_cast(SvmInteger::new(x), cast_type), - Value::I16(x) => really_cast(SvmInteger::new(x), cast_type), - Value::I32(x) => really_cast(SvmInteger::new(x), cast_type), - Value::I64(x) => really_cast(SvmInteger::new(x), cast_type), - Value::I128(x) => really_cast(SvmInteger::new(x), cast_type), + Value::Bool(b) => really_cast(SvmBoolean::new(*b), cast_type), + Value::U8(x) => really_cast(SvmInteger::new(*x), cast_type), + Value::U16(x) => really_cast(SvmInteger::new(*x), cast_type), + Value::U32(x) => really_cast(SvmInteger::new(*x), cast_type), + Value::U64(x) => really_cast(SvmInteger::new(*x), cast_type), + Value::U128(x) => really_cast(SvmInteger::new(*x), cast_type), + Value::I8(x) => really_cast(SvmInteger::new(*x), cast_type), + Value::I16(x) => really_cast(SvmInteger::new(*x), cast_type), + Value::I32(x) => really_cast(SvmInteger::new(*x), cast_type), + Value::I64(x) => really_cast(SvmInteger::new(*x), cast_type), + Value::I128(x) => really_cast(SvmInteger::new(*x), cast_type), Value::Group(g) => really_cast(g.to_x_coordinate(), cast_type), - Value::Field(f) => really_cast(f, cast_type), - Value::Scalar(s) => really_cast(s, cast_type), + Value::Field(f) => really_cast(*f, cast_type), + Value::Scalar(s) => really_cast(*s, cast_type), Value::Address(a) => really_cast(a.to_group().to_x_coordinate(), cast_type), _ => None, } diff --git a/tests/expectations/compiler/array/access_array_with_loop_counter.out b/tests/expectations/compiler/array/access_array_with_loop_counter.out index cc9aac384d..aa01f01377 100644 --- a/tests/expectations/compiler/array/access_array_with_loop_counter.out +++ b/tests/expectations/compiler/array/access_array_with_loop_counter.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "e638024190743e42d22971bf4a5d2ae071661a5c05a9774f97763362531c3f99", unrolled_ast = "6c3c238b5b5a947d4da4a8fa2970f57aef2c497f9f5c3bc709023bcdc710cc9e", ssa_ast = "1a26356c38ec1d902f6c2bd032e4a9bc10d5e89182a464cf29f1048c7b687032", flattened_ast = "5484e569ec2bde5b9d72bb4e3df069dcd9ac21fdb87ea3789d910675f7f81a43", destructured_ast = "c62faac4d2186555e41b433ab94c1bb1f9f28eaae8b74a0bb103479974954914", inlined_ast = "c62faac4d2186555e41b433ab94c1bb1f9f28eaae8b74a0bb103479974954914", dce_ast = "c62faac4d2186555e41b433ab94c1bb1f9f28eaae8b74a0bb103479974954914", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "e638024190743e42d22971bf4a5d2ae071661a5c05a9774f97763362531c3f99", unrolled_ast = "beba3ab73d74d432e8365604f4a79bfb3b5f73e94cbd2d4fd240265bd6f4083c", ssa_ast = "7552ec1370efd76bd2114a064d0533bd356c9c6fe5bfde8db992b72a9a6792a6", flattened_ast = "3c3d9236c7344249df0c46877483005e067ea6e0e29aa47018fa898f87120ec1", destructured_ast = "c72743517eb7322122fb4e9c52f7d1d8fd1218a745ff407a8a8021d0974772f2", inlined_ast = "c72743517eb7322122fb4e9c52f7d1d8fd1218a745ff407a8a8021d0974772f2", dce_ast = "c72743517eb7322122fb4e9c52f7d1d8fd1218a745ff407a8a8021d0974772f2", bytecode = """ program test.aleo; function foo: diff --git a/tests/expectations/compiler/array/array_variable_access_fail.out b/tests/expectations/compiler/array/array_variable_access_fail.out index 09c942f083..0f0b2fd752 100644 --- a/tests/expectations/compiler/array/array_variable_access_fail.out +++ b/tests/expectations/compiler/array/array_variable_access_fail.out @@ -1,9 +1,8 @@ namespace = "Compile" expectation = "Fail" outputs = [""" -Error [ELUN0379001]: The array index must be constant. - --> compiler-test:5:16 +Error [ECMP0376009]: This array index could not be determined at compile time. + --> compiler-test:5:18 | 5 | return a[index]; - | ^^^^^^^^ -"""] + | ^^^^^"""] diff --git a/tests/expectations/compiler/const_prop/big_const_prop.out b/tests/expectations/compiler/const_prop/big_const_prop.out new file mode 100644 index 0000000000..1198dae27b --- /dev/null +++ b/tests/expectations/compiler/const_prop/big_const_prop.out @@ -0,0 +1,8 @@ +namespace = "Compile" +expectation = "Pass" +outputs = [[{ compile = [{ initial_ast = "5cbcd50332399444b30c73067d7ef7daf77967457f9b3cd7aa2156625e8fed1a", unrolled_ast = "78310c007408427564a9b9db93b211998a37d962832119d4f7d5a490594cb48c", ssa_ast = "a30dccca916e660adb5455f653d2014b58e26fc3f47bf5950fc6321a1e8048ef", flattened_ast = "d47703c44fba0674fe529e17ac555f2a965f74f10ae2d97c6ca35d4ba28293ac", destructured_ast = "908bdff35c6de3710aa8b917f35d45fadd1fffbac13f15c3b9f21d327131d7cf", inlined_ast = "908bdff35c6de3710aa8b917f35d45fadd1fffbac13f15c3b9f21d327131d7cf", dce_ast = "908bdff35c6de3710aa8b917f35d45fadd1fffbac13f15c3b9f21d327131d7cf", bytecode = """ +program test.aleo; + +function main: + output 33554424i32 as i32.private; +""", errors = "", warnings = "" }] }]] diff --git a/tests/expectations/compiler/const_prop/compile_time_const_fail.out b/tests/expectations/compiler/const_prop/compile_time_const_fail.out new file mode 100644 index 0000000000..c5a85a36a6 --- /dev/null +++ b/tests/expectations/compiler/const_prop/compile_time_const_fail.out @@ -0,0 +1,19 @@ +namespace = "Compile" +expectation = "Fail" +outputs = [""" +Error [ESAZ0374007]: Binary operation `1i32 / 0i32` failed at compile time: div overflow. + --> compiler-test:4:20 + | + 4 | const A: i32 = 1i32 / 0i32; + | ^^^^^^^^^^^ +Error [ESAZ0374007]: Binary operation `255u8 + 1u8` failed at compile time: add overflow. + --> compiler-test:6:19 + | + 6 | const B: u8 = 255u8 + 1u8; + | ^^^^^^^^^^^ +Error [ESAZ0374006]: Unary operation `0field.inv()` failed at compile time: attempt to invert 0field. + --> compiler-test:8:22 + | + 8 | const C: field = 0field.inv(); + | ^^^^^^^^^^^^ +"""] diff --git a/tests/expectations/compiler/const_prop/core_functions.out b/tests/expectations/compiler/const_prop/core_functions.out new file mode 100644 index 0000000000..31f4c0aacf --- /dev/null +++ b/tests/expectations/compiler/const_prop/core_functions.out @@ -0,0 +1,26 @@ +namespace = "Compile" +expectation = "Pass" +outputs = [[{ compile = [{ initial_ast = "1e241a1f7a1a0490bab43f3d4b4f249d67f5d217b6d28661262b07d6159ba4df", unrolled_ast = "d7e12729a270a51bcdcd5c68c45f38a8a72b154e9082843799520e7295a6255a", ssa_ast = "d753dedd7b3261a5e437486c976477dce703e56f2e7d83ce2eaf3dba37280721", flattened_ast = "3b2d7ed604f12b566ecf19a58c8be2fe3d1f2ba45604dd5d702788313668cc86", destructured_ast = "4fe0247ebbbc22c09568e555e526ab73c9329fae2f35eb2b9c2e115277ae98a3", inlined_ast = "283f7f33909d4a630c91e0448791d87b4441189772b5b483c2e7f651d7f8c895", dce_ast = "283f7f33909d4a630c91e0448791d87b4441189772b5b483c2e7f651d7f8c895", bytecode = """ +program test.aleo; + +mapping mfield: + key as field.public; + value as field.public; + +mapping mgroup: + key as group.public; + value as group.public; + +mapping mu32: + key as u32.public; + value as u32.public; + +function main: + async main into r0; + output r0 as test.aleo/main.future; + +finalize main: + set 3236679066651405816080778725233890125628939339772420925284755583710370794371field into mfield[5790452939377792755765199267124367999665041371398929631131254663397134656511field]; + set 6108511972326079101406626541757505382902231607391431570208365002437568455742group into mgroup[6245268830463555179812861046132051182013738772733163565331565952498608839676group]; + set 401375299u32 into mu32[194685703u32]; +""", errors = "", warnings = "" }] }]] diff --git a/tests/expectations/compiler/const_prop/evaluate_const_fail.out b/tests/expectations/compiler/const_prop/evaluate_const_fail.out new file mode 100644 index 0000000000..00ecf5eff6 --- /dev/null +++ b/tests/expectations/compiler/const_prop/evaluate_const_fail.out @@ -0,0 +1,8 @@ +namespace = "Compile" +expectation = "Fail" +outputs = [""" +Error [ECMP0376007]: The value of this const could not be determined at compile time. + --> compiler-test:11:13 + | + 11 | const SOME: u32 = a + 1u32; + | ^^^^^^^^^^^^^^^^^^^^^^^^^^"""] diff --git a/tests/expectations/compiler/const_prop/loop_bounds_fail.out b/tests/expectations/compiler/const_prop/loop_bounds_fail.out new file mode 100644 index 0000000000..dbd69f099f --- /dev/null +++ b/tests/expectations/compiler/const_prop/loop_bounds_fail.out @@ -0,0 +1,8 @@ +namespace = "Compile" +expectation = "Fail" +outputs = [""" +Error [ECMP0376008]: This loop bound could not be determined at compile time. + --> compiler-test:12:38 + | + 12 | for j: u32 in SOME+1u32..STOP+a { + | ^^^^^^"""] diff --git a/tests/expectations/compiler/const_prop/some_loop_bounds.out b/tests/expectations/compiler/const_prop/some_loop_bounds.out new file mode 100644 index 0000000000..aa4ca5e294 --- /dev/null +++ b/tests/expectations/compiler/const_prop/some_loop_bounds.out @@ -0,0 +1,21 @@ +namespace = "Compile" +expectation = "Pass" +outputs = [[{ compile = [{ initial_ast = "7c564fd41a17cda14272593666d1f59f666d8d15f2f0c9a1cba0459ae7f15db5", unrolled_ast = "cb80d7160962145460e60ddbda035d22ccb2f086ed006134c2b29b6f3394df34", ssa_ast = "de4ffc2f8658d8d9544cf396f9c16ddc544319348de2d44883721f051e140306", flattened_ast = "c70bcc8cea86b54e6a818ef612b9bf21b6b9392abbfc7dec51e83bc113e70dd6", destructured_ast = "b9d1251b876353dbb3034abc5b0491cfd924eca5caec4560dd80fc0196f14d2f", inlined_ast = "d8aca0e49b6de75c6291b5da67299ff11b0277d67d2fb6ed9b3ab47d2ee22857", dce_ast = "d8aca0e49b6de75c6291b5da67299ff11b0277d67d2fb6ed9b3ab47d2ee22857", bytecode = """ +program test.aleo; + +mapping m: + key as u32.public; + value as u32.public; + +function main: + async main into r0; + output r0 as test.aleo/main.future; + +finalize main: + set 3u32 into m[1u32]; + set 4u32 into m[1u32]; + set 5u32 into m[1u32]; + set 4u32 into m[2u32]; + set 5u32 into m[2u32]; + set 5u32 into m[3u32]; +""", errors = "", warnings = "" }] }]] diff --git a/tests/expectations/compiler/const_prop/tuples.out b/tests/expectations/compiler/const_prop/tuples.out new file mode 100644 index 0000000000..197106287a --- /dev/null +++ b/tests/expectations/compiler/const_prop/tuples.out @@ -0,0 +1,8 @@ +namespace = "Compile" +expectation = "Pass" +outputs = [[{ compile = [{ initial_ast = "a6dc954157f3ceb76a9266c54c270ed7a8ff581ba45c87e3967f393d524104c7", unrolled_ast = "8322d2b35e0ab220fdcdeeaf3fc125ef16cb3785186d29af249c4835c5183e37", ssa_ast = "9be11e3411114daa5ddfd01edcc585fb9ea766bdaf85990907baa044110ecd30", flattened_ast = "5ec388837bd67ef1c399551d0b01fb3ecd86cc8b80f446e87f6892b212670f8f", destructured_ast = "694710733ba774c889aed0f2ae7b65a7d65bdb7aabcc68a20eaa57fc44e6759d", inlined_ast = "694710733ba774c889aed0f2ae7b65a7d65bdb7aabcc68a20eaa57fc44e6759d", dce_ast = "79708bdc7dead403d8d67708d2cbe4540eb0134f2d176343d157eb668d285ecc", bytecode = """ +program test.aleo; + +function main: + output 12i32 as i32.private; +""", errors = "", warnings = "" }] }]] diff --git a/tests/expectations/compiler/constants/const_tuple_declaration.out b/tests/expectations/compiler/constants/const_tuple_declaration.out index 304b72d000..cef2ed245e 100644 --- a/tests/expectations/compiler/constants/const_tuple_declaration.out +++ b/tests/expectations/compiler/constants/const_tuple_declaration.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "38245c6dcf3dd2eefe622109ac7e464c771fb453600c0abbe56b09d35b53aebd", unrolled_ast = "3817d89afa2678cee2a2294af9da3afe17ff530d003917945b2f06bd266e1a5c", ssa_ast = "50063478ed3b14cc9857fdeda14e694bee9fd9be35e3d3554d71abb8f695e561", flattened_ast = "be38e1363bdb23f8d918014f842536c9846df2f6f285007f86af15d83bdd0789", destructured_ast = "d4fac05b4de0549fe402df68883c6eb5ad98dff86558b58075a7acf9492e953c", inlined_ast = "d4fac05b4de0549fe402df68883c6eb5ad98dff86558b58075a7acf9492e953c", dce_ast = "9bd219dab0350702181d09f2c998e0fe2727d6b96e36e342cb6130863a26d6ca", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "38245c6dcf3dd2eefe622109ac7e464c771fb453600c0abbe56b09d35b53aebd", unrolled_ast = "9506dd7a90d75952ef2041ab6a7f2b865cba0563a95ccece0c7406f54759b75b", ssa_ast = "524471c59f42a20cc3c8d06170923a957516e123d6af99ae99e2d88de7de04cd", flattened_ast = "5330318d7cbe5027e7703e5650a046b8ef2c5e054d2e6cfa9279bc485f4a232d", destructured_ast = "d8075c8380ceb4470054e0d2216bbca26e27d1f2dc66b26c6b8bd4ade4fe6b84", inlined_ast = "d8075c8380ceb4470054e0d2216bbca26e27d1f2dc66b26c6b8bd4ade4fe6b84", dce_ast = "54cf5c279a1c3127a6e4468db56d031a41bfcc12c020c327314fbcca261bb5d9", bytecode = """ program test.aleo; function foo: diff --git a/tests/expectations/compiler/constants/const_type_error_fail.out b/tests/expectations/compiler/constants/const_type_error_fail.out index c4d9b01598..e87eca5e84 100644 --- a/tests/expectations/compiler/constants/const_type_error_fail.out +++ b/tests/expectations/compiler/constants/const_type_error_fail.out @@ -1,11 +1,6 @@ namespace = "Compile" expectation = "Fail" outputs = [""" -Error [ETYC0372070]: The value of a const declaration must be a literal - --> compiler-test:7:9 - | - 7 | const B: u8 = ((1u8,1u8),1u8); - | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ Error [ETYC0372023]: Tuples must be explicitly typed in Leo --> compiler-test:7:23 | diff --git a/tests/expectations/compiler/constants/constant_finalize.out b/tests/expectations/compiler/constants/constant_finalize.out index 041314142c..487075653a 100644 --- a/tests/expectations/compiler/constants/constant_finalize.out +++ b/tests/expectations/compiler/constants/constant_finalize.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "be00d02ab3c3b889fc1842c26280c35c1d2811e8ad97dfe9aae939cb6e17528d", unrolled_ast = "492de3b239329a520383e6f09fc9988dedfecd6709006127af2d32f233a1c76e", ssa_ast = "88f0d788cc578eb9255c096157fa8d3e801ba656314f39459a3413de844a52fe", flattened_ast = "5e2bd3e32ab5add74daaf4f7d0287d4f987d3ea34a87c953ffc1a3207511e8f6", destructured_ast = "d49494485feecc89a2dc13fe39e0a904d17e79630f6dd2bc61c03a8fae22967a", inlined_ast = "4e916f4e4287ff120cf4c99ab5c6c652e44bc083f1a994d8b9e7118fc3b6c26c", dce_ast = "4e916f4e4287ff120cf4c99ab5c6c652e44bc083f1a994d8b9e7118fc3b6c26c", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "be00d02ab3c3b889fc1842c26280c35c1d2811e8ad97dfe9aae939cb6e17528d", unrolled_ast = "6786a3fe7a1ff16f7e763e957a3639b3747760b44f68ee22d7bb70b508238dc3", ssa_ast = "671a0efcec6d306703e15bc1419a3aea2ab46950ac72d33b9ae5d4873e659555", flattened_ast = "3cba8ccc00b7aca789890a0f0e1048fa71fd2382967a0394fbb36cce6dcc4159", destructured_ast = "3d9e6e3de395a2e2dbe84a5ce7b35bee720564a57ff192bb917e85f46d74cc28", inlined_ast = "3712e27cf6467f8441330ba01fa1374b17cb640c8320189af89875ad8815d345", dce_ast = "3712e27cf6467f8441330ba01fa1374b17cb640c8320189af89875ad8815d345", bytecode = """ program test.aleo; mapping account: diff --git a/tests/expectations/compiler/constants/constant_loop_bound.out b/tests/expectations/compiler/constants/constant_loop_bound.out index 96dd7fbd90..066c825c84 100644 --- a/tests/expectations/compiler/constants/constant_loop_bound.out +++ b/tests/expectations/compiler/constants/constant_loop_bound.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "812159a832e2cf564c38afc08d09e2bae9f3d1cf76fb833b5cc554aebc32c90a", unrolled_ast = "4c7b504a055e87b6d66c422948f92d80e217befbeecd0ceb516640ddf86e856c", ssa_ast = "fa37881cb2d269b64d1dff545eeb1401fab77b7b7bd3024e1de01901891945d5", flattened_ast = "44f9bcaa25c18eac15f590f7f10e92936efaeb03b09aa483768c565498868afa", destructured_ast = "42cc22d4eff9e56e800453aae7e0641b1a96e79f7951530e467902768ab3fd9d", inlined_ast = "42cc22d4eff9e56e800453aae7e0641b1a96e79f7951530e467902768ab3fd9d", dce_ast = "42cc22d4eff9e56e800453aae7e0641b1a96e79f7951530e467902768ab3fd9d", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "812159a832e2cf564c38afc08d09e2bae9f3d1cf76fb833b5cc554aebc32c90a", unrolled_ast = "efd3586e4f7826174cc10749be668cf48d36c64de1c45353cf5ad8eb9df7458d", ssa_ast = "0f5f9b4119a08c9460bb903c4f1041069fabc25de3dc8e4df4fd13529cbe3600", flattened_ast = "08d03308948a79c87eb7e080b1bb30e763f923ae1e53b230c08d516922a33230", destructured_ast = "f7e0b2a2519d4519592f12db96f6907eb78ee8e3e8111508ad4b5b1df27063e8", inlined_ast = "f7e0b2a2519d4519592f12db96f6907eb78ee8e3e8111508ad4b5b1df27063e8", dce_ast = "f7e0b2a2519d4519592f12db96f6907eb78ee8e3e8111508ad4b5b1df27063e8", bytecode = """ program test.aleo; function foo: diff --git a/tests/expectations/compiler/constants/loop_unrolling.out b/tests/expectations/compiler/constants/loop_unrolling.out index 7137f9c0ff..e638a5767e 100644 --- a/tests/expectations/compiler/constants/loop_unrolling.out +++ b/tests/expectations/compiler/constants/loop_unrolling.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "6deebcd133753c70df38755447443e16cc528daee1b9832cd43abdb154276cba", unrolled_ast = "f6b34af4d2326918cbb95643894b7b3d3844f33b44aef65b4505372b8e11399d", ssa_ast = "d6f28bcd6daab23b594ff1354042486d0c7e2e116ff4608abfad1934dc83b2f2", flattened_ast = "b2642e703ed986b943c91de0f79a1057161d82f434aa0d41a5373ff4f25cd7f5", destructured_ast = "71b82ad80dabf3561b97175c95f3cbd8e87df04a2b37f64caa43f90d1e1ff73a", inlined_ast = "71b82ad80dabf3561b97175c95f3cbd8e87df04a2b37f64caa43f90d1e1ff73a", dce_ast = "7e25594b758786c219cdd31ddf385997f029bf317121ad416b5c7de3f2d57946", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "6deebcd133753c70df38755447443e16cc528daee1b9832cd43abdb154276cba", unrolled_ast = "c0397749e85d0c7ae287ad01eb3f6ac5f71fcac8c3e556bd601fbcd7e8cfbd60", ssa_ast = "d2469ac2595064d003d9c78fde9eefa0b892a77a3ba8676dfe4f9b421b18236a", flattened_ast = "a4489bc94f9e05eca781ed0f24b7d3361633457e7e33489bc89ba3065d90e6ed", destructured_ast = "ed9d88755d62e8f3196f614070f4c024110ca1277ae3784690402a592045503c", inlined_ast = "ed9d88755d62e8f3196f614070f4c024110ca1277ae3784690402a592045503c", dce_ast = "d065c418fe2a90ea37c0a5aedd34a7048ebc117f98778377d3dc024aa06c2bef", bytecode = """ program test.aleo; function foo: diff --git a/tests/expectations/compiler/constants/unroll_loop_with_tuple_definition.out b/tests/expectations/compiler/constants/unroll_loop_with_tuple_definition.out index a2444bc5fc..b5f886f2c2 100644 --- a/tests/expectations/compiler/constants/unroll_loop_with_tuple_definition.out +++ b/tests/expectations/compiler/constants/unroll_loop_with_tuple_definition.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "163b4dae689a449686c0502351d2551d84266e67e9fb1615e4d9111980318b98", unrolled_ast = "93f3440b8800e944c29b9f76bcc1aac385d1df9f3facba569a744875c610dfce", ssa_ast = "f246b5298d48b9ffb241d2b2c3959ee22241e14c2248a87db55fd396c03d33d2", flattened_ast = "2ebd0b45cf084d70a3b9db138244e9c7c83f2a1d590701421afcede4cc3e8bf9", destructured_ast = "571223a491008f79dc5c55781f179d2ac2d43b6cf7294581bafbd2dc0bc58c9f", inlined_ast = "571223a491008f79dc5c55781f179d2ac2d43b6cf7294581bafbd2dc0bc58c9f", dce_ast = "32a6c4051ffade501e825cf381f56d967e512fcae653189e797d08ed81f35b47", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "163b4dae689a449686c0502351d2551d84266e67e9fb1615e4d9111980318b98", unrolled_ast = "916e3a7a2113916fcc44d65b44402b68414f33fd06c4e0a537a24903716c0879", ssa_ast = "51de2b1cbe49dc07af1c8867b8ec4b3f19391cf84f59642ea659de56ce875e39", flattened_ast = "12418c2f85b68040b8809c78aecdce66dcfc4f22c4bb94fc89038b4c8449d9c6", destructured_ast = "c849fd3c4345c7e0b0f5655181a4c4bc59037e668703588faa5b6e6068ba1a13", inlined_ast = "c849fd3c4345c7e0b0f5655181a4c4bc59037e668703588faa5b6e6068ba1a13", dce_ast = "61390312771870c4af22384b22ce532510071ff946ce5b5e064575430462816a", bytecode = """ program test.aleo; function foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp1024_commit_to_group.out b/tests/expectations/compiler/core/algorithms/bhp1024_commit_to_group.out index 61d0ba3649..735fc7f575 100644 --- a/tests/expectations/compiler/core/algorithms/bhp1024_commit_to_group.out +++ b/tests/expectations/compiler/core/algorithms/bhp1024_commit_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "1c163f034fd1e1185cdc76efb2e337dc3d46a4b12d55497245f209399c064a24", unrolled_ast = "1c163f034fd1e1185cdc76efb2e337dc3d46a4b12d55497245f209399c064a24", ssa_ast = "4e0df0b799fafd9e6fc57904ef02e0b026a17042cb6fbd3c19231d20124696cd", flattened_ast = "5bf3de768dd0d1772bb76aeaf703ab13f72e5e372a3e49a91ba37019df6eb613", destructured_ast = "3b5e2a7639bd0ee09f32d1a8ecf7a98345b173333fe419bdfc5cb3a26287a1fe", inlined_ast = "3b5e2a7639bd0ee09f32d1a8ecf7a98345b173333fe419bdfc5cb3a26287a1fe", dce_ast = "6611276029e033b62fc0192539ae527a042085a066404dd3923267d6a28b2a2c", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "1c163f034fd1e1185cdc76efb2e337dc3d46a4b12d55497245f209399c064a24", unrolled_ast = "157581110b60570d6c800e407532799af41ab31bf25d83c6cf759bc9a2db99bb", ssa_ast = "10cdbabc20cf637d45730684e5b687b4c19955196cf8acff60c4382ac0a5e5af", flattened_ast = "0d3cec78d4941a7ba5b078efdeab7f9b681c7bc226d4a6e7c386b77d1dc66808", destructured_ast = "6a87c6f107e7007171935775a144552548648d5b47beba47de340ec065544bdf", inlined_ast = "6a87c6f107e7007171935775a144552548648d5b47beba47de340ec065544bdf", dce_ast = "b48080416400388fba6c2e4903178f37b85b2c0aeadf68e94dd0f912ecdefc4b", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_address.out b/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_address.out index 00b5fc8c34..8f8874efff 100644 --- a/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_address.out +++ b/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_address.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "a3dd97bc31b1dc64c7608e1fc5ad68b8d0d3f781e49c207928f5d425f1fd1bf9", unrolled_ast = "a3dd97bc31b1dc64c7608e1fc5ad68b8d0d3f781e49c207928f5d425f1fd1bf9", ssa_ast = "ed3fd32fe2f8d8f419bdbf1abf78c6f1af1e0ee9ee74188e48886205b7a9744a", flattened_ast = "1296938ea71288a8b64f116c48377f091f366a4a01cf9f20a9aadd3676d89a84", destructured_ast = "aaf2797e71fc28e403368fbceb36062a0b1352e9d7ac6caeecb1d250f0e9e84c", inlined_ast = "aaf2797e71fc28e403368fbceb36062a0b1352e9d7ac6caeecb1d250f0e9e84c", dce_ast = "f22471183488a6b6d96935c302e8b542b24e5e7ea3c947b0c8f01c52687bc37e", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "a3dd97bc31b1dc64c7608e1fc5ad68b8d0d3f781e49c207928f5d425f1fd1bf9", unrolled_ast = "e06be32522f1fdf91fc05697d9159c601c4a6eb9e247e0359597763d2fc89d07", ssa_ast = "7106adf81d83a9d8c31b3dda931dd9eff617246b455c066edd4f647886296206", flattened_ast = "e405e1aefd4cc0b1e93ce4d559df2ca392722954e0c8491dd4b6a5955f2f28d2", destructured_ast = "d37126ab062737d6ad9e2b139127074a1b9b62cb4d26153f3b10265e67789250", inlined_ast = "d37126ab062737d6ad9e2b139127074a1b9b62cb4d26153f3b10265e67789250", dce_ast = "23f6df23ca49f840e7157e7a17d3528afb98fea8ccc67dcce9ef750594127abc", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_field.out b/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_field.out index 5ae5a49fda..7892600b65 100644 --- a/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_field.out +++ b/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_field.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "61fef7bc7d35be574e5f9353c089561c113afe14c755051cdfac56879b67b6f8", unrolled_ast = "61fef7bc7d35be574e5f9353c089561c113afe14c755051cdfac56879b67b6f8", ssa_ast = "5de3029f4a7bb61031f1852bcd6163cf8e40e10352746016f33aad682f810e5d", flattened_ast = "dd29a1fa78efcb5fa7e428276e9285105ffef017e43d8d4a3eee6a47d3604fab", destructured_ast = "420edf1819b67e9e9e25822608379793a3aa7a9c85e858695c0349a6dbc34881", inlined_ast = "420edf1819b67e9e9e25822608379793a3aa7a9c85e858695c0349a6dbc34881", dce_ast = "3cd075a82acacaf50339ddc532e27e0504d7c337ae6468998c2d8e82f20bfe40", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "61fef7bc7d35be574e5f9353c089561c113afe14c755051cdfac56879b67b6f8", unrolled_ast = "62d3782e637d42e65b26cc28b134c914b10b78bb4ff954b5495a58def7e529fe", ssa_ast = "73f7d99b1110c1b00a28177d9bc27e8de3432e01cf2177bf1c323883ef74ae26", flattened_ast = "a532b1682b91e55bd91ea832f72da5c5d76c8a7fb29a2ddb23b20f548a667d08", destructured_ast = "39e7cc1109e3e765da197247e7177576669b95730e7a6769cf7935bac8dd1baf", inlined_ast = "39e7cc1109e3e765da197247e7177576669b95730e7a6769cf7935bac8dd1baf", dce_ast = "9a35dc0ea62d2ae6e9560099f1e5847afbeaa25dacc0b9209a044ef189399b06", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_group.out b/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_group.out index 77b340e01f..5e85c8c167 100644 --- a/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_group.out +++ b/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "69ba7af7318b356010c470baa89403e4b3bf78c69678f4bdb8ff2a8795b622ed", unrolled_ast = "69ba7af7318b356010c470baa89403e4b3bf78c69678f4bdb8ff2a8795b622ed", ssa_ast = "e7c54cfae2b8380df7a81f6cc3da47ea623b350766897ed1070e6ca9888bc4ad", flattened_ast = "11c06e77fb2d9c279653af9fe561ebdb18afc0d7d12209a6093716aae15e90f5", destructured_ast = "0e3d7a62e620506342a715698e35dcc1711298adb8c49c88386bf0e16992f5d4", inlined_ast = "0e3d7a62e620506342a715698e35dcc1711298adb8c49c88386bf0e16992f5d4", dce_ast = "a99474055784ba90aa18abb8f629f9e782426703805aa8221dad832b2fa4aa4b", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "69ba7af7318b356010c470baa89403e4b3bf78c69678f4bdb8ff2a8795b622ed", unrolled_ast = "8ef312b80e8d59ad0848b683fbcfc8d896bc10d26dd7ccc1d1e15a163fb9aab5", ssa_ast = "77ed4ffda1a596a60b0b4b754ab3f78b899e8b2cd09873327b9c49bb5e8faccb", flattened_ast = "3980382ec0f40c513e0f18fd526284ef7be92a93dc859fe05f8ba647d67c3385", destructured_ast = "fd8270f60e08d57319c932902e2a4dedda5f9ee9b75f56ea730826947c2b5b76", inlined_ast = "fd8270f60e08d57319c932902e2a4dedda5f9ee9b75f56ea730826947c2b5b76", dce_ast = "b45069cfc89aade6ccb01a0b3fde2b2086d01f2bbfba5e218ff6c44867f021d4", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_scalar.out index be06a15f90..f59e9fff72 100644 --- a/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_scalar.out +++ b/tests/expectations/compiler/core/algorithms/bhp1024_hash_to_scalar.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "f405095809db6c091f111abe5150dd9006a07cd0f132f06b27a2a8b508358e18", unrolled_ast = "f405095809db6c091f111abe5150dd9006a07cd0f132f06b27a2a8b508358e18", ssa_ast = "18e01f5084ba96a39dc25e18c44d911be333b8e9580dfd595f1de026582e9c19", flattened_ast = "fa21a9ca89789634065434f5ebc78410950a531176db8a832c7cc67d5a8f54a5", destructured_ast = "1bc4d9e39e98ef64605bb826914d34a4396b47a08fc6fa8160d4441355e64893", inlined_ast = "1bc4d9e39e98ef64605bb826914d34a4396b47a08fc6fa8160d4441355e64893", dce_ast = "0d3f409259a87700f5d103681faecd747c6aeb3f4f1d614dfa45ea2910b65f02", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "f405095809db6c091f111abe5150dd9006a07cd0f132f06b27a2a8b508358e18", unrolled_ast = "9d5bcc27f2ff66e122fb00edd5db5cc19a14d32451b01914f066ce50c1f0f5de", ssa_ast = "31a873d938378148be6786133eeaa0e8df8c4b4cdbca7571012406cff6a44be0", flattened_ast = "71f9546584f93cadd8c6320fd4c72769581a39e96d84a8218c9b5a32b663d08d", destructured_ast = "cc23d822a7304e409d59ca0ea6834aa864401f2452bd21eacf025e8da3eceefe", inlined_ast = "cc23d822a7304e409d59ca0ea6834aa864401f2452bd21eacf025e8da3eceefe", dce_ast = "fedb4d139531355cd1b2b73729fd14018647835cf781707106bb3d9b4688109a", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp256_commit_to_group.out b/tests/expectations/compiler/core/algorithms/bhp256_commit_to_group.out index 945f86fe2d..751f64eed1 100644 --- a/tests/expectations/compiler/core/algorithms/bhp256_commit_to_group.out +++ b/tests/expectations/compiler/core/algorithms/bhp256_commit_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "e3bf36328e9bafe4e3b81ae0ceb5bd6dc73cc9ca51727d14501a5673d25afa53", unrolled_ast = "e3bf36328e9bafe4e3b81ae0ceb5bd6dc73cc9ca51727d14501a5673d25afa53", ssa_ast = "da0e22cfd7aae96b559fc2e2b41a6992c7bf4c277d67545c335a1586d4de7c7b", flattened_ast = "566dd8c1f54b3e74efa7e577902dd03f601f79d826b7dcf0c63872a94b59e560", destructured_ast = "f5b521fa1d75e961db1d41251288d968c27e40266402ebc69dbffa3a80d13861", inlined_ast = "f5b521fa1d75e961db1d41251288d968c27e40266402ebc69dbffa3a80d13861", dce_ast = "7579e9d7d7bb4299281afb520d80f1e28309ea773c68ff5f981da57338d82ef0", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "e3bf36328e9bafe4e3b81ae0ceb5bd6dc73cc9ca51727d14501a5673d25afa53", unrolled_ast = "1ae9ac1149f398d0e07c75524941f5e1324a62cdd572ebded49a07362ac2ef43", ssa_ast = "93732fb0c178bcce0fed11956c746f529181b15f6f5dc7ff8abcd8b5e532df40", flattened_ast = "bd6769a8d7698f49fcbf061ff36de163930953a8978ac9eb7d921906f076bdb0", destructured_ast = "35e3ad579c962e4a94c478af5b624d31921edfdb2b8cdb57c875093138e8a2e4", inlined_ast = "35e3ad579c962e4a94c478af5b624d31921edfdb2b8cdb57c875093138e8a2e4", dce_ast = "8c142364e2051e6d2bc6b3954550a1c72995508ac36a6d72f3429ca475b79cdd", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp256_hash_to_address.out b/tests/expectations/compiler/core/algorithms/bhp256_hash_to_address.out index 21568d739e..160b2c63c5 100644 --- a/tests/expectations/compiler/core/algorithms/bhp256_hash_to_address.out +++ b/tests/expectations/compiler/core/algorithms/bhp256_hash_to_address.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "54d5789b9203beae85c2a109a1cb48db19e732fc5a1c4ebd961404b548cbfec6", unrolled_ast = "54d5789b9203beae85c2a109a1cb48db19e732fc5a1c4ebd961404b548cbfec6", ssa_ast = "19f9e1226c418bfee16fb4db866978220a04685453abc1ea78b4c1ce9b8fcc6a", flattened_ast = "86050d5626e8e03a046b9c6e98ed1abe7ed1fcdceb928ff2bd536642b5cf46be", destructured_ast = "2e1906abbf3c7ae55a4059dc421c68c854135a22723e6560bbd6c5824137180c", inlined_ast = "2e1906abbf3c7ae55a4059dc421c68c854135a22723e6560bbd6c5824137180c", dce_ast = "0462c15d429b8c65c4375284d9496131c4441e67282fee93a9f0b9a581c9fc87", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "54d5789b9203beae85c2a109a1cb48db19e732fc5a1c4ebd961404b548cbfec6", unrolled_ast = "6220194a35392eb96a4ff9bee9baf0b70fc988f88e54bff61a28079d3f85f0f9", ssa_ast = "e2b3fc2bfd739d79d1a7ed3eb0082e9fda2755254f0791912d5adc4bfc62312f", flattened_ast = "f8b66950ba4e509a86aea139d526f423805f3afaf464f3cb6d9aeb6ae1310e82", destructured_ast = "e5f4ff2cf2c792a10ed974a6b9e6bc51049c413d4ec4bfd9bb7c027c0532a15c", inlined_ast = "e5f4ff2cf2c792a10ed974a6b9e6bc51049c413d4ec4bfd9bb7c027c0532a15c", dce_ast = "f216cb036f8d869188042e194bedc00472a5a13bb3f913792b4a66bec56d6e08", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp256_hash_to_field.out b/tests/expectations/compiler/core/algorithms/bhp256_hash_to_field.out index e4f816080a..51e6ab0dcc 100644 --- a/tests/expectations/compiler/core/algorithms/bhp256_hash_to_field.out +++ b/tests/expectations/compiler/core/algorithms/bhp256_hash_to_field.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "f761e8138c6766dd7d8a1707de6ccec23c5c377812b477ebec3d295bc2f79a02", unrolled_ast = "f761e8138c6766dd7d8a1707de6ccec23c5c377812b477ebec3d295bc2f79a02", ssa_ast = "d9145a2183c23ebb95bd6518bff3b3f012f2e6da03e1d7e9cd3579f15720e7a6", flattened_ast = "ce87bef92fda0939fbd0d1ba19647df9cc91e17e51df18a8975371b56a6ed23e", destructured_ast = "1f3e64a523f29f00fa59c82fe910d5005031e8ebd21c789d51734c5d8e13aed5", inlined_ast = "1f3e64a523f29f00fa59c82fe910d5005031e8ebd21c789d51734c5d8e13aed5", dce_ast = "cffb2c5eeb571350d21a5dd1d3a42bf9e8c81b11107852f549745c115aaeb604", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "f761e8138c6766dd7d8a1707de6ccec23c5c377812b477ebec3d295bc2f79a02", unrolled_ast = "5e47dae18f98b4e4918f2e15a70b6bf70848eed8c43af2441821f05678321f93", ssa_ast = "ecc357d6d276d4b7c6f04cfd8bf2ada32814da1025cd288fd3e2134fead8898a", flattened_ast = "dcadbb89154ef7f846f0c30f0366b729c5533c995ce67a504a579a0769d86469", destructured_ast = "da35da94ab8d5478ddaaa796a904ae7483bb6ee5007347f3bd223fb52f6a7adb", inlined_ast = "da35da94ab8d5478ddaaa796a904ae7483bb6ee5007347f3bd223fb52f6a7adb", dce_ast = "57a8a4fd4d9d34b3b6e76eb0e08f68fb22007c930cf4c174208c061c76083b2e", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp256_hash_to_group.out b/tests/expectations/compiler/core/algorithms/bhp256_hash_to_group.out index 5a3d110fec..e488c6332e 100644 --- a/tests/expectations/compiler/core/algorithms/bhp256_hash_to_group.out +++ b/tests/expectations/compiler/core/algorithms/bhp256_hash_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "8e44992dd5fe4fe9e1e522e695ca70d239f3eeccc3728b150ed9364421be09c4", unrolled_ast = "8e44992dd5fe4fe9e1e522e695ca70d239f3eeccc3728b150ed9364421be09c4", ssa_ast = "6acbe24af7ad5a0c469dd53118362a8882c8d59a5f766af6782531108c47326c", flattened_ast = "9373e82b218ce1b7cd4f5276cfaf3295f93b3d104ae073c6b04e225018bb57fe", destructured_ast = "e85f838f76070991ca098bdba4c1dce1f7918403840321920525250fa5ee4073", inlined_ast = "e85f838f76070991ca098bdba4c1dce1f7918403840321920525250fa5ee4073", dce_ast = "b4e7468676095289b2e6048f8644f63f87391e9670df3b27a60eba3089b4e3ef", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "8e44992dd5fe4fe9e1e522e695ca70d239f3eeccc3728b150ed9364421be09c4", unrolled_ast = "4c054c4b4207c35202befbc50019c5eecf25d7cadcce3caf28cfca78870e8c20", ssa_ast = "834af12d9e7450d09bf05980a7b8a56d198c1e4ce46265b03ecb5bc2544dc915", flattened_ast = "6ebf9ea971d0e17ab3517464deb6eac94fcc1966ffdd790ad13fd10fa6901b0d", destructured_ast = "d58f893e1ac8bdb8a4c84b1eae3d72c91691de378b8efcff5c500055e35ea07a", inlined_ast = "d58f893e1ac8bdb8a4c84b1eae3d72c91691de378b8efcff5c500055e35ea07a", dce_ast = "a38fa4ea1315ff2cce998d8df098b62820d2e0f4eca8855c86d027e72e2a923e", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp256_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/bhp256_hash_to_scalar.out index 4dd58f4989..8cfa1de3e3 100644 --- a/tests/expectations/compiler/core/algorithms/bhp256_hash_to_scalar.out +++ b/tests/expectations/compiler/core/algorithms/bhp256_hash_to_scalar.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "e24ee1bcabcc08b4b186df3883e05bae4f6452569f613294a6ee7aaa5b51a67c", unrolled_ast = "e24ee1bcabcc08b4b186df3883e05bae4f6452569f613294a6ee7aaa5b51a67c", ssa_ast = "42bb275bb8f30f844e720e95ff44f8c2d8b2edc12ea4d29245ab4b13068b480f", flattened_ast = "018dc16ea828956c4831a0867627751a833bef0e4b474918db2bc17b3658b1d8", destructured_ast = "821596ca67920e30b4904b190cd9387029414909381747860fdd7575b671533a", inlined_ast = "821596ca67920e30b4904b190cd9387029414909381747860fdd7575b671533a", dce_ast = "82b0310905bf404ce4d12c69f1955ec06b6e7d09e957b532f73fd9191aeb4fcb", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "e24ee1bcabcc08b4b186df3883e05bae4f6452569f613294a6ee7aaa5b51a67c", unrolled_ast = "a82e90122640e71692c87232f54ed72343776430612e099308a296c6ca4621eb", ssa_ast = "f9757af6c272677bc92b4acd70bf0d6407f6902f966e4fa738f6c431b98f7e97", flattened_ast = "03a6fabc1d76ce9be96c0947d5dad6a0abef0efa86dd7078279cb3a4cb0fca2a", destructured_ast = "06ff3c98b67c549d18518005762f0553eecc0055b1656f0275f83df1b5e4f7d9", inlined_ast = "06ff3c98b67c549d18518005762f0553eecc0055b1656f0275f83df1b5e4f7d9", dce_ast = "d6612d524ac00941c4fe43cf741d0b88e67c2efce76c334bcb10e0128d752c1a", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp512_commit_to_group.out b/tests/expectations/compiler/core/algorithms/bhp512_commit_to_group.out index 546a4c85c9..9417b25260 100644 --- a/tests/expectations/compiler/core/algorithms/bhp512_commit_to_group.out +++ b/tests/expectations/compiler/core/algorithms/bhp512_commit_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "8e5af978a77e15bbbf47f9025c5ad93b11577ef9b82a1b20835d7b476000074a", unrolled_ast = "8e5af978a77e15bbbf47f9025c5ad93b11577ef9b82a1b20835d7b476000074a", ssa_ast = "e937decfcaff95c515d583feb0a34bf731c67bcbda8630d0582b1401d2f6c894", flattened_ast = "b1edf1cc607cb5008e0bfb45fd1c335b31877b4701f3b9cdbe1f8dafc2dd7e06", destructured_ast = "8fb196364453dd517d282ecec4cbf3214d001ec642a084b62b75214b17469cfc", inlined_ast = "8fb196364453dd517d282ecec4cbf3214d001ec642a084b62b75214b17469cfc", dce_ast = "91b7c373ab7d91ceaed92088c802966d231a1c58c82cf3ae0ec21fa48bb66b69", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "8e5af978a77e15bbbf47f9025c5ad93b11577ef9b82a1b20835d7b476000074a", unrolled_ast = "558031266fb0e1342788c538df67e022740dc7c4893a28af704f3f4214aa53cd", ssa_ast = "4b69d2ca86fa9d66b2ce867180e5d8d7946c65c61ec4266b6bfd83e501236b3d", flattened_ast = "b32764b7dc19f65b493def0c49d1ac8b12c1741c2193d86a5d663dc315994da5", destructured_ast = "fc02f31a9afc57fe5cf266130ffd2fc8c8e927a197c3e3c6d70ee923f2f64c83", inlined_ast = "fc02f31a9afc57fe5cf266130ffd2fc8c8e927a197c3e3c6d70ee923f2f64c83", dce_ast = "d203a848a9cd98330dcad191a5b42df051e98ace161801683d2e041727477c2a", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp512_hash_to_address.out b/tests/expectations/compiler/core/algorithms/bhp512_hash_to_address.out index 5244516fb2..d900c6d4ae 100644 --- a/tests/expectations/compiler/core/algorithms/bhp512_hash_to_address.out +++ b/tests/expectations/compiler/core/algorithms/bhp512_hash_to_address.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "5f33c08cdb5e22d7c1205004378e2f12c9c1995ca6e2e5a4d26e3998f508c95b", unrolled_ast = "5f33c08cdb5e22d7c1205004378e2f12c9c1995ca6e2e5a4d26e3998f508c95b", ssa_ast = "8bbbff498274b89e30b9f1198241543378e0d6196b8b03035e2af4aafd054a7d", flattened_ast = "e8ce32f070f276be670a8f16e75875b64f602ccdde870e32f9379f065bf3bca8", destructured_ast = "ecbd683e2fe643bf66884f87e51189ebb546e9911b6fdee878bfb2e6af1e6851", inlined_ast = "ecbd683e2fe643bf66884f87e51189ebb546e9911b6fdee878bfb2e6af1e6851", dce_ast = "0462c15d429b8c65c4375284d9496131c4441e67282fee93a9f0b9a581c9fc87", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "5f33c08cdb5e22d7c1205004378e2f12c9c1995ca6e2e5a4d26e3998f508c95b", unrolled_ast = "40245f8f52927a0fa430b4a8458847810e2ae03eb6ad345e8f591048b7373291", ssa_ast = "e6b63ebe4cb21e5f08b6ff12ac52726889016bab3feb17da76d7f142ffbeb245", flattened_ast = "dabed03dda67a8033846f6643059305b501ce10d4a33da40693e456ccc716f10", destructured_ast = "c6eca056cb723e62aee643eb3e1949ffdb4cd8eaffbf72bcce93418513a8f56b", inlined_ast = "c6eca056cb723e62aee643eb3e1949ffdb4cd8eaffbf72bcce93418513a8f56b", dce_ast = "f216cb036f8d869188042e194bedc00472a5a13bb3f913792b4a66bec56d6e08", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp512_hash_to_field.out b/tests/expectations/compiler/core/algorithms/bhp512_hash_to_field.out index 7c49c13829..dadf68282b 100644 --- a/tests/expectations/compiler/core/algorithms/bhp512_hash_to_field.out +++ b/tests/expectations/compiler/core/algorithms/bhp512_hash_to_field.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "16cc9b0724e9b9710a1fb2b2a102bf195cdf67ef04faff80eb44a98684d53287", unrolled_ast = "16cc9b0724e9b9710a1fb2b2a102bf195cdf67ef04faff80eb44a98684d53287", ssa_ast = "fdcb2dd71b3081a87535865597a60e3611c6d06099cb5f1437f87e8a854b860b", flattened_ast = "9622685fa672d5e99ecf1274e696cc0a24994bc508bb1cdaf49286344ff1e526", destructured_ast = "bc838823e9e86bb974a1f6078a49b60ba274812bca1058d5b276a6829f98fb1e", inlined_ast = "bc838823e9e86bb974a1f6078a49b60ba274812bca1058d5b276a6829f98fb1e", dce_ast = "c66a2e365c334442bd39de0096260a8f6d5dad071e3681fc5c24821f73978eb7", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "16cc9b0724e9b9710a1fb2b2a102bf195cdf67ef04faff80eb44a98684d53287", unrolled_ast = "d670f721cfe7b6853116699734d548543278b6eaeb3e952140c8e8462720a8d7", ssa_ast = "e7cc7fc56217cf9477599a012abb3ed6bb399abf838cb508adfb35f0a200fa11", flattened_ast = "2bdc2d48635f2a53f1d515f406d16da0b2aa89527c9279eb365f421a09305c99", destructured_ast = "71342b109f6089f0272c15b5df2dfe0513b6088980cce9e0399555cb632c75d4", inlined_ast = "71342b109f6089f0272c15b5df2dfe0513b6088980cce9e0399555cb632c75d4", dce_ast = "1ab58b911588ab84af0775e8e13c2ba97206bf2a4cf139cbb3d0d275960eff0d", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp512_hash_to_group.out b/tests/expectations/compiler/core/algorithms/bhp512_hash_to_group.out index 8dec2e9191..62b4589ac3 100644 --- a/tests/expectations/compiler/core/algorithms/bhp512_hash_to_group.out +++ b/tests/expectations/compiler/core/algorithms/bhp512_hash_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "f41b5d1390511e0b7498f813fba346f400ef66bf636f0d1e28dbb55869a80153", unrolled_ast = "f41b5d1390511e0b7498f813fba346f400ef66bf636f0d1e28dbb55869a80153", ssa_ast = "cbb8a516a4b76218ff24a3c56e42a435b0b8acb6ea33e2cb074a787ef51b22ab", flattened_ast = "87ba6241b5819ea21eb90f7eb502bd1674196560d3343f39c59119c8b380a402", destructured_ast = "e4612e20aa9f9dbb9128f4423910188ba27e66b21eed6afe615e6bb1574a500d", inlined_ast = "e4612e20aa9f9dbb9128f4423910188ba27e66b21eed6afe615e6bb1574a500d", dce_ast = "dea0015bae3270eed36e9d7e9a1988ad1924df3eff4728499da344346f5fb439", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "f41b5d1390511e0b7498f813fba346f400ef66bf636f0d1e28dbb55869a80153", unrolled_ast = "5f8af7898d61e0b52ac7ea36ef87f28b024f431f8e2305c0d4160d9ee1b766c5", ssa_ast = "f3ddf01e091f98d3df4f4c1471bf744273457dd6f0890e1bb9b0529827a98bbd", flattened_ast = "734d0577bb2075407dac4927928cd9f0eea62cc5ad5b8208488b9ae3e610aaf8", destructured_ast = "f4a08738e66e90b3c3b271e3bbe15ddc161dab9e7f8eac68d3597cd415090db0", inlined_ast = "f4a08738e66e90b3c3b271e3bbe15ddc161dab9e7f8eac68d3597cd415090db0", dce_ast = "f6e6331a8e25bb53dc1f975def720467a900ef4b76ab5334fb5e6829d0d35fe4", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp512_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/bhp512_hash_to_scalar.out index 93fa418a00..42580ff937 100644 --- a/tests/expectations/compiler/core/algorithms/bhp512_hash_to_scalar.out +++ b/tests/expectations/compiler/core/algorithms/bhp512_hash_to_scalar.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "d60a209f48b0a4b33519f098daa79b8b28be280323adeae4c0a616bcc5d62110", unrolled_ast = "d60a209f48b0a4b33519f098daa79b8b28be280323adeae4c0a616bcc5d62110", ssa_ast = "30b3e677012b1457ef425207307f185d8c6197ee1d5f6ccf368b74ed85b5048d", flattened_ast = "0f86fd9e319aefdb84bc8c75a61a1fa3be1f3df572b7eeced37a4e26b86ffb92", destructured_ast = "77819eeb958302ce40bf40378fef4754d014a35cfbd966b8ea0bdd315fd0c0e2", inlined_ast = "77819eeb958302ce40bf40378fef4754d014a35cfbd966b8ea0bdd315fd0c0e2", dce_ast = "81b680f52e95ccb1c95e0342a4d2265504bce5056e28435d4dc99e3491ec4775", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "d60a209f48b0a4b33519f098daa79b8b28be280323adeae4c0a616bcc5d62110", unrolled_ast = "78d218d40218d972b274da39abf96be8c73c76542f6baa4a0deb6ba4d85a2b12", ssa_ast = "3545bd40ffacc70f3e300d5dc3038f750d6a29da08d085884e8188bd09b1581f", flattened_ast = "07522cf4073a847234376dccc7ec5621b461a0a74e4a2713c2a4c466691770d2", destructured_ast = "b0dab9717288ef9afaae81d806466f9cb55c00e7472fe641f357ecc4952c4bf1", inlined_ast = "b0dab9717288ef9afaae81d806466f9cb55c00e7472fe641f357ecc4952c4bf1", dce_ast = "484a6aa023ee82c0181203da9a7f797c77a938c1fe41d721e84c374899a91890", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp768_commit_to_group.out b/tests/expectations/compiler/core/algorithms/bhp768_commit_to_group.out index dc941e7a5e..ed2dbe561b 100644 --- a/tests/expectations/compiler/core/algorithms/bhp768_commit_to_group.out +++ b/tests/expectations/compiler/core/algorithms/bhp768_commit_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "fb08394f4d3809df07ea2bd43d1a2d603a5b60bd5ec0ebea53924e2e477932b3", unrolled_ast = "fb08394f4d3809df07ea2bd43d1a2d603a5b60bd5ec0ebea53924e2e477932b3", ssa_ast = "7459d8925c091bdd6d6114d393ec10fd1b244dfa08cd35c2770cccb3dd14d74b", flattened_ast = "2c7a7d7a588435725614843424b7c52c5ce25e02c20a84af98b9c6312a6bf7c7", destructured_ast = "e33b97e520f7e1f94c024641d11365b706c815c4bc3af2f4c5ddd4d15abd7a1e", inlined_ast = "e33b97e520f7e1f94c024641d11365b706c815c4bc3af2f4c5ddd4d15abd7a1e", dce_ast = "2ca3e75ed482aa6b570ff3a7ac124f10f3d243f9eba535c10759c4c36ce79070", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "fb08394f4d3809df07ea2bd43d1a2d603a5b60bd5ec0ebea53924e2e477932b3", unrolled_ast = "2597dcaf791eff668515cc8527cf65320614f8b4c0d9280c81fd7efc4b2d4fd5", ssa_ast = "18c45c9ebb0c018c6d2e0e8e9c7b989d8374cc2a949680bed5253a84994fe9f8", flattened_ast = "3e6f818fd6a8beba3ca873f1be90e0253631e64b94a05b0421ccad270d712527", destructured_ast = "b4caf60461e32329e0ca1f727dc3cd0b429cd57d863e96dff6750be180404b94", inlined_ast = "b4caf60461e32329e0ca1f727dc3cd0b429cd57d863e96dff6750be180404b94", dce_ast = "83db82b50c496ae78db4ad98186cfa92d82cf88a078f5d03c87dee1ada49273c", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp768_hash_to_address.out b/tests/expectations/compiler/core/algorithms/bhp768_hash_to_address.out index 284c2b98b8..4949ddcce5 100644 --- a/tests/expectations/compiler/core/algorithms/bhp768_hash_to_address.out +++ b/tests/expectations/compiler/core/algorithms/bhp768_hash_to_address.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "3e30a24d3bdbc75b54c300a8e99fc4e1d513af6c597b1291c9dfb7e67da8c297", unrolled_ast = "3e30a24d3bdbc75b54c300a8e99fc4e1d513af6c597b1291c9dfb7e67da8c297", ssa_ast = "9be7ed8b9da16a2c38800e35ebcfc92d33e7ffe72f68ee3b19bc46ec2c162dfd", flattened_ast = "8e8a6533cfd710c1e78601156991d3105b67d8a3998cf9e3986d35a92e7faedc", destructured_ast = "3d07ad984a3a1b8968fa045b62b6ebb7e8f7ecd654c1b59060147ec1b6c9598f", inlined_ast = "3d07ad984a3a1b8968fa045b62b6ebb7e8f7ecd654c1b59060147ec1b6c9598f", dce_ast = "0462c15d429b8c65c4375284d9496131c4441e67282fee93a9f0b9a581c9fc87", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "3e30a24d3bdbc75b54c300a8e99fc4e1d513af6c597b1291c9dfb7e67da8c297", unrolled_ast = "9863883d19c818138a29e0960443c3ee8abbacefc6aef267f5f028e6dc2effe4", ssa_ast = "126202e371a49193414242ad4ff9958193b6a8f30921bdae69069864709603fa", flattened_ast = "f85002c19f358e86e0e3482a752c8abc5488683470107bd255ce77ddcb5de1c5", destructured_ast = "9c8c9b758a000a0a37e6fd9c651875d9d415be34188ccccc4c1dbff992174246", inlined_ast = "9c8c9b758a000a0a37e6fd9c651875d9d415be34188ccccc4c1dbff992174246", dce_ast = "f216cb036f8d869188042e194bedc00472a5a13bb3f913792b4a66bec56d6e08", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp768_hash_to_field.out b/tests/expectations/compiler/core/algorithms/bhp768_hash_to_field.out index 2aa8054904..c2fa160790 100644 --- a/tests/expectations/compiler/core/algorithms/bhp768_hash_to_field.out +++ b/tests/expectations/compiler/core/algorithms/bhp768_hash_to_field.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "6b68c65600169f8c8cee0a021d375084f0ddeb6149fae46b9573c699766c5ab3", unrolled_ast = "6b68c65600169f8c8cee0a021d375084f0ddeb6149fae46b9573c699766c5ab3", ssa_ast = "ee19175861e7e4461f9fa8cca8cae7fadf14c65c7b01a8b8be6954204dafcc8d", flattened_ast = "10cd22a4a10187d6e06d8c06634296f3645b14a042df3f9ea0ace3f4a6b74231", destructured_ast = "c91853dca89651fb270296c523104264a444cd1e60770ce61f814f049d24cd41", inlined_ast = "c91853dca89651fb270296c523104264a444cd1e60770ce61f814f049d24cd41", dce_ast = "745d5f7d5e373f50f54aeeeb329f068083761fdae2946b3edc490a04f0c4fd99", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "6b68c65600169f8c8cee0a021d375084f0ddeb6149fae46b9573c699766c5ab3", unrolled_ast = "3bf96022d2edd65deff5555719f9c320fd83879fc42df1e9dcc86907fe0574ab", ssa_ast = "d7607591ebdd1ff40eaa35bf7627bc114a87f3b9430684bf097e385b285c3ab3", flattened_ast = "7be76e5de9f110812dd29568e582d39d85ebc93f1edbff85ed5b16735d15cbb1", destructured_ast = "cee470e932e5891e9be42ec7e855042689263439a7502c6cab7299eab28c015e", inlined_ast = "cee470e932e5891e9be42ec7e855042689263439a7502c6cab7299eab28c015e", dce_ast = "e715909768cae7cd27293586ad029359938f118a31c5b8d18e905cb54ae841a7", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp768_hash_to_group.out b/tests/expectations/compiler/core/algorithms/bhp768_hash_to_group.out index a91ab8bc74..c0447d297d 100644 --- a/tests/expectations/compiler/core/algorithms/bhp768_hash_to_group.out +++ b/tests/expectations/compiler/core/algorithms/bhp768_hash_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "3a42543b6248f5911940c48649b66b5e860f25a8b3255f3912a5e2770eef5ace", unrolled_ast = "3a42543b6248f5911940c48649b66b5e860f25a8b3255f3912a5e2770eef5ace", ssa_ast = "fce17cd4c6a2f8463bc87e74d74d0624658b8a862ebf3ee7e525a59316876223", flattened_ast = "0b78985bfbff4a61ecfc090b94041c542d923cf1cd6253a8c5473b04a7cb5787", destructured_ast = "e8a2fa4796f18b2c05b6702358ed9fd66a552446a322891ca8981ea1125e9893", inlined_ast = "e8a2fa4796f18b2c05b6702358ed9fd66a552446a322891ca8981ea1125e9893", dce_ast = "32495442d293a49ba12481bba5ede7887615d7b5f631053bb75be087a41acdba", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "3a42543b6248f5911940c48649b66b5e860f25a8b3255f3912a5e2770eef5ace", unrolled_ast = "4c167a2dea70b234b4f1967e2121c0543a442901f2d3873f6f292c9fdac4159a", ssa_ast = "175ab910f1cc4dc6d4302a613a1af74cb59f1885fc70a6dd4d720ec722e4b1ea", flattened_ast = "ff0f19330d4bede1690b6b5d77e6d1c3c7a3172dcfa45cce6b5669b2b1d9097c", destructured_ast = "1ea4efd87baebbc969a4b08d45179825d062a8a057a40ce8763bb228ff29ab7b", inlined_ast = "1ea4efd87baebbc969a4b08d45179825d062a8a057a40ce8763bb228ff29ab7b", dce_ast = "8502e5779a67bf961b705bbae4143ffb841ecc5e48ef452d17017fc82bca95ae", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/bhp768_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/bhp768_hash_to_scalar.out index 4dd58f4989..8cfa1de3e3 100644 --- a/tests/expectations/compiler/core/algorithms/bhp768_hash_to_scalar.out +++ b/tests/expectations/compiler/core/algorithms/bhp768_hash_to_scalar.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "e24ee1bcabcc08b4b186df3883e05bae4f6452569f613294a6ee7aaa5b51a67c", unrolled_ast = "e24ee1bcabcc08b4b186df3883e05bae4f6452569f613294a6ee7aaa5b51a67c", ssa_ast = "42bb275bb8f30f844e720e95ff44f8c2d8b2edc12ea4d29245ab4b13068b480f", flattened_ast = "018dc16ea828956c4831a0867627751a833bef0e4b474918db2bc17b3658b1d8", destructured_ast = "821596ca67920e30b4904b190cd9387029414909381747860fdd7575b671533a", inlined_ast = "821596ca67920e30b4904b190cd9387029414909381747860fdd7575b671533a", dce_ast = "82b0310905bf404ce4d12c69f1955ec06b6e7d09e957b532f73fd9191aeb4fcb", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "e24ee1bcabcc08b4b186df3883e05bae4f6452569f613294a6ee7aaa5b51a67c", unrolled_ast = "a82e90122640e71692c87232f54ed72343776430612e099308a296c6ca4621eb", ssa_ast = "f9757af6c272677bc92b4acd70bf0d6407f6902f966e4fa738f6c431b98f7e97", flattened_ast = "03a6fabc1d76ce9be96c0947d5dad6a0abef0efa86dd7078279cb3a4cb0fca2a", destructured_ast = "06ff3c98b67c549d18518005762f0553eecc0055b1656f0275f83df1b5e4f7d9", inlined_ast = "06ff3c98b67c549d18518005762f0553eecc0055b1656f0275f83df1b5e4f7d9", dce_ast = "d6612d524ac00941c4fe43cf741d0b88e67c2efce76c334bcb10e0128d752c1a", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i128.out index ee822c225c..14c83ef68c 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i128.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "442c5362ae1cccc6219eb6ed3535001f3aa1d8211912e35855d268e36c35d71e", unrolled_ast = "442c5362ae1cccc6219eb6ed3535001f3aa1d8211912e35855d268e36c35d71e", ssa_ast = "a2fa6a2378ffe24ed6cbfe450e75935793bee13d0c62c8f66597ab20f6215b6e", flattened_ast = "282f6dacfa73e9b5344db2b401d04d3bbe20a106eb596c7686900bec344dbd95", destructured_ast = "f1749d788d7ccf00e5c8dd89d2487b8d92489c5ae09006f394e50b6d2ee712de", inlined_ast = "f1749d788d7ccf00e5c8dd89d2487b8d92489c5ae09006f394e50b6d2ee712de", dce_ast = "2a8b0ea8985ab9c858f663ce59e0277a6d77f20820e0ac4960459e49efeabe0e", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "442c5362ae1cccc6219eb6ed3535001f3aa1d8211912e35855d268e36c35d71e", unrolled_ast = "b2510ba2a468faaa30159639da4eeb0bc232d171c0d95a20d520ac4f0f89b183", ssa_ast = "47dbc8769d9458a321dc5e4c289e5584d5f6ad5f0e13f165455e9153f3c36e15", flattened_ast = "43583d62b29fa5e10ceecca4ccff0c8a15d4bcab1e2050709ca8fb082402a1c5", destructured_ast = "9257cb8d84fb77085b58830c21a84a29b38e979d604d05d9d8eee6b7d3611820", inlined_ast = "9257cb8d84fb77085b58830c21a84a29b38e979d604d05d9d8eee6b7d3611820", dce_ast = "4148bf5fd57130336cd20d2eb8ddfcdcb6cc206c0b54f47a9a1c71b217338fbc", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i16.out index 103aee1bac..fe170ef65e 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i16.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "1d5396288476d5e898e696c848ab2eddd039d20542dd4544de4fd5d47d742520", unrolled_ast = "1d5396288476d5e898e696c848ab2eddd039d20542dd4544de4fd5d47d742520", ssa_ast = "32842d3ffb2864a3aeb3560af67fd76d6bd2bcb7f499637b54a01bb723ab9e62", flattened_ast = "aab3af9dfa62a5d527fd350086e6d2899a485253ecc9c109c506f13bdd7efa9f", destructured_ast = "593e17839928f2e1ec1fd09989e710f90665cebef945ad2ea67a01485793b882", inlined_ast = "593e17839928f2e1ec1fd09989e710f90665cebef945ad2ea67a01485793b882", dce_ast = "62a27df6d35c3089d230b998d718f2ee2ebf71c4208093460f36be8c524d5494", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "1d5396288476d5e898e696c848ab2eddd039d20542dd4544de4fd5d47d742520", unrolled_ast = "385d87bd57bc2ba461869cb82865f72ad3acd49a0311c04c9ce28fc3ad13c618", ssa_ast = "a9cc7860d02b8de1e2596899f3d3459ee52ff76f7dec0a4567da62380b77577a", flattened_ast = "1e39bcce9571a6ab22293fff24a374e59ee92af23bdea093a95b814a8f5379a1", destructured_ast = "3dd7c1536fca430fbd9b613a1ed79f6f7169e065a179d216d6974db2bf9a1eeb", inlined_ast = "3dd7c1536fca430fbd9b613a1ed79f6f7169e065a179d216d6974db2bf9a1eeb", dce_ast = "b57d7bd5c396aa3998e16b9680d37a7ab43eccb778445d252198a6370fb436d0", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i32.out index 66d06050b2..cdfce98693 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i32.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "468a619ae62ffb64127629908968dc3d9a7542085ce407f7513522de43b57e59", unrolled_ast = "468a619ae62ffb64127629908968dc3d9a7542085ce407f7513522de43b57e59", ssa_ast = "1c8e3b4ee612253ae49a68bbb5f1f022e2db729405765845eae1e78f4dc73aa5", flattened_ast = "3b9583c20cb047fba616d5d78c0528c775e3f422dfbd0d13980062f8d0576498", destructured_ast = "088e16c326f423b71e7a86380bf75e68cdb900fdd4c6f3d9626a5cdcadb36e63", inlined_ast = "088e16c326f423b71e7a86380bf75e68cdb900fdd4c6f3d9626a5cdcadb36e63", dce_ast = "02fa890d859e83b08f1e3aa06244ff3ae1b4b9b5349934e431fd878ee05dcfd5", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "468a619ae62ffb64127629908968dc3d9a7542085ce407f7513522de43b57e59", unrolled_ast = "ec899c2fd707adabc61cc0f617a1baa251ae11f9a3cc5ef10c6ee92696bf54fe", ssa_ast = "c2912cc23ed3ed7fe4af54711da80952f6112341280b169d5658a50a9b5a70dd", flattened_ast = "10fc8581c18e944f706d54cbe2014a25fbd354de9da2ccc04b9434763813e00d", destructured_ast = "dc8803e0a500839dd1b45da6171517cd644cfb553aee44bd2fdf1010098edb64", inlined_ast = "dc8803e0a500839dd1b45da6171517cd644cfb553aee44bd2fdf1010098edb64", dce_ast = "c492712aa033bde5e4f35460b4d35d8702c16ddbb015ea26f6e3363479103930", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i64.out index 0d3d9fd9d2..ce96892b3f 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i64.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "ef6a8b12ab9a2990728744af5eed85e7488f25e22611778f05633be09dc639d0", unrolled_ast = "ef6a8b12ab9a2990728744af5eed85e7488f25e22611778f05633be09dc639d0", ssa_ast = "6b57a9b84a5ba37ca589290b095883c39c40fff348600456f4531b130506a4d3", flattened_ast = "1d390bcff74a7da50935a7c3d8e9bc9348902ea22e481fb7634f46cbc6e3077a", destructured_ast = "43ff018ba2b76a0532fd7e1c2753552ac40822b9654c55e0daf588e65f41fbfa", inlined_ast = "43ff018ba2b76a0532fd7e1c2753552ac40822b9654c55e0daf588e65f41fbfa", dce_ast = "498731da2308c28a6d1fb4a8f10757664918b05bc0a85a2987a93ab2573a83b4", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "ef6a8b12ab9a2990728744af5eed85e7488f25e22611778f05633be09dc639d0", unrolled_ast = "f0ea511748d6c83b05f22dfdd39fd10d67a4f243189783908c1e54e3825a4a5b", ssa_ast = "9a48a5eac89bb5c818e852f2d43f30670853ea4b3a879c638da47764507a1786", flattened_ast = "16e3044cbb9eb12e998d9c8c5b7dff905e86b45397ee7efb3d0e7be5993e7338", destructured_ast = "8ab58971537d5fd20c7b92a5a60e5945b25948968137ed56f8ba01a1beb25b7a", inlined_ast = "8ab58971537d5fd20c7b92a5a60e5945b25948968137ed56f8ba01a1beb25b7a", dce_ast = "e43a37c70954610f49a8d667a69241c0d32d31aa22bfadc9d5b4e8ab4783fb4c", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i8.out index fe0894b71e..2b9143be27 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i8.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_i8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "e0a0f783611f7bcc08271c7259ef2978ee4571cb86633016317f8a61263f9bdb", unrolled_ast = "e0a0f783611f7bcc08271c7259ef2978ee4571cb86633016317f8a61263f9bdb", ssa_ast = "1a8cded804c2c0bea4d3100239c920f9c05e27453743bb92d0c97de1876b922b", flattened_ast = "37a3d3534e557cdd41f43d1843889b5864ef5844cf784feaacd6ece2ce7531f1", destructured_ast = "0b1c52c255fbb1d040c11c4abba2918759cb98e5097e3ef22804728d548e80a0", inlined_ast = "0b1c52c255fbb1d040c11c4abba2918759cb98e5097e3ef22804728d548e80a0", dce_ast = "eec36bb7ac4980ba963769eaa1b9acae62a248aacf714c98c3e592560e1b38e2", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "e0a0f783611f7bcc08271c7259ef2978ee4571cb86633016317f8a61263f9bdb", unrolled_ast = "182f642fec7cfc6176780ef0ddc1bfcc99eda38656a13da8cb1fdfeff8c6be50", ssa_ast = "ca57e4fefb5266395c7be1629bc32e73788320964379c64647bbc976df62a0f2", flattened_ast = "89127f7411cd4d3198602d7e33a64c4ae68beaead283e77cc5e4858eeab06d8c", destructured_ast = "73d626ac27fd38013298c98b612029f53282d64f76c5c03dbc11f5000c1cfa59", inlined_ast = "73d626ac27fd38013298c98b612029f53282d64f76c5c03dbc11f5000c1cfa59", dce_ast = "3c8d3669a2254c81a30fc6485766af6341693970fc1ec51e7bfe9848180e4952", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u128.out index 472a2f4013..1e2fcba9f7 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u128.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "f186cd70d912c729173ba3daa52d09f432de6752ebcf8eb98c9ec9a173a6345f", unrolled_ast = "f186cd70d912c729173ba3daa52d09f432de6752ebcf8eb98c9ec9a173a6345f", ssa_ast = "cd21ab42ba7b71d49d574234afd69882e11252730169908971aec498a1da87c3", flattened_ast = "d3cb0c896a08af1429e3f2cb5d92a4d1fcda1c7eaf992ae2ab73b45ea724ab43", destructured_ast = "c509420b78791136df0db3e5e22b164c01b8b55fd7cb1bc0951659bf127496ec", inlined_ast = "c509420b78791136df0db3e5e22b164c01b8b55fd7cb1bc0951659bf127496ec", dce_ast = "6c887cfc2804ab34098bd3cf43cfe6bfffde928c0daf118656a00d27542b970e", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "f186cd70d912c729173ba3daa52d09f432de6752ebcf8eb98c9ec9a173a6345f", unrolled_ast = "4a87a4601622a5c549c2c41b0201d292231475043d19a914f5026d53e8c84d3d", ssa_ast = "46813c4e2d618c5e4ed234c3b7249caef5d969383bf3ca042a49f7727915d68f", flattened_ast = "cae660c492cc03a3f6e681736feb5a0299dd9d18ab8ad0f7bba1df5946c78467", destructured_ast = "579a56cedfbd8a78dcac459f3225587a245c4575050c5c83a2cd15f393c41d9d", inlined_ast = "579a56cedfbd8a78dcac459f3225587a245c4575050c5c83a2cd15f393c41d9d", dce_ast = "0bcc26e8b9845d9c28ef67a8808b6ee925ca1ddd4be197997de8daf2c07f561d", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u16.out index aab1925da1..e2fed05f92 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u16.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "52e8149620770b85c4bcad0c3166c45ac4a4b16f2d40245f461e6fe66e1437ad", unrolled_ast = "52e8149620770b85c4bcad0c3166c45ac4a4b16f2d40245f461e6fe66e1437ad", ssa_ast = "421c0602f61bd698d43479fb6822dfae87f9884b7ef91850ad3f3cc62ead9320", flattened_ast = "034a7232997144e71bfc33239ea6c56efc63151542b2c44228a9518a1c3c410a", destructured_ast = "4eb45d45ae72325a2bc7f92321cd38b717e449cb735a5562a1b043ee594e0beb", inlined_ast = "4eb45d45ae72325a2bc7f92321cd38b717e449cb735a5562a1b043ee594e0beb", dce_ast = "292b3e8a07570b27a6458ded0eab716827bdf9829a70e9cac4736c9bd0eb669b", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "52e8149620770b85c4bcad0c3166c45ac4a4b16f2d40245f461e6fe66e1437ad", unrolled_ast = "8a7be6ca05da5e3f6427625a17a89868c20e4d9f02f302d58fbaf34a5920f914", ssa_ast = "659688f612371264a5edac1d9474200e87b38d7db4cabe337168bcadc328e516", flattened_ast = "c37b72f013801a334ea148d290638d58b38a65a5c9d9b1a16f7faf4b65dea160", destructured_ast = "93098a9214b2d04527a912f0d05e68f49b2fafbb65fa0d552cbb9ec5a1116d35", inlined_ast = "93098a9214b2d04527a912f0d05e68f49b2fafbb65fa0d552cbb9ec5a1116d35", dce_ast = "690e2d9d0278d9418be6ef854c906b50a9deb62e84a7b0cbc4debd27dbeca60b", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u32.out index d3d3594a79..35f8030e50 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u32.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "0bf4f3e0c0909add978c1c86d40acfb2d6bcadf3fbefe2ee4716718d953d0d58", unrolled_ast = "0bf4f3e0c0909add978c1c86d40acfb2d6bcadf3fbefe2ee4716718d953d0d58", ssa_ast = "e87e2291f9b5f42b8a9c24b56ee6cbe91704ae9f0009de34d5723f431a7843fd", flattened_ast = "daabc553ae9cb250c1eab2b5f1329fdf0682bfb965ea230789485a04a06a546a", destructured_ast = "c3693dbe23dc7d5e4af38d8a01729fa0b7fbbbfa73ec839a861bcda889994842", inlined_ast = "c3693dbe23dc7d5e4af38d8a01729fa0b7fbbbfa73ec839a861bcda889994842", dce_ast = "40ee13466dabd45ba897e77bd2d403f749622fe926adc57df9c220c4670769b0", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "0bf4f3e0c0909add978c1c86d40acfb2d6bcadf3fbefe2ee4716718d953d0d58", unrolled_ast = "abffbb2d38809b858937a838192d0990fbdbf40468f9f33ab1187795378f5bc4", ssa_ast = "b217b2422fcd3125e756677a8793071ac32a5706e3a9c82751cbc2e7f1375797", flattened_ast = "ef8a069947819702862f85f11ac4a3e8a0ddcd08d10015358bceba7b86cebe60", destructured_ast = "82c4d88d9b4c6585ea8489d2d06f914b09f1fd293de4d6b364fa7fade96e4596", inlined_ast = "82c4d88d9b4c6585ea8489d2d06f914b09f1fd293de4d6b364fa7fade96e4596", dce_ast = "09b442679455fe6b3ce90bb6a225614a544e23b81d9867a44e97cdee123bd219", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u64.out index 4e7e1ee43e..da5b2369e0 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u64.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "ebddb7d5799f23e53b3d61632ee643912bbb48b9cefa4ac065be85d37aaa50bd", unrolled_ast = "ebddb7d5799f23e53b3d61632ee643912bbb48b9cefa4ac065be85d37aaa50bd", ssa_ast = "018b8ea7eeb49f42121314644edcdce86c83acef33a7ac68a880b6a704fc85e1", flattened_ast = "809214e2a2f8f26a32fb09b29c01cf435e0249508518b2699d0bd9e366ceef78", destructured_ast = "39010d7217c8fede44a27f2a90075d5c4873c2bba208861fdf64f1386557e70e", inlined_ast = "39010d7217c8fede44a27f2a90075d5c4873c2bba208861fdf64f1386557e70e", dce_ast = "d2661ecfe254e43626511a2b506cf506ddf02ec58688c4a4372a84ee6a2cc873", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "ebddb7d5799f23e53b3d61632ee643912bbb48b9cefa4ac065be85d37aaa50bd", unrolled_ast = "913a42cfccff6cd9ed4f2e2a6b15559b1caa3a63fb128319315a0343817e385a", ssa_ast = "815c3229dc38d1059128bf46b7faf0acfde42d2e4754ee4aebc8320aea0ce47e", flattened_ast = "1b9c53b8281bef2e1c3ac1414dfb368ec36121160eeb9ac9a1608815357b36ba", destructured_ast = "dc34fae9ff8b35bc9baa9d802d75f45fa77a7258489ab435e49fa189d419a4c6", inlined_ast = "dc34fae9ff8b35bc9baa9d802d75f45fa77a7258489ab435e49fa189d419a4c6", dce_ast = "871b59fc820e29cec8accf78d8ff915c00c2c29147deb6ea90fd6bfc35b881ca", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u8.out index 872928749e..b28d993f15 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u8.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp1024/bhp1024_hash_to_u8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "9aff620dd76ac53998b174eb9bf08401e5afd8d6a467b967e2b46cb5558241b6", unrolled_ast = "9aff620dd76ac53998b174eb9bf08401e5afd8d6a467b967e2b46cb5558241b6", ssa_ast = "a5606345c7d4ede71acbf5525ad84760485d9cc717fadcbcbe4781e793bbee1d", flattened_ast = "0e262d936c09fb33795e7b050f9f3f7d127bc0769e16e8963a7ea5fa6dd0dbe1", destructured_ast = "a7f1a1acd14648f9d51cd504046bb439b420c20c07cad054ad04ba0aaac7e68a", inlined_ast = "a7f1a1acd14648f9d51cd504046bb439b420c20c07cad054ad04ba0aaac7e68a", dce_ast = "037797e09ffb65db0d8e7afff652625a87d6d6774d807d10985e271533621d77", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "9aff620dd76ac53998b174eb9bf08401e5afd8d6a467b967e2b46cb5558241b6", unrolled_ast = "a9dca2879c37837473a0ca903c2ab1d10549f307bd8922e8c493a7348e6d7d9d", ssa_ast = "c7d8d6d59015d693bd1682c9d217df2ca454f0cd4e8a1924933ef92b447b298d", flattened_ast = "42747cb2c52c0d5e9d7d4846814d3b9560bd651141dbd897205462a98a10f949", destructured_ast = "6a7007fa34b0b11cd0db431864c8939e77c927bc262c14b8290b0e4e52ae1f6a", inlined_ast = "6a7007fa34b0b11cd0db431864c8939e77c927bc262c14b8290b0e4e52ae1f6a", dce_ast = "26f1b5a1c411ea2a980f04463e0cf35802a62eabca0ea8299365e5616b22e853", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i128.out index fafdefdf32..c60322fa96 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i128.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "aa9928beca3c8bebbf79c20fdbde7a985791d8489b5d32aef9689ecbc0325a14", unrolled_ast = "aa9928beca3c8bebbf79c20fdbde7a985791d8489b5d32aef9689ecbc0325a14", ssa_ast = "8265f4821b9744859e75afbc1e3f10be89252f1d65690e1025126c5d520ffc4b", flattened_ast = "87946afc0b53932ab784c974297704446c17f52a98b8dbe0308e39f0b05c3cf2", destructured_ast = "61ca4389d23ae33791dbe6cd6168e9b277a873fa0824385390ece4b665834c15", inlined_ast = "61ca4389d23ae33791dbe6cd6168e9b277a873fa0824385390ece4b665834c15", dce_ast = "a2dc0baa03e57cf937b52d4e2cbba3f6949d77dd84addff39f8f6ae2f92d9564", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "aa9928beca3c8bebbf79c20fdbde7a985791d8489b5d32aef9689ecbc0325a14", unrolled_ast = "8fe1404c0e7406f972ff4f0be1e20bf4ea2f5b31c35e98d4ba53dc631e8f80e0", ssa_ast = "444db1fa22933f607d5e159b4bcf350b732c8475f366380fee69efa8ef17fd78", flattened_ast = "8588a4d8d5330c31e76451b8e414f0cae00fca57cfc2c7c276868093b29d690a", destructured_ast = "86a75a9ea3b356668beb756bd421baf8742c45c0ce8c8752efdb4d0bbefe8e3d", inlined_ast = "86a75a9ea3b356668beb756bd421baf8742c45c0ce8c8752efdb4d0bbefe8e3d", dce_ast = "ac173fadede934b3a83a692a8c0718747aae1fd7040cf0441341daa7bbf9a2b6", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i16.out index 65b50d3b1e..016dc04e10 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i16.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "f46880150d359516cf54e876dd4b1b42cbd311d8044d50bcf2d6f6aeaf8e7047", unrolled_ast = "f46880150d359516cf54e876dd4b1b42cbd311d8044d50bcf2d6f6aeaf8e7047", ssa_ast = "40a71ffba556963cb091c24494d41295641ab71cac1f727e3347a385da4f89a4", flattened_ast = "492763110f4f20ddf27d4307adf8ce851d7bf680dbc1e1aeaee446dbc6daf4aa", destructured_ast = "e8dcd4318b6090dca39ea9169dd5a42d1034bd41a1feb2ce878578454da96482", inlined_ast = "e8dcd4318b6090dca39ea9169dd5a42d1034bd41a1feb2ce878578454da96482", dce_ast = "c227849d36b096f5c3cdc2070c4a5b073f2e8d2e7088db60d50865b131ff4ed4", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "f46880150d359516cf54e876dd4b1b42cbd311d8044d50bcf2d6f6aeaf8e7047", unrolled_ast = "4dbdd4a81b9d8c97d4884df62d2a9eebeb45f9f77e28f76c49141c07d94f1dac", ssa_ast = "c9898a431b04604e9fe8565c05c0983724385c47621f3eefe972ada38d6be0a1", flattened_ast = "3e418690bda9fdd75751359af19796b6b57e14e773b5d4e91ec211ad28991ddf", destructured_ast = "4b145bc7de5e3385c03c2498e1fe2b86349d90adbda227c7d9e93e7ed9d2510b", inlined_ast = "4b145bc7de5e3385c03c2498e1fe2b86349d90adbda227c7d9e93e7ed9d2510b", dce_ast = "15cc529871e1ced7d23ba498485f5ee85dda1925ee4d4b500a416ef2dca3d88a", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i32.out index 61b3145634..49b1c634df 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i32.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "b46c4964c34bb041010d44e5e224a2a89044f42e7093b3c062fc6980cd70d35f", unrolled_ast = "b46c4964c34bb041010d44e5e224a2a89044f42e7093b3c062fc6980cd70d35f", ssa_ast = "53190bed8a22df09ec5db6440bfa899efba7b447539aeffd5b4214f8aba55706", flattened_ast = "bf6b8e019ade473fd54467317ea77b3a7feacd5ba9132988d702ff5c3e6ec275", destructured_ast = "9a76ad3b97e006b61e7729c287e917bc19f0aa6ea7a8e75341b28303d21ae354", inlined_ast = "9a76ad3b97e006b61e7729c287e917bc19f0aa6ea7a8e75341b28303d21ae354", dce_ast = "3db1184f6015256fb4a1ef9a3c49564a98bcbfccc86cf06d0bf806858d7d1e25", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "b46c4964c34bb041010d44e5e224a2a89044f42e7093b3c062fc6980cd70d35f", unrolled_ast = "712632fe4d1eeef99ac50d06dc88ebfafe073169bf8dff3d6da4d40f8dea8f62", ssa_ast = "04c581da25aec02d6a2db3e53e38dca03272276505320b37b4423e2a4a631bfb", flattened_ast = "c0d89019240f3bed91bd0e95c77cce5c21eae941a9585ffc1ba602d055636b01", destructured_ast = "d04e634bff73eb5713f258f65f779435eb4884f79599e61058d8ad2c3409c6ef", inlined_ast = "d04e634bff73eb5713f258f65f779435eb4884f79599e61058d8ad2c3409c6ef", dce_ast = "c047e9a70d3c79fbe004f212b0a34f1e70fd0abd6e6fb3ac4084c6f24b08804a", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i64.out index fc58b1f5af..eb6569b99d 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i64.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "0663047e3d732d241fd9d28c6b15973a8f08a87590ae3bd6b06daae22eeb1889", unrolled_ast = "0663047e3d732d241fd9d28c6b15973a8f08a87590ae3bd6b06daae22eeb1889", ssa_ast = "ace9783581390ed0bc01010c74019fbf8200301442726d0efcba18a3174f16ce", flattened_ast = "9b2db2b1fe2adb61f7b19eff215f0e54eb31133c5188b577e9035fe1a500a9ca", destructured_ast = "2564df5ef89ecd338c70b821e946cb8ec1d017b89be6ffef0bed9345e4b0c0de", inlined_ast = "2564df5ef89ecd338c70b821e946cb8ec1d017b89be6ffef0bed9345e4b0c0de", dce_ast = "967099a9ba69e9789ffd15bcf6cf87c15938103bbb57e5aac7f281ad1d02fca5", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "0663047e3d732d241fd9d28c6b15973a8f08a87590ae3bd6b06daae22eeb1889", unrolled_ast = "23a02ccd5082e374abe5d9b38e8d3baac281d931867c6a98781f066bce9a3004", ssa_ast = "3a1163591d1df62707198de27190028ec701b2616db2bc0bcfe2acbd78c71dbc", flattened_ast = "f0601285b6c8d56a340fdfa5699b2c110536b618f11dc67b991455f931087014", destructured_ast = "0dfe5f0181c851a62282d35528cec8e130627beba50840063cd6d79a96a668fe", inlined_ast = "0dfe5f0181c851a62282d35528cec8e130627beba50840063cd6d79a96a668fe", dce_ast = "bdf6089fc21cf84272f0b96b21595e642a7816a5646e9d4ec65afb34be2b5aef", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i8.out index 80e77548ae..bedf00abf8 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i8.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_i8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "408ff092c48d0daaa2603e45c07951f3449da4c82a2468b7a70ee081f2458868", unrolled_ast = "408ff092c48d0daaa2603e45c07951f3449da4c82a2468b7a70ee081f2458868", ssa_ast = "99e2733b269c445b983c7b2f0cd63c4cc4ca488108ee4bd925a23401638a5715", flattened_ast = "677fbada1a53c0960776ef17bea7fc34865d59bcd6db7d406c70dba0a4c7bccc", destructured_ast = "21824a5baf65bf0c9ef44c4fb456766e25237032343e55ff35a73b8d9b44dbf6", inlined_ast = "21824a5baf65bf0c9ef44c4fb456766e25237032343e55ff35a73b8d9b44dbf6", dce_ast = "6db69551c717f92c133ee992629a9971e1c9f9325ac76c1103eeb6219b35e29c", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "408ff092c48d0daaa2603e45c07951f3449da4c82a2468b7a70ee081f2458868", unrolled_ast = "f28be55beec05cbed9b23ebaf76d09766198c243497f895912a25b7294e90f89", ssa_ast = "ba9a83bf741be8c4d22ec5f5da49bf30eb8c0a13a3587539f1580a07079e712d", flattened_ast = "633ba587eec2bb768c8ebea97d390b2f483e30e6706be8fdaf980a27b3e8f49d", destructured_ast = "a956a96e4eb565934913690fb84382e401978f915a10594331c01aace30ba9a0", inlined_ast = "a956a96e4eb565934913690fb84382e401978f915a10594331c01aace30ba9a0", dce_ast = "48548133d071433597d84b45e8c08d2c26a57ab89d65d86b7b18d6a5fe50540c", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u128.out index 525d5295bb..5fcb66f726 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u128.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "5af291cee1598234a6dbc2d2e57253e795493ee900ca384b4737d32df27e2275", unrolled_ast = "5af291cee1598234a6dbc2d2e57253e795493ee900ca384b4737d32df27e2275", ssa_ast = "0b66886f95df7f84a1b58b3b78e80b7101a5eccb82f6048048a2e50e8723605d", flattened_ast = "8ad71b1d813a93068312826625d541b70baac4ba709507c0cae87292ac9a371b", destructured_ast = "faeea0fbe56481bd8153d6c617a540429132235031acbe89454ecc7aa3e29e46", inlined_ast = "faeea0fbe56481bd8153d6c617a540429132235031acbe89454ecc7aa3e29e46", dce_ast = "29ed2ce1d8ec68c8e121670344ddc01532e3b5b82b37fd285d7340fb21326cee", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "5af291cee1598234a6dbc2d2e57253e795493ee900ca384b4737d32df27e2275", unrolled_ast = "fc58735c08504a6ed2da94baf6db65961276655ed06beb035606eec5c0789082", ssa_ast = "994db6f5a7f894b7edcf03fa046d4cdf34b2f9d540e353976994410ec1396d5f", flattened_ast = "3f430a6fcde32e3c8e1f08a70c3100c4093d99923f69fb0b7ef8590c1413279f", destructured_ast = "e835cc2c658315e57c49c8440874cb281abdf5c6ffd851259abfb51367d52bd6", inlined_ast = "e835cc2c658315e57c49c8440874cb281abdf5c6ffd851259abfb51367d52bd6", dce_ast = "27f6d3e5d398cd724f2fbb10870f11e987d6cb7330502e11e35e3d6d232ce757", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u16.out index 6e6ae95ee5..10a4425998 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u16.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "127255a3073f38401e6dd2747da420529765cb6056b842f67b5d24445b09a69e", unrolled_ast = "127255a3073f38401e6dd2747da420529765cb6056b842f67b5d24445b09a69e", ssa_ast = "369444a205e7b3d36a387a9570d9a70c355a06999a096f99b6587f3d63ff5757", flattened_ast = "13ba34fe717920cd5cb7340c42636ca5dcebd9e83a7f4225412b8e1ddfa13328", destructured_ast = "ef4cc482f373bf70d1434362c79570ce04ffcb38e94fda60c6f4cdd78be18450", inlined_ast = "ef4cc482f373bf70d1434362c79570ce04ffcb38e94fda60c6f4cdd78be18450", dce_ast = "a791412ddde8c80a016548b946bf27ad8f6dc74dbd50c5012efe1b7258274817", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "127255a3073f38401e6dd2747da420529765cb6056b842f67b5d24445b09a69e", unrolled_ast = "214ae8bf4c67eeb4ed855d731dee87f7e14b893bd980c6c35e4944d206614252", ssa_ast = "2305f6c8916385083432868b9a9c30c3f8453b69746b9350c802b1e86457bba0", flattened_ast = "ba2354fb7dd36609a8da5e27b4ccd061b5d4010c3754a23be03713323c1790ba", destructured_ast = "cace9396f925ad500a816f17dfa6d044d9bee9a1a73cb17279bcb370d3372160", inlined_ast = "cace9396f925ad500a816f17dfa6d044d9bee9a1a73cb17279bcb370d3372160", dce_ast = "0cc65aff419980c3f98ceced8f38877a029c74498c2f63a8e8dd4bf3a536582c", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u32.out index 851c57f6c0..ebbb49d186 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u32.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "c38ca1536436eda5344a2d62c7c6aa43cd8c4982f48668ca304c2236f8c86dbb", unrolled_ast = "c38ca1536436eda5344a2d62c7c6aa43cd8c4982f48668ca304c2236f8c86dbb", ssa_ast = "5c6f03fef5e9020bdef9e4ea4dc3166b14cab4d556b793ac907392538226b1aa", flattened_ast = "f6547c44c34a549f14d2c246fc2bd5fcd72648286c306ce6dd540978bdac4d29", destructured_ast = "7cedea608cf5971eaa783638c455f107d930ff0d18de7247dbd656427202901a", inlined_ast = "7cedea608cf5971eaa783638c455f107d930ff0d18de7247dbd656427202901a", dce_ast = "ae53c63dbc3bba96f89c89a1833884b8cae9b76cd3b6d56b9f300ef14343e4e6", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "c38ca1536436eda5344a2d62c7c6aa43cd8c4982f48668ca304c2236f8c86dbb", unrolled_ast = "73bc7b7046ecacc92adcec079d2372c03cb79f6d34fc76e1c71bbb0c0f986e31", ssa_ast = "ee8212326fc6c5e8e8ce3e01b19cd75c0a469072956ee5576124b685147ee572", flattened_ast = "5a8c7f2cae983e95fc8f8e99aba1a67e07c23e13fd27b82f25942cdb2ccb15a6", destructured_ast = "ebdb24826db6d7521639dee8b4a253a8343c3ba290cf489d2c5d18b0b26a4d26", inlined_ast = "ebdb24826db6d7521639dee8b4a253a8343c3ba290cf489d2c5d18b0b26a4d26", dce_ast = "9f086e603ca7c1aedcaab0e063def1ace81ec54f23014d93ccdf372ebcfada75", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u64.out index 8f8b7e4bc7..1cb203a23c 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u64.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "f408a1ea2eb74d53724ef1ffd004c190ac3586d062c27e9992582e3a002e4ff6", unrolled_ast = "f408a1ea2eb74d53724ef1ffd004c190ac3586d062c27e9992582e3a002e4ff6", ssa_ast = "a9e7ad59884a3c6aa0958eddf7b8a0e77f9fcfb81d41f2a6550515169a4277d1", flattened_ast = "264d89b798325f71b1fbc95d09362f8f7020518c7a283ac200c44510fa676d60", destructured_ast = "48fe8d5b30c0508afd694804818c67da804253b48e6b19050f5f9d6bc6af7cce", inlined_ast = "48fe8d5b30c0508afd694804818c67da804253b48e6b19050f5f9d6bc6af7cce", dce_ast = "e985f0eee0e65ea90d9314cd333c17b4bd9ca0d546f2c7f4079afa955f1f344a", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "f408a1ea2eb74d53724ef1ffd004c190ac3586d062c27e9992582e3a002e4ff6", unrolled_ast = "e7af15aafb217a868851e570e591fee210b273b531800df94b70d2d1e19eb1bb", ssa_ast = "6bbe7c986de130aa454a9eea472fd806505d61d214b4961fd9c942513d3cd80d", flattened_ast = "1696b63186df8f819b8c92aece1dcc43bcd40ec2a2bb556d86e5ed86aad0336d", destructured_ast = "0a9711391095ebf559ccf3a4a5673fc636e826e1aad3552106663e6a5291093e", inlined_ast = "0a9711391095ebf559ccf3a4a5673fc636e826e1aad3552106663e6a5291093e", dce_ast = "946e74c2fa0cccafd1947c66bb5f791fc84cf22f3fab7592bd59587f75f504c9", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u8.out index 2600a086c7..39fb8e03af 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u8.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp256/bhp256_hash_to_u8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "7b45e451cd1777a58559ac04d9af6d6e1d86e65b09442ec159330a4f38b59546", unrolled_ast = "7b45e451cd1777a58559ac04d9af6d6e1d86e65b09442ec159330a4f38b59546", ssa_ast = "f948344b4c93f2297791b903f0e2b5ae7220c77826cb04d8db1fe95a69aba719", flattened_ast = "921d72857c375c96832749ecfe50dd3e14d87ac15f6cfbe47cbd0a954ea177cc", destructured_ast = "524918abcf48ecb982df3fa247929998abba8b72252cc10a26908c3a1bb0177e", inlined_ast = "524918abcf48ecb982df3fa247929998abba8b72252cc10a26908c3a1bb0177e", dce_ast = "4c22e9208417f9e791d9eb2d509c2ed027511bae40abcc92df98120ba16eef8f", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "7b45e451cd1777a58559ac04d9af6d6e1d86e65b09442ec159330a4f38b59546", unrolled_ast = "d56333546c189de4980cb991e15e6d14f3299f039332920fa160fa3265a3a77a", ssa_ast = "9f3375a30608a2c12cee0d68bf50af81a75d399902e88d808695259c96c92ba8", flattened_ast = "f2876bc74ca7555b6a831dfc274f3ad70ae2a6664cfb0eb85044a4ae397aaed0", destructured_ast = "14d4bf710eeb61612c0582421751eec70e7257253cfed7bb411a7bbbb8accc7d", inlined_ast = "14d4bf710eeb61612c0582421751eec70e7257253cfed7bb411a7bbbb8accc7d", dce_ast = "eebdc31285b45e624a080f81b9f68f4cd2a81cb76a21bbc5821d98493e24a87a", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i128.out index c826eb4a0b..4ab67da07b 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i128.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "a7f690d5f9fdf10e4861ed37c5291db9c543859523b890b74bb80e91a460ed9b", unrolled_ast = "a7f690d5f9fdf10e4861ed37c5291db9c543859523b890b74bb80e91a460ed9b", ssa_ast = "5564d4a3af024639515800558bd59978f92edca4c9efc2aa746be0d24e0dae3c", flattened_ast = "8d3444b5c693ae303e395cd8355b224f719a1a5d9189f5cd6cf58ab056d33e95", destructured_ast = "656d5c1b8f115cdc3961e6b9396634f2e3240db6d1925bf1409f070a1bfbd25d", inlined_ast = "656d5c1b8f115cdc3961e6b9396634f2e3240db6d1925bf1409f070a1bfbd25d", dce_ast = "1a839c56a2dd66194e81afdd9b4b5be212927ae57037f8a86253bf48befd49e1", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "a7f690d5f9fdf10e4861ed37c5291db9c543859523b890b74bb80e91a460ed9b", unrolled_ast = "2dc2d53370dac8a00776a3a7d4f11fbc531d6999c78ef02fe7c52af8e0cad1f5", ssa_ast = "eb5c0a7481459686a1cd71a4d9d5c003bae0860fa5a89642e7bdc488bc56e91a", flattened_ast = "a90431b7a490780d332e679f4c5b3d3ef3b61b541c506bb9aa34b2146061ae98", destructured_ast = "e8fff26e9267458fd8ed6b9da58de37ad6e7972e4469afd77d8d6d8a9a5b4f0e", inlined_ast = "e8fff26e9267458fd8ed6b9da58de37ad6e7972e4469afd77d8d6d8a9a5b4f0e", dce_ast = "4e636a2df3cd8d7f40057452a32b7b2373da56bc1f8c8ec44bd7b35b00a25fe0", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i16.out index 795d6e6379..f778ce5a9d 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i16.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "f4733a66bc4cddca0d350e8af547fdde33e43b715ac5105f62aed7e45503ca2f", unrolled_ast = "f4733a66bc4cddca0d350e8af547fdde33e43b715ac5105f62aed7e45503ca2f", ssa_ast = "65321971d129d6995335b03474e46ceaeecf691f11e22a49add789e481594b6e", flattened_ast = "040f2ba657c6d1ced86c37d521d8b3b6ad433a043ec2e2037a872b78f4170f18", destructured_ast = "225d62b3ae7240a81e5a9b94379c8e44543fc97a34b60ad118eef21d46ac563e", inlined_ast = "225d62b3ae7240a81e5a9b94379c8e44543fc97a34b60ad118eef21d46ac563e", dce_ast = "c103e4a82ac0f087032a18d0e25ab4220164bb33aa42d610f54be19f8003b5ad", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "f4733a66bc4cddca0d350e8af547fdde33e43b715ac5105f62aed7e45503ca2f", unrolled_ast = "8d7e7b1e01cb32519a9b53c6fa9dbd0ea370b8064da4f6224081c4776d65c9f6", ssa_ast = "9639ab3befcfd3fbd4fc21c8c117b0b0df2ace72b66f017c6e269327be4e826c", flattened_ast = "9e15b4e3d4acd4dedb047cfb75c4da19af0ec45622dd4530d3fa5cdf2e0922f8", destructured_ast = "d766c90e79002aa6a6c5bf036deb2dbb96343f696de390ce45e36aaee22e21b2", inlined_ast = "d766c90e79002aa6a6c5bf036deb2dbb96343f696de390ce45e36aaee22e21b2", dce_ast = "da37b555501c7d90067ac4342b02694fdfe83e5c3f07ff9354a4a154f227137e", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i32.out index a211a351d6..3f125ba8b8 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i32.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "ea822de086b74c197715a51d4a757600ea8ffdd388ae030bab9f4b6614742c37", unrolled_ast = "ea822de086b74c197715a51d4a757600ea8ffdd388ae030bab9f4b6614742c37", ssa_ast = "7df3a178cba9d0b69b911dc44167a60972aa3c34e588bec3d57022559e9066f7", flattened_ast = "6cc4cd251dab34f09631ef598a6a561b08398edf50dce39c252f5734c7684755", destructured_ast = "1ad6889aec9136d62dfda9109e2acc717afaf070623bf4d8380abba3d0f4637f", inlined_ast = "1ad6889aec9136d62dfda9109e2acc717afaf070623bf4d8380abba3d0f4637f", dce_ast = "18c9c5e92f57823ecaf704b5f5635fc93c589129d0c23c11f30f652af57a9b05", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "ea822de086b74c197715a51d4a757600ea8ffdd388ae030bab9f4b6614742c37", unrolled_ast = "f601d1ba21e436096951deba463683752359f493b76c87eff136b11cc1d7c544", ssa_ast = "03a2165f050ab968f229b89058505e7878a05f0535348c1ae6c8592ad8178daa", flattened_ast = "31b797287c18138370f23408a628090701d489f188680ecfd3f02a9e68cc1ab0", destructured_ast = "9b3838200f03716d60ff37baae33ef671cfd33659b9845e4a820eafbbf5b26dd", inlined_ast = "9b3838200f03716d60ff37baae33ef671cfd33659b9845e4a820eafbbf5b26dd", dce_ast = "20227a1a3e56502c78a58d9b8a505e04f7179e19be922b84c554d7d251bbb822", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i64.out index 2f25682fe2..d7f572df38 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i64.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "564575f4e6373b12b437541baf545a744ce94d322c8cc9d806584d3c6f0103ce", unrolled_ast = "564575f4e6373b12b437541baf545a744ce94d322c8cc9d806584d3c6f0103ce", ssa_ast = "8a7508cf9f6617d8210ffffed2c37dc77a6ba66be481cfc63b59574f01b48113", flattened_ast = "72154b9fb27d28872245a159162cbcdac0ce64391e0f083365407cdb0eb720a1", destructured_ast = "25f8298e6e2c9f33fcf5861d84885361474a77f81c5d245180d158d09097398d", inlined_ast = "25f8298e6e2c9f33fcf5861d84885361474a77f81c5d245180d158d09097398d", dce_ast = "a9f29be99d9d4cddb1efd8d3b2556a199ff3b26b82f4b75d751a69dba85cf3bf", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "564575f4e6373b12b437541baf545a744ce94d322c8cc9d806584d3c6f0103ce", unrolled_ast = "85577e1da3f6a36f1e82732f077bf859dbae1031aa042cd3b7d674fe6708aeb7", ssa_ast = "4cbe622571a971e31f8b37407d579eb276616aa75b4b0ba135c47725f2c9c259", flattened_ast = "322b2aafef93b3989c80b792f63c0190d9a200978f2d0b83cf8f21d4b7d0ce17", destructured_ast = "29c55f49e694eb67c7f7a5254d09e17402da76a473e35d504856e9624553e865", inlined_ast = "29c55f49e694eb67c7f7a5254d09e17402da76a473e35d504856e9624553e865", dce_ast = "297a671457987f9ddb2e06529c81c05a06a91dddac49d4141a9b96a7e5a8b92a", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i8.out index 30edb0b810..ab75a6d59f 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i8.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_i8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "bb1650e04dbda5691d388fa7084fae0615de6bf8ff6a2c337baecd93f72fadbe", unrolled_ast = "bb1650e04dbda5691d388fa7084fae0615de6bf8ff6a2c337baecd93f72fadbe", ssa_ast = "acdf836505e7c677d05ede8cc857a750fee9d155f897b38556806c1841b3fbee", flattened_ast = "46b32fc44e663f2812a325929e52cd084b75fa196427fc472adf1ad03b66caa1", destructured_ast = "9be0bcbf92b813b4a1baf8f5046c80ff553901130b9444d3682b1b48dbd6a583", inlined_ast = "9be0bcbf92b813b4a1baf8f5046c80ff553901130b9444d3682b1b48dbd6a583", dce_ast = "45c5dfbfcfb155a61b14a260dadd1eee5117612c4d76759ba08e88e3b34a179f", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "bb1650e04dbda5691d388fa7084fae0615de6bf8ff6a2c337baecd93f72fadbe", unrolled_ast = "5a055863d48096422184166777966cf3a0edba531f725bfb5f0f8545164400b1", ssa_ast = "a43b63ee503556d61c0c508caa734d7b4d095cb0b039652db3132c5b6796e0ae", flattened_ast = "64ad882bf405e95d55ecfa2d03ef599fdfb5dc72e3853a54190bc8aae8a383c1", destructured_ast = "00caa31b3a5dc9f692c807ce1d5932839d2367fa0bc7b6a1e5c103c11bc8fe12", inlined_ast = "00caa31b3a5dc9f692c807ce1d5932839d2367fa0bc7b6a1e5c103c11bc8fe12", dce_ast = "51608ca3b6d76152faf075f4eafd2e3aeadeb96cee77d018a64dbc0502420bd2", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u128.out index f858b5302f..da52a0c0ab 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u128.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "ee4f60c5f316176f57612508cde4f131b0c2d4d243d3496abbb2dc7f8f99899d", unrolled_ast = "ee4f60c5f316176f57612508cde4f131b0c2d4d243d3496abbb2dc7f8f99899d", ssa_ast = "9ffd0cf1ee7ffb34fadba77e8c360329b417d6115679bf7b1bc88d3b09effbac", flattened_ast = "89b974e2eaf8f031827080f3f9f4c1e0a096c1a6cb958751d956baa4969b637c", destructured_ast = "22cf49fcbf07f2d92ac978f9bf0b53e4fd2eefdd307fc04a6a22088a89091692", inlined_ast = "22cf49fcbf07f2d92ac978f9bf0b53e4fd2eefdd307fc04a6a22088a89091692", dce_ast = "1faac211d091b6dad82c9652559c60d878dfb923eea1e83888e7d7a8042fcb86", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "ee4f60c5f316176f57612508cde4f131b0c2d4d243d3496abbb2dc7f8f99899d", unrolled_ast = "c54e29711a44721657eb7191b30bbf5cd461bcbd51bd55cfc95df91a366a75ee", ssa_ast = "8df64eeee85baf12e41876fbbe054d2a7d99a3ecfe7e1fcc14aef1b3da6ec2d2", flattened_ast = "e0c6b26aceea81051fc6cfd95e2c839b200b88098132357edf0e6d4707e1cfdc", destructured_ast = "46980abaad188738a2a0aee8b6be85e9cf0784b1ae5b700efcf9d983f0f4fbb2", inlined_ast = "46980abaad188738a2a0aee8b6be85e9cf0784b1ae5b700efcf9d983f0f4fbb2", dce_ast = "ad57d64750f571349fc1064424a9cc7da6c3a904cbb6674fb3383f91797db2ca", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u16.out index b350971bd0..a261a4e97a 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u16.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "6d7537ee933b51746d93325a2d2aca7315b8ff642a78f92d3e63c4f6f54d1f82", unrolled_ast = "6d7537ee933b51746d93325a2d2aca7315b8ff642a78f92d3e63c4f6f54d1f82", ssa_ast = "a1b8266d3af8e572e7d5aaa36922e1a0a71c37091ecd2089f67b7b27c47bf88a", flattened_ast = "ee8e7f9275ec183e42cd33038a42b0c8e7534470b8655295be65210ffc998120", destructured_ast = "9f8ec201e2c36c9798d6dd3a374e71bad9bc7a72f3e63f7f166c238aa3ac8209", inlined_ast = "9f8ec201e2c36c9798d6dd3a374e71bad9bc7a72f3e63f7f166c238aa3ac8209", dce_ast = "1a42396891fab9726e3a34425ce5171653680b5dedab11ea35b89b494d6a9f92", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "6d7537ee933b51746d93325a2d2aca7315b8ff642a78f92d3e63c4f6f54d1f82", unrolled_ast = "d98a38aee7384d1961d2b5d33a6b12102c261f1f87d591ac8b22dcf4a2e65fc6", ssa_ast = "e76e986194eaf1e821ac59dd886ec112e4ca98f4dbc0066c794e22c99d101b4e", flattened_ast = "64b6bbc4bf99796289d4c6bc38ad0a2e146989c56bd628b1213dc66d47a88899", destructured_ast = "dfc014fa6a9d4740992e2a8eba89dbd4d28f5afc613cc655b6220a1316d191ff", inlined_ast = "dfc014fa6a9d4740992e2a8eba89dbd4d28f5afc613cc655b6220a1316d191ff", dce_ast = "502b0c512607bf460fa79cb314cadde51f75dfd70115c50bd0ea6c9b9ceddcd9", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u32.out index 9fb95b3000..32ba1eb7fd 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u32.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "9e1e981d6feb7eff67a920f434d9b7fa996e1a7d3f7ef324ca443375e3e26b08", unrolled_ast = "9e1e981d6feb7eff67a920f434d9b7fa996e1a7d3f7ef324ca443375e3e26b08", ssa_ast = "fdfc38625f6c2298e3f63920725a6d432b9c673aeb261436e3a78f360d695558", flattened_ast = "df95d687dd5269b64204c26d363d1e0788fab1cf728f2503afe023bfaae7ce8a", destructured_ast = "222f915b75310106b189bf86a67237d4498476e5c3ee4ff508cad9a17e519215", inlined_ast = "222f915b75310106b189bf86a67237d4498476e5c3ee4ff508cad9a17e519215", dce_ast = "21a69ca0665b0d54c5c401ff8c62159c4b3d10531456da6730e1dc56987d4ad2", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "9e1e981d6feb7eff67a920f434d9b7fa996e1a7d3f7ef324ca443375e3e26b08", unrolled_ast = "f723dab02b06249d4e556a6ecb0812747bb246a88cd17ae75ee9b6a83983afbb", ssa_ast = "31f0510272fa35f17679dab3bfcfbaaa8936ef7aed685be6bd78b3065cde7415", flattened_ast = "cbabb87b4589e883dd61cf2fd8dc65f04b59ac027f199aa0850ef5fe65aee4f4", destructured_ast = "1473448bff4699b5936814bf81b59d1fa2c0a792e0ee9fa15e2d6f02e2bed174", inlined_ast = "1473448bff4699b5936814bf81b59d1fa2c0a792e0ee9fa15e2d6f02e2bed174", dce_ast = "02f8a7412a0bc307be07bcae6b726a9256ba0cf30cae99edb97ca8d906722077", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u64.out index 859dad2568..4e23b95961 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u64.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "8c3c3ee913d30cec14aac66a3ebec4e26f52b701c055da68b865a78f1bb02b09", unrolled_ast = "8c3c3ee913d30cec14aac66a3ebec4e26f52b701c055da68b865a78f1bb02b09", ssa_ast = "9f318d9e4bb2499591fbd2e00d6351c22a2358de2d161909dd1eaec7678883bc", flattened_ast = "91afb7de33059bde04c931844797467a691972eb27d1d1a5f189938270b0309b", destructured_ast = "0f87faedf33eadd3bd6e4e0132c6f57625fbf89a5b96a38cea828a39ba3ef4e4", inlined_ast = "0f87faedf33eadd3bd6e4e0132c6f57625fbf89a5b96a38cea828a39ba3ef4e4", dce_ast = "36c799bc081842581f4523788b6130ce459e264fd4db9e2004b5ea23c278808f", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "8c3c3ee913d30cec14aac66a3ebec4e26f52b701c055da68b865a78f1bb02b09", unrolled_ast = "cfcd50cede1cdfda370e909c33d7f4cac60f0b26697e91b1723dfbd9b69d70c8", ssa_ast = "0c6e068c1f8447019dbc0b29bbb1c93c31a6762bed39a8b0eac4030d10c80609", flattened_ast = "46fdd6647e583c009aacd6fa8aabbfeefd3555e0272089963f306f2ca66a0871", destructured_ast = "fecd077621a831d67e23d9420b233570b133593282017f56427c6c4ab2dd7492", inlined_ast = "fecd077621a831d67e23d9420b233570b133593282017f56427c6c4ab2dd7492", dce_ast = "5c07c1a89bfbd47a7ac983e02a7874f4d3aa9f1fe6970efa44fe0ba3089da938", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u8.out index 536fcd0479..aade820c46 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u8.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp512/bhp512_hash_to_u8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "809e522a97319e26936730436d965cafd891d81f25cb06d55a64d162a3150af4", unrolled_ast = "809e522a97319e26936730436d965cafd891d81f25cb06d55a64d162a3150af4", ssa_ast = "084be717b0c1df862b1ace8c9c23502229bcd1dccc6b18b8f2f6d570eb49dfff", flattened_ast = "932cf6b59e89ccb25b5c696d2230b890a4908d47c2dc657fdc26bd3f25d5259c", destructured_ast = "805a82b294cbdf098b6ac664076f77a6ca4b53011d557ca9aedb0fceeee864c0", inlined_ast = "805a82b294cbdf098b6ac664076f77a6ca4b53011d557ca9aedb0fceeee864c0", dce_ast = "6ce5b75c99ffaf52f71f87e5d54a26322407890f726f6e0fe8cdb65cd34b08ef", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "809e522a97319e26936730436d965cafd891d81f25cb06d55a64d162a3150af4", unrolled_ast = "18df2b9c798cf3398f738ecb3a0237c6e5ad4241910300b4f937e474fd182904", ssa_ast = "179e53429a9c6c3404a3ea9a3354eab8f3c10feca25dd4a54e6caac2fde0b8db", flattened_ast = "c8e2edefc3dec7214f45f70a6f54b7fcc037782df289f004b1e5cb7fda8a8a12", destructured_ast = "40ddcb68d5d1a6e1c83007d77abc5e50d4c97fe1fcbc4cb019608cdc0be548ef", inlined_ast = "40ddcb68d5d1a6e1c83007d77abc5e50d4c97fe1fcbc4cb019608cdc0be548ef", dce_ast = "1ddbd10c10ea7c0906a489d3130b4187c73d41d32aaa9b939b6d45c521959720", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i128.out index e4df765310..039c80c2e9 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i128.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "913aaf9590b036c45a6aff322458b70e7fa8d2223c6afba92ad58507eea4c64a", unrolled_ast = "913aaf9590b036c45a6aff322458b70e7fa8d2223c6afba92ad58507eea4c64a", ssa_ast = "ff280e316fa470880a27669605305a3500f5c9bf58ae8ee5eea1bb3cb4d438bc", flattened_ast = "ab88b31abf8f6ac0a759cc7ebfa60f9266726184f3e488add4f02ebd8dae1e13", destructured_ast = "e6259a369a77290cb27d1e50eaaf1b388beae03aafb52b754fd8a6b6b8ccf31a", inlined_ast = "e6259a369a77290cb27d1e50eaaf1b388beae03aafb52b754fd8a6b6b8ccf31a", dce_ast = "88cb819df191958d934a2757cf083c353424174ded80d7516f93945da1c86b19", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "913aaf9590b036c45a6aff322458b70e7fa8d2223c6afba92ad58507eea4c64a", unrolled_ast = "eb39e5b7f7445eaa36cc7c6737b517802681091c44d4e9ce0fb741ade4e0a7d7", ssa_ast = "63f892a55f0af17d99cec11298b447ff695bc44fb8ad0775dd96fc87d63c2076", flattened_ast = "c080cffe7a074effb993cfdde4d15d43fda9ea4375a005e44f5d6889dd0fa124", destructured_ast = "5c8d00cae596551bfee4de2e8df72e897ccc5f213edb14b7192dbb44f9875937", inlined_ast = "5c8d00cae596551bfee4de2e8df72e897ccc5f213edb14b7192dbb44f9875937", dce_ast = "4b0b88150151d99ff4c5d684eb5d18dbc148e73e1e5492527540ec7c1c5510ee", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i16.out index c6f960d920..fb3dbb2d0e 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i16.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "f3ecdb06b489edec882570532e6b6cfe1a0414fc505ebbd396d7872f5a34f306", unrolled_ast = "f3ecdb06b489edec882570532e6b6cfe1a0414fc505ebbd396d7872f5a34f306", ssa_ast = "f5b8fd722f3f6c8f37836b7798e0b8cbc85df6a88cc6c352df64f397e9bc1b22", flattened_ast = "d0dc43aae4eade3fd602297a0cd83a75ce57be8417ed482d9b9f52876837ece7", destructured_ast = "1af79fa10ad46976e61b8e5e58f702ce812d1492cf746225fca43021310ff39a", inlined_ast = "1af79fa10ad46976e61b8e5e58f702ce812d1492cf746225fca43021310ff39a", dce_ast = "39f89e6eb4c6ea1834731ce1d86a7c4bc684631ffbf42be5bd9a9606415247f5", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "f3ecdb06b489edec882570532e6b6cfe1a0414fc505ebbd396d7872f5a34f306", unrolled_ast = "a91c624ade81d0bd01118525319296a494f7e47cd66249ff4f53ae9624e723d9", ssa_ast = "5c88225fb95968fa5cdfc7832e9ed4d54fce5cbea05bd50f706b24025e752192", flattened_ast = "f12d42219ec26931150409d50f70859ce4504263fd621544f09b603bd58368c1", destructured_ast = "8e9180899db82e5281c3776a2bbd7368c57a35e2c316acb35663ef429107f0c7", inlined_ast = "8e9180899db82e5281c3776a2bbd7368c57a35e2c316acb35663ef429107f0c7", dce_ast = "c01fbb5402eeb9aeadace7315fdda76f889fc27a9502e962710e7661371c9191", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i32.out index 8a994c034e..2432e73e75 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i32.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "c22554507a52c39fa2dc0b2bd5e706eb40e537c141c5c79c1563e53f2c9d6a9a", unrolled_ast = "c22554507a52c39fa2dc0b2bd5e706eb40e537c141c5c79c1563e53f2c9d6a9a", ssa_ast = "b4767f26617ac261ca3d0ffd6456ae8c05cb3a798010ad5c6b12487ef3c5db90", flattened_ast = "d2faf7cf2cea9d5912b1bcd0954d6d14db20c840c200411218a855c314f8507d", destructured_ast = "5418ebd393bf8a00318a2f2427fee33e02202f824028906ada449b15d1a74a8d", inlined_ast = "5418ebd393bf8a00318a2f2427fee33e02202f824028906ada449b15d1a74a8d", dce_ast = "906fc44e416c70828e5221d29cdcfaf17b74f80a4136b1fe4feefdcb59d978f0", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "c22554507a52c39fa2dc0b2bd5e706eb40e537c141c5c79c1563e53f2c9d6a9a", unrolled_ast = "29c0979ec2582cfabd2f126682a0c2de6a0848b4cff6aca98094b05aebd92e1d", ssa_ast = "196e2faeef47a07d60f72727b363e2066febba55a47da586ec86484bdcf1f4d9", flattened_ast = "6c3c0e62d639b7a78f93c08c5bd7010c2dd353a9abc8e3c25b68014a03154f53", destructured_ast = "0f45cd038273e80f1935464caba7985fdc14f4f4c36579d99d9a9d52d2d29734", inlined_ast = "0f45cd038273e80f1935464caba7985fdc14f4f4c36579d99d9a9d52d2d29734", dce_ast = "95cf2e0e5c2f68a03d73c4cca70efc2a21762ad39688c30f09de155aeeb9f837", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i64.out index 805ce353c4..5e53bca09d 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i64.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "63cf391a302c5a16dde79e1bbf9b2dcbc474d0ba6ab04a261d8187cb1206e9a4", unrolled_ast = "63cf391a302c5a16dde79e1bbf9b2dcbc474d0ba6ab04a261d8187cb1206e9a4", ssa_ast = "782efa5a3599fddf556e2477f5f9d921ee26ed0b526bd3bed574ad5dd809da4e", flattened_ast = "f6774b66177923fea86808b0516cd14a4d712cab54801fb346366378228fac60", destructured_ast = "a5a980b7b318f2906926d39b6b2fb8abf8d3ff91dfd944a4f2988348ecefba37", inlined_ast = "a5a980b7b318f2906926d39b6b2fb8abf8d3ff91dfd944a4f2988348ecefba37", dce_ast = "4ea3b0e6554811354c802d8f7c778c8319f4a5f07c11010c4cc139da22a1d5ac", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "63cf391a302c5a16dde79e1bbf9b2dcbc474d0ba6ab04a261d8187cb1206e9a4", unrolled_ast = "4b6c21526e41358fc068425d950bc0a928ef2acc2f922132ef29605df4fcdadb", ssa_ast = "20daf41338f6cf5d16eb320179942acdbfe461ad7719356a06e584fcba55674f", flattened_ast = "2b2951201acb425c83c01c899f9ebab05ffd25e22a461a06fd89dd9e14dea51d", destructured_ast = "bac405908fb483771f8d2edad8d4cb921b7eed09795610c67076ee8af2d90b6d", inlined_ast = "bac405908fb483771f8d2edad8d4cb921b7eed09795610c67076ee8af2d90b6d", dce_ast = "554896284b6cc73155ba7735ac9ddbac2df0e60ee7228b0a554209e9b335e12e", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i8.out index 5c84ab4ba9..14151e29b3 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i8.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_i8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "d3ee63ba4d7268393907d4e0eca081f3db1e9ec5357904551691b3755a80d47a", unrolled_ast = "d3ee63ba4d7268393907d4e0eca081f3db1e9ec5357904551691b3755a80d47a", ssa_ast = "65c2712e74359c63d261c520c15d22c20243eaf011a669db2eb6df18897f6ff6", flattened_ast = "8c30005ef561aeffb0d8767e1d5f9518b8f5a3e732ef09d573d4d3ab2045ca07", destructured_ast = "b959d22c25d8c573f2be98b4000d2acc29c46be8d57604ea9380626b03652ff9", inlined_ast = "b959d22c25d8c573f2be98b4000d2acc29c46be8d57604ea9380626b03652ff9", dce_ast = "f1cce96804179d4b902cda1c86a3d93e7480978d4f9d1d7744b489ecb0fcf2d1", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "d3ee63ba4d7268393907d4e0eca081f3db1e9ec5357904551691b3755a80d47a", unrolled_ast = "08abe68012c29a0697687ebb514dac3483a1cdf8b2732eea3d7aeb0105dc2223", ssa_ast = "00944bf4e9b991927ff5f3abcc7e87d3ca0f1d18f2f743ed139d4af83037b494", flattened_ast = "ad089f6345c7132e853f2faae0579d929a1de9931cd50ad7b4974491b33fc3f1", destructured_ast = "5012620b2bc544e6b3f1d78fb2cf9d533d76d08b04d01075a387546542e1c13a", inlined_ast = "5012620b2bc544e6b3f1d78fb2cf9d533d76d08b04d01075a387546542e1c13a", dce_ast = "83cd8ce6e2ab8fbd94963fa341df6864b231bb6d2883007159734a54625779b2", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u128.out index b6c1c433d5..e9e41693f4 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u128.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "c99a58051d5cc5187a6402726f8ba001e03333d3b2298de813a46f4aad889f2d", unrolled_ast = "c99a58051d5cc5187a6402726f8ba001e03333d3b2298de813a46f4aad889f2d", ssa_ast = "0d2cdec54b1641aafcaa28a4e339a443ce57f0a3bdd6f22a1dc39f02b5dba9f0", flattened_ast = "f2c381e4c8fbed78a982a6186602526d8899bec45167e975baca81793dfd32a3", destructured_ast = "d1b800bd754cf87e7a78b7623586b7fc82e6d6a5f23794a20feea74eedd14507", inlined_ast = "d1b800bd754cf87e7a78b7623586b7fc82e6d6a5f23794a20feea74eedd14507", dce_ast = "e1b8f81f24efa30178177af10e77a3f252dfbb2824186a061a077fe650d9b069", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "c99a58051d5cc5187a6402726f8ba001e03333d3b2298de813a46f4aad889f2d", unrolled_ast = "8f7161c0cd3e9e58d682343a359876a1e03e847a97145034b7cdf370d151dd34", ssa_ast = "e134c8d6477352daf7803408aae76b9b7134b241af114e6f0e45e04967b36c8a", flattened_ast = "1fb32eb70340eefb2b32e4ef5bb41d4f429e9af30ebccc1dae1ed793f077e87c", destructured_ast = "b47590d97e28b8c0ed879e7aaec2adb9b4c31fa686c1df7df431ec59f62c2799", inlined_ast = "b47590d97e28b8c0ed879e7aaec2adb9b4c31fa686c1df7df431ec59f62c2799", dce_ast = "5d6a24aa05ea584d8b0a9c47c47803fbbc1561132750f3d8de25099111197e2e", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u16.out index 0d59d0ab1c..afa832a55d 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u16.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "b8fcebf03abe1036145e4bbe5648bc5ef97533dff35bb04dc55a82641e1903bb", unrolled_ast = "b8fcebf03abe1036145e4bbe5648bc5ef97533dff35bb04dc55a82641e1903bb", ssa_ast = "7744090e575da126d59c5404b42fc8183804f171a1cddc5d833c850dc337fbb2", flattened_ast = "597fcff0e883eaa4ebd1c6dbc670fa281d7c8b05ace1d0aa1f7b04a863499812", destructured_ast = "bc8d1016eaa1487f1ee5ef7c528316d3c0765bdfc4ef46472f9fd661fb8c7f61", inlined_ast = "bc8d1016eaa1487f1ee5ef7c528316d3c0765bdfc4ef46472f9fd661fb8c7f61", dce_ast = "938bcdd0f4345e9c3d49c30c703ec3e60f5f2dc5bdcbe1a5e3a02a50b3a099a7", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "b8fcebf03abe1036145e4bbe5648bc5ef97533dff35bb04dc55a82641e1903bb", unrolled_ast = "2aab17354a87872a6dade3db36fb25f104b933209b799c880db1d358abdd8a4e", ssa_ast = "2b5e089e0f4cc4b6298fdedec9f62d631effa4464fd117fd50e840360f6b2433", flattened_ast = "85410eb049e30a64dfed8059b80781d2fb2f9c2bed60d6e40f44741bf5ce20d9", destructured_ast = "602e3801461ee97a07a6b3d9c4ad2afd199d4cf2cbb892358a818ec0fe802fba", inlined_ast = "602e3801461ee97a07a6b3d9c4ad2afd199d4cf2cbb892358a818ec0fe802fba", dce_ast = "059372be7829d41bcd9a0813feb3afcfbd044329dcfbe2adda9e3834926bff43", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u32.out index d06b4fe70a..115bcd8fad 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u32.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "8a8959681eb6ba84ccc3524c3c93d423b01dcba516a72e37e82944a0744be54b", unrolled_ast = "8a8959681eb6ba84ccc3524c3c93d423b01dcba516a72e37e82944a0744be54b", ssa_ast = "800902faf5921129f9c8b6415b56c994f6e1c46064fa3c8bfee36b3aff461f22", flattened_ast = "44346f8c071c2bade8aa466554f513ed1ae6a23bbec68fafd232d9c4d5d6aecf", destructured_ast = "519c56dd311791ae18048cc10fce3b869592abb6a46133c506cbf381e3add3e4", inlined_ast = "519c56dd311791ae18048cc10fce3b869592abb6a46133c506cbf381e3add3e4", dce_ast = "259ab1eef5667a691847fac77945a73bd0653b788b118988076508da1378f0a6", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "8a8959681eb6ba84ccc3524c3c93d423b01dcba516a72e37e82944a0744be54b", unrolled_ast = "21de15e96391e149d8d76f4db06c51176e483e9edd98cf88286d8ea77b991c5f", ssa_ast = "b606207f0d4f91b92249a77de22020a83f474fa0ed79536744cd18841dccdef3", flattened_ast = "d800a62e36820371b3fb5dcaaef65932bd17a9fbd19e7930a389d2758d8976a5", destructured_ast = "a16f8d7fb6ea77673f9e9b39e5d6b6f84aef471911393a5dfc7c3cd3e6cc118a", inlined_ast = "a16f8d7fb6ea77673f9e9b39e5d6b6f84aef471911393a5dfc7c3cd3e6cc118a", dce_ast = "871275a207ea62e8b66147ee1779ad1a984ba30c562a9494a461497ef3c366dd", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u64.out index faf8437c53..4b2e958ce8 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u64.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "6ef04889ddaa77a5b9307ccf41746047b642577e0274e8e095dd50adab77f259", unrolled_ast = "6ef04889ddaa77a5b9307ccf41746047b642577e0274e8e095dd50adab77f259", ssa_ast = "fb6cac3c3e632a0a39a6467378bbda251bde571fd0905409d32b16469dc93ece", flattened_ast = "74601f20d70267be259db14bb36815c8311bb2d39d37b91270d9c31c522d3c70", destructured_ast = "76d28123bbf3e44d31181e52b4a5cd478503105b57e027abd4cda627e6630afd", inlined_ast = "76d28123bbf3e44d31181e52b4a5cd478503105b57e027abd4cda627e6630afd", dce_ast = "ecf71b8e2d496188c53db6dc8bc970c2dcb15bce1614ec871f72cd9477c31211", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "6ef04889ddaa77a5b9307ccf41746047b642577e0274e8e095dd50adab77f259", unrolled_ast = "451137058b769582e58b35da381727fdb05fb76b4c4ebea7f982ba6431066fba", ssa_ast = "ee4815d6298f4a2ca019932d1fbf04a5449ea468320719994f3ee2c7f223093f", flattened_ast = "05705af5a5dba910eb8048f747679d1fd9e98ab40402f978f45de28aaa183469", destructured_ast = "3f61d66018294e6a3eec22b783f653c273a5f1c8d95a108bb497b93e6e609836", inlined_ast = "3f61d66018294e6a3eec22b783f653c273a5f1c8d95a108bb497b93e6e609836", dce_ast = "e18d963c0ef546ec70770fe24903ebdf47ea873af1879d4bb0a68f90cb10af73", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u8.out index c8cc77a681..b4200e199c 100644 --- a/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u8.out +++ b/tests/expectations/compiler/core/algorithms/integers/bhp768/bhp768_hash_to_u8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "c2cd904f9ff2b53dd22d7ac9884433de236f0718691f36f41ad4400ccfcdc8d7", unrolled_ast = "c2cd904f9ff2b53dd22d7ac9884433de236f0718691f36f41ad4400ccfcdc8d7", ssa_ast = "3c17bf2b3ad8c7d4aa6e9794057e326641325088966dbd5fba3252e7f5ed47cc", flattened_ast = "49192f6707c27d69d754b79e554e29f942b995482fbdc8eddfd7f2f54b56c414", destructured_ast = "2b12033cc76187696a1a4f7eff994c09e3137ec77e7c803c23651b9c90594796", inlined_ast = "2b12033cc76187696a1a4f7eff994c09e3137ec77e7c803c23651b9c90594796", dce_ast = "3b7f4a85737ad47f1d661568a401e3c7c2b89adfb448382c6508082295aee0d1", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "c2cd904f9ff2b53dd22d7ac9884433de236f0718691f36f41ad4400ccfcdc8d7", unrolled_ast = "2c8e31a0eb902de9743cc29267bc119b73bff7ceeb19593520582b331910146c", ssa_ast = "36c68534cf88e6e568ef489b11224862722fbd6fc0993099379f6c9bce62cb45", flattened_ast = "b9efab57790d57e19b4f9356919c7426e5454776f4df025b32bdbb3f58f6258a", destructured_ast = "0d6a1b640497bd2520df3df07c8f9989950d8308b76f66110e50296cc485e215", inlined_ast = "0d6a1b640497bd2520df3df07c8f9989950d8308b76f66110e50296cc485e215", dce_ast = "5858d3de5a4e6ed0df1f409afee3e78289858da403c86774447e398f3e686dbb", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i128.out index 5f5eede800..92bc3d8e05 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i128.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "0219892567a6b33def9f6105d7d8a09c9242fa4745ab19ea8e48d12115d8ba20", unrolled_ast = "0219892567a6b33def9f6105d7d8a09c9242fa4745ab19ea8e48d12115d8ba20", ssa_ast = "2a5086d81441cbf5d429710c89afab365b346913b2b5bf46b5c350d820af23f2", flattened_ast = "9d40a2dd4e5f2931000afacf0b96b64d2a5c2d3b5de40c21773a1668c3e59b03", destructured_ast = "d7204f01b4217c8df75a18d764bc3410df629c6a29502332eb0dd4c5eda9d353", inlined_ast = "d7204f01b4217c8df75a18d764bc3410df629c6a29502332eb0dd4c5eda9d353", dce_ast = "0fda7fb582c7ed29083e34fcb2773dfa46d47c9616ef9397f0a82be465680ad6", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "0219892567a6b33def9f6105d7d8a09c9242fa4745ab19ea8e48d12115d8ba20", unrolled_ast = "71a1a47763b66f35ac7953d8e7d53005636502eec4b54fe56f21e4188836361b", ssa_ast = "db35ecc96d279de6d89a863947c3d4af750f8f5d330fad9c66ef72c13b583da9", flattened_ast = "4ea684fc20a1e11bc770707b29e337fc011bde9e6db4ec9598c52c375645ff27", destructured_ast = "9ead8eb87ca5efe77ee15fa4e3c3e6517f299e073f77be3cccaebe190905fd86", inlined_ast = "9ead8eb87ca5efe77ee15fa4e3c3e6517f299e073f77be3cccaebe190905fd86", dce_ast = "45e400b935e69bba5477c814dffda401d35ade36981a7659526c70072bbd74bf", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i16.out index 75b46324d3..00241a6bad 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i16.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "8a2829ac025a0fe899c1cba30f6860be3cde6e9eaf0cba5fcb09595d0dd4e241", unrolled_ast = "8a2829ac025a0fe899c1cba30f6860be3cde6e9eaf0cba5fcb09595d0dd4e241", ssa_ast = "4b1899b900bec14033efa872cf3413e2f275771596eca682e31a880a8e1b14c4", flattened_ast = "708ac258505acf4018a89cef8145aeeed13ea8d5a4ba43c80fcf59d940df91bf", destructured_ast = "1450d18b1770459b545c8d0fb7f36f59c000122c55a879c6cefab3048a283e6f", inlined_ast = "1450d18b1770459b545c8d0fb7f36f59c000122c55a879c6cefab3048a283e6f", dce_ast = "6c154619844b2ad895e7a659ab4da865ce8a585a18e0fd2720edf6f7e565a760", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "8a2829ac025a0fe899c1cba30f6860be3cde6e9eaf0cba5fcb09595d0dd4e241", unrolled_ast = "cc08b455f32adeab32469bcfb580dfba2aca0997b4f14dcc1e287858da8034a9", ssa_ast = "7e35057183c157d4b5a4b099b33da924dd46d5147642bba8ef94fabee8266ebd", flattened_ast = "38f064768f983870c7c5dde7e49993f1c7ab1be1ebe7fff2f88d2b8895e7f5db", destructured_ast = "0e9aaf6c18a1e1eb041c0b75e588c03496c18893f025d98819b711a0c661e2d6", inlined_ast = "0e9aaf6c18a1e1eb041c0b75e588c03496c18893f025d98819b711a0c661e2d6", dce_ast = "51638758aa5cc8955ef14e35a09ad333f228d5d15f081a3f614752473217ebcf", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i32.out index bc8365ea5a..8065649ff5 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i32.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "d5c535250da9b9a05592b1a0543d2520c8ee90c6378a51446f44f4f56ab83135", unrolled_ast = "d5c535250da9b9a05592b1a0543d2520c8ee90c6378a51446f44f4f56ab83135", ssa_ast = "ade2a8f25360850e57f37e862392a0efc1784a4b3249c7ae931f80cd45e4fd9b", flattened_ast = "6f14d2cc73d4815c918a4a123070a1602dc15736b579e9404a58ffd1f7b73eab", destructured_ast = "9b13bdf83e230b0f05d1255df2e19c57652a6a1070ed1d270672921d278cddec", inlined_ast = "9b13bdf83e230b0f05d1255df2e19c57652a6a1070ed1d270672921d278cddec", dce_ast = "e1e8189a21ef91ae7fc59993edc82734827eb268e954a287bb04edf64eb57beb", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "d5c535250da9b9a05592b1a0543d2520c8ee90c6378a51446f44f4f56ab83135", unrolled_ast = "2d4912858f4d81919cc45f9e1a2d43f7cb33f512ffa039892be9007661d9ae34", ssa_ast = "7a8558448352912ffc9c5c56fd2350b2129f3cd5abeab7ca72107b5430b93268", flattened_ast = "be553843d50a61569a07dd0f15e98696bc9edac65fd1c41511fb63ed46abda43", destructured_ast = "d04095651441c69719af91faaa56c65152d9c4c6233976aceaa25e6cdb28d0b8", inlined_ast = "d04095651441c69719af91faaa56c65152d9c4c6233976aceaa25e6cdb28d0b8", dce_ast = "c07097cea88810e0eb41e65a4a53174c2319f5e6b2dde250c372bd984de3cfb8", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i64.out index 81ddd95905..ae785ef63a 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i64.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "9ab673743f3594d0979bdab5fcc40d7eff16e8a010a7e78c494c6b6253c49b42", unrolled_ast = "9ab673743f3594d0979bdab5fcc40d7eff16e8a010a7e78c494c6b6253c49b42", ssa_ast = "6a33264186dbca4f84dbfda9550b9ebc1f343b7d2c05164ed66d781d658708a3", flattened_ast = "93a762fef97c9afee0f6f904e8977445bfdb28c67b661641e78a88d03c565edb", destructured_ast = "89b71b66017fb49d87105014799b40b0c5e4f3da1983566ce4610604f5f95936", inlined_ast = "89b71b66017fb49d87105014799b40b0c5e4f3da1983566ce4610604f5f95936", dce_ast = "d830edb12dc5ce2d45cd99c4f144feb768c88804eb55bdb1c7aa968ded1e0c87", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "9ab673743f3594d0979bdab5fcc40d7eff16e8a010a7e78c494c6b6253c49b42", unrolled_ast = "14f202cc3d7a7922719b4e030c18c6e2a8cc3a0539e9f2a9674c381d6c5cc650", ssa_ast = "116b561c6ed5609f1510e9bb3079eb775f988884802422eba3d78335debafc45", flattened_ast = "5ea0de805b996844f4bbdf39544e5dbd3f9985f0df4ee706f7efe7f844fc7614", destructured_ast = "8c650af99f8d5c3dca0dba274c5983894f919a41c0580c6a7c38ac14e62153f3", inlined_ast = "8c650af99f8d5c3dca0dba274c5983894f919a41c0580c6a7c38ac14e62153f3", dce_ast = "3ba453be308ffe9ace567c2d5ce3d30251c84aff5226e3e25afa94e1dd0bd190", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i8.out index a8aade33c2..9d6386d72c 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i8.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_i8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "cfd38b25169a6a9a4e582c2192fd35bd5f75df99ba69603139810b73abd5bf02", unrolled_ast = "cfd38b25169a6a9a4e582c2192fd35bd5f75df99ba69603139810b73abd5bf02", ssa_ast = "3d3df77a510a6dacfe7c5c7baddf7a3d583f1a65029991ddd759974cf246e769", flattened_ast = "9885970843ae001071c5873488c1e73f3383922fdf8ea61d4177cc4b52715285", destructured_ast = "942ba0190600c00466f55b5784f0793aba749b7a39ea34aba6715fcb65f6e54f", inlined_ast = "942ba0190600c00466f55b5784f0793aba749b7a39ea34aba6715fcb65f6e54f", dce_ast = "e6ba927ef5c9cfc65bd0949e67a12146d01e0aca1dbd80cd91582c00f6e41f94", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "cfd38b25169a6a9a4e582c2192fd35bd5f75df99ba69603139810b73abd5bf02", unrolled_ast = "f7e6bd1bb94e86638793ec694b4590225a9170a87d6686c5667304dc164bb3a2", ssa_ast = "1de8f569a014c2db03724ea7536a718cfcdd5d389251b31030511eceb912489d", flattened_ast = "516516f2f45c939b6cc84656d958c559b0d3a1965afccfd24a96167d64ad4564", destructured_ast = "6d2a36f11cf3c6ed64160245bcec479a9e2d88313b298d158febe8d28297290d", inlined_ast = "6d2a36f11cf3c6ed64160245bcec479a9e2d88313b298d158febe8d28297290d", dce_ast = "39ae4a00ff375dfa9a594f82a014f0e8fcac3f5e9eb209e28b533464abd78956", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u128.out index 7756234e42..0488fdc017 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u128.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "8d0eb730df6c236c4ce33fef6479ee55a30474b53850424c5cbe2b1544f1be07", unrolled_ast = "8d0eb730df6c236c4ce33fef6479ee55a30474b53850424c5cbe2b1544f1be07", ssa_ast = "10a89e419d3b7b02bee6a6efbd1318ded6beae1e4784cbbc3ebdaf2fc9d68ff9", flattened_ast = "346ac5476f2410177a7adc05c61a1f1c1d8b6840b3db1a82193a19410d22f618", destructured_ast = "cdebe1f7a58754d7699074304c9d544d713b35d571282f2e266dd6879750835f", inlined_ast = "cdebe1f7a58754d7699074304c9d544d713b35d571282f2e266dd6879750835f", dce_ast = "9c400b98eca3a3eb0f3ed05514becedcfd94f7150df1cb9c6ab03978399fa666", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "8d0eb730df6c236c4ce33fef6479ee55a30474b53850424c5cbe2b1544f1be07", unrolled_ast = "4d4b9a6e978c8a45ca1b0455e6fbb8ce43c2970f615e380ce20112a585e57155", ssa_ast = "0c68935f3f64bd387d8239b5fc3fd25106fb52e2383315c5b7ce80c17f4ff259", flattened_ast = "2ab46185d81131955d5472ed74064ccc1b77621a175e7316b01aa2592a6b91d7", destructured_ast = "a98448ca846613e39b9949317229f6ca4ea957f91b4988919339e2833457bc1e", inlined_ast = "a98448ca846613e39b9949317229f6ca4ea957f91b4988919339e2833457bc1e", dce_ast = "8930f5db7aa9a77174aba610389a8c41d208a14a2aee735ce34365bf7e231235", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u16.out index 510c04802d..08c6364ebf 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u16.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "b0f80eef333158a3dedc3b31aa88c1073f10423c52b26169c2be1aa23bcb7127", unrolled_ast = "b0f80eef333158a3dedc3b31aa88c1073f10423c52b26169c2be1aa23bcb7127", ssa_ast = "eba91b49ba040c117e2b24cce084c0d4fb3db081c8f4424b985d469db0577c65", flattened_ast = "a5bcf17fbdd950885e4e8f08f288fc9850fb04a0d1427eeee22fc62baf47b171", destructured_ast = "d291fc8b68267a25818d55f4e47d8a338537ac6cb027025c06e9d48b406c221b", inlined_ast = "d291fc8b68267a25818d55f4e47d8a338537ac6cb027025c06e9d48b406c221b", dce_ast = "60ea36ee353326fbb6b95478a2010f27883daf2b6db2050c9b6b5669e3a526a5", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "b0f80eef333158a3dedc3b31aa88c1073f10423c52b26169c2be1aa23bcb7127", unrolled_ast = "fb4c48eb6d349eb4b484bf76cb82bb41a40be03cbcf4ce0fc0e555912618b779", ssa_ast = "41b98fe6aed5b1533cbbf5f9fc7f421d45614d4385f780653db38088afe11a06", flattened_ast = "4ebd2c8dd9ec4e0612a6c65ae9c1364dfae7a50abe5522094637f453abb70523", destructured_ast = "5c8f7c477e6399f96a22909e54e440b39f91fb0c6acaa4e0e5860f0b25fba415", inlined_ast = "5c8f7c477e6399f96a22909e54e440b39f91fb0c6acaa4e0e5860f0b25fba415", dce_ast = "96e55ac3e66cd4f84782849c968e99fa7dc1d0cd9944b97df8d7e18a146b408e", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u32.out index 5498506d32..edfd46efd0 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u32.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "1e89b481628f609f74cbdae36b2aaa4dae117f0e552ff0ba06e266eb1671e7ad", unrolled_ast = "1e89b481628f609f74cbdae36b2aaa4dae117f0e552ff0ba06e266eb1671e7ad", ssa_ast = "0f5829bc300159f779e49f7c96931298be5248cd5d1f21307ecb835d6c69eb88", flattened_ast = "eb1b365e4f1d861b5f1094ff7e306c9bf13d7a8a3c06e086abe20e1c06ccca3b", destructured_ast = "7eceaf1c92d312ada9b98715672b35cbf9163fbbb48f0c378bff3f86aa42d006", inlined_ast = "7eceaf1c92d312ada9b98715672b35cbf9163fbbb48f0c378bff3f86aa42d006", dce_ast = "64bca8c58bf19e8b3c459bf44e4ca6c684e498290f4b14d498fb776c62312bb8", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "1e89b481628f609f74cbdae36b2aaa4dae117f0e552ff0ba06e266eb1671e7ad", unrolled_ast = "fdaa3767795a3cbfad59eb24fc5099db179c255dbac132fb87922bd1dd06955d", ssa_ast = "1f4c164b2e4466d51b730f7b9d4539b98436fd537381fafa543309890b7a7a15", flattened_ast = "162695e2e16f95b4498be6d2c43cf5c95b6f31f50bcc861a735a7fe900c86b80", destructured_ast = "89f02502eda1d8673a18b5e09ab4842d33f11832461c22ada50c46ff1aaed601", inlined_ast = "89f02502eda1d8673a18b5e09ab4842d33f11832461c22ada50c46ff1aaed601", dce_ast = "7fbaf9780949aebc1e087c3ff99034711197fbf648b80eb40a475f0274b656f5", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u64.out index a15e1d27e9..f1f8784b4b 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u64.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "fa2a745862f5902a0844fc8a9344c2c16c863dfe2cf56d75e6db563e5dcf9708", unrolled_ast = "fa2a745862f5902a0844fc8a9344c2c16c863dfe2cf56d75e6db563e5dcf9708", ssa_ast = "1db427b7d2a775b57169e60a3de479e9839f319062a9b515098b9d4171491947", flattened_ast = "26d413cfb97d0ffefed89a5dfe154e6ba920f58a1098275819c6c61c7c936cf6", destructured_ast = "a326d8c8eec43a9de7585f50d9690ba4945c5e2603ecb9c2a19f2cc77eb4d75b", inlined_ast = "a326d8c8eec43a9de7585f50d9690ba4945c5e2603ecb9c2a19f2cc77eb4d75b", dce_ast = "077abf2c4f00fa50708559ff3ee1ef2fbcb35e65d0c83f0c835a182db1caacba", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "fa2a745862f5902a0844fc8a9344c2c16c863dfe2cf56d75e6db563e5dcf9708", unrolled_ast = "016f922601b75b57fca10572e503e4f9815d1b11fc6e7c534d0632f66d25df60", ssa_ast = "b240995eddfb51138673644cf8e6bc099fd813ab2a36e86cf8a0b5a3d56c04a2", flattened_ast = "27c65c21635b5c2e7eb99c648e931b852a23bd5fd4890d0f9dc2e4df9133b19b", destructured_ast = "a592e0f3eb126e76e19bc7a8c3ca50fa4e48f7c9408d0bd235646896d792b62c", inlined_ast = "a592e0f3eb126e76e19bc7a8c3ca50fa4e48f7c9408d0bd235646896d792b62c", dce_ast = "cac8c46aa9e1f7bc7683f52e505803327146ffbbb297ddd4569c51736d75be7f", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u8.out index a84174462f..ea9ab8cd71 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u8.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak256/keccak256_hash_to_u8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "1a5f4223050526af9c2bc183f162231b468371b6553204a1138f3af6c389a64a", unrolled_ast = "1a5f4223050526af9c2bc183f162231b468371b6553204a1138f3af6c389a64a", ssa_ast = "9c61afbf1007db9c29c4099ec9498da651fac926c5feb22df5c1189588a4e1ca", flattened_ast = "7ef58606225e1250bf7b55724eabaa5e59124b7b6f1e0da0774201e57f2996f8", destructured_ast = "524e0e019bc2a49966276c5c13b27278a1ed53cb2135947664c63c44594d21dd", inlined_ast = "524e0e019bc2a49966276c5c13b27278a1ed53cb2135947664c63c44594d21dd", dce_ast = "8e13d17b8e5af92f6b2f3bfb5ddf1aa92f938ecbffee73218eead391711b84b9", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "1a5f4223050526af9c2bc183f162231b468371b6553204a1138f3af6c389a64a", unrolled_ast = "240f64545a0655bd307da8856165076d44a7b62ce3bf84f9e50c26278bae8d56", ssa_ast = "6c7acd17482e347543a95ac894b89779c0394c21f9d5c675143328abdec13509", flattened_ast = "46e5eda70672a988dc2b2cd05a81b16171a650701ebd0e0a385369d7814c7164", destructured_ast = "f1a5323a4fb3738d3bf62934a275716ee90b704881090a4b7aee8ee375e4d31d", inlined_ast = "f1a5323a4fb3738d3bf62934a275716ee90b704881090a4b7aee8ee375e4d31d", dce_ast = "965ac7172979fc4a0285feefb6d43c974f93c28ca89f7b5f2427c1b660f0dd50", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i128.out index e53188a24b..a5a087e556 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i128.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "8518512436454079e4f9559e223ef664b9db6b03a5553fc8546d526b88760013", unrolled_ast = "8518512436454079e4f9559e223ef664b9db6b03a5553fc8546d526b88760013", ssa_ast = "a57aed4551c77589d289a6995a1d6d022e5b8c89223ceb7dca0297ea928dab83", flattened_ast = "c92166f101d059e2fba1c9907bdaaa5f7d8cb2337fad2c82ebaa4f4ae3956c9b", destructured_ast = "50ac7287a314cf813fc0a5bd5d793747e947b457913804426761235373c320dc", inlined_ast = "50ac7287a314cf813fc0a5bd5d793747e947b457913804426761235373c320dc", dce_ast = "f2b6ffbb16357802347aee4d16d5e05ce9146dfbf668d8a24e9f0350b643d49f", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "8518512436454079e4f9559e223ef664b9db6b03a5553fc8546d526b88760013", unrolled_ast = "34ed427b64403ef2a6949f62c2131d830ac638294e79b9c66819774ea173182a", ssa_ast = "c68e267a647e10b4e34df46132c0633de2819b2c4e5b6ecde6eee9dc194d4b02", flattened_ast = "c4be214a9d1c255a593ee319518404c6d708d7de3d2d2d1892cd254c4b95d11c", destructured_ast = "75574f6bdb33e8d604ee01b9246b132bf0e74e814f2f4b2c417327f1ed43fce1", inlined_ast = "75574f6bdb33e8d604ee01b9246b132bf0e74e814f2f4b2c417327f1ed43fce1", dce_ast = "9f094fc8b368139af040a29ae760311469a534c7277b98acc13ee4c4d596514c", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i16.out index f5e3eaa855..b80f402f9c 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i16.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "ba3898259a2824f95be822a5daf97931fe2080f30f9bfcef5607beba6c099213", unrolled_ast = "ba3898259a2824f95be822a5daf97931fe2080f30f9bfcef5607beba6c099213", ssa_ast = "fd6494afbcac01c1dec21bc662a2248814bad2488e7f36cd104bcdcfc43e3d6b", flattened_ast = "2eb33f23b55bfebc1a0ba0280a0fdb4a6cea7a8a39c6cf6689f2001fb0cfde64", destructured_ast = "5a466aece670095f525d6d9e38532adeb41e6ccd441fcbacb9d7c217af5502c1", inlined_ast = "5a466aece670095f525d6d9e38532adeb41e6ccd441fcbacb9d7c217af5502c1", dce_ast = "142d35ed20ee6dbf9d41b1cbdb8b9aee6e80abb9c746f5b835e5bee79b411857", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "ba3898259a2824f95be822a5daf97931fe2080f30f9bfcef5607beba6c099213", unrolled_ast = "2a355f47d695c0c6949bbcef122b3b4353d60e1ce61e897a2f6f3d31e140a83b", ssa_ast = "0d2ff4f646563d1d678e630910b9eb1b5753bc755c731d4f36617b3c9a679de3", flattened_ast = "7bddc9ed0ef826b54c0581b2b795e54bd358fcddbd86734dc5359d0b6f3d435c", destructured_ast = "8d9bf49e46229079bd275869d625c40bbf816583aa49107241d5ca08f5c0ad63", inlined_ast = "8d9bf49e46229079bd275869d625c40bbf816583aa49107241d5ca08f5c0ad63", dce_ast = "e5426a583945a001b564b8aeb0acb2828f5247a5d44f0bb84f0a09e06ebf8384", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i32.out index 132493f96c..93153ec92a 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i32.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "bfdbedeeb92b1ee61047a14fa9252a847fb77b08fb50da440dd49b7f017a8cbd", unrolled_ast = "bfdbedeeb92b1ee61047a14fa9252a847fb77b08fb50da440dd49b7f017a8cbd", ssa_ast = "59fff31af3a3c47401e51244a03bb5361e206db9ca04ad5a27747248e61c349a", flattened_ast = "ba3930860561f29fd19c13519e18579898367dfe36e76899ee828d35bce22083", destructured_ast = "5a71c107177d2737debd76da247e6d2abff590bd071d6c012266de2c5a1dac5b", inlined_ast = "5a71c107177d2737debd76da247e6d2abff590bd071d6c012266de2c5a1dac5b", dce_ast = "e2aa83f4debfdf0d05e13d08c0b87e1465e67f549f1b27454aabe26920e3babd", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "bfdbedeeb92b1ee61047a14fa9252a847fb77b08fb50da440dd49b7f017a8cbd", unrolled_ast = "24df053d232f604b549cc8a228df62491d02b477f5b39dd099291744ad3088da", ssa_ast = "fba62bbabdfca10e50c0ee10e1efcf71ad5af828ac69d10d3687c7b630daa6b5", flattened_ast = "679d4dba7226f648e8febc153f7d1919439c9fc10fcc15d055aed863b548199b", destructured_ast = "d0d79cf270bb96f8b09071f1326b93842ab8ea9891eff41176bb2842973a708b", inlined_ast = "d0d79cf270bb96f8b09071f1326b93842ab8ea9891eff41176bb2842973a708b", dce_ast = "469559a7255ed03d88ea04809177fc04b5b49ba933c39296907aaf6142062610", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i64.out index 01af444469..cb2b85f810 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i64.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "b25fb77b11b643939ed5c49d9139f0b98e96d93c0f41b826e84098e6f32fdacc", unrolled_ast = "b25fb77b11b643939ed5c49d9139f0b98e96d93c0f41b826e84098e6f32fdacc", ssa_ast = "feb8df3f031d4decc90b8829832727392a126a6c90abfad1fa669409d2f401e3", flattened_ast = "14cf66577cc0b3311f383d839cd56eca91d4281360ecfd56d23e65e8c162db84", destructured_ast = "5de4d1ec25088a606ebc07ee80750f90ffee00c4eaab2453c9b61cd4a8023c2d", inlined_ast = "5de4d1ec25088a606ebc07ee80750f90ffee00c4eaab2453c9b61cd4a8023c2d", dce_ast = "6bface0a7e45eeb927840757fb12fffb19bce9e27b13722ce5f093b3d37732dc", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "b25fb77b11b643939ed5c49d9139f0b98e96d93c0f41b826e84098e6f32fdacc", unrolled_ast = "d5e095d8b0d1ae5e684026bc74673dce48184503332ef27c74ff0ffeea922e12", ssa_ast = "e270292487504d9f03742b0e068c77c9010677d8650de62a88f98d4bf4aeef1b", flattened_ast = "0629c871d68b9be8c465c473d9883e9166a05df3900e85b4022f97f3a363c515", destructured_ast = "4fe7cd46316ebc75138453e85065af386d90b68c339b2bb3d34a75b41130c1e2", inlined_ast = "4fe7cd46316ebc75138453e85065af386d90b68c339b2bb3d34a75b41130c1e2", dce_ast = "c936180170b8f2672f417ad878f1a86e31fa132e8c9e22ece7297c344c9517fc", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i8.out index db27e2aed5..2c0e22ac95 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i8.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_i8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "36443dddd6c85acf7616f5527e0f601464378a8ca65226f4800b4a3d61f1c228", unrolled_ast = "36443dddd6c85acf7616f5527e0f601464378a8ca65226f4800b4a3d61f1c228", ssa_ast = "045c04b5b8186f116f9d5ea8fcd6cb648c0ac4d08d879ed76001f85acc83248f", flattened_ast = "ee7198c9a9bc3f6b61af2cbe2c2990349ad0333a060cec741d390a38fcc86196", destructured_ast = "2b4804691be550351737afd19f9a589e073404b93a7c3d5585edfa913efa9cef", inlined_ast = "2b4804691be550351737afd19f9a589e073404b93a7c3d5585edfa913efa9cef", dce_ast = "897fcbf1be15e3efd19aec131dd59f1e137f6ca8802fd46af15db9cde4e8175c", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "36443dddd6c85acf7616f5527e0f601464378a8ca65226f4800b4a3d61f1c228", unrolled_ast = "e3a67b69adf54beee472dc314749b048eba4456cb86ab7ed24ac92c9592e8886", ssa_ast = "aab48864321961d99eb1cf29d7eeb7ebe836fbabda0eb5032b8476bc3db7551b", flattened_ast = "ffa72d4af68a33811041e80760d2c84d2a845f8f3c181762cb8a19de35c2eab2", destructured_ast = "ae57e94f64f2d77ca17b3b0b6f7ebe92b127ad2a63195d87b2e04dd6e539fd06", inlined_ast = "ae57e94f64f2d77ca17b3b0b6f7ebe92b127ad2a63195d87b2e04dd6e539fd06", dce_ast = "f7affaeada193fb995688265d941b46f2c51d3a59264405866ccfce9db4ce7dc", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u128.out index 5ed1763c2b..49f90a384c 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u128.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "bb02614a739dd4440d009c7e122f55a73ba018b288b51c5675b75d0d8597ca76", unrolled_ast = "bb02614a739dd4440d009c7e122f55a73ba018b288b51c5675b75d0d8597ca76", ssa_ast = "c85e100768e5b01ccb17402136c2f4e14fc2ff21aa11ea2263fc951f3e7fbebe", flattened_ast = "8c5a1bf8e4696195182b10c0ecf0224c28af4991405cb62d6f066d74cb3039c0", destructured_ast = "be3f8be7855aa0aa26a6ef52872e7eccfcefd9c387201cd78374ae5f2bde9991", inlined_ast = "be3f8be7855aa0aa26a6ef52872e7eccfcefd9c387201cd78374ae5f2bde9991", dce_ast = "1ab967ed6b82fc04f127e4ee10f5ca7395b136e8210d8760db1f58ec76ade859", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "bb02614a739dd4440d009c7e122f55a73ba018b288b51c5675b75d0d8597ca76", unrolled_ast = "e23daf3a8a798909fc5f2bf5eac47fa2affda89bf59aa3f1c0b78fd974dd7348", ssa_ast = "9390c67e55cb8395eb37e911bc58910f2071a596b4981c09df80f8edaea823e8", flattened_ast = "4e585a2a842c3ae00912f8a52d988ec40e473b053fafbd1f419ec50fca5226d5", destructured_ast = "3b575a91f2a1608ab64599501a12fd5758830c8a2a4c55752947eb99edc461e4", inlined_ast = "3b575a91f2a1608ab64599501a12fd5758830c8a2a4c55752947eb99edc461e4", dce_ast = "67a872ba4314136985e9e1f88182f4a58d564598c8072fd4514ca57752ff2485", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u16.out index cc6cc1b8da..bfa8074388 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u16.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "cc5bf0cffdb84101459d2aac374724bd575cd6f9c63475b95418330634360b39", unrolled_ast = "cc5bf0cffdb84101459d2aac374724bd575cd6f9c63475b95418330634360b39", ssa_ast = "bb7cd0f232cb86738b6a00e93f3c90740859135d28bc6c7fd455ff87ed8a4182", flattened_ast = "b9057c03e948cb8a8db2c36c7a8014982cb9a06455db8a198ea597fefb701adf", destructured_ast = "0e63c61f208e42f7c77cf915d0c4f8f01958f741799afa6a7ee89b5a2fc9483c", inlined_ast = "0e63c61f208e42f7c77cf915d0c4f8f01958f741799afa6a7ee89b5a2fc9483c", dce_ast = "fe7182fb99154f09a443752a0c581065f5746e06cac6cfb49a6266a252053582", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "cc5bf0cffdb84101459d2aac374724bd575cd6f9c63475b95418330634360b39", unrolled_ast = "8323f7f4a7054fa2106f7418e21f966ff0de05a85a66466c10682406f9f5fcb4", ssa_ast = "966149edd4b1f83b0070f7a7235c141e9131bcb53813be8903759dbffdadf6a5", flattened_ast = "c594de47ec250ab5adc150543411830ca0755190db5716064a71bed1743bbb9e", destructured_ast = "4f336fee721fabbd45a111154d919f759b83c6c57e3a36e9ea75290ae2b11cd2", inlined_ast = "4f336fee721fabbd45a111154d919f759b83c6c57e3a36e9ea75290ae2b11cd2", dce_ast = "9c9f97d83cd2a0001cd5df904c3f56df9497c0fe68f0e4ec9be7d61a57c792f0", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u32.out index 21c5216682..df25dd54b1 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u32.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "932ed6f215497eebb5ff8e9685ceb0056385c0ca52972b75816ab64cec8ec2a4", unrolled_ast = "932ed6f215497eebb5ff8e9685ceb0056385c0ca52972b75816ab64cec8ec2a4", ssa_ast = "ac5f9d81b2ac804832a95285e99e81ca0d7d8048389a80dad21a770bfad4708a", flattened_ast = "58b79a6ab405ea234929433ef45a9c7f21fcb6cfc8cc2d4ae9743b8ed086ecab", destructured_ast = "2ae097e24c7fe1a4a7c95eb7bdb8542d0a83277cc396523e83d747bf6fda27e7", inlined_ast = "2ae097e24c7fe1a4a7c95eb7bdb8542d0a83277cc396523e83d747bf6fda27e7", dce_ast = "dd66c81bc235771b7e0e3141f8825f8442b69ce08739f53d35269be6eeec634c", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "932ed6f215497eebb5ff8e9685ceb0056385c0ca52972b75816ab64cec8ec2a4", unrolled_ast = "49e86ba9c2eeabbddfc6ec4413461c48651017817784430eda125ce6da710cbf", ssa_ast = "28925ad2c63a0085b1b7ca0c778af6b46bfc76cd2419365335dc2e00963a211f", flattened_ast = "c525ca8039ef5aaf79c262b6fdf67ec38e475a6084ce91edb8276615fa29d18e", destructured_ast = "786f66000707d59f292a291c9569fd98d0c86ba93597d73bdd29716babed7094", inlined_ast = "786f66000707d59f292a291c9569fd98d0c86ba93597d73bdd29716babed7094", dce_ast = "d39d2886f2b8cfdc1dedf0b9e4f410c4ae45f9a800e59086b918f39219098a9d", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u64.out index 92aee84a3b..48e481fc85 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u64.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "fbc425432e4bb5f196cf15abded34b03c2561dda3b3f3893a13729e5fd5451b4", unrolled_ast = "fbc425432e4bb5f196cf15abded34b03c2561dda3b3f3893a13729e5fd5451b4", ssa_ast = "d1baeaba60462458e6df188fe19c46ea37d991f81fe726d7e2bb8a4e4917f440", flattened_ast = "86bfec7d06f017f4534b3a525b7f992fa3a83fad16d3752a37dbee0db0713290", destructured_ast = "4ea05d10385e7ec975633f1e7fdde2178abbc81d9db211be2431b5790e2bbfe0", inlined_ast = "4ea05d10385e7ec975633f1e7fdde2178abbc81d9db211be2431b5790e2bbfe0", dce_ast = "1e3f8cf6138191870cebaaf54e8994caa04d7a61117e929e13f242a4b0faa4ab", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "fbc425432e4bb5f196cf15abded34b03c2561dda3b3f3893a13729e5fd5451b4", unrolled_ast = "e1a935101071f2b72e99a0ad728df75166baf3c1b877c50b6b7ec27cc869f6d5", ssa_ast = "cf3c32c8d26d22698ed10c51e9ea479306105fe33f419700e9b2b6e41643598f", flattened_ast = "09f29057f411183772e6ef67c226c5b5fbc536b4e2f4915575925118260ed21c", destructured_ast = "b61669b4ceb13763e92eca216cb3ad241e6c44e8b9c6c669ff03551a8edb747e", inlined_ast = "b61669b4ceb13763e92eca216cb3ad241e6c44e8b9c6c669ff03551a8edb747e", dce_ast = "63f98377cc0b21b787dad75f860fc1654ca3513ac79df61877a34eb2e8c9442c", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u8.out index 4e4fddb54e..a63df794e0 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u8.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak384/keccak384_hash_to_u8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "7cbefcf233f595dd332a73bfc95c09142070e1a3d522064d3e72c50a3995cbc3", unrolled_ast = "7cbefcf233f595dd332a73bfc95c09142070e1a3d522064d3e72c50a3995cbc3", ssa_ast = "3d235bb27ea9a6855a26838932654330770853dc748b8170fef0539d9c8d4d7b", flattened_ast = "679bc7c371e24e6977a31751bc155098c91ccbcdba3f55356e02565c799bcd6e", destructured_ast = "819bdc3657b2cc5a6ec457416533a81f301b61267557403e9cd5d7ffb9613bc6", inlined_ast = "819bdc3657b2cc5a6ec457416533a81f301b61267557403e9cd5d7ffb9613bc6", dce_ast = "d06a46481785a801e5af8404a5ee5276034b3117f41872217cadb455efed3995", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "7cbefcf233f595dd332a73bfc95c09142070e1a3d522064d3e72c50a3995cbc3", unrolled_ast = "a686fa1cf6504a1dd07ca33137cd468c05917389302a07364baaa9cd7d1c3b46", ssa_ast = "f3f978d939f2605d5352bfa408cbf237faa3b58024f0eafa4e8c2bd49c9a4601", flattened_ast = "cccb409253889053ebe51d12f7b1b1013bdf82f1c274ff0ab261297c198d4804", destructured_ast = "eca19896565d02ac61208d814c32582fec0fc4eeeb3927d0cd9b506ce55ae5a0", inlined_ast = "eca19896565d02ac61208d814c32582fec0fc4eeeb3927d0cd9b506ce55ae5a0", dce_ast = "1512da502bcc4627413e4308c6c1f0e7c745a9f981df4475d040f802f05ac48c", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i128.out index 50308c034a..be055d0460 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i128.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "a61e87cbd1a7003003394f0b138c512a729092387c97c2df550c7fcb6c7aff61", unrolled_ast = "a61e87cbd1a7003003394f0b138c512a729092387c97c2df550c7fcb6c7aff61", ssa_ast = "9bf40054a5f81c2265f28d1bda2b6241d90bcc904ce368dce16d413e10ec0b58", flattened_ast = "facabec340f058efc6f8f5f3873e056dcbac447a1639c91b3279c92eb08025ba", destructured_ast = "324766b45d2b33de664673e96443c6cfb2f76e66ddf7e4902f47653b158a5fd1", inlined_ast = "324766b45d2b33de664673e96443c6cfb2f76e66ddf7e4902f47653b158a5fd1", dce_ast = "4e5f7d2c73bb5d9d1ea5cd342687429c84663f73c5972031c3bee078a2daa06b", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "a61e87cbd1a7003003394f0b138c512a729092387c97c2df550c7fcb6c7aff61", unrolled_ast = "c8b98445e69839e1f3436032f3317dc5891c1423b32182ea65d77609c679e310", ssa_ast = "f3b0da20ff61c8411623dc71acc22cf87db9c27d7cab505fa6d79178ca1e5288", flattened_ast = "d6619de01375b680226abd2f483af014b78ffd24e6470232f7dc88106ecc7ec5", destructured_ast = "c9d659c5767a8f8e92da9377a1a4b3c3a9e2fa655b29e5f107a64ba5d0241b39", inlined_ast = "c9d659c5767a8f8e92da9377a1a4b3c3a9e2fa655b29e5f107a64ba5d0241b39", dce_ast = "d610e548eb0e5e76d3b04e95a00f83d41c02b89b345c919d3e2d988092ad73ac", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i16.out index 6a48862047..21f4ddec7c 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i16.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "29911ed87b03c07bd6b99b62195e59211a2e7d30195513e508f0072d14a3f0fd", unrolled_ast = "29911ed87b03c07bd6b99b62195e59211a2e7d30195513e508f0072d14a3f0fd", ssa_ast = "cd23739278b3c7588036d4f0309cdba551c85e829067ab1afb6cc4ea3b698df4", flattened_ast = "5c62f135685d3eacd1f6a0e81b8bfc5d53762db270a63b7429d2d758a4d0eb1e", destructured_ast = "cc85a1e8ce174107377c1cd724246c405a62dec85afcb5a08a5750d1af7bac63", inlined_ast = "cc85a1e8ce174107377c1cd724246c405a62dec85afcb5a08a5750d1af7bac63", dce_ast = "dbc9a9ccf29e511a0ff2b7fd6e2648d52f7b3e2533ef80d68ffb07a893f9e3f3", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "29911ed87b03c07bd6b99b62195e59211a2e7d30195513e508f0072d14a3f0fd", unrolled_ast = "f2e7a25ed833b23872a228380f55e091c3ad3b75e0622dd742e5a1946bebf32e", ssa_ast = "10df31e4f505c0ebf58d96b968cfa485440209d1c54322673f85ff03d924af3a", flattened_ast = "f3630f1803979c89095f23546aa9e70604d1e1c0d55977c8b226e10c717de363", destructured_ast = "fcb6ab38e8d8c09aa05eb9fb7c0996b31a9b3d5e8c9bb014b95126c6d175b9d4", inlined_ast = "fcb6ab38e8d8c09aa05eb9fb7c0996b31a9b3d5e8c9bb014b95126c6d175b9d4", dce_ast = "c719912f047f388dab440e6aaa839cb418aaf3cca1b15d8213e3c41f27c32fb3", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i32.out index a30b161c7d..5a6d278e2b 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i32.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "6fadb2f85ac266943cace73ae380b0d89c255f1d504974df0e3160c646d85dbe", unrolled_ast = "6fadb2f85ac266943cace73ae380b0d89c255f1d504974df0e3160c646d85dbe", ssa_ast = "1be47cfd3379c333efec08a42d797da32be5b527b11855afab9a2efc3cb05873", flattened_ast = "b97a51c3267d339b65e71542d1444d4280aed288e7f347d25e64731ccf8f175d", destructured_ast = "8c0544ada1098ef6f58b3261416492c80456abe7ff78ea44bedf065343f0a249", inlined_ast = "8c0544ada1098ef6f58b3261416492c80456abe7ff78ea44bedf065343f0a249", dce_ast = "b766fe47c44764acfa615d8a4c447f4a02fc8b757a0ae9135f5c3de5d3d3251c", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "6fadb2f85ac266943cace73ae380b0d89c255f1d504974df0e3160c646d85dbe", unrolled_ast = "44ef621b0a17a15083445531ba54d2b992e5f713cb1f97ed1f775de9823ca7d8", ssa_ast = "de821a59d3462dedc51a48d6cf11deea7dd52a40bc3c8a8a636e0cfe6d3b8a0b", flattened_ast = "642e910878156ad20b650adfa09adbb174c3376f8bd1eb584230e6bf2037cdf1", destructured_ast = "0da7c4ac7b486df37cf18982d27a82f29b43b64fbbc05f27107ae631d673f5aa", inlined_ast = "0da7c4ac7b486df37cf18982d27a82f29b43b64fbbc05f27107ae631d673f5aa", dce_ast = "c2349192eac88d9da5c122cd7012d7c88c0aaa434417ae0f90f9943660805f3c", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i64.out index 410ad39244..fccdcaf47d 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i64.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "5b18e361e04a6588772c916f04aa608f0bf38efff2eaeef74f9b51b84f6c38ee", unrolled_ast = "5b18e361e04a6588772c916f04aa608f0bf38efff2eaeef74f9b51b84f6c38ee", ssa_ast = "b81812c55cc10f47dbf9882513bb234f247119cb2a7be2eb24727b0d0bfeec1a", flattened_ast = "7b6243287dd81f25d72f0edee9512bb58acfb34a7ca59e6f8132b4e167cce2fe", destructured_ast = "e88b3d7fbcdf3bd450ac0fb67599513d84d8fc542fcb0e40fc6b4901f30730a8", inlined_ast = "e88b3d7fbcdf3bd450ac0fb67599513d84d8fc542fcb0e40fc6b4901f30730a8", dce_ast = "9f86938b2f47f721c3934a7cfaece81a90a69670acda3d45775031d369f0104b", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "5b18e361e04a6588772c916f04aa608f0bf38efff2eaeef74f9b51b84f6c38ee", unrolled_ast = "2121fcd3b1e760f6b85fa9030b301aa3d0b35c8ccf7bbbc4e6df281455c9f099", ssa_ast = "e4434a820dbcdfc526a4f478ed31d7ce8a257ce47941e9d675449c94710c514c", flattened_ast = "a7eaf8764de38a4dd10950390ce449e03063767b9a18aa89d09b37852569d9ef", destructured_ast = "56cd8dec104165dfc4970e8700d9bb2a604c9339a8858e622210c8573f44abb9", inlined_ast = "56cd8dec104165dfc4970e8700d9bb2a604c9339a8858e622210c8573f44abb9", dce_ast = "6d131ee2a61c2712131ddee84ff8bc8dd89f29b63ac304c758de9cf5bd4cb474", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i8.out index 5134ac6c85..3115afbe37 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i8.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_i8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "581993f9ddb206fefa3e24d1086e7d890ad289aa2973f630e8e1a692dde767a5", unrolled_ast = "581993f9ddb206fefa3e24d1086e7d890ad289aa2973f630e8e1a692dde767a5", ssa_ast = "a21c48d2cd3f38260583f4608465c168e57e936de0628bd3e68ebb33c87d81d8", flattened_ast = "0dad05bcfc040d470ddfc5ded9124eabacb3660202560e2815107db7ed0649c8", destructured_ast = "80d5c3180478992f4999876ba63d7614afcb6aed1586705c1e75729773c8c601", inlined_ast = "80d5c3180478992f4999876ba63d7614afcb6aed1586705c1e75729773c8c601", dce_ast = "7c99e01e7f88df4a0e61cb54f89f579ef0085d478eadfa6ce5363dc66fed261c", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "581993f9ddb206fefa3e24d1086e7d890ad289aa2973f630e8e1a692dde767a5", unrolled_ast = "1c39e30b1206f6f518817b85fa64685afb86837de037759c2bbe5b6eb94ef435", ssa_ast = "baed6b7b9cb25e5dde28711d1aa75eaa409214c8239d4a2a46a3f9d24e9ba4ef", flattened_ast = "737f7f0730c997f0a4f9ab3f02ee4a27d4245cd7f398f3eeeb743fdbe5c855cf", destructured_ast = "74c501834c275e2120b99942a2a5b5e8e7a8ba82673ec1c83d990e70eba736c8", inlined_ast = "74c501834c275e2120b99942a2a5b5e8e7a8ba82673ec1c83d990e70eba736c8", dce_ast = "567e5e08c8a3b6a31247c73b7d5f7c359380f415e9f5e2a0bba3cf3be788e17f", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u128.out index 4f3d467ae1..f08683adae 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u128.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "0aa2b1ad01a3a839835a1b55dbda18cafe66aca55d824ee69eebc375cb8a692d", unrolled_ast = "0aa2b1ad01a3a839835a1b55dbda18cafe66aca55d824ee69eebc375cb8a692d", ssa_ast = "bcacd688da4627769e8959664338bec2d47fda295e6262fce3dabf66df5de7f3", flattened_ast = "922bd9eb5ef1f391c4cfec9560a3f6c4f1faf011f40eb15df580f49d1acdacb6", destructured_ast = "dcf738447dcf30c69655d723ad4f205ae42ef9ecec899824447857db336a31ac", inlined_ast = "dcf738447dcf30c69655d723ad4f205ae42ef9ecec899824447857db336a31ac", dce_ast = "70e704a186c6c81c56c7dc96343c60d791aa3f98425b7253ff21548a6646738c", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "0aa2b1ad01a3a839835a1b55dbda18cafe66aca55d824ee69eebc375cb8a692d", unrolled_ast = "868edd8f183064ea44e723500e3159382d8616cdbd74b133ff6d4c5d6d2f5b02", ssa_ast = "44508e324017c40081925da7f22dc7cff2721c8ef09af70734048834736897b6", flattened_ast = "b6ef4c2c38c56da6564d6155232658265c38910e11404f4bb1ff9602705fe659", destructured_ast = "0ee599d2a98a3ac42605cc87ed09103df994da52ff8326c683ad99edf84e4a35", inlined_ast = "0ee599d2a98a3ac42605cc87ed09103df994da52ff8326c683ad99edf84e4a35", dce_ast = "d212f108e3c2a03aa4fbc5e773327f697ac665d8f9e9d9020867d0dbb346f0fb", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u16.out index e667e81ab7..111acf93d1 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u16.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "3c23bd11eb47b2a6bf9791442a6e6c860568c865a411efc5f5079f1f011dc8df", unrolled_ast = "3c23bd11eb47b2a6bf9791442a6e6c860568c865a411efc5f5079f1f011dc8df", ssa_ast = "baf15e83d5b029d1a2a245c987b234b1da0099f1b13774348e50a77818280ccc", flattened_ast = "071527d3eed490dbcc66b935a0cc8c771aa344b4a03f736352077ae3bf9cb9e5", destructured_ast = "295c2afd824442cbca7afc910e3905c0bdaadec959215df863ac9a30ac7f988b", inlined_ast = "295c2afd824442cbca7afc910e3905c0bdaadec959215df863ac9a30ac7f988b", dce_ast = "b40ada564ca5c8ad4a6524bf2239e152bf295fa004287f86499caa04cc8ea20a", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "3c23bd11eb47b2a6bf9791442a6e6c860568c865a411efc5f5079f1f011dc8df", unrolled_ast = "beac55e5c74e6683ac5218c212659ac617052de6dbde59bc39762d2a8f5d52d6", ssa_ast = "40ab75754f1abc8e2d0c975ab3f732bcd9b99de18a3642f1f128d000932acba1", flattened_ast = "8908565a89c867831dcfebe96247a81dab18cc275e19748569d42d403dd0989e", destructured_ast = "e2ad7006075f51eaad6c5cc6b775c02e9199b4ff1c99d3c0bd6f8a4f6f3ad69b", inlined_ast = "e2ad7006075f51eaad6c5cc6b775c02e9199b4ff1c99d3c0bd6f8a4f6f3ad69b", dce_ast = "caf7598c811d086440db8db80a2192c8f44bda687fdb54bf6e591a9194d57aac", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u32.out index 0a395ab5f2..129c560ff4 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u32.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "205a779f3db953f58162ae6206d9f39f82801485f471b7ab90c1f2ba4c2b4325", unrolled_ast = "205a779f3db953f58162ae6206d9f39f82801485f471b7ab90c1f2ba4c2b4325", ssa_ast = "94859a9de50f3ec38a12eb3bb0d589b031f6f4cc757277b4caebc6003ca5f4b5", flattened_ast = "1b74b4583ff09f1ad9510256148c1da78abde83475b678306748fbae2ff7b96b", destructured_ast = "f00de24de158275d52488ed6845d864cf6efec6f1ceeb6033b839682eeb9d95a", inlined_ast = "f00de24de158275d52488ed6845d864cf6efec6f1ceeb6033b839682eeb9d95a", dce_ast = "0dd912f49dbf14b7bbf2a5703e956fa3c137eecb5cf47642a03823c1a3d69e85", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "205a779f3db953f58162ae6206d9f39f82801485f471b7ab90c1f2ba4c2b4325", unrolled_ast = "0851c36d6155124e00b500c84fb5f34dc77f795332a241f6e19c17518e059487", ssa_ast = "9417e82271d1dffc0e6c3854225fc4fc7d6cc65830d41250934c73683a9ec835", flattened_ast = "f17a7559a29441f977484f42bbbe05ec8dd9c211f46c9a71e7931d1f354f84fc", destructured_ast = "c764bb62644d7f9da0a41e4448da0680a68c026aaf5c7a62f9909db231f06af7", inlined_ast = "c764bb62644d7f9da0a41e4448da0680a68c026aaf5c7a62f9909db231f06af7", dce_ast = "be719227dabaf093cc71e68beb51e9f4e311ace6017ec470818c579ebab52392", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u64.out index b5daf80fe6..395e972073 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u64.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "5a498c7969381b7386bca021146a670dee84f2cd0e42803b41fe0ac878845ec2", unrolled_ast = "5a498c7969381b7386bca021146a670dee84f2cd0e42803b41fe0ac878845ec2", ssa_ast = "48a81d35f8ade04fcc8abfea8a8a5282e00a8468162071461ec8f2ace0864975", flattened_ast = "25edbb4bb70f5695de03e17b5c57a3781eab459ea9fbaa133b43b158a8b270cf", destructured_ast = "2ab891b1d88e0bc1e0603597f0e9f4bbaf4e62a94529248c783c598fb3d6acf5", inlined_ast = "2ab891b1d88e0bc1e0603597f0e9f4bbaf4e62a94529248c783c598fb3d6acf5", dce_ast = "5e9d256dc258a1b0de3504b957b747fef66c641b28a7649fce7d01b2c172e088", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "5a498c7969381b7386bca021146a670dee84f2cd0e42803b41fe0ac878845ec2", unrolled_ast = "e2c6afe63435501a5d3fac9ad35f9c417971aaee8f3a1758f6c883ee1cc9b4c9", ssa_ast = "611aa1afed1ceb6e1ef2d618444183c066a152ea35b070e586d23aca2786f679", flattened_ast = "cb2131402c1ba62b01ccdcd860753dac0c0e4b2437e415303bac807e2b64f115", destructured_ast = "262ef1b8b659fe9b127b252e90720639739abec2a2ea09c52aed4556b2c0e8b4", inlined_ast = "262ef1b8b659fe9b127b252e90720639739abec2a2ea09c52aed4556b2c0e8b4", dce_ast = "b7163fe0dd853978a24aece803d53994c02a5c1e3e30c942c4d943feb9aab5de", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u8.out index 43c6878642..ad5aa86c87 100644 --- a/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u8.out +++ b/tests/expectations/compiler/core/algorithms/integers/keccak512/keccak512_hash_to_u8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "7c25e5e1c9dbb015b4c00372ec73f6d85665b29ecea3cc41c7a0bdb01aa107eb", unrolled_ast = "7c25e5e1c9dbb015b4c00372ec73f6d85665b29ecea3cc41c7a0bdb01aa107eb", ssa_ast = "d10a2b494f51f7b5eef363f80ce8c28272d1b8cb1e9c2a3b6fcc7e3580b97de5", flattened_ast = "9fe368220b9bd5b40f1865a518688ee016d9dd1f3e1dfdb29af31111dc515afe", destructured_ast = "a3a01af30838ce68b87b7e12b044c1be4f4cae3a70e8756bbea3d065533a4446", inlined_ast = "a3a01af30838ce68b87b7e12b044c1be4f4cae3a70e8756bbea3d065533a4446", dce_ast = "dac297dcea43fb032d89ed57057665c8af192eb80ab88e141a65108a3d73dd42", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "7c25e5e1c9dbb015b4c00372ec73f6d85665b29ecea3cc41c7a0bdb01aa107eb", unrolled_ast = "3156cf66595766f7a73f1e69d55f54be33b6d81cb78c6a06de6babdf54e8361e", ssa_ast = "08633529142e2cea240d6e8839ef65fddd1be29f513d7750c9420f54386d8bf0", flattened_ast = "2a54c871e5112a8bd69f78d84d4ce7d3809dea2fdc9aa8f13c8f5add357800db", destructured_ast = "fa748d2f857c687c4f4de47888f4be50e63790434fe5cd42cad5ab10288e1084", inlined_ast = "fa748d2f857c687c4f4de47888f4be50e63790434fe5cd42cad5ab10288e1084", dce_ast = "4d1d4f0ae7f86b185937d4ed0f7a101bdc8694761ce3799085436c388694f676", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i128.out index c431029e6a..e5efe98ff7 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i128.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "9045f1c6891518849abb5853f5abb34124c693ae5c3dd04bd2df6cf4f24e0708", unrolled_ast = "9045f1c6891518849abb5853f5abb34124c693ae5c3dd04bd2df6cf4f24e0708", ssa_ast = "5a2c78fa7db8d771a0bc05e6efe3cb1a7f548a4a7b57709268dacba374504b74", flattened_ast = "315fde849a79a5134fe24b5a3682964ee96c18969ea0ce4da98ecd4d4b3e27d2", destructured_ast = "8effb966af7ff4aac4ac6edce5e79d576bbd934ee5cad55657d634eb0864cf70", inlined_ast = "8effb966af7ff4aac4ac6edce5e79d576bbd934ee5cad55657d634eb0864cf70", dce_ast = "54c843349afdb0d0b6d73bd188eb531b1e4d133ffc4628cded90c4e670e99f2c", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "9045f1c6891518849abb5853f5abb34124c693ae5c3dd04bd2df6cf4f24e0708", unrolled_ast = "b2793847f9d1980e7355be93da11d13597e631328896bbf1f6ccb37ce2f647b6", ssa_ast = "76445d5e6014e2fb7600bb8ddd57a3009b09b8941353b4138e4a693d5158176e", flattened_ast = "9dc8f6e4fc7d9fa5f4efb4af4bae99ed8c2e704f4c2191f989a9366ab6163eb5", destructured_ast = "dedaad1cda6dbdeebd680d57d0d466720f0ffcf044c5b299f81a8bf98337244d", inlined_ast = "dedaad1cda6dbdeebd680d57d0d466720f0ffcf044c5b299f81a8bf98337244d", dce_ast = "bc428304afc142717f25aaa85ff949031b1904f9e1d08ba2e3eb2ca569528d3e", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i16.out index dd2206f639..4e2b58d897 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i16.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "c880644ce96d9b55e498c5cd619122b0796780c0b8510ab53ab36b938b3422ae", unrolled_ast = "c880644ce96d9b55e498c5cd619122b0796780c0b8510ab53ab36b938b3422ae", ssa_ast = "6fa269fe2585a5547f26497836077d862f3d407315619beaec631744999aa76f", flattened_ast = "c2f822156e4e17b65846007102e44853d79d38b8134da6df50b3c603042e4605", destructured_ast = "784f1aee83338ef3de1bb9ec63171355fa09a665064bb3ccb6142c3971b71b01", inlined_ast = "784f1aee83338ef3de1bb9ec63171355fa09a665064bb3ccb6142c3971b71b01", dce_ast = "304c505ecd2a048435cc5f667e08d6634ce6fbc7e341bf049ec4907cb6bda263", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "c880644ce96d9b55e498c5cd619122b0796780c0b8510ab53ab36b938b3422ae", unrolled_ast = "f79db16cda6077237f0b3d742f96e3633743c42c5ebd48c938a759ddf8426490", ssa_ast = "25d6f8bb80468b46e03d0e0b478fffcf381f80b7f1e2a1aad8ceec98187470c3", flattened_ast = "f120cf5698b5cb53e728aeb80f6586944ffb3ea985d9abe23bb4a59b0bfc77e2", destructured_ast = "bda1880cbf68c80b4d2d555150354de1b8ce2c556b92ea50840b33a4ea0091e5", inlined_ast = "bda1880cbf68c80b4d2d555150354de1b8ce2c556b92ea50840b33a4ea0091e5", dce_ast = "1123666a45435cec9d5c2faef54ee1534570c9eb6fd55f5cd78f613d55a34268", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i32.out index 9add36bc40..ff40b013e7 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i32.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "c604091ed1b0ef2f8f74f60da81466777a76f822a33f66560990646e77a28755", unrolled_ast = "c604091ed1b0ef2f8f74f60da81466777a76f822a33f66560990646e77a28755", ssa_ast = "d98ca67df0c22b56df4672fdee20176535a6c1126e48cc129b2d1f91a54d11d1", flattened_ast = "c47942c335c3a148bf6822c03035998c49cd849d16074201e9c7b88dd2b94fb0", destructured_ast = "57c3f3dd46c7df20bdbeafc59266edd266fb5af09a80a1de057e9e2b38adddbd", inlined_ast = "57c3f3dd46c7df20bdbeafc59266edd266fb5af09a80a1de057e9e2b38adddbd", dce_ast = "6fb87e4d1db2153348b6cf5cf88b2a37592dea16d7cd12a9d234c1a967ba52fd", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "c604091ed1b0ef2f8f74f60da81466777a76f822a33f66560990646e77a28755", unrolled_ast = "9c1551ff27d5d5fafdf7bfebadd740cccf0d7ed3defca048e261bf3f21fdf1e2", ssa_ast = "267c101bc44773cac8e5c94a7dee8abdcb20cb6873698cfe0eb08bfd609c538c", flattened_ast = "5acdea9403c92100d7f55cf21734b4ae6498b7611fa84528a159359c56d073bc", destructured_ast = "af4ae8728efba7a68cbc42e161810661f365e8156db9379485543fc7e257d7bf", inlined_ast = "af4ae8728efba7a68cbc42e161810661f365e8156db9379485543fc7e257d7bf", dce_ast = "09641621e0aaa31b9d8cce92903b416211ed64b8e5e105c2e6fdd7d1c9fbd669", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i64.out index 3c59afed28..f7594f885b 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i64.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "1126c03bb84955620cf582684ae46f43ad823b881ecf3b34e7f6ca219be096bc", unrolled_ast = "1126c03bb84955620cf582684ae46f43ad823b881ecf3b34e7f6ca219be096bc", ssa_ast = "52c1dd9e4f4d63e6158039ccb8416d629b0b17dd51096d329a5a40654b5fe829", flattened_ast = "541df2ef9f01f3d9b86937c0d308dd95755c3de8ecd405c945ee70780e96884d", destructured_ast = "010f8932e9ccda2c77f022264d79cd7a06d5b88d727009daf587152c046ca7ce", inlined_ast = "010f8932e9ccda2c77f022264d79cd7a06d5b88d727009daf587152c046ca7ce", dce_ast = "9d1d8a603b42eef09273506112cd2195f66c7a4e375576230c6f10a0c1d0a8fa", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "1126c03bb84955620cf582684ae46f43ad823b881ecf3b34e7f6ca219be096bc", unrolled_ast = "48d7fabc3bd3d7ff8b31580134e0c2ddea761bcb0b7f3c2eabb920f0241d9c89", ssa_ast = "2fa35bf3c5b88b25cee53ca8382967a50f9ab6cd137a4de02c6ae6b39aa828f3", flattened_ast = "7ffc554f5076c8fbc0ee875f1ac957e4a5055dbfb9857cd3bd6770bccd1143ba", destructured_ast = "4e4293ce18d507b188e04e7a939cc9ccc88f67734e7b8d678a4cc4637b19cba1", inlined_ast = "4e4293ce18d507b188e04e7a939cc9ccc88f67734e7b8d678a4cc4637b19cba1", dce_ast = "a51f408744c3472ea500ca6fa46c959df9dc3a32002f6c169048d64bac4bd3f3", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i8.out index db99e6b997..3caaae0ca7 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i8.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_i8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "394f33f5fc7e344d5dc8df077357941b2c71519e0778775c551843c8ef1f9e47", unrolled_ast = "394f33f5fc7e344d5dc8df077357941b2c71519e0778775c551843c8ef1f9e47", ssa_ast = "54733106c8f2085e37c274479c336ca3539bc31bfede010e1a459c5f7a928710", flattened_ast = "6ef23edc65fec7ea908771e842b81d10b70cd06e0382e7f1f3cf68b321df4cf6", destructured_ast = "25be0252a2b269208e731a7aebe42eccb46bfc51c409939704d0be71305813b8", inlined_ast = "25be0252a2b269208e731a7aebe42eccb46bfc51c409939704d0be71305813b8", dce_ast = "cd670b44cd3a3a910ecb31dffdc903f1aba0922f2d6781a9d5e5f6e56e1eb4e1", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "394f33f5fc7e344d5dc8df077357941b2c71519e0778775c551843c8ef1f9e47", unrolled_ast = "ac1ba1ec758d6c5d89aad97cb769b2d1423f5bc35386cc2bcc6cc8707d5a3ab7", ssa_ast = "271a2a9215a847616a7af7bc08d8e9aa32a4cef62df8b315f83bc48b55a89939", flattened_ast = "692fa59830e1ae2c6b03babf08936be77888c588adc15d7ad00cfbe3d3526b6a", destructured_ast = "a65432e03c56483facd7e241e32cd083045b162d0127940da53cbca4953c1691", inlined_ast = "a65432e03c56483facd7e241e32cd083045b162d0127940da53cbca4953c1691", dce_ast = "d7d3035c67c34739ec730a23f17cf6f655e53bdd1f0fbf3902619e85c763bbd8", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u128.out index 4666acb503..0193a1ea3c 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u128.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "b254af55b872a3cdb3d77e1f254861daac1a30bea52ee59e588f91a4fe6f3ede", unrolled_ast = "b254af55b872a3cdb3d77e1f254861daac1a30bea52ee59e588f91a4fe6f3ede", ssa_ast = "8b626521a33976ce9453bf94ce3ce39b5666d0db3a7ffbaa2ec49dbbfa8830fa", flattened_ast = "677667bfda8670ce3abe072f542b15b26e876e3971f300f0a14b9043fa6fb363", destructured_ast = "7743269dfc491503498a3f7e0b893ceac6e258005eed80dd71ec65195e94053a", inlined_ast = "7743269dfc491503498a3f7e0b893ceac6e258005eed80dd71ec65195e94053a", dce_ast = "8a4bb72b3f928324f72a17d5a209c90f8ce93b76201a324185ec2ef69ac3388b", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "b254af55b872a3cdb3d77e1f254861daac1a30bea52ee59e588f91a4fe6f3ede", unrolled_ast = "17da6dbac28f6f53b9595367e5df911f4a0a8b93146f2e093c90c2f92a52cf47", ssa_ast = "ac779f106d83e4be8cf2dfabd309ca152c63d56cf8d8f93ab09266d67cbc9db3", flattened_ast = "360ce5ca9c8411ddf80839e57c482eb2d1efcc520e3b31a8f762f7b5df490295", destructured_ast = "e7249360d72057e5e1b470127812015aca20f72d86698a8e5103dce22c258988", inlined_ast = "e7249360d72057e5e1b470127812015aca20f72d86698a8e5103dce22c258988", dce_ast = "4c8e3b91baed53ec162f6ac9235b2ee68ab151ed8c8d87e59b8df79b761e39b8", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u16.out index 5dc64bb81d..9305b29acf 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u16.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "7de274aa8783324202c13f77267cf359a3407741b6f5b1250ceb81ae85bd0619", unrolled_ast = "7de274aa8783324202c13f77267cf359a3407741b6f5b1250ceb81ae85bd0619", ssa_ast = "c6301cd3ead8c3a00a0fbe9d57f56c860a517073bd7338fd6350d0816249990c", flattened_ast = "8f5c64a8fb958fd2257056df9efb754636e04175a7f5b2029abfb98139067c9a", destructured_ast = "a82bbaf99f309d28c80d50409137927035e4b464b8a9470ce1b361ec450386d3", inlined_ast = "a82bbaf99f309d28c80d50409137927035e4b464b8a9470ce1b361ec450386d3", dce_ast = "e719b645e243e99a0e9a979c7f58ef1a4a57d62423cda9e8e30518666a726c7c", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "7de274aa8783324202c13f77267cf359a3407741b6f5b1250ceb81ae85bd0619", unrolled_ast = "995e95866a5c3d9c0c7bf1567ac7e01f35bc23d001e90b2f8aac84288c0d4ed1", ssa_ast = "6ba5640025cd2593bd699751b5692fdd6de23661e7d539d33820839cdb812655", flattened_ast = "9f4cb477d9e8d38fb7778a0f31d4e639455e60d81800f7cc280be951b99d8be3", destructured_ast = "95143744591ee2ae1e2a6d3b5a74c39ef4c88a33ef098e47e74585aa242ebfb7", inlined_ast = "95143744591ee2ae1e2a6d3b5a74c39ef4c88a33ef098e47e74585aa242ebfb7", dce_ast = "05826e84be0aec0b46eb0de2d9010b334c649b383edaf0c1343d8b95ab7c0d6b", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u32.out index a3ad8e35c1..ec5c952bb4 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u32.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "3fcca316604bac2592335d5620a8c191dfc6bc2786b0b4ae4b989ad90632f3d4", unrolled_ast = "3fcca316604bac2592335d5620a8c191dfc6bc2786b0b4ae4b989ad90632f3d4", ssa_ast = "1b7ccdf930ed7e4fdb6b3df609ce384d4edb1144d87d971c9fb3358a75f742eb", flattened_ast = "0841a8fc5b091c4fdce18a60dca998dcc2b42533260c87b6d28559835dfb2577", destructured_ast = "7d73c77802d132d6e0ec7233cf7d6ac8540df13f3976cb40ad4ee364d7860032", inlined_ast = "7d73c77802d132d6e0ec7233cf7d6ac8540df13f3976cb40ad4ee364d7860032", dce_ast = "a5a2221e951038455d8896e0771a7b31988c2336145371999d948bf4525bb51b", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "3fcca316604bac2592335d5620a8c191dfc6bc2786b0b4ae4b989ad90632f3d4", unrolled_ast = "4b9f6ca1d1ffcf27dc744d098d6afb842fbb4c66de3c30d94eca656d15739450", ssa_ast = "f6e94fefe0601d456fe34abb76a97dffb109caf464544d17ef48f856bd7a4578", flattened_ast = "af4467171608015af958e14824b6090fb3050d607df34a6134e1b4843df0c2f9", destructured_ast = "4b77eb9dd0f093cc1468795669ac534d87a7cc542bba55928b09d8d150c901ff", inlined_ast = "4b77eb9dd0f093cc1468795669ac534d87a7cc542bba55928b09d8d150c901ff", dce_ast = "7406cd7f200af09b26b1a20c60c3b4c2f9b71efa02e8c811bc4466d1ae8740ca", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u64.out index 25182e1918..da5e871724 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u64.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "01a5f6fe5c737445438873ea2094c48024457bc59f573a791cc32ce57b500832", unrolled_ast = "01a5f6fe5c737445438873ea2094c48024457bc59f573a791cc32ce57b500832", ssa_ast = "f8a7351fb597b4d2156c30065b75486daba306a656bd5c21e548438045826a78", flattened_ast = "a34bb665b690e176340a03111b2e5893a616211d6f030bed25476dde5181a8a7", destructured_ast = "f2622c4e568dec96b87bc573b2059cd6376326ab0b1df292c266401f9b985c98", inlined_ast = "f2622c4e568dec96b87bc573b2059cd6376326ab0b1df292c266401f9b985c98", dce_ast = "0d68f5e10223623d0c3fc61356ab3c8d05974174fd231b81765478d45833ca02", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "01a5f6fe5c737445438873ea2094c48024457bc59f573a791cc32ce57b500832", unrolled_ast = "8a6eaafdda37a4e95b6a81c444c889ce2d77c80fdab00ef433c18936d305411a", ssa_ast = "7ce63ae186d9981880a32c3a4200d5c39c4062294a8f79cef8803bc8f712e787", flattened_ast = "c4308f805e1a9769461ce2eaa52e9023567bc01dd2206c82e6534d16851d53a1", destructured_ast = "d50b2eb8a9c6bc221d121eb1c9365b0106e6ccad242b7656e2d9a0b083101f08", inlined_ast = "d50b2eb8a9c6bc221d121eb1c9365b0106e6ccad242b7656e2d9a0b083101f08", dce_ast = "de394e8eb86ffbfd9a16758cfc46f566df0058f6c20aa4e4f7d2cc02f02bab3c", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u8.out index 3d36e070c2..81ab4c032c 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u8.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon2/poseidon2_hash_to_u8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "c347a7372b50683ea132c34b26743cc9c1c97dcfaa02e992137c6185f1269bd9", unrolled_ast = "c347a7372b50683ea132c34b26743cc9c1c97dcfaa02e992137c6185f1269bd9", ssa_ast = "320b8a470116216cc5cbfa2ac07c55cd7b19b4e54d44bfc4ce44164303057d73", flattened_ast = "3e592a0051f0a8bc0305266087537e61f17b04bae50f734b90994794fd57943f", destructured_ast = "b5439bcb83e818dd368e6779abce31d8ea0ca9f702e223bc120681ac89e07d88", inlined_ast = "b5439bcb83e818dd368e6779abce31d8ea0ca9f702e223bc120681ac89e07d88", dce_ast = "a10ce5789f02a607988605f7994fdb48ec4739e88ca2c7e757a3679764ca2374", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "c347a7372b50683ea132c34b26743cc9c1c97dcfaa02e992137c6185f1269bd9", unrolled_ast = "1037f218877c1f56e698732fda4fd58d680193785ab895830fcce78893c8761e", ssa_ast = "78ec895c826bf16cc06013f78ade6c49c6ec255a50d99d0eb37b7f8f5ce89a7e", flattened_ast = "c463de425d4a8ff24be46074bbda9e4da75961fd61a59d857a3588c42711d1bd", destructured_ast = "e4d82cc42c7be007e7671afecde0803cbc2b15fdf1f056d0c83a27e57507449f", inlined_ast = "e4d82cc42c7be007e7671afecde0803cbc2b15fdf1f056d0c83a27e57507449f", dce_ast = "30dea1810973353d14e4b8cf78f7e6b2f47debaf48614a0be3680e353e4201cc", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i128.out index 333c56f2c2..532db2bfb0 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i128.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "5ef33053311145dc90b2b76628fde77d2501f094c8bfb5e56031d8f5845ed148", unrolled_ast = "5ef33053311145dc90b2b76628fde77d2501f094c8bfb5e56031d8f5845ed148", ssa_ast = "3ce59b451272bd0f5146af3b56dc4f49bb23eca483a729ebbbe5b389854c2931", flattened_ast = "5eaf1f979396ace5e990f2a6e05a13282009c73fba6f255ba81ea9acac24b9c0", destructured_ast = "592d676e925d04b7ee0c458fb0e6ec876e2faa37a0b04d5bf2b8657290d86d6a", inlined_ast = "592d676e925d04b7ee0c458fb0e6ec876e2faa37a0b04d5bf2b8657290d86d6a", dce_ast = "d109be272b5948261767ebe9dde5f9f5110cdada3a5766d5efaa9624050e7483", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "5ef33053311145dc90b2b76628fde77d2501f094c8bfb5e56031d8f5845ed148", unrolled_ast = "25d27ffd3ad854f23dd81baa9f4f86d531f0cecde5dc0d2093184dcb5ac5283b", ssa_ast = "8d648b07a2a6192264c13417e221c1982279c787e30d4ec47b696049e486f43f", flattened_ast = "0ca5ca1dae7527d2a8382e07ef734850f475c76a400026408677e74b7b4b4491", destructured_ast = "c7eb500a487b761f04180e56c5fc51906801e04639c05379946c3b9ae7df069e", inlined_ast = "c7eb500a487b761f04180e56c5fc51906801e04639c05379946c3b9ae7df069e", dce_ast = "2c3b3d84e9daa6a8ea5df2160c3b189ddad3182e7a5df1901e2d7ab8b8f19686", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i16.out index a852885813..48dd963a7f 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i16.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "562e7f4ac19ec3990dd7d955b2ac892131961174e28a6c72afe761653435969c", unrolled_ast = "562e7f4ac19ec3990dd7d955b2ac892131961174e28a6c72afe761653435969c", ssa_ast = "84ec7ad4e586f34eee01befda12b839bfdbafdb021977d9c65ad9dad1573e0a5", flattened_ast = "58d3119c65ab252cccc5271e7e7edf40c07a9f8495950fb60fe2cb7d2013d6b8", destructured_ast = "28181766b1eaeabaf066139c412a9b7840c4c7379a0072ad2308671799e8d3c8", inlined_ast = "28181766b1eaeabaf066139c412a9b7840c4c7379a0072ad2308671799e8d3c8", dce_ast = "e69f7b68676a71043a216ce9d2ff775bac53e66f203082d8dae2c8f68ff3fb37", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "562e7f4ac19ec3990dd7d955b2ac892131961174e28a6c72afe761653435969c", unrolled_ast = "19c4a6f0feb84957e8c118df04c7b1ec9cd1ec27bfb72c9d10431156fe775bc0", ssa_ast = "7766efaee1b4f1e9db2bf31e57454b628afe0cbba19a2c82c1947fe922e3feb8", flattened_ast = "12451e7207f3bbb87b9cf4ec311dea5e0ad2139f09fb9fae2df57f8b9ac491f1", destructured_ast = "0b7c65422e21f54e15fe518d6392b90adf1406f2bee0547e80eeab326c7ace64", inlined_ast = "0b7c65422e21f54e15fe518d6392b90adf1406f2bee0547e80eeab326c7ace64", dce_ast = "8e73712683f9f2ab2013122c7065e937ab354480190809be29f1b1dfce2984ae", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i32.out index 579d4a699f..58680490db 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i32.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "a579556ce9e5a6a603b2159e05f7a3e308ea61787eb07cca9400e1675a6f1989", unrolled_ast = "a579556ce9e5a6a603b2159e05f7a3e308ea61787eb07cca9400e1675a6f1989", ssa_ast = "68145d551fb5d6913346f10c9fdfc3fb340fc539c27fedb33e7a19aad590fc7f", flattened_ast = "5cb5fa08b8f3c64f0b70bd5cf029463652ba98b5fa7b79833a28127ff2851855", destructured_ast = "9681234be7360a4c69f8056feb6850dd0f1f56d9260ae7a18a36a211a8c21fd9", inlined_ast = "9681234be7360a4c69f8056feb6850dd0f1f56d9260ae7a18a36a211a8c21fd9", dce_ast = "6f822f21fe5a7988c7b2098ef5c0d38093b9d6ad59825bc05f6c66169e686595", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "a579556ce9e5a6a603b2159e05f7a3e308ea61787eb07cca9400e1675a6f1989", unrolled_ast = "a175904c404958304afa24583f1aa73349e137acd80e56f984509ababa62c7ab", ssa_ast = "e40d16bd660fdd024b5becd5db3b704e6ac6264e05c1b6a34573a4cfd6855781", flattened_ast = "054698dbddea0e08703613711c81e8b6b1ce152e59c96e36150b0a561cd17882", destructured_ast = "bf62fc71a2684cdef351bd4284227b13b0981713ee57bf97db6c31616879ae40", inlined_ast = "bf62fc71a2684cdef351bd4284227b13b0981713ee57bf97db6c31616879ae40", dce_ast = "053699a58aee78815b1629a6e9e2a94c669784500d1162dd3f273b54e3719c13", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i64.out index caa83bae48..4442dabab7 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i64.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "9be323cb447651b7b9a6fb610727b9b4ec9d76ff4b132cbd7821cd87d5f5106d", unrolled_ast = "9be323cb447651b7b9a6fb610727b9b4ec9d76ff4b132cbd7821cd87d5f5106d", ssa_ast = "842bb677549dee2ec789b79bede43c01788bc848708f4e91f4ca681c876193ff", flattened_ast = "bf4ea994d0dacd5f8b217a6a9cec117b5c67d8d197e65e277a51d7e9bf9b7a8a", destructured_ast = "10e380fc0b563c0eede0434eff42a1e7afac6e28dccb65fbd88fd640149646ff", inlined_ast = "10e380fc0b563c0eede0434eff42a1e7afac6e28dccb65fbd88fd640149646ff", dce_ast = "746bf40faf2f8c3ed03da5baabefb5bea9862a18603c69f2b7455ab16eee08b6", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "9be323cb447651b7b9a6fb610727b9b4ec9d76ff4b132cbd7821cd87d5f5106d", unrolled_ast = "538f2d84ee2e0879425433923eabbeaa09dfd1f780e61a668870869b219521d3", ssa_ast = "01c890e13322f50b12b606c5c1e190f96a2e14c7431c35e6ce39b79780fa1ba1", flattened_ast = "e3377ed8c0c753a5b26e2cd9ba8c94563ebefaae6c704bb3862d4a18e37cffbc", destructured_ast = "3a58c9afffbcf16e604fea55bf53be730fb3538956dadd3a21668b53e25f4597", inlined_ast = "3a58c9afffbcf16e604fea55bf53be730fb3538956dadd3a21668b53e25f4597", dce_ast = "81324a5e35ec0de14ee71fb42b16d08830563a0ea5e4b1323826184c7cb165e1", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i8.out index 9d67612be6..205861765f 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i8.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_i8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "fe3121c5c80553ab5612bf475745db23fd25d3b76aec71d6d25cb1b50d5ff712", unrolled_ast = "fe3121c5c80553ab5612bf475745db23fd25d3b76aec71d6d25cb1b50d5ff712", ssa_ast = "0b59d5b24800ea6c837d32d7d9c9bff54f1fe92de78bf55af152eb64e0f76d36", flattened_ast = "dc183224c27e6bd2a8bba6561bc1239724272da4e7cf3b1b4941bf0684393c50", destructured_ast = "582fbcb0a714354cbe7e77a3e2d9caf8b37daa500c3b016a9d43a722fc8680f1", inlined_ast = "582fbcb0a714354cbe7e77a3e2d9caf8b37daa500c3b016a9d43a722fc8680f1", dce_ast = "1dde0ce67331638d6f8aeef06d4845c1556481fedb0b82c9954cb07230f173c3", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "fe3121c5c80553ab5612bf475745db23fd25d3b76aec71d6d25cb1b50d5ff712", unrolled_ast = "1280e0433bfb8a788c7e1b682ab1bd1d56fff0a0c9f6a315a38dfa2163d56a87", ssa_ast = "dac37bbcd5a892a6e93dd2d8c50ea6801dafe65d8840313ce7fc8647bc5d0db8", flattened_ast = "c6c35ab510a775277af6f84c7eea14e656d0f60882b0a532b7b492da8edb35ce", destructured_ast = "665eae1950c3c697ea07b7c9206ee878790cdeb3ff1064ec1a0e1fb4485a87d9", inlined_ast = "665eae1950c3c697ea07b7c9206ee878790cdeb3ff1064ec1a0e1fb4485a87d9", dce_ast = "ca620029245ebb82f85a455c0110f51c90f1fce9e16140f055914d948a0eb6f9", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u128.out index 1af0629ba8..0b0c99512b 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u128.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "82e34468184916ce4d8d9a0b3c2403e1440b11a4d6c6cee1acef2dc6f3204334", unrolled_ast = "82e34468184916ce4d8d9a0b3c2403e1440b11a4d6c6cee1acef2dc6f3204334", ssa_ast = "35ef7e1c1656033fc45c99c937c197ff87aab68d9ccc9a898c842c4e298f53e6", flattened_ast = "b757676619c88f5a31b8bc2ddb767eb1071b3d8cbc095b4de0f1bb81eb93a9d7", destructured_ast = "f95773bbb24ef096c87840b6bfb45355a4fcec5cbb63a085648d1ebf7dea6efe", inlined_ast = "f95773bbb24ef096c87840b6bfb45355a4fcec5cbb63a085648d1ebf7dea6efe", dce_ast = "59f4681ade3362f8de04b68a0d0f9da8bb9d67527e6e662889e6410e54cc1a72", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "82e34468184916ce4d8d9a0b3c2403e1440b11a4d6c6cee1acef2dc6f3204334", unrolled_ast = "0a4534e57dfc3d63c99173251adc7bc10ec069aac965eb807888aa00fcba6893", ssa_ast = "cfcdddfa5e8cac0c270c4133e7f7fd5e91704817521832085c406f4d81898b1c", flattened_ast = "47b7798a471be8dfc2505f55171ce2deda221128687cf23cc68afc791f7487c4", destructured_ast = "e16ee02582a33b9d9c3d7cbb6d5d17cc9ef8c9cee9349acbef36b9627af2b0ff", inlined_ast = "e16ee02582a33b9d9c3d7cbb6d5d17cc9ef8c9cee9349acbef36b9627af2b0ff", dce_ast = "d63bf54dcda8aaaa25f52a94798b0c3714e45e3934e6c74d33178b2db2633a60", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u16.out index a93d01d6d5..330b2aa181 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u16.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "fbf888dad304e879619b4887c101a1ffd7bab2caa03cd3b3d69fcdfde32f3f26", unrolled_ast = "fbf888dad304e879619b4887c101a1ffd7bab2caa03cd3b3d69fcdfde32f3f26", ssa_ast = "4cf5ab0fa1c75be02ae7109e562221cec799ddceb96c1526cae5f1da2c1e5c2e", flattened_ast = "0ed51c4d8aa69373e7311019f888818144f3bc86213505bb8f5960d7c620c662", destructured_ast = "762bdd3fa614126e9fca6b214a4656e25c9e9093cc8ba1d925c177f30334df87", inlined_ast = "762bdd3fa614126e9fca6b214a4656e25c9e9093cc8ba1d925c177f30334df87", dce_ast = "f184b2be6f92c21698052fe43bf359ced32ffc3f3bc833e8d41d31e837abbc7f", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "fbf888dad304e879619b4887c101a1ffd7bab2caa03cd3b3d69fcdfde32f3f26", unrolled_ast = "a0a50e68e46300948214913066cb86a6a9c9df331e9e2be5633a4d20a74ee31e", ssa_ast = "09e0637421ef8ba543f769683232b0ce49e88a3a10d7c57ee45a0ecdf1a491e9", flattened_ast = "eedede6cfb7fa30292a34b3992f0d8d020eaadeb5b20e65da2f05c84bebbd58e", destructured_ast = "38e80378b8ba30c4b6565a399f82cc8182ff79b64ce6a665425a6322dc28be5d", inlined_ast = "38e80378b8ba30c4b6565a399f82cc8182ff79b64ce6a665425a6322dc28be5d", dce_ast = "9b57598991bcc328755f1af12d5b0166d7f3ee085d64c889d5efbeeee2521299", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u32.out index 2a3ebe0e55..77408bb256 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u32.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "3eaf0882db0cfcbf6de5835a3e371866978dcdcbcefa64c51831e73206d69ba8", unrolled_ast = "3eaf0882db0cfcbf6de5835a3e371866978dcdcbcefa64c51831e73206d69ba8", ssa_ast = "9c527ce526f07aba7d0f6d0785ee79d07fe1462d3770f25ab683890040625e0f", flattened_ast = "ea2c134e40254362faf8bb4c2703982d6a0a74936a53cc9a745831f799924adf", destructured_ast = "c818cb8f2516201db5d6d429691368ce1a851d0814093f960f7a0ba7f10148ba", inlined_ast = "c818cb8f2516201db5d6d429691368ce1a851d0814093f960f7a0ba7f10148ba", dce_ast = "30aec32f34f0b8b51bca4049f1dcfcb1082e200706105c3d94528ebcd41efd8d", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "3eaf0882db0cfcbf6de5835a3e371866978dcdcbcefa64c51831e73206d69ba8", unrolled_ast = "0d39cd55388792e26833596112e0c54939c703761067ac42a09bb624a5107147", ssa_ast = "91c6291f44c1b3d4ca7b37d12a174970ec550da09d401fef35530d64144192a7", flattened_ast = "1166761ddd42548289210278f8730e3dadfe1ee6f8b56bd9fb3a969cccf705bf", destructured_ast = "76d9aad1e555b5e5c8e67e79bbe50d86569491e0d4c6169fc996aaaf47444a19", inlined_ast = "76d9aad1e555b5e5c8e67e79bbe50d86569491e0d4c6169fc996aaaf47444a19", dce_ast = "3e6d6b6010912be2d3176362dce5f7d06299a02b0ebaba6fee8df29ad22c40e2", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u64.out index c7d79d9700..a79ebd6fa0 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u64.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "ecd1783a08ebb34de50fb69b55fbe0c99294456867038c29865988b70384244f", unrolled_ast = "ecd1783a08ebb34de50fb69b55fbe0c99294456867038c29865988b70384244f", ssa_ast = "efae1e5dbbddee3d09403601f0d44a801358e04818d2647225008760e58be2db", flattened_ast = "26e61e527a784189bfe049b8abf5359077da40985b8f85291f2524b36f997e48", destructured_ast = "22e55f6c2a48a6ab503bcef7f1151dc6687b047ceed532f9bd9bd00edef3ba7a", inlined_ast = "22e55f6c2a48a6ab503bcef7f1151dc6687b047ceed532f9bd9bd00edef3ba7a", dce_ast = "5913bbafdad0ae6b6576152efde28b775930f9c3a42667866880ec2591bd495f", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "ecd1783a08ebb34de50fb69b55fbe0c99294456867038c29865988b70384244f", unrolled_ast = "081c90454ebda57bb729bc61dbbc2f1853beece00574f490f947e8f8ac3dbc33", ssa_ast = "4397c14d041d1533652d906c16affbc993712903cda884fd559d5af46d668fe6", flattened_ast = "6fec300abd272063d7a1a1585a4631d0cdb2ea7a7c23b6fad0d6ddc2800aebe1", destructured_ast = "6e76550ba1f52f892bada0a3d7c8ac327a2dc9109c3ee05f83470c3d98cdf1e9", inlined_ast = "6e76550ba1f52f892bada0a3d7c8ac327a2dc9109c3ee05f83470c3d98cdf1e9", dce_ast = "3883bc3b3d790b194876f766f86c861c7f20b297f0f997497016b625308a7dd7", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u8.out index e9cf9e62fa..478dab8359 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u8.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon4/poseidon4_hash_to_u8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "97b71cec08c5c1f7e92de47bd251eaac3d28a993b5fa40c7aeb136149b62089e", unrolled_ast = "97b71cec08c5c1f7e92de47bd251eaac3d28a993b5fa40c7aeb136149b62089e", ssa_ast = "84d4dd4346daa19517d55a1d22dbfbf36d05524d9973d30d6824e7f0f911c894", flattened_ast = "4ed24cfe562b3581f6f48185ce00fd1e68ff15513f39060f8fea82c7611d5a01", destructured_ast = "10a67748bdc7745628c6ac7c0af0717e8cdb26d96cb34ce9eed9a5457c06571d", inlined_ast = "10a67748bdc7745628c6ac7c0af0717e8cdb26d96cb34ce9eed9a5457c06571d", dce_ast = "f8116a7dcc7d3d75643851ec46bde22004eac83b5c6155b446c3b750955608a7", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "97b71cec08c5c1f7e92de47bd251eaac3d28a993b5fa40c7aeb136149b62089e", unrolled_ast = "13f9347a923b51a139f9a04a8306864c203d5831a0bd77308222ccf3da198860", ssa_ast = "bb4bb3b80de02d34418081862ca7a0a73919e34a5f4feac5dba836b8835e0a87", flattened_ast = "9b8b78f557feb8efaa1e1e45301acaabf6d6be7aa40fa0bdb200f500576bbb25", destructured_ast = "cd9df3839580a85f0b48aa0ac50ac747a142a9618dae91b362a33fef0a287697", inlined_ast = "cd9df3839580a85f0b48aa0ac50ac747a142a9618dae91b362a33fef0a287697", dce_ast = "8fa6f707faf5d7d2cf45e929338b2a001fa511d07fed5086668f207979356dbc", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i128.out index 5253398473..5fcbdefb9d 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i128.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "610a4fc456f8595c56e139dbde29fc86d523c2155ad537651b6a6ca47f14032c", unrolled_ast = "610a4fc456f8595c56e139dbde29fc86d523c2155ad537651b6a6ca47f14032c", ssa_ast = "b48ad4943d89f58c8275b4b6032c76717e45fd1858ce663f46304c40d1aad345", flattened_ast = "6765f19d31c23ed1b83f1ba71377e30196f791fc3d694c7aebddb3e7aec1a8bb", destructured_ast = "d95bafd3423a813cfc3daca7560353b5b4a6515a61fe75568ef3647e6456edb5", inlined_ast = "d95bafd3423a813cfc3daca7560353b5b4a6515a61fe75568ef3647e6456edb5", dce_ast = "53b57c954fd3076aa2a21c6a2b8eb43ecf279df1329164f1d0130be5534cf171", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "610a4fc456f8595c56e139dbde29fc86d523c2155ad537651b6a6ca47f14032c", unrolled_ast = "bac34290e15421c6e1135df37db278613246e9a0550e88d2706cc89e2a47ba9d", ssa_ast = "2c25468f52cd17b4061bb37baf5a45b876664ae4085d925ddc8df2a6f9dc20bb", flattened_ast = "dabdf476e81b3c680861abaac10ed58413903b6c08099ed8911bf1f26a39dc0a", destructured_ast = "380549ae6edf64f5564f50f953a85a2280f7a9e980e6b034fa6795b4531c215e", inlined_ast = "380549ae6edf64f5564f50f953a85a2280f7a9e980e6b034fa6795b4531c215e", dce_ast = "0b3cbca56f5e782e1b146db4c2ad0401e4864ccfed103a2de34aef0bfbcae55c", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i16.out index e931a2f393..6e0b75210a 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i16.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "57146a576730ce6d4582fb576ee24b6442b24b3ccc3a351d3f324a039da2e9f7", unrolled_ast = "57146a576730ce6d4582fb576ee24b6442b24b3ccc3a351d3f324a039da2e9f7", ssa_ast = "1f3f1583a5de76b84e07a7f6a21808dd6a8ce082510ae37c3c99a1cde4ba362b", flattened_ast = "110bd744c5c54af18deecd246ea54c8290c8b70fcefd1fedf6a2ed43748706ad", destructured_ast = "6564295989a392ee5764be5bb0d7450ba5358e2d9829c30f76db3f8387e1254a", inlined_ast = "6564295989a392ee5764be5bb0d7450ba5358e2d9829c30f76db3f8387e1254a", dce_ast = "96c3a194da95781a583c1a4815c396780bf076d52d41d56cbe5a553abc0df964", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "57146a576730ce6d4582fb576ee24b6442b24b3ccc3a351d3f324a039da2e9f7", unrolled_ast = "55e2bfe3512de8772cb98ab9e678cb8b798bac982f9503c1b52b781193ecb51a", ssa_ast = "d5a71d711f4f5788efc1c8969c349eae6bb43bb9ce1654d1b24160fc1257787b", flattened_ast = "6a7be1099d4c70b0cea433b0564a8f1fafa4a6fe2ccbe631619babbeab6a870d", destructured_ast = "b9b809dcff2f5348a4170a3763d48e7d16f7bf74546ff8436343e4e43db4827e", inlined_ast = "b9b809dcff2f5348a4170a3763d48e7d16f7bf74546ff8436343e4e43db4827e", dce_ast = "e85ba453d1fc9fb7be011b05bf492456225608e08f74bcbcccf7ac26afa2ecec", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i32.out index 7f2eea7c7a..311fe2fd6b 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i32.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "dc8053afd958f2b06f02249a810f2dfdbb9746464b5ba27f1b430abf07d3cbd8", unrolled_ast = "dc8053afd958f2b06f02249a810f2dfdbb9746464b5ba27f1b430abf07d3cbd8", ssa_ast = "b40a44c2291c533b8ce8b70c75b95f99b08671bd19a4b9fef419ef29cee8dc8e", flattened_ast = "fd2b87b4358f53e37ddc4eb3b4d677842ec52c2a53079a9485d324d6fd681d37", destructured_ast = "7acecfa95a2c3cc438a5ebabdde0c360e54dfa61f7c17047a607c75c9ee1836b", inlined_ast = "7acecfa95a2c3cc438a5ebabdde0c360e54dfa61f7c17047a607c75c9ee1836b", dce_ast = "99a7f0a60b4b6c9db1dbb6b1d168b158a534fcc219a10d9d77fe81284f38073f", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "dc8053afd958f2b06f02249a810f2dfdbb9746464b5ba27f1b430abf07d3cbd8", unrolled_ast = "89e76aeacc93e34b6a15dac8a82c4ff6a440e7274e0b0c29991c2d13cfcb25b1", ssa_ast = "333621a244a2b1477e731cf377238b8e419c96ba58eaccf0727d6709f407d869", flattened_ast = "adf0c5d818bce455ff51543fdd116685a3b561b4e7e0d82c066bb27c9989a921", destructured_ast = "d5238ce8c00cff9a075b4b87d9c7f1ed25fe537a576c835026e8bcc240cda6b1", inlined_ast = "d5238ce8c00cff9a075b4b87d9c7f1ed25fe537a576c835026e8bcc240cda6b1", dce_ast = "6f0f0b4a30313d8a789b70a704502fc0863ef969f9788f9c0467c2a23e7a5671", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i64.out index 1133f3626a..4ed67d308a 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i64.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "00824cc0d881d5e7396530ec52624760cabd072213e5d0f740aa98b0144eef83", unrolled_ast = "00824cc0d881d5e7396530ec52624760cabd072213e5d0f740aa98b0144eef83", ssa_ast = "c2e1b3522698cca9ca55a66a55d6921b8a1828a4f7fc1a3b062d208d33cb7cc7", flattened_ast = "415dfa18d51267df3a1e2c789e0458aa1b54e83046e8ea3d197ba7032bf5bda8", destructured_ast = "0ab7fae44bfd467b7e01ee79fc9f73d6fa4ce9358a61d1ea89c846e29ca0b447", inlined_ast = "0ab7fae44bfd467b7e01ee79fc9f73d6fa4ce9358a61d1ea89c846e29ca0b447", dce_ast = "981658b16267a5024414e70915da08fef79b462bfec4fd57f0e294463324d304", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "00824cc0d881d5e7396530ec52624760cabd072213e5d0f740aa98b0144eef83", unrolled_ast = "d4b4c47f74bd2f55143406a669c0bbf1770eb91590505c40f7a6e98f15aa1e09", ssa_ast = "2b9448561b1abdf4e01faad632d703b340500173c8f1f900a94c6601763ba974", flattened_ast = "658a720db3b449afacaa53622a32df3d0164aa0717cb16fe6a4054363ebb6ca5", destructured_ast = "d0ec72f968a9b1cfa59c135ab471a538962e00695288fc7143a461754f581eec", inlined_ast = "d0ec72f968a9b1cfa59c135ab471a538962e00695288fc7143a461754f581eec", dce_ast = "9d834ec2b1c8f0c1ba38554e4cb11937e9a9fd84dfbf8026051d3f0198f7187d", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i8.out index b5969eba2e..c94dbae9ec 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i8.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_i8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "1c9f49397fd75d957445f0b55438c7febcc25168b8203ec0f58b7062cec0320f", unrolled_ast = "1c9f49397fd75d957445f0b55438c7febcc25168b8203ec0f58b7062cec0320f", ssa_ast = "7c7c67740d1c367d8cfa5958e420a3606a6aaf08751715c2d471d23e5b7e637e", flattened_ast = "fcc272442d12a84c6ff2a67e8c4340bce58d8dff5633b4ddd7ff3961c101584d", destructured_ast = "3ed111a56618910a88a8b1b1abb03c5c83e8b0e4dfd5b2258c43aa9329f08037", inlined_ast = "3ed111a56618910a88a8b1b1abb03c5c83e8b0e4dfd5b2258c43aa9329f08037", dce_ast = "a664e60ba46defcceb087ac51ce83a2cbf42363997d0e4425b542acbb5be9670", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "1c9f49397fd75d957445f0b55438c7febcc25168b8203ec0f58b7062cec0320f", unrolled_ast = "bad8e1c2156cf91f372ebb756a83a445c8b946ca48dd54c7163be7c0965954c9", ssa_ast = "f64bf2041305a0d210063aebdf3712064d7053090346d4766db60ac1359cfacc", flattened_ast = "76a31197a0c0e7ea917eae47a785af7d8b0e79e4d3c311bf15ea30977e51b33f", destructured_ast = "f3498fccc0f0a3299a058daa0a1bb23a817251195a58e21d7dedba70529cdc5e", inlined_ast = "f3498fccc0f0a3299a058daa0a1bb23a817251195a58e21d7dedba70529cdc5e", dce_ast = "4bed8e4e2838ecb5b43525fd82a397b774834bf8992795b7d31b7665c4e82dfa", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u128.out index 06f6fa4d21..77b79382d8 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u128.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "37e3030c0ca5670696b638e483d0ca931f2dd0693e0eca0b5256ba94ed224884", unrolled_ast = "37e3030c0ca5670696b638e483d0ca931f2dd0693e0eca0b5256ba94ed224884", ssa_ast = "76023e20fdae8d7885a93df26e726d3d2d6edb07079a7690ad54fd1c09b712ca", flattened_ast = "075f94e248854b040971f7039bb0af9c7cc7889d934d5571924cfe4b13d9cabe", destructured_ast = "aee576c16c53e41416825469e72387b2127eb0316f8575d3a013cce80dfefd3c", inlined_ast = "aee576c16c53e41416825469e72387b2127eb0316f8575d3a013cce80dfefd3c", dce_ast = "9b4fe711304f173f429afbf2975a99be5ca3634bc1cf7837daf00ac60df6640f", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "37e3030c0ca5670696b638e483d0ca931f2dd0693e0eca0b5256ba94ed224884", unrolled_ast = "ef4b2fad2ed81f9f32de1a18c4dc67a8801535f9f8e9be34b4578294c3b74079", ssa_ast = "353991fed5551dcb153c0c15b31eace7acd18e2be8ecf73dcd880f6279c30cf6", flattened_ast = "8bd4cf077261494a72d6590e3c0b09c2c629ca619ef2c553a48e9c732e65e5d7", destructured_ast = "bd7129f334c1d21bbc53fe818698810e15a0383ee1266906131cbbf569fda059", inlined_ast = "bd7129f334c1d21bbc53fe818698810e15a0383ee1266906131cbbf569fda059", dce_ast = "0f03fed192e83d137cb05128457cd6bb062a20f654bac95428ee8ac30d564d5b", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u16.out index 6a94156ac2..65019d49c8 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u16.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "bc6c18fdd0847d82aa9953712aaf214f2b69c6f024d54f9243768a7e23a01f27", unrolled_ast = "bc6c18fdd0847d82aa9953712aaf214f2b69c6f024d54f9243768a7e23a01f27", ssa_ast = "7a66c447b759d6f0f423f88f51f6656ecb633901cdbda7caaaf5e08e214cd1d2", flattened_ast = "f964e4c2b81adf062acce84dbd15f2733c36f73c28a247f8a7ceea3ca384d41e", destructured_ast = "80e987efac8db7364219ce80d6cae24b4391c5765f4ccecc16616d2bd6addb70", inlined_ast = "80e987efac8db7364219ce80d6cae24b4391c5765f4ccecc16616d2bd6addb70", dce_ast = "8f93842cf8b100c32e02f6abf4a323677d392e362c03adbaf6f69fb58d7be699", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "bc6c18fdd0847d82aa9953712aaf214f2b69c6f024d54f9243768a7e23a01f27", unrolled_ast = "0a4061f42d8a1860cc525a2648267a264c23469bde27d57fe4f932fbf650d888", ssa_ast = "6f347867c489f369d8d914ebae90924041a69386b3acd590cd8dde0b9aeeb06b", flattened_ast = "a754f3658ed8d9ecc75d0eb6a45c5fa772483fe1fafb76cc85bbef5a81f8d3e3", destructured_ast = "54769125b211d8b458069f17ffdb201ebc8b70948b61cc21497638205b9ef66d", inlined_ast = "54769125b211d8b458069f17ffdb201ebc8b70948b61cc21497638205b9ef66d", dce_ast = "d0380a75a2bc060fc2206af015080ca753ece0abbe55ae43e172eca9d889df97", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u32.out index 5af6c8a312..15030969a2 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u32.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "5158ab59e76691bc9dc7308772f454480333ab6c9f0d129ef7a40b6ab7cf5ce3", unrolled_ast = "5158ab59e76691bc9dc7308772f454480333ab6c9f0d129ef7a40b6ab7cf5ce3", ssa_ast = "dfa7d8271a74c497fa9d39f2b5c461d38b95fb5b713cbc750a774da93abbc259", flattened_ast = "0b57da3e04d35a6a070eddb0b8d095622239930cf4f3b426c5acc006e621e75d", destructured_ast = "42bc931a1e84974a2273b697d3a4300a520d4c2f8c4c6e70ff349b1dbc656a01", inlined_ast = "42bc931a1e84974a2273b697d3a4300a520d4c2f8c4c6e70ff349b1dbc656a01", dce_ast = "ed31fa75248372b4f4867192e2aa3ffdad4ca63b97edac35c15d7e5b676a192b", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "5158ab59e76691bc9dc7308772f454480333ab6c9f0d129ef7a40b6ab7cf5ce3", unrolled_ast = "353dfbfea722925b0f6c2d3c73bf993bc585620b9cdd3ef676cb37d077117028", ssa_ast = "f67641db7223f77961e92425ecd9d78d2a24d63f57a6558e6736337eb6bc0d52", flattened_ast = "49995a2c84ee86f5d4e071b35d6c86e392b08445878402a6da2fac4761404bfb", destructured_ast = "855828a9f73212931415a27dc588d676be75ca18e536efde599fc15627cdc5ba", inlined_ast = "855828a9f73212931415a27dc588d676be75ca18e536efde599fc15627cdc5ba", dce_ast = "9f9d64cef65b5524dad12328313c4fe0b9e5c22dcb27b7a6d6b03f4d50004c69", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u64.out index 871e0fca80..8b02400f6e 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u64.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "3ad56b01d05844bfa93a7b61929cfa41826259ba721b328e8f68e8185305a546", unrolled_ast = "3ad56b01d05844bfa93a7b61929cfa41826259ba721b328e8f68e8185305a546", ssa_ast = "0be044c301724de8f47b48c95f316e1b57c4709fd23996a709074c725afb073a", flattened_ast = "36b506fb8e9e4c429b49684fff5a2f179610cff32469103baa5a5504dff879d6", destructured_ast = "1d4f2207ee3ace82010dfbe60b4d4998523153adeeb54c35b4f022dd8efc7798", inlined_ast = "1d4f2207ee3ace82010dfbe60b4d4998523153adeeb54c35b4f022dd8efc7798", dce_ast = "2e12e1a5a72c8a9c52001bf5b1db803d11b844a49118c5fe88c80cf0f83b10f1", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "3ad56b01d05844bfa93a7b61929cfa41826259ba721b328e8f68e8185305a546", unrolled_ast = "5d2d64b5b9cb0f02859f2762747aa718543c6f3d184d0708e4def2a1286bea4e", ssa_ast = "955516e6ebd1fee439799666b04060203ac158cf892af7de21f45b409498d08b", flattened_ast = "7d847b8ec6e75c88c58900587eac711a1e4c83d283a2eb1c31b4722ffc43be14", destructured_ast = "7137b1cf5cb555d23295a1cd265bfe6a6c17080978799ebdf95bbebf6cbc61df", inlined_ast = "7137b1cf5cb555d23295a1cd265bfe6a6c17080978799ebdf95bbebf6cbc61df", dce_ast = "6831bb97667f2f90c6b1477e1dbf1121339d010d675f02a4f0ad65b7d3b7fa2c", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u8.out index e486b030c4..4961f28042 100644 --- a/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u8.out +++ b/tests/expectations/compiler/core/algorithms/integers/poseidon8/poseidon8_hash_to_u8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "d1ece7284dfd737c90106d9e554b11831875e95935c645d35ffca94dcf45a179", unrolled_ast = "d1ece7284dfd737c90106d9e554b11831875e95935c645d35ffca94dcf45a179", ssa_ast = "572e636cd581d90be6b1d5a08f5f02466ff1c5394f5d98b5c74c7afd5a931370", flattened_ast = "9b5b0c6486ca3cdaf2f5f5f1cea4a3ab1e3e5a7b3047b18e432592f55ea6e5dd", destructured_ast = "d523fb4308702f3215b8087018a9b4086588cc30c3c9a57e07fdb429d3d02329", inlined_ast = "d523fb4308702f3215b8087018a9b4086588cc30c3c9a57e07fdb429d3d02329", dce_ast = "3aba054ea095cb9d74fd8950afcaf488c47bb65e5661e04aee2fa9cb399b3f62", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "d1ece7284dfd737c90106d9e554b11831875e95935c645d35ffca94dcf45a179", unrolled_ast = "0b699d49bb8b74dc0b07925a81a6215970b8c2ab236c561012bb35e64e0f5e2a", ssa_ast = "6a0b4682092249b07ca165bfdcddc3b0ff15391d3176663f679afa28b332eb31", flattened_ast = "faa9233ae32056c7b69f6354f2fd1ced1973c3499bded32e7d6f88e22f66b7a2", destructured_ast = "af5bc7febf682a94aef2072f7a115e5110a84fcf90f35e473ddc1453f7476ef9", inlined_ast = "af5bc7febf682a94aef2072f7a115e5110a84fcf90f35e473ddc1453f7476ef9", dce_ast = "8356dbc86f62044293517d7485a61fcdba1615ced6f90498bb40c4688acc13e2", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i128.out index 3ff9edc8cc..8997dd4fd5 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i128.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "1c85acf659d264fc2b7c7391b8a0c6133cc8864d8ace248ce0aaf54ceef6aed7", unrolled_ast = "1c85acf659d264fc2b7c7391b8a0c6133cc8864d8ace248ce0aaf54ceef6aed7", ssa_ast = "e52682262d7b1a1fa63b0269f94dc7a099d6383280bd0f187c6e601ace23208f", flattened_ast = "103f52de251854396d254e63bcf6085fa24a14f27eb31b7b0dcdd52125907e03", destructured_ast = "decc6093cd84a5904ffaa0a38b5aaf3465c814222f7c98d23c50f90aaa5259d2", inlined_ast = "decc6093cd84a5904ffaa0a38b5aaf3465c814222f7c98d23c50f90aaa5259d2", dce_ast = "0186e2fca6edf433e160053643ec6c5f170adbfc97229294ef5c246fec7e5081", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "1c85acf659d264fc2b7c7391b8a0c6133cc8864d8ace248ce0aaf54ceef6aed7", unrolled_ast = "00e31a71d9ebaf9cdd102e954dfaf249169f4d752461f1ca1fb493ef2d0dcedb", ssa_ast = "b3f07c9a80bc4375d9c11c823f4b6aa14451da40ce43cb9f752bd36b6037e4d5", flattened_ast = "3828b55408891e962604d70eed25d4892c65c4a8217e25a741a0ceef091fda5b", destructured_ast = "4de6c90e81844d36009dcfaadeb92b5e0b08c0d6b683246f64a188cb993cc021", inlined_ast = "4de6c90e81844d36009dcfaadeb92b5e0b08c0d6b683246f64a188cb993cc021", dce_ast = "8d8eabe876898236fa1f7411688789249517172462e44565d1fb781e391e33e3", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i16.out index 9ee7c5f502..9f84cfd254 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i16.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "4b4a906c5b2e7563f8618af9bc7acc3422332542ef6f208c0809cb0dacb84ce3", unrolled_ast = "4b4a906c5b2e7563f8618af9bc7acc3422332542ef6f208c0809cb0dacb84ce3", ssa_ast = "961233d302212ede87cea7db34c02df2cb0fe927c5d56ac3df53f9c2b12addeb", flattened_ast = "e3136b4b1669b51dcc017352a065d00fbb433c71f33b3623c7e2be26301be2a2", destructured_ast = "55f25578880aad70b47696fca8b8f9517ca38e34bdf7a68ffefa748d9f1abcc5", inlined_ast = "55f25578880aad70b47696fca8b8f9517ca38e34bdf7a68ffefa748d9f1abcc5", dce_ast = "e48153e7a05af3f3ac5fe75a5adbf2f5730fd208b615771e44eb6260f3462bcb", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "4b4a906c5b2e7563f8618af9bc7acc3422332542ef6f208c0809cb0dacb84ce3", unrolled_ast = "637bbe35ff5c9fdeb6f9a2eef14e5acb6828ae990539bd2585f6782e7501813d", ssa_ast = "a590f864d4a0c43113581127f6a6a464253a5c44a772efa866bdd53de2f15d62", flattened_ast = "c83d65f7d9d1b4e63a8e802def8ef506743c9bf1234658f3275931a14b33c1c9", destructured_ast = "8917ff3bbe82af8a639766b26f01b994beefb80cd75c5371ebf2aec87f2c69fe", inlined_ast = "8917ff3bbe82af8a639766b26f01b994beefb80cd75c5371ebf2aec87f2c69fe", dce_ast = "dfc85d1eed5c7f1280e9f450ea4d6ed77fe427e17e82d01233d7fc08c746c647", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i32.out index 8a7441220f..4cf0e5c336 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i32.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "9608ff8b894d92df33318bf170b22fa473b7b9a302a150879ec7a3fe41c144a7", unrolled_ast = "9608ff8b894d92df33318bf170b22fa473b7b9a302a150879ec7a3fe41c144a7", ssa_ast = "3dd87b6dad9193abd90249ebf6754e8916956ebbf4bdbf50700c8362a4a58005", flattened_ast = "f3bfa79f8c0c6d905a156b8079c8426159349f643fe930a3519f5bfab5da3ac2", destructured_ast = "ee6283c2ea4ba74834e1c33046ce2cbe0d9e01ae41f291b5088563f5e1db5d41", inlined_ast = "ee6283c2ea4ba74834e1c33046ce2cbe0d9e01ae41f291b5088563f5e1db5d41", dce_ast = "e3bac8a994add5ca9a944c904ddaafd6eab3ffcc1e35041789d7a951a024d2b6", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "9608ff8b894d92df33318bf170b22fa473b7b9a302a150879ec7a3fe41c144a7", unrolled_ast = "dc0370a030efa51fa6cb8adb551f76226cdc820f7723e82c3f92851c45abf6e7", ssa_ast = "36674c6f91fa700b0ee246b81df2ca2c1a3520e8049e7a54695e0e182c04f3bf", flattened_ast = "10e1ee9d0e1debe4c037f8f5fcfdaa582f44cf525b029967bf65a7391ef7ef54", destructured_ast = "2d8f60f67fe782cdcae97ff243c5e6972d6a49660c3abd5194972356e5191176", inlined_ast = "2d8f60f67fe782cdcae97ff243c5e6972d6a49660c3abd5194972356e5191176", dce_ast = "24285718f7f3aea58b24d9779db8d151e6d78e6b94896ceb751c0326bed97dc9", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i64.out index f702501313..c3c90b484c 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i64.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "e7c13c39a9619ea30d0eebce39238253b9f7d7c19c1bdf66328994543d6978ca", unrolled_ast = "e7c13c39a9619ea30d0eebce39238253b9f7d7c19c1bdf66328994543d6978ca", ssa_ast = "82deb8939a61b6e880c8efbdd17e7cfeed9092d727184fd4b1822737aaf078a1", flattened_ast = "365203cfba4cf356e3b4f6778e76a70a5e51832e0c785e1c48b26e82bfade52e", destructured_ast = "a42dccfacec7d7c6428d179a8fc18984291e64509870ae141fc5719182205f1e", inlined_ast = "a42dccfacec7d7c6428d179a8fc18984291e64509870ae141fc5719182205f1e", dce_ast = "42a0c3e54575bd6832aea66eba13bd8a9c0a419f8860a8551e9f52117bac625b", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "e7c13c39a9619ea30d0eebce39238253b9f7d7c19c1bdf66328994543d6978ca", unrolled_ast = "948846a8dbd8ea4955b3b5670bf6e613f4bdcda8858897598ce1bc04b0e79f89", ssa_ast = "c2e80058c4e4c07355d0e3762c23029794181e268adfe9c59adf7a5755e54e48", flattened_ast = "cba2c3ac7991c8801e884545b741c9086042838e49176cfaff0a86edd9579fc8", destructured_ast = "bf17e5c7ff2f31eef74f9f785f43e1595a57a6487e65d70fe251e256a8499970", inlined_ast = "bf17e5c7ff2f31eef74f9f785f43e1595a57a6487e65d70fe251e256a8499970", dce_ast = "01cbf55b348794ae2b6bad10ff625b9c4683e9d8c222b3b0486bac51d4ab4794", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i8.out index 0d96cb1ba7..2376803f52 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i8.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_i8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "0e6a1aa546ef79f888222be77c1b69c26c74bc1f60cdc4383965239c4a7bec4e", unrolled_ast = "0e6a1aa546ef79f888222be77c1b69c26c74bc1f60cdc4383965239c4a7bec4e", ssa_ast = "96cd421723dad28692f77f1ea5c692aae1efc1f54d153c02768a0885b3ce34a0", flattened_ast = "a2c3d693f3b7dad80232ee0c1ecee983f7b965a73c63cb2a5ede5dac046c383d", destructured_ast = "c27ccc181e689be8a68e8e504f39ae38ab8a8372d2c4ef90be2d7987b9e6c117", inlined_ast = "c27ccc181e689be8a68e8e504f39ae38ab8a8372d2c4ef90be2d7987b9e6c117", dce_ast = "44fd533359ca6c9b4400efac55db18dcd15fb9f070bd97c7ed04c615ee15f84f", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "0e6a1aa546ef79f888222be77c1b69c26c74bc1f60cdc4383965239c4a7bec4e", unrolled_ast = "87146363031654ff1e32ea0764734d2d326cbab0c3645360fc4e0d1ef278ebe1", ssa_ast = "507dd36979336f1451113810a66ddf7c8ac8a1cab95e95aec9ae83322009aed5", flattened_ast = "c5478432218afa3e1ac8c215913b02f7c059dd3d1f872a49cd23c8d605feeee7", destructured_ast = "20827605b8b0054e54ed9a0182d947bdcfe7d51efb8bff9ddcf0df37bd15ce3e", inlined_ast = "20827605b8b0054e54ed9a0182d947bdcfe7d51efb8bff9ddcf0df37bd15ce3e", dce_ast = "65cd910357ad71020221ef840c274f582e997ccfc0a85fe879e6823c7bc4b47a", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u128.out index e164c6ed92..6b3129171b 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u128.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "a9aefd5a57ccd41ca80b73c28bcd3a2d0bda241029bcac325847adcd1008b416", unrolled_ast = "a9aefd5a57ccd41ca80b73c28bcd3a2d0bda241029bcac325847adcd1008b416", ssa_ast = "84e4adf6612547e977e73135bc24d9429901e59b62d38d1d73f4a853f937a454", flattened_ast = "a19ddb4dad5f8cdd3998c461abddcbe6068a79e2450e97f883da0369ecb63c4a", destructured_ast = "c06bc8e693b71a3edbb318b2d3f1d86a30fa5d961fdd9d7fc0aaedea69bafb7d", inlined_ast = "c06bc8e693b71a3edbb318b2d3f1d86a30fa5d961fdd9d7fc0aaedea69bafb7d", dce_ast = "462a747af8a5e530c25ad8444ade3c8982057c1341ff0ed73d1712df97b33f17", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "a9aefd5a57ccd41ca80b73c28bcd3a2d0bda241029bcac325847adcd1008b416", unrolled_ast = "de4ced408b980ac7343a415fa5a395cad1d6f44d6cc05f29a1e3ef7a8a5d7d34", ssa_ast = "3e0fa3d9c44d1752b71d34f5a9ee2ef375c7bd72eeeae6ce911a51b9b78ce1c5", flattened_ast = "e3425592ca0d51dd058818774aa0b2edea1a24065d4e0fe2c51291ab433c261f", destructured_ast = "8f089cc5d963797225d009ad47badac5bce4f4f9d93fc3e2c6abc3201641cafd", inlined_ast = "8f089cc5d963797225d009ad47badac5bce4f4f9d93fc3e2c6abc3201641cafd", dce_ast = "05a02f718b4ec74ed3f96de81e05ce1ad49205d9feb3f5d53688ef910d45b924", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u16.out index d466e5adc0..6da34589f5 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u16.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "06e4abe9646e9b63439b9c74626f42fb7e3705e35c67dd243fa42bcf80495480", unrolled_ast = "06e4abe9646e9b63439b9c74626f42fb7e3705e35c67dd243fa42bcf80495480", ssa_ast = "9a7504d058596f766e8c22f0969ffaed1d5e7fe85be2a8c0f37f31057d82ee54", flattened_ast = "676e73e9b304b5f0c604cdb57099e3c9a7c3e68df06b067039104501fd21a1d4", destructured_ast = "cf6cdb357b38bef32d74c87d16aefe0090c49665045f7cb9e72b4a288887381f", inlined_ast = "cf6cdb357b38bef32d74c87d16aefe0090c49665045f7cb9e72b4a288887381f", dce_ast = "30a57dd68a390ebef1807212df65f6cdad3e283ded6bb65a24fa64ac420181fa", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "06e4abe9646e9b63439b9c74626f42fb7e3705e35c67dd243fa42bcf80495480", unrolled_ast = "d96f2cdeb16f71c6045db9153dc54a68ed423d47d7e9692c67dd7236cd66f899", ssa_ast = "38cba50bc22d1d67c67f582d520888890cb56bb6fee0c16564dc4191d5003e26", flattened_ast = "0180365e7ac836876d124aa9eb59c8a59c17d528d9d9e1996c316b6c44f68d7c", destructured_ast = "add4855103e2a382aeb86d0e6b4bad2f801dc30cd1e333fb8418d551ced800e3", inlined_ast = "add4855103e2a382aeb86d0e6b4bad2f801dc30cd1e333fb8418d551ced800e3", dce_ast = "5802b338da0831dd346cb93d4a8dad96341de0ccba8eff4a20610ebeb374b23f", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u32.out index 12eabd26a3..0eac09361f 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u32.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "2d3becd68a72424b2af986c1bfeb673817f2068c6063700f48abb82f4db301fb", unrolled_ast = "2d3becd68a72424b2af986c1bfeb673817f2068c6063700f48abb82f4db301fb", ssa_ast = "29d35ce4692ddcc7e1663ade5b43cda8c057db141e6df624068442cd00b2f627", flattened_ast = "5e69487bd30e2d909ab167e75ac39a53a1c4a23d7cc05b7e64a441b78dae8c56", destructured_ast = "5d6a989004373219f625dfc577f08108d0859fde75d81a7b1cfc9b5189612c68", inlined_ast = "5d6a989004373219f625dfc577f08108d0859fde75d81a7b1cfc9b5189612c68", dce_ast = "ca744c969f0c51ac773f6d26caaeef8af4f2c8e17781585c3e51b7425234cc82", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "2d3becd68a72424b2af986c1bfeb673817f2068c6063700f48abb82f4db301fb", unrolled_ast = "23e9e43f0c5d612f854e3b80072f424ccd9de53925fc96dbe0064db3d30d8c84", ssa_ast = "67337b05b0b6bdac854f7184f41a0ed3d521aefdc4982c2dcd3c9b836fa5bb31", flattened_ast = "5efbe6eea97a69b00c642e3f90e432ec44e763569131991897c51cdb4010051a", destructured_ast = "d94c3c5a3a2b69642f4ce219f087838191e82ff9af70198dc6462b32a65009ac", inlined_ast = "d94c3c5a3a2b69642f4ce219f087838191e82ff9af70198dc6462b32a65009ac", dce_ast = "dcc48d8f9b6c4af0a942a2af365b5688cd14eb537641bad9d140497ec3b19ed8", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u64.out index eaabb51087..87edf470d4 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u64.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "5f5f34657b55e6a0239853b9d2480d11b3a388d2ff501c8d13c1f5535a1c5230", unrolled_ast = "5f5f34657b55e6a0239853b9d2480d11b3a388d2ff501c8d13c1f5535a1c5230", ssa_ast = "392e041307359fde6bb72b4385d7d6bc461e26866a8afd604f6c41855982f023", flattened_ast = "818843b1d4c4fdb8981ed7f98d881fc6b509e4189748c07380b6e5cd28dfffb7", destructured_ast = "e84dd15e4ea85ec2408aac584e38abfd0a07278e875284eb7e64e90aa51151d6", inlined_ast = "e84dd15e4ea85ec2408aac584e38abfd0a07278e875284eb7e64e90aa51151d6", dce_ast = "05fd0e62447bf6e34e42078695ce57e2df4cfdcdd28059f8091fa24b7994652b", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "5f5f34657b55e6a0239853b9d2480d11b3a388d2ff501c8d13c1f5535a1c5230", unrolled_ast = "71a6d55a3a16228b65625b43d251b2f394f68e37a7e40ec34f24446d2f010900", ssa_ast = "31ae16fd353b3fd2912682bba563762164105129f19d286c2decdc52b5ad7716", flattened_ast = "e3d8f2c3d88ae65b4ac892056ff56aba6cc0b04f8ba60cf017d4ece10eabb760", destructured_ast = "803d4e797b784c14abfcceb6668965160560f174bfe994694fce9eaacb4c0308", inlined_ast = "803d4e797b784c14abfcceb6668965160560f174bfe994694fce9eaacb4c0308", dce_ast = "ed948431e2b1e2680e2b4d24d663192f4c16ae6d514b2dd3f2db1dfed4d0549c", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u8.out index 9465d59170..233354f959 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u8.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_256/sha3_256_hash_to_u8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "5a73ab94ec24dade18c55adac7089f0f799d2c357eabfc47d3a5f628409c1c59", unrolled_ast = "5a73ab94ec24dade18c55adac7089f0f799d2c357eabfc47d3a5f628409c1c59", ssa_ast = "c7f4e507f6e492bf42a2714c6c5e82fc72ba97debdf937f3c60dc4d259fa3db1", flattened_ast = "aff87f1b851fed1d0d4f80260cc4e85285e72eb577c2f46ea75d731ac0cde9a8", destructured_ast = "f9bd3e829e5c0fd697ed8b78c9e22ae91e980faf9c1dcc324dcbc0edc4f92bb8", inlined_ast = "f9bd3e829e5c0fd697ed8b78c9e22ae91e980faf9c1dcc324dcbc0edc4f92bb8", dce_ast = "c4a45b0d06874fdea8ad279c3d57b3560da3762983905118e8e6852497940ed2", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "5a73ab94ec24dade18c55adac7089f0f799d2c357eabfc47d3a5f628409c1c59", unrolled_ast = "88f387333d3ade7ddb55378ee3c02203030e4932aa8a0f5d4252e83484533051", ssa_ast = "cbac176a86abcad56ef6aa734c4e60620a04da0d469b49cec68013b269927249", flattened_ast = "8ad46762795eac4f1daaf90ba0dd010b7af624c5815328be76f43354027dccfe", destructured_ast = "b8ef91ddd4a04af4a988a3e040ea29935482d43d75b401d07a6d8bc98e5bf2ac", inlined_ast = "b8ef91ddd4a04af4a988a3e040ea29935482d43d75b401d07a6d8bc98e5bf2ac", dce_ast = "50188177ad3c58806046cd2894cb7276983c3562b23e21531c6ab86df478c8a4", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i128.out index 52c5b9f635..754d6add8b 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i128.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "32d29b8d35e483f395d43352cf84625105e446dfd1856822a5989770a795f55d", unrolled_ast = "32d29b8d35e483f395d43352cf84625105e446dfd1856822a5989770a795f55d", ssa_ast = "631f813e26cf515e47fabf9cd82255b0c746f71d3537262c3110ab85f2de2265", flattened_ast = "d9d0a4da610bf304ff8157d47489ea3dd42943155fc79ebdf29b4789484ddfde", destructured_ast = "6f904ed8251cb91e026c2ddcc3336931fbc41a71752176728971f6672d5b0969", inlined_ast = "6f904ed8251cb91e026c2ddcc3336931fbc41a71752176728971f6672d5b0969", dce_ast = "36343a98cb9368a6314a1a58bf5a6af64bd09d6acd5593366a5337dfb6202c5e", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "32d29b8d35e483f395d43352cf84625105e446dfd1856822a5989770a795f55d", unrolled_ast = "2412e836bd31d24a1b0522b311a616232a3939d252dfdccdb8b02cdec73cc496", ssa_ast = "72a00975e14bcc4190ed0240d2c61efa3f6bedef62766dba36b9afd71e67e3dc", flattened_ast = "52db33f50057205423233f7c8dd7dcee02a77c79905a3c5a0da758fe20aabb91", destructured_ast = "9d27be751816e0979a842c88b299dd4c6e016ad6c00355128ec8a22c78d130c4", inlined_ast = "9d27be751816e0979a842c88b299dd4c6e016ad6c00355128ec8a22c78d130c4", dce_ast = "40df30922b1a63c4b9797768d776c12849bac7ba0e2edfbdc5dec7f62eb4ba8f", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i16.out index 481f3042a1..5e019230c8 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i16.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "6a02390331cb369f1184a36b17628b11e2413503aa9166206f5c4bd7609dcfba", unrolled_ast = "6a02390331cb369f1184a36b17628b11e2413503aa9166206f5c4bd7609dcfba", ssa_ast = "52f57f31810d96f91b3f44bc66f2ae756bc8e88780e464db771a4c10a830965a", flattened_ast = "4ee771ac020863c19017c883bf747082748a52e4e980ffd428c2145e2bcf4dd6", destructured_ast = "593e95523a037f9d62bcbdbc237d34fbc26e78d2420b1c6f9c7db9ea1f933120", inlined_ast = "593e95523a037f9d62bcbdbc237d34fbc26e78d2420b1c6f9c7db9ea1f933120", dce_ast = "64edd43fb803485c46ca09a99ce4a110b6dd3672e14ffbdd7c2f981008400a88", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "6a02390331cb369f1184a36b17628b11e2413503aa9166206f5c4bd7609dcfba", unrolled_ast = "46fbfd23bbe5fd20510e277432bd9d961a6803b3d3657f6a1099ae9621be06d4", ssa_ast = "5d473f65647dee9261bbcc4c7622607eecaca3b13f59c719dfc8570d61778e39", flattened_ast = "3803b59665bc83a81de849e025a3dd7ee3d0cbdd41a178f439c16b5720d1b8e5", destructured_ast = "afe1d83a7c9c776c739412024f4767fe20c69bedb416346231a05612e7ce4c41", inlined_ast = "afe1d83a7c9c776c739412024f4767fe20c69bedb416346231a05612e7ce4c41", dce_ast = "9a51910b6922ce5d8b8bab5ec80ec1c2294ba0731137facc4ff92c30df4c90a6", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i32.out index 9a9da6850c..567c3bfd17 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i32.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "373ae22f6ff6381ddd7c191f60d0dba6112e25f027571815146c5458dcde3d74", unrolled_ast = "373ae22f6ff6381ddd7c191f60d0dba6112e25f027571815146c5458dcde3d74", ssa_ast = "2b1e9d60d0f4610cc8237e3114084399265f2079d910510e77d79ac77266a987", flattened_ast = "7265b0365904cdc6a425614b032447690c510bcaea4d44f5438af10604f7a3dd", destructured_ast = "0da14ee179e25b27cfb1f1cee5a3eb63f74178aa5f874d1557bdb241bdaa9bfc", inlined_ast = "0da14ee179e25b27cfb1f1cee5a3eb63f74178aa5f874d1557bdb241bdaa9bfc", dce_ast = "2f2cd2c012f63769a425496eb9e102a0766f12b03c0d3bcfaaa49ad9d2a50680", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "373ae22f6ff6381ddd7c191f60d0dba6112e25f027571815146c5458dcde3d74", unrolled_ast = "123786bd2b8c2dafa53b6d5cb64c97c53516158594d353fa2a3194391368a4ec", ssa_ast = "f21228a5f1ffa1afcc9af88523d7825bdb02b99ac867accd39e543c68bd18633", flattened_ast = "04d2260ee2dd2ae4ca4bfe44ae3e7feee552c9af6558142217de877a8f619fee", destructured_ast = "f6b11594b1696f2ca431bf37b8a72687f7763d583b0c9d85e5f4f60d8bce5f7f", inlined_ast = "f6b11594b1696f2ca431bf37b8a72687f7763d583b0c9d85e5f4f60d8bce5f7f", dce_ast = "48526e0cf0a2397e8004e1001ae11c3a94a10bcad67e5d3d2a34ae58a5d3f3cb", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i64.out index 52668cb9f8..875291beb1 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i64.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "b1fa62ab197a47ab43ef459327aba7e6d4496ebfe87275d7344cb3a1e449322e", unrolled_ast = "b1fa62ab197a47ab43ef459327aba7e6d4496ebfe87275d7344cb3a1e449322e", ssa_ast = "99e4fee74028cee7d0e892da844f4fdd79bfa06942691fb6da79ea53d18656c7", flattened_ast = "3f0b755c9450ee48201cb1327f3f7166dcc051de1b7890a44d8f6fc10c7ab2b0", destructured_ast = "c445af1e47d39736adaab0a8b386df45729953b9b0cae8735419ca6198b6f9e5", inlined_ast = "c445af1e47d39736adaab0a8b386df45729953b9b0cae8735419ca6198b6f9e5", dce_ast = "e0f5814e4ff2c18520ac3c974c5ccf6d49713df8e2b6b561cb4b2b3e3f3f1221", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "b1fa62ab197a47ab43ef459327aba7e6d4496ebfe87275d7344cb3a1e449322e", unrolled_ast = "a0e9f5a79926b02f8910c4458ff6b4b2ed171c3abb4028748d360ab690a4bfcb", ssa_ast = "7b3715c6406a450e73e97f4981e22cedd28c0076b57957d4b28d68839bf63999", flattened_ast = "97337346c506839af91af2196f5ae6c448d4bbe9cfb59fc2f1dbad0cf4357d9b", destructured_ast = "7fe2593d576bdb525f223f21b770754d3761170bd8993902b885a318eb9d848f", inlined_ast = "7fe2593d576bdb525f223f21b770754d3761170bd8993902b885a318eb9d848f", dce_ast = "e6a3571664822abe566690c54fa84b3209251238b0f936564844a73e9b81f525", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i8.out index 1280c8038b..a1005f1daf 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i8.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_i8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "d1c4e98c028288fd29621a0efba7739caba77381590d8656b090f782e91c8853", unrolled_ast = "d1c4e98c028288fd29621a0efba7739caba77381590d8656b090f782e91c8853", ssa_ast = "c7cd199e508d2036848a2611a97ecc6a39e349741fea0a20be424c66e19e645e", flattened_ast = "cb7ff42ca179e0f6fedb7c04235816acc472283f69c45f45a8bd4643c1256b21", destructured_ast = "2f38f81544473d78cc89ca76f119a5e2569cec193e3faf99c136bba9f71e42c5", inlined_ast = "2f38f81544473d78cc89ca76f119a5e2569cec193e3faf99c136bba9f71e42c5", dce_ast = "4bb2c3240705a4388c660693cf9787103b5e87ee1e5f6682c279a56230c83973", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "d1c4e98c028288fd29621a0efba7739caba77381590d8656b090f782e91c8853", unrolled_ast = "0712872c703d2bb44ddbb09903b515ece944400ed398f72465f079686d4e9be1", ssa_ast = "82ad434b403e5e2c4e0631148058d083e5d595b82bcb847307b8a2312aa12944", flattened_ast = "7093ad0c76982c0cd9ffdb183efc4d16998e512eaef03765c762b3dc30d21ba2", destructured_ast = "2b32d0a176aa0349d444cf9b2fc7bde40892e30caf6a47fa33d0ce3c0f211cd0", inlined_ast = "2b32d0a176aa0349d444cf9b2fc7bde40892e30caf6a47fa33d0ce3c0f211cd0", dce_ast = "e2796ae528443050dc417674875167199e07fd1a58e1016c4b0d276635fe4072", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u128.out index cfcf47e436..a8bdf4fcca 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u128.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "39fe927b534e754f7f8710fe5f999efdae55c675b1f680398e37f62bd170b9e9", unrolled_ast = "39fe927b534e754f7f8710fe5f999efdae55c675b1f680398e37f62bd170b9e9", ssa_ast = "d6a3ff617321ffb5f9ada496f13885deb788a9fe3db1308f77f230f1bc588c2a", flattened_ast = "e507e3c618f133e2d0044c6705a167c7e8ff068bbb6384127aceec461f11dd4a", destructured_ast = "075f1d45ca77fd31deb3d093f4700482ee536def38345ab76ab9ea5ce17a8739", inlined_ast = "075f1d45ca77fd31deb3d093f4700482ee536def38345ab76ab9ea5ce17a8739", dce_ast = "dc6cb9402a404b819a2c8155d87a3311a29e9f7ecee56cb419e33df366c70fcb", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "39fe927b534e754f7f8710fe5f999efdae55c675b1f680398e37f62bd170b9e9", unrolled_ast = "24be41318bdc676f805033140255b7431726ff36c169ae19d4e59c26c0b6472b", ssa_ast = "47a41bf426431675a73ce0d147c1838d30d80d5cbff4b29c5dfd57778304458a", flattened_ast = "0ce1b47cb39d466fc5f02aadb4bd682aaaf854fe331d4d66c13f44fa2d734cf9", destructured_ast = "9a3b2eee9e4df87ca175afc8300715e5daad65d9dcb6cdc3a3184b1b02ba9bfa", inlined_ast = "9a3b2eee9e4df87ca175afc8300715e5daad65d9dcb6cdc3a3184b1b02ba9bfa", dce_ast = "8415bd330e6dd16ba31e1baec51030ab96dc51733d3574cda0009fbd22af8d69", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u16.out index 5db6a73325..5bd73137cb 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u16.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "9139db4330378e226ad2bda413324fa0a720dc01f521f9ecdc95a6fedb3562e4", unrolled_ast = "9139db4330378e226ad2bda413324fa0a720dc01f521f9ecdc95a6fedb3562e4", ssa_ast = "2d3b0656b2c32a5a9dc8ad64198210551d4590ec294b9431c6bbaaf6a65b29fa", flattened_ast = "e850748c904afe7de7c778f2136c50c0fd38a08a83de816fc11765b70657812c", destructured_ast = "d53bb72a74e8056d7cf0a098ec2c95bbd6776b2d97c1daa7ce1ed2205fb7e3d8", inlined_ast = "d53bb72a74e8056d7cf0a098ec2c95bbd6776b2d97c1daa7ce1ed2205fb7e3d8", dce_ast = "7f9610abbff970fdc349b21ee3ce0fc16d7461353274bc449db706bf15c547ce", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "9139db4330378e226ad2bda413324fa0a720dc01f521f9ecdc95a6fedb3562e4", unrolled_ast = "543c778fad03664c308b6a8832967a6af01a843823c2ec3c6087dc589adadc72", ssa_ast = "7d0098dadc3a1cfa0b75328242ad4cb81d0841a63b4c54d58183a3e9978fc0ec", flattened_ast = "f77085b2abb309f273b4c6e5f8d88c7b505ba021b117ed00b09050c51b7f12a4", destructured_ast = "dfec69c4edee8af1cb8812ff41f169ee030c70388e51d0896d0cb1dde210af01", inlined_ast = "dfec69c4edee8af1cb8812ff41f169ee030c70388e51d0896d0cb1dde210af01", dce_ast = "cd29438e3e6230b40a76fe992085ed9c1c97e1d981f790322635e7898ae0c7a3", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u32.out index d18d3cd856..5452a0ae02 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u32.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "50e10e14ecd6376b09dd684ef54dddaca54117bb8db8d76036f2edbfc4b7bd31", unrolled_ast = "50e10e14ecd6376b09dd684ef54dddaca54117bb8db8d76036f2edbfc4b7bd31", ssa_ast = "8997064575d640d7bef49b14ca2a052bc3895312c72c4b7bec43232ec2adc828", flattened_ast = "8d8c5bc1f57976c6b728aea95a170f0c079c1997322f0623d625f071fb2000ea", destructured_ast = "e871a73f45f01171ac9d483e5064acc10a1ce84fe6d2980ae5697cfe0a274ff1", inlined_ast = "e871a73f45f01171ac9d483e5064acc10a1ce84fe6d2980ae5697cfe0a274ff1", dce_ast = "5b01e996bb53d9b18f87aa97ee2bf2f68e8eddbcb44a5e0cbff46800e935c56b", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "50e10e14ecd6376b09dd684ef54dddaca54117bb8db8d76036f2edbfc4b7bd31", unrolled_ast = "3ea40fec6208be4c8723d2db559df8d7aa22136b3043ebdc8ab20307ac4729fa", ssa_ast = "4b8ebb5f5f759c25c0e92eae4a64df3b77d1263f7d7de0ddbcdbfdc48bc772f7", flattened_ast = "339f38bc456d33eb3ef6500a82bc9eef1520f020c5c16fb65f9949e9ba86e8ad", destructured_ast = "1b61fac6283e07558f629052705e92446c19c8cab6748f6f060a06261421ce65", inlined_ast = "1b61fac6283e07558f629052705e92446c19c8cab6748f6f060a06261421ce65", dce_ast = "b92c86ba1589b8e04d50387cecab6cd5cd1bb3a74f3f7a4cafdccb19b3ce69d7", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u64.out index 856594e867..eda934183a 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u64.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "c7e57a0cdf92c76b8b50e8ec3d235cf608ff50280225ce74e96ca0c738d7f15f", unrolled_ast = "c7e57a0cdf92c76b8b50e8ec3d235cf608ff50280225ce74e96ca0c738d7f15f", ssa_ast = "eed19d00d4307a17fd4e5373dd0fd567435b8b506bdce53148a13e0ab23af6ef", flattened_ast = "80bf5ee91f6f0402a25f27f3ceaa2d28499b7ef107727f3342e07698a2e2925d", destructured_ast = "97c90a25805e211c96678f608f76ab3034696ee90b7aed13f30c2e88cdde85d9", inlined_ast = "97c90a25805e211c96678f608f76ab3034696ee90b7aed13f30c2e88cdde85d9", dce_ast = "d6f8c53832d1d4248daa89cdbf70f7a3df8bce758283a5af2323e829d6109047", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "c7e57a0cdf92c76b8b50e8ec3d235cf608ff50280225ce74e96ca0c738d7f15f", unrolled_ast = "22298eabddc4c885a16dd7e3f41b351848ef974bf0275adb4ba2957ab63a8718", ssa_ast = "fd9899bb8354088e32f6fe92f3ce4ddbc85db50835eab0436e3f184be765a13c", flattened_ast = "8fa7a0198e8fda6514ff1b6e8315d50a757477a8e6304a931b01ee3c383953a6", destructured_ast = "4311474f8d1a03a0cbda86cafa787e2d5e8e562215381d31e76b72afb10b083e", inlined_ast = "4311474f8d1a03a0cbda86cafa787e2d5e8e562215381d31e76b72afb10b083e", dce_ast = "fb159310599b5cbf16ff2538b08113e3fcd750cc2f91769ccef10ae75c9837d4", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u8.out index 9aef4ead6e..27e6f59dcf 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u8.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_384/sha3_384_hash_to_u8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "1aa805837be0dec5f94284d159ea46882c1e2fce604da581cb9ee63b97e01098", unrolled_ast = "1aa805837be0dec5f94284d159ea46882c1e2fce604da581cb9ee63b97e01098", ssa_ast = "11b07d387e079a3e877514c648f566c0198ae8ad9c5020a5e76e32f5609137a0", flattened_ast = "32d974b8915dbad0b061856815ff68917836e1bee009125ecb784567a6e9369e", destructured_ast = "74952076cf353f15b83aa35bafb85ab28870bf86fa659cc581f67783c9fd8a8e", inlined_ast = "74952076cf353f15b83aa35bafb85ab28870bf86fa659cc581f67783c9fd8a8e", dce_ast = "bcb40a4f4d510068d6f67e518e7b0471255500a40235677a45d8482254953c5d", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "1aa805837be0dec5f94284d159ea46882c1e2fce604da581cb9ee63b97e01098", unrolled_ast = "51bde6f32919860a0391b4403efe6cc2d4d74a478cfb5393a65cebc6c0c8eb9e", ssa_ast = "ee27d73e2d86abfc215c73a29e57a108e76efc0f1fc8121745ba4ebd1210049b", flattened_ast = "67791c733c379575bb6d641aaa7c3d3683a7e8cae6f01c274682377b2485aede", destructured_ast = "dc69d12ae802a974d3e2393ba4cfdf4863d112b00e74ea110d23a54e03b4cec6", inlined_ast = "dc69d12ae802a974d3e2393ba4cfdf4863d112b00e74ea110d23a54e03b4cec6", dce_ast = "545e65fee9d5eacd57aa2fd8b4772b96d6dc128f23debe66c752896f4832899b", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i128.out b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i128.out index 914b8e8346..517d897ba8 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i128.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "452b70275dcc7d6d898d3c9d14dbe4449e80d2c41fd678bae8df1c23f3a57147", unrolled_ast = "452b70275dcc7d6d898d3c9d14dbe4449e80d2c41fd678bae8df1c23f3a57147", ssa_ast = "4fdbc261ac200178b4c2d05a61ec004e18c4ce1b7246e6e9b6639c9dc0c8fa68", flattened_ast = "efec4d6f59176ea8a10c735d64a67d6425d854a8be29ef94c8b6f2268eb08421", destructured_ast = "8653bfa272eb3c54bd7a66d15987ae5560133576087c5ccec500aa7334e533bb", inlined_ast = "8653bfa272eb3c54bd7a66d15987ae5560133576087c5ccec500aa7334e533bb", dce_ast = "037ef92e2d50f9185834191cbf7dc35806538718f0fee25ed02bb3813248f9cc", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "452b70275dcc7d6d898d3c9d14dbe4449e80d2c41fd678bae8df1c23f3a57147", unrolled_ast = "bb55c20ad9a89e10c192d1af79f707bffaa1626c948312b2416225e30294a3a1", ssa_ast = "584eaa8357f2c37bd401e4567c10b4600c2ca0bc2b87f02bcd4e916253d3ee83", flattened_ast = "640de8ec7d6ad4b263450e0ce8a90e36685bdd2520509d377ff571a748fd9df5", destructured_ast = "fcfc72768f6965b2e744109e821a9695c951ff9fcbdb36062b9d7d66d11c22d8", inlined_ast = "fcfc72768f6965b2e744109e821a9695c951ff9fcbdb36062b9d7d66d11c22d8", dce_ast = "d9de5d381479c51a63885890d91168d9cd59407c4a3d4e296cdff48c356bdd20", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i16.out b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i16.out index de35e39e60..21583e554b 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i16.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "a5171c9e0e27c27d5b091a83d839594d73fc0029e7d1d2d2608a279c13788ade", unrolled_ast = "a5171c9e0e27c27d5b091a83d839594d73fc0029e7d1d2d2608a279c13788ade", ssa_ast = "db5e84fb37fe6ab12116c529341bff5e1124632880d9e49659d469d66de67480", flattened_ast = "d1f1d7bc800415d6a1ca722dbc8c03636bc01fefb240b64b33e51861550f0361", destructured_ast = "fdaab78ff95b62f6ca2850664f02967d426cb252c9a4c40db2ce7fc72bdb9ca1", inlined_ast = "fdaab78ff95b62f6ca2850664f02967d426cb252c9a4c40db2ce7fc72bdb9ca1", dce_ast = "e3bfc27fcb886cbd920d8aac258246fcd9c11e1d6334f5813269a98100e781d0", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "a5171c9e0e27c27d5b091a83d839594d73fc0029e7d1d2d2608a279c13788ade", unrolled_ast = "18f92e1e57c4a9985853e6becf8f73d542aeede373fcc424bb12b9e072cfbb3d", ssa_ast = "a15b0d300d6557484d716ce1ac0ddbd1192481172916506b5b290ac95b7f6c7f", flattened_ast = "8b866c087617250fa00a0b552ef625dbfae86ba80ebf4ef41ad83c1a86964670", destructured_ast = "1526b5d701d04208d70f1ddc775d5fdb5ca65ba190442b2a9ced51300ab7a8e3", inlined_ast = "1526b5d701d04208d70f1ddc775d5fdb5ca65ba190442b2a9ced51300ab7a8e3", dce_ast = "70078f13af2a35d81f9e270440a6bde6ef79cf1a61c34658062fcfa4b5ffe61a", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i32.out b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i32.out index 22549d90cb..99bd409130 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i32.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "8deb064d633d0cee64e55886dbccdc46815a8a75c94cd751bd624a93d172bb99", unrolled_ast = "8deb064d633d0cee64e55886dbccdc46815a8a75c94cd751bd624a93d172bb99", ssa_ast = "523560043aa200e00ff32e6ae2a690ded25c551ca3421db0bb20b4c47719c327", flattened_ast = "417272422d1b447526d47e67dfb5e8f0a98b8776144fd9107b26c9c04c0c63a8", destructured_ast = "08be4756138c0a733a8d0471c5222434aacd45a66de287252d96b6d6c5880fb3", inlined_ast = "08be4756138c0a733a8d0471c5222434aacd45a66de287252d96b6d6c5880fb3", dce_ast = "3b8b422a6822c7e3b0db53d5124179b387f5b4b1fe231d93313b8f73eb43df76", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "8deb064d633d0cee64e55886dbccdc46815a8a75c94cd751bd624a93d172bb99", unrolled_ast = "ed8902a06e3ce03bc46aadb894162b5fde4234e8350d4375bffe5b129374fe8e", ssa_ast = "f78315e6867be7bc59e0b3cfcbb5e5289bdf256c55e27223e38b1b28c9f2b313", flattened_ast = "d5d815231f46dc7da8ebc10373845dd89d50cc9ecfb62301592eaa1f1495b2d4", destructured_ast = "67d4e9bbbc78460a41cab9b22546b8139aa5e5f5e06e9c18ed10925aeab905fa", inlined_ast = "67d4e9bbbc78460a41cab9b22546b8139aa5e5f5e06e9c18ed10925aeab905fa", dce_ast = "eb464343816405681cfe8eabf6d5a38a713aaa3dd43d93c81b86ec924551f9c1", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i64.out b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i64.out index 87c2c3347b..6ee7d0f66f 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i64.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "53e37b94dc1614c1b3e1621cf35649470be38a3e77221bceba6604edbc3910bd", unrolled_ast = "53e37b94dc1614c1b3e1621cf35649470be38a3e77221bceba6604edbc3910bd", ssa_ast = "76b5fc991549c95491a92990e94650f3f20ec8bfec2bf665caa31cc050b7bfb8", flattened_ast = "96c8111af5c35374428394e1cf0b90cfea4af8014051b3fc02822a990b31daa6", destructured_ast = "a2d5a5ebb317929df6b481c1a98acbee6c1a31cc2e3b969dbac210b48dee2cc1", inlined_ast = "a2d5a5ebb317929df6b481c1a98acbee6c1a31cc2e3b969dbac210b48dee2cc1", dce_ast = "73c5b8845a3720cfbcb115272aedca5011c14c53f9d13f7ef15e5c137310d93e", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "53e37b94dc1614c1b3e1621cf35649470be38a3e77221bceba6604edbc3910bd", unrolled_ast = "4133bd231564e2f146a96e2d36df918a71875e410f3f1f730e3f6f7b72396340", ssa_ast = "a31a7acd485dcd70a6b6d784c8d56b1316f49c37a33d1a35ab9d260cb49e646f", flattened_ast = "f72e596c6bb15a42efc375cb0a2ed14c5460eec0f1cb44d66672daf361309e32", destructured_ast = "f1c81806cad0872cd576779af9ae91869906647625a42ce52563cc6fda91e01b", inlined_ast = "f1c81806cad0872cd576779af9ae91869906647625a42ce52563cc6fda91e01b", dce_ast = "52a4188b1a4cdcf99652f5b09e043ec7eb7cbfc01de8b5b81a3b056d36bcfac5", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i8.out b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i8.out index 4b0da8ea75..8a8a7b7bfe 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i8.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_i8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "bb9c440c0f7af326869bb9a49fd759b80ed80b2c68939a0ecae478415a7b9460", unrolled_ast = "bb9c440c0f7af326869bb9a49fd759b80ed80b2c68939a0ecae478415a7b9460", ssa_ast = "269594471f1d2c227f75a132195456cea74ddcc0941e4bc37aab9066f08e7d9a", flattened_ast = "633f279191efe4ef2f731fe7c900a340b5996b6545fff7ce4bdc32469e5ce0c1", destructured_ast = "5a20f3fcc36901b334b1dae22e518a1377f4a9d4d9672fc73528555fd298d820", inlined_ast = "5a20f3fcc36901b334b1dae22e518a1377f4a9d4d9672fc73528555fd298d820", dce_ast = "68617baea94599f2c55ad317cdb8992dcb73026db81c9ea255ba7c704b43fbe7", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "bb9c440c0f7af326869bb9a49fd759b80ed80b2c68939a0ecae478415a7b9460", unrolled_ast = "11564b6eb7914762c67a32ecb22ad07a73a47b3dcb82d2c389d475b09cb4a003", ssa_ast = "a8c61b010142ce5e745c480e2e4904a8475a683f59b384cd48137a2c88fe223f", flattened_ast = "163a60b12a4e6cbc6f5b668f3d51fcb537f652d05a8bdd78e0e44df0c8d8b98f", destructured_ast = "6166b5054ed298815cfa3ef2f776aa4bfd480852e9c3e4e233766aa5546810c4", inlined_ast = "6166b5054ed298815cfa3ef2f776aa4bfd480852e9c3e4e233766aa5546810c4", dce_ast = "72e7ead69e162206ef524c73797c08d7977afc0156330e2ef25afb433e943f9d", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u128.out b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u128.out index e7cf3096ac..e84c5c789a 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u128.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u128.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "2522991a18b115397a49160dddfd5452cff99bfb2b7be818d3bc95c80fce607d", unrolled_ast = "2522991a18b115397a49160dddfd5452cff99bfb2b7be818d3bc95c80fce607d", ssa_ast = "31ad06c4a6c87931fa36d849c6a400b735415370e5fff11b35cf31441ef36f33", flattened_ast = "3d85978ca5aa9408e3d7ce50580edb1a83bafa0abc948b0ed5dafe07378aa1bf", destructured_ast = "89fae896f66a6c9208fb224cb88bc77568d78117e3df4a0f50ab29cdb30a5484", inlined_ast = "89fae896f66a6c9208fb224cb88bc77568d78117e3df4a0f50ab29cdb30a5484", dce_ast = "79ae72f46f6c10635fb52e327bbea41068a236577d82f12668405c6284d3f61c", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "2522991a18b115397a49160dddfd5452cff99bfb2b7be818d3bc95c80fce607d", unrolled_ast = "e36aca6d6fb108b60bc81785ff89914b03c141120b2a7a04c07b9fddb5df6f81", ssa_ast = "3bc83c375f1f88e40730666c204f8495ea9b05f231482cdacd4d713a3002811a", flattened_ast = "cd38ecc43031999a49408e1adca4178783c4c99b57ccd9a06934df248cf152f6", destructured_ast = "32fe965fafaec494bdcc3cb1bd0c14577e39f06974b8679a2ae47633f2186fc5", inlined_ast = "32fe965fafaec494bdcc3cb1bd0c14577e39f06974b8679a2ae47633f2186fc5", dce_ast = "b82fa79892df421591e130fc0585d4138ee815ff4632cd93b036d7b8d940645f", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u16.out b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u16.out index b061d2267e..2edd6e9367 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u16.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u16.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "2c366d71da521e2a2f3080590cecfeb74758e6477f97137ec50dbe40d4054444", unrolled_ast = "2c366d71da521e2a2f3080590cecfeb74758e6477f97137ec50dbe40d4054444", ssa_ast = "fe8be11a548c7168b41777c5e622c44cceac4dd3d42bf9afaa617f74618d604b", flattened_ast = "03faddc6e5d41b410e17ea85b5eb0bfa95de6f1a2572c6d70ceee1a2f68f9b2d", destructured_ast = "ca4fbc0f5153f89a590d5d0bd639969ae586c4bd99e3a93168511a711b1666e0", inlined_ast = "ca4fbc0f5153f89a590d5d0bd639969ae586c4bd99e3a93168511a711b1666e0", dce_ast = "eed4b276c6f502b2a05315ee9e5c8f6cbed894ff8cf81ae62f71e5b9f31d923b", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "2c366d71da521e2a2f3080590cecfeb74758e6477f97137ec50dbe40d4054444", unrolled_ast = "80e204b540a77096880539eba4c42a4741190e61a6703c85676e864a187655ca", ssa_ast = "c989d6a9b15af7bf4674d5b05031df134caa189f63b96493d62f1bcd9a34937e", flattened_ast = "2c6756fde0eee7379da09fed6e7624a2dea20614513bbaa986954ec0bf8905c1", destructured_ast = "0224e38e607fa9d02afe6f1096691fd705e5215a9d0e5691fe0222b6f3f34939", inlined_ast = "0224e38e607fa9d02afe6f1096691fd705e5215a9d0e5691fe0222b6f3f34939", dce_ast = "3005bdde15f6ae468424c4d71fa3799a2e11cd4fbeb0e51181f70719b6632555", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u32.out b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u32.out index 631b780411..e0e7c2db7f 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u32.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u32.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "05baa32e2fa561f6d38e1f907c7d28780950b702258c5938f6d51bbce81ba282", unrolled_ast = "05baa32e2fa561f6d38e1f907c7d28780950b702258c5938f6d51bbce81ba282", ssa_ast = "67d2e24b4828209b71596714a55ab233b005da2e56f22cd65195639d65673162", flattened_ast = "1f920c5ed23e287494a641f2143cc1feb2c2c8fce0cc31f249e8b373b1677e4b", destructured_ast = "9407a2f209cfb00a79e6005419f5f41d62cb579959a5e26193e35fcc1d939ea6", inlined_ast = "9407a2f209cfb00a79e6005419f5f41d62cb579959a5e26193e35fcc1d939ea6", dce_ast = "d1ef2f9621747be017d84449c8f37581a458637b5688c9efda52c1c54cb148b8", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "05baa32e2fa561f6d38e1f907c7d28780950b702258c5938f6d51bbce81ba282", unrolled_ast = "e819c7347579f60f7fb03d7f2a005d959b25453972fea8653f9ab02f62f413f3", ssa_ast = "c385f8c2a8d806e94811c7127bbab25fc8ba34d99c3dc8eae7cb952cc93e5e49", flattened_ast = "6fcf2f85f1007381070c2a699665c96f1eb0f54f271d33c28e683a69ca0299e4", destructured_ast = "0d7302563c4c61d2cc1e2c57a1407513e0cf414d891c1675fd7e4868ff511773", inlined_ast = "0d7302563c4c61d2cc1e2c57a1407513e0cf414d891c1675fd7e4868ff511773", dce_ast = "d9887a06bb05ede936b8be8fc83f443f884ddaaca49e5c39f8744ae62c811e41", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u64.out b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u64.out index 412f2d467a..335581dcda 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u64.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u64.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "f989f75222007a99205066af709068dbdb1995ef222cbc8907dd0bdfce8fb369", unrolled_ast = "f989f75222007a99205066af709068dbdb1995ef222cbc8907dd0bdfce8fb369", ssa_ast = "3928792c6dc280c604e0b13a36a38ef1e99d7b49d3e6dbe20972911592c9ae86", flattened_ast = "b34501d94a2f769f12cf6384da198cb477f8a1c0306cc0b75e5ae6251d445107", destructured_ast = "02c5bc8b8c20c94ab65a476d48ec65bbb90795008a39e67e4e766bbb6d3d9add", inlined_ast = "02c5bc8b8c20c94ab65a476d48ec65bbb90795008a39e67e4e766bbb6d3d9add", dce_ast = "82f6687e8f1094b19dd537d6f4a76c1ef79aee1e3bf73489db88446654e406d8", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "f989f75222007a99205066af709068dbdb1995ef222cbc8907dd0bdfce8fb369", unrolled_ast = "127122854a1be21846b6657bd7e67d4327f07c933dd2a0a924c519cfc8bb8e91", ssa_ast = "017544a529457db681d5f42324961c1ebca6d812afb45c53b54cf8014ee90e0e", flattened_ast = "5f3e281fd9e3c96d4117ccd9125401fd091edfb37278f4b085e64fb4eaa03bcc", destructured_ast = "ea85e7cccfdf55fd631e30d311aa60676d65a26f055a8c96890f473d2475de12", inlined_ast = "ea85e7cccfdf55fd631e30d311aa60676d65a26f055a8c96890f473d2475de12", dce_ast = "fa92e9d49870ba159c9895c07c9ee4080a6391aadc1279aee6aabf018b3de5be", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u8.out b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u8.out index f47e69c187..074abfb56b 100644 --- a/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u8.out +++ b/tests/expectations/compiler/core/algorithms/integers/sha3_512/sha3_512_hash_to_u8.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "ad1198c962c93075ba1e73bf9da17d4678aa007691ae84d6799305dbd0f224d2", unrolled_ast = "ad1198c962c93075ba1e73bf9da17d4678aa007691ae84d6799305dbd0f224d2", ssa_ast = "4452a93b00354e4bf2cfe485ba7c7271487b0db51cf575aad3886de2396a2244", flattened_ast = "0b77e9d4a211cec154ca9e81f5630cc0e01c1db5fb530ce4b901922cf993c335", destructured_ast = "4e80148a9ef857e0a93512001fb2b2151a442dd5d59d343eeb9ce291d63a40e0", inlined_ast = "4e80148a9ef857e0a93512001fb2b2151a442dd5d59d343eeb9ce291d63a40e0", dce_ast = "0f1a39e31b8117fffcac72525390bb389ea14b6d5859e3491871f12229adf715", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "ad1198c962c93075ba1e73bf9da17d4678aa007691ae84d6799305dbd0f224d2", unrolled_ast = "4ad53f20923629d36645e563bb2070338e714466e44236255a49355a2108f0c4", ssa_ast = "c2f1a0e04972e5dcd820a8b0f00f7371a9854085d068e314392882269096118f", flattened_ast = "cd958bbbd8c8f77b6507af62de24e13e81bfc21b2ddb29b76d176cd8e4fa013c", destructured_ast = "502c0858ffa197a03e824586fa0063aa858bfc20c4209b2f039129737e07a426", inlined_ast = "502c0858ffa197a03e824586fa0063aa858bfc20c4209b2f039129737e07a426", dce_ast = "107a4e09fa91fa7d179f39f08e3f2a031df6d63eac9b5ca84c4335325126afad", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/keccak256_hash_to_address.out b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_address.out index 30174bcab2..3e63192b27 100644 --- a/tests/expectations/compiler/core/algorithms/keccak256_hash_to_address.out +++ b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_address.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "b9e2727bddbe86c998d286d3ed6b59e156781bb2c70993313efd7258af038ffd", unrolled_ast = "b9e2727bddbe86c998d286d3ed6b59e156781bb2c70993313efd7258af038ffd", ssa_ast = "734c08d7a810a9adbf8fd13841ccd34fca58b78ef047ee43cebdb3533bd8ab83", flattened_ast = "4110be8e4f10bbf3ea94e14c6749be2ec5e57da1afcf6866b6ddc11208e8c547", destructured_ast = "787d8dbb38be23f08430884495e8e62abb342b6ab90e9a3d4862387ebe5b339d", inlined_ast = "787d8dbb38be23f08430884495e8e62abb342b6ab90e9a3d4862387ebe5b339d", dce_ast = "545d2e6a4e25d8cb6d8859ad191cd91193083c79a374291f9bf60d337d3e0382", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "b9e2727bddbe86c998d286d3ed6b59e156781bb2c70993313efd7258af038ffd", unrolled_ast = "f5eb6f33a876eed443ac7a760ab0371e9ec19939caa5327edb21d9a4c93d5222", ssa_ast = "6fdedf510e0c895b3b01cfe2e5c5148ebce827e2d0d68ec76e2aa4df38cc98a3", flattened_ast = "23111ad05b333cc3871bf7f72bd414494744c1df4716f1699b156c3d6a37fb77", destructured_ast = "9934e2199820e40f9f7f31a857ee39642001e3b6d8ec2f011d94f582eacc8e81", inlined_ast = "9934e2199820e40f9f7f31a857ee39642001e3b6d8ec2f011d94f582eacc8e81", dce_ast = "5774bd89f0bdaedd9c740804ceb31c7715dd68268cc8cac850bdfe2aa1915293", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/keccak256_hash_to_field.out b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_field.out index d1fcbbddff..71dcba33d9 100644 --- a/tests/expectations/compiler/core/algorithms/keccak256_hash_to_field.out +++ b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_field.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "cab8003802752190e7c4f2864bed533921b8b034aca69ac4bc5a1edb5106816c", unrolled_ast = "cab8003802752190e7c4f2864bed533921b8b034aca69ac4bc5a1edb5106816c", ssa_ast = "5bdd56048fd9405a8be6ba13da095a65d23401228fbba4255cbca66ee3b176bf", flattened_ast = "3b3026b7cb6c0f1328e5337807edcbef13e062e4888b558be70c6a34239bbf5b", destructured_ast = "c46cd7f928b22343ebd818d005154a5be3239f6df8f5b39088faf9ef5da472bb", inlined_ast = "c46cd7f928b22343ebd818d005154a5be3239f6df8f5b39088faf9ef5da472bb", dce_ast = "c6138cf41c4c2dd4bf099a4c16483f9c6b8e43d4c99623ccc8e77cc2c145934a", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "cab8003802752190e7c4f2864bed533921b8b034aca69ac4bc5a1edb5106816c", unrolled_ast = "eb37f13e1257bb70097272df831edae5646c418867e4bcc05d3b3cf424206701", ssa_ast = "07f83c09a73f45cbdc8516600631521f273fe151e3354cb949cc9b4bf802799d", flattened_ast = "d94a2ed7417cf655085cb3102bfb767d3f3a294ac4d0c35fa93d07e90d26d563", destructured_ast = "55e0d81d99788db7aa21f65445705157c74e2f7fd405e198ab64d888b1785976", inlined_ast = "55e0d81d99788db7aa21f65445705157c74e2f7fd405e198ab64d888b1785976", dce_ast = "8ef36a8cd7bdf2a0dadda84d0601188098f35da0a1ff868fac7bf380fbae7097", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/keccak256_hash_to_group.out b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_group.out index 946c1f5c84..a548beefda 100644 --- a/tests/expectations/compiler/core/algorithms/keccak256_hash_to_group.out +++ b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "cc093d6a83bb665373722835cfae55694b7e24fc7313946ea9e278b7588ced06", unrolled_ast = "cc093d6a83bb665373722835cfae55694b7e24fc7313946ea9e278b7588ced06", ssa_ast = "91aa77e9e5e9f683d6b6255ec87c66adb756caebe3b035d5a229668e253e7fb4", flattened_ast = "4a7470723d3cbc21650bfd6353c60cc9b35af9b3d81099fb32951bf6d6a566e1", destructured_ast = "f3c16e0921a81c924c9891e0cabb2cf6d35da9638fff88960b5db85a118297af", inlined_ast = "f3c16e0921a81c924c9891e0cabb2cf6d35da9638fff88960b5db85a118297af", dce_ast = "708bf194448ad9b82e98264a5a389c3caa1031434a2b95f8fb01478ff98f2740", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "cc093d6a83bb665373722835cfae55694b7e24fc7313946ea9e278b7588ced06", unrolled_ast = "32a935e65cc19cf2e989c08ffe756836a1f77e989ae44524c61b53ae43c01d48", ssa_ast = "f928714d36c03a14a745d5b1b378f253473f689f97a33d91df1bef8b104e1fc4", flattened_ast = "90f576f9a04f76961961cbd81f1b26d8206829bb67e1cde2d0849053359114bc", destructured_ast = "2db154844d3da671e3cfb6fd738abd813fa7c13bdd00a1b8ac0f460126f4bbc0", inlined_ast = "2db154844d3da671e3cfb6fd738abd813fa7c13bdd00a1b8ac0f460126f4bbc0", dce_ast = "e81b15a1cc6561713eb14f96066f204a18f6d40a09cc1b492a15623790c6a352", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/keccak256_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_scalar.out index 033f385aaa..2799ad1c96 100644 --- a/tests/expectations/compiler/core/algorithms/keccak256_hash_to_scalar.out +++ b/tests/expectations/compiler/core/algorithms/keccak256_hash_to_scalar.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "e10a17cee32002ee90af585238e7c8914f00e482cd0d16dd9ce0c4932f6cf237", unrolled_ast = "e10a17cee32002ee90af585238e7c8914f00e482cd0d16dd9ce0c4932f6cf237", ssa_ast = "cbdbae9ded78ba4c9e353a8795c02d396ddc90d04f6eb8651fd0b82c3ed2a529", flattened_ast = "77c31c1bd65c16de70a8c6dd4b55a1ae0e25baedef73310d782fbc1dc40b68c6", destructured_ast = "9d8bc44994d4940dd89fdbbd342a2268ac0a32272606075d79cf01780e7fdf75", inlined_ast = "9d8bc44994d4940dd89fdbbd342a2268ac0a32272606075d79cf01780e7fdf75", dce_ast = "6cff51e721f3bc1189183bbeedd73c075e553191f808a7ddc4a55082239df45e", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "e10a17cee32002ee90af585238e7c8914f00e482cd0d16dd9ce0c4932f6cf237", unrolled_ast = "0ae305c09c9f497411c789515045619bc5441c9ca031e45918160bf769e08af8", ssa_ast = "3fffb4ae57b3f6a210fed6e4f70f9c469d74ab6334f0a2688161e67874ccc4b8", flattened_ast = "0ebf2b1140259b1e9958ed950885b9bec0e4804760abd36c2195bce086bf4c74", destructured_ast = "d223431194e890f42c337ace6f8321b587ea728fa7ba16f2e9ec9b2482e3dc98", inlined_ast = "d223431194e890f42c337ace6f8321b587ea728fa7ba16f2e9ec9b2482e3dc98", dce_ast = "380906b5b16fcb413dd3ad1d4893cb5bc03c348dacc36e937d29a2fcf5f074af", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/keccak384_hash_to_address.out b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_address.out index 50850e94c1..f4e5af1b8f 100644 --- a/tests/expectations/compiler/core/algorithms/keccak384_hash_to_address.out +++ b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_address.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "2d1030f1eff5750328a32d33307069f4e28e0d6d3bcc77ae5a4209c08d33e512", unrolled_ast = "2d1030f1eff5750328a32d33307069f4e28e0d6d3bcc77ae5a4209c08d33e512", ssa_ast = "f7c642ab4f01c6eb1c007f63132c7d9216f176766b70f519b9dfdcaf0ec86737", flattened_ast = "09206bcb155481938c5c5a864321a3d30392a85d2b7041b38dd0dd214c4ea7a9", destructured_ast = "e7dc63cf258e52a236bbb6b629d91e473320d6da27eda4b3c9cfd209156b0e45", inlined_ast = "e7dc63cf258e52a236bbb6b629d91e473320d6da27eda4b3c9cfd209156b0e45", dce_ast = "545d2e6a4e25d8cb6d8859ad191cd91193083c79a374291f9bf60d337d3e0382", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "2d1030f1eff5750328a32d33307069f4e28e0d6d3bcc77ae5a4209c08d33e512", unrolled_ast = "1420ccbf80f835a281ec521f42cfbfe0e65def4c069669c562c06191e49cdfb8", ssa_ast = "a89f904c8b0e880b114a844329e64e35e80a6f4e4d2ef9366d2a22a1b717d6cb", flattened_ast = "3bbe8c83421aac7d97bf73473cf7e6b8ffab0663d6277dc6831b51895e10d5ad", destructured_ast = "a486b9c1957433f9e8791428bb0b08a1a0c9429921407acad4bd7b93f3975904", inlined_ast = "a486b9c1957433f9e8791428bb0b08a1a0c9429921407acad4bd7b93f3975904", dce_ast = "5774bd89f0bdaedd9c740804ceb31c7715dd68268cc8cac850bdfe2aa1915293", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/keccak384_hash_to_field.out b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_field.out index c699e7605e..cb5a4d8b77 100644 --- a/tests/expectations/compiler/core/algorithms/keccak384_hash_to_field.out +++ b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_field.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "54be870deacf63d85496695ff69928512c5a66efdfdb6a4bd9f95387bbea476a", unrolled_ast = "54be870deacf63d85496695ff69928512c5a66efdfdb6a4bd9f95387bbea476a", ssa_ast = "6cd917c7a65a3da282963e3ddef12889c280392296416bf3f19abcfb435b44fb", flattened_ast = "28345cbd33e92c5da6bcef14061d295e8e9bc1b65cce5021ee17244807dbd740", destructured_ast = "8d4945296c98254198eec969e6254f3d9a634bfd80863b99e5e5721279b50454", inlined_ast = "8d4945296c98254198eec969e6254f3d9a634bfd80863b99e5e5721279b50454", dce_ast = "63e93cf3d44ae6583ac0a22cabbc88f44bb8d2bfebc184563e171d12a2a935e2", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "54be870deacf63d85496695ff69928512c5a66efdfdb6a4bd9f95387bbea476a", unrolled_ast = "e312a64816b6a43226db021710d372fa2cdc7849197bfdcc60d2bd3853817d84", ssa_ast = "011b86bf762fe56ef43b8bda6d2db39012c7ad1e0d0b0da1e4c5af9db764d802", flattened_ast = "e3f03c9fe6f46beffd5c305fa711fd3a9b9bc89c3bfbd22e3435857171aca289", destructured_ast = "3015a7d3166508712fa4fdc02db02117621d203000b292fba3182f9403618fca", inlined_ast = "3015a7d3166508712fa4fdc02db02117621d203000b292fba3182f9403618fca", dce_ast = "6cf44955069e0148aa261ed5105b975bb0f6fcf1de20d41ba6b8f46369bba30d", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/keccak384_hash_to_group.out b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_group.out index cc30939356..cf35dc912e 100644 --- a/tests/expectations/compiler/core/algorithms/keccak384_hash_to_group.out +++ b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "ae3069470893b83bd35cd176a9dc6659a4942279f2638a276de6537da4e1a3f0", unrolled_ast = "ae3069470893b83bd35cd176a9dc6659a4942279f2638a276de6537da4e1a3f0", ssa_ast = "11bef271792e8cfc0b4b7d8d9da727021a150a351e37a7129db1b2fc3715a252", flattened_ast = "82cf2877bca531ba8e682959cf6aa06fdbf2f7c5f69bb15407a3ad02cad55be0", destructured_ast = "f4d5677cc6d0cd31979394af985fa4da9a60d52c655c9a28591472f3e43a48e5", inlined_ast = "f4d5677cc6d0cd31979394af985fa4da9a60d52c655c9a28591472f3e43a48e5", dce_ast = "df203be7e374f0a4a827d12cfab82a2ae5012cf2ae22b2fe0a1ef934839aa29b", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "ae3069470893b83bd35cd176a9dc6659a4942279f2638a276de6537da4e1a3f0", unrolled_ast = "77f1d335bcd2bc7e9b83493ae6ea6fc54a033aed855c3de510d47c9bb7db3734", ssa_ast = "8044e1f17794493f06ebe4dd6cf7b51a326b69b092cf256b31d82689a912594f", flattened_ast = "1d03ed3ca9dd1827b26d302d7a9bc17636455a39bdd0c874d66f99f2744eac89", destructured_ast = "22391987b31e494532fa8d92616a255228c61064706d9ec45c801a468f4379d3", inlined_ast = "22391987b31e494532fa8d92616a255228c61064706d9ec45c801a468f4379d3", dce_ast = "8177f77655b463561fc16de2703bc585b14f951603bfe6d0ee2279beeb29f577", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/keccak384_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_scalar.out index 992d5556e9..eab5b5a477 100644 --- a/tests/expectations/compiler/core/algorithms/keccak384_hash_to_scalar.out +++ b/tests/expectations/compiler/core/algorithms/keccak384_hash_to_scalar.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "74b91eea4dda00f41f01bfdff6b44aeb540ae4b2d44a4cff3f3b02c1a1bd15cd", unrolled_ast = "74b91eea4dda00f41f01bfdff6b44aeb540ae4b2d44a4cff3f3b02c1a1bd15cd", ssa_ast = "df5c45125cc9a84d279357b3495da36e0677c8ead3f8449b38c3ff46553f7834", flattened_ast = "e197eccdcdc2be0b9622c852547bbc61c81545a6ab8fb4b49b0cb8b710e4752c", destructured_ast = "3710261fdcf3e2a6802ec4cac251533b23a2db91533e8c4317033163762b60f9", inlined_ast = "3710261fdcf3e2a6802ec4cac251533b23a2db91533e8c4317033163762b60f9", dce_ast = "b31a97e372902bd0bc562fc4431f8cd84b0c175fcbcee2aacf4a75fb823345f6", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "74b91eea4dda00f41f01bfdff6b44aeb540ae4b2d44a4cff3f3b02c1a1bd15cd", unrolled_ast = "637226377c65a60a5cc285f39c8d4f2d5b889cdd107b4704c13905d94ea67d63", ssa_ast = "1fda94f3e2be3299dcefb0435039419d206c87b52aca884744a595a15d420722", flattened_ast = "20d913f18161e3482af0f88b1942d9756639808bb55f0071074fdccbc296bb23", destructured_ast = "9ab555e3d56b1cd4a555b1c8749aabe40bcf4448ed01aa07b7c649198aa69c12", inlined_ast = "9ab555e3d56b1cd4a555b1c8749aabe40bcf4448ed01aa07b7c649198aa69c12", dce_ast = "9da91243c2946b016ed5f491b4c9612d68d4a3c9c961ce8e439e751a13eeb53c", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/keccak512_hash_to_address.out b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_address.out index 27bd0d77bd..d3cedc9da2 100644 --- a/tests/expectations/compiler/core/algorithms/keccak512_hash_to_address.out +++ b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_address.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "4a840d912e8d128a80e86bf234df35a1d53f98a7013a008974c7f2a60bb896d9", unrolled_ast = "4a840d912e8d128a80e86bf234df35a1d53f98a7013a008974c7f2a60bb896d9", ssa_ast = "405cc86a910535ae3b138ad315798c7219e315342651f3691cfab27063e90f55", flattened_ast = "033b89a31e31bc35b5a02a062eca1b497854329152687f08f6444c4cd65407d3", destructured_ast = "4781f62534130cb1fc8c797056838e5d1e37a3e5db853d949da86b786a7063f9", inlined_ast = "4781f62534130cb1fc8c797056838e5d1e37a3e5db853d949da86b786a7063f9", dce_ast = "545d2e6a4e25d8cb6d8859ad191cd91193083c79a374291f9bf60d337d3e0382", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "4a840d912e8d128a80e86bf234df35a1d53f98a7013a008974c7f2a60bb896d9", unrolled_ast = "e210962a6fa3f8e5f3878cba40c54551e522a5f8ff9c0c9ef6cf58bbf2ae8739", ssa_ast = "3e73a625b12c019085578ebe8ff0c5d93e42f10b0d8f7cd913f078a9ff85fe55", flattened_ast = "87e5ad0cba1ae5986388ba015c82c316d22393d0f457ae55d61002dfacf1a483", destructured_ast = "4ca92ac147a741398949f772f84fcf537426ef4cfecc76dd475db9b2ee4fa108", inlined_ast = "4ca92ac147a741398949f772f84fcf537426ef4cfecc76dd475db9b2ee4fa108", dce_ast = "5774bd89f0bdaedd9c740804ceb31c7715dd68268cc8cac850bdfe2aa1915293", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/keccak512_hash_to_field.out b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_field.out index 085bd12626..c07a040f15 100644 --- a/tests/expectations/compiler/core/algorithms/keccak512_hash_to_field.out +++ b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_field.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "f6fdd3e73a3226c11749276f1c9f520ec00180b840734423988be1d895516676", unrolled_ast = "f6fdd3e73a3226c11749276f1c9f520ec00180b840734423988be1d895516676", ssa_ast = "42669465990c5282b43606e55d17b15e411cd84754eb0a9d7f9036416d97cd44", flattened_ast = "918fd6d12cb08b12d18f2836730b9bc28f612ad5379e2830694cd6c22b22d782", destructured_ast = "291463fc1a3818497b063fa1f6e61bff3d20178af50ad3a55a129db820d43d25", inlined_ast = "291463fc1a3818497b063fa1f6e61bff3d20178af50ad3a55a129db820d43d25", dce_ast = "9851002d14aa5e18f3d7559bc6106ba950a0ac2a7dceb9cb4589d5aa57d2eab5", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "f6fdd3e73a3226c11749276f1c9f520ec00180b840734423988be1d895516676", unrolled_ast = "e82e6dad1ba11604572fc19910148c7433032fd7434d245006d07f3bc3377e77", ssa_ast = "93d937ba75f35ef90ed1b06b71f512c94ff632e123b625cd2552b95e151218d3", flattened_ast = "9d44865c4ea89382decda9e1b4585ecec3682cdd0afc0a8932d1c355ea8a0612", destructured_ast = "69aefc9c5bc799fd47c38f39706abf0867ebcbe66884cc8ad0bf50345d90a22c", inlined_ast = "69aefc9c5bc799fd47c38f39706abf0867ebcbe66884cc8ad0bf50345d90a22c", dce_ast = "e12e848f5374c87f9c6eb671b10e902f1b11f7ce45ad1e901e9c8526ec0e5998", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/keccak512_hash_to_group.out b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_group.out index 678c5065ce..f52b91bd48 100644 --- a/tests/expectations/compiler/core/algorithms/keccak512_hash_to_group.out +++ b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "dd6ac1c6c62ac89024e10d02c484c2202e33775616deb5f810e8a1ec725bffe9", unrolled_ast = "dd6ac1c6c62ac89024e10d02c484c2202e33775616deb5f810e8a1ec725bffe9", ssa_ast = "8183c24c84fb9948c11feed73caee5f6f1e50701607c823a49226b9a5fd05343", flattened_ast = "f540c117187c936e3ef9e087c765d0ed950e6e8fe1f6a5ffb998a327c5b08ec6", destructured_ast = "42b76a97d141ff83a01a8fcfdd5979d36e254730e0095b37f3f73367ee61f4bb", inlined_ast = "42b76a97d141ff83a01a8fcfdd5979d36e254730e0095b37f3f73367ee61f4bb", dce_ast = "5989ae9fe6ac607c7f3b168ab82830beee2bfa8a12bf57d98d99ef4228414232", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "dd6ac1c6c62ac89024e10d02c484c2202e33775616deb5f810e8a1ec725bffe9", unrolled_ast = "ac52635d31780fc47dad16022608924aca45ba9a4bd6cc8dad54fdc22e4f9c2d", ssa_ast = "390e9d49113df4db730bc958ff98e506b514fd38d62d941e30dccc80efd250fa", flattened_ast = "a3797c8eba61bedbc1ee34ecddbd8f65bae5d97a4cb5dc93b59700c50a1ea323", destructured_ast = "277e53c4afefcb302e6b854657d8485aca873af08c7796307b710ca7c7043044", inlined_ast = "277e53c4afefcb302e6b854657d8485aca873af08c7796307b710ca7c7043044", dce_ast = "c6bf8c83175c6acdedab57ec737aeb87a6508c3779769252f94b0e90426441b0", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/keccak512_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_scalar.out index 90025167fc..b8e5be18c2 100644 --- a/tests/expectations/compiler/core/algorithms/keccak512_hash_to_scalar.out +++ b/tests/expectations/compiler/core/algorithms/keccak512_hash_to_scalar.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "e465c1be07416336b57caabc74b8b483025361da199d70aa100ad0fa4f9c053f", unrolled_ast = "e465c1be07416336b57caabc74b8b483025361da199d70aa100ad0fa4f9c053f", ssa_ast = "bee0a4213806c9f3fca234ec0cf2cf42f73d50d8245bc86f921bb1ebc3f431dc", flattened_ast = "de827d878a20cd16a4eb1b8c673019ead768bdffeff16064ba3b99d06b312aac", destructured_ast = "c8b84c20e5b5f761c412bfca3df1bb5a303c36770e15b021698bd786256e789e", inlined_ast = "c8b84c20e5b5f761c412bfca3df1bb5a303c36770e15b021698bd786256e789e", dce_ast = "8aa9c6b07da94d1a70c79fa1efc552ee380d5877087524e18a20cef592591e1a", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "e465c1be07416336b57caabc74b8b483025361da199d70aa100ad0fa4f9c053f", unrolled_ast = "c58303797ced6262bdd87360848abb8d23e4f20447f33892420f64d90c173929", ssa_ast = "39e1770dee5ba344bd5df87706108359116b1429fbed5d1bfb1c9a618d111655", flattened_ast = "ba0565f0df24183bbcec40602903270bb12a09406e7ecdd6a1bd727fa49cb02e", destructured_ast = "201744fad04c1b1eaf002b182d917a733d53f78247ab106145a187701391e3f7", inlined_ast = "201744fad04c1b1eaf002b182d917a733d53f78247ab106145a187701391e3f7", dce_ast = "b23c75edb7c1859d06f06815921de74deaa31269262c4549878e704b16f20d43", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_address.out b/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_address.out index 4a688e7cab..c39f8225c3 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_address.out +++ b/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_address.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "74f217b6c5e7a8b192fcece47a44e6ddbbd142c8d4dff924008c8da0d7a22e31", unrolled_ast = "74f217b6c5e7a8b192fcece47a44e6ddbbd142c8d4dff924008c8da0d7a22e31", ssa_ast = "d85e4a21c690f5e9d73b1bfa3d6672ad58a4bb7624c569a99272a181106a7430", flattened_ast = "a37f2ca450c849ed171f9b7908a4e5bb559f2371bb49e5500661eb0ff745551e", destructured_ast = "5f7c8acffdd2627554eb310018e40328b508805d463fdda163ea02c4daefb778", inlined_ast = "5f7c8acffdd2627554eb310018e40328b508805d463fdda163ea02c4daefb778", dce_ast = "55c12a97d35053d29f6d4210233920eb364c474383173cfecb07a89baad7d9eb", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "74f217b6c5e7a8b192fcece47a44e6ddbbd142c8d4dff924008c8da0d7a22e31", unrolled_ast = "31c6e0b888b5a46918b0dd408f8ca09bb67969895d027b94a9309aae53589b4d", ssa_ast = "1b4ead7a432773647824497b78bbfcb3ee8d1512122de46193b4f706a63f2c99", flattened_ast = "a551600d3e7c94876c19b603ba82637594b12feefd152e15144a65ebc18ccfb5", destructured_ast = "ebb0829d71b75bb0e08924f1e97891553e515a6b9ac8757bbd1eb08eeb795f0a", inlined_ast = "ebb0829d71b75bb0e08924f1e97891553e515a6b9ac8757bbd1eb08eeb795f0a", dce_ast = "ffd7b8f5a92dd80aade8b795b0c50242872972604fa3173a7b000a98cffb2f30", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_field.out b/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_field.out index be82e5a011..2ede5d925c 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_field.out +++ b/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_field.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "6a16cf7cc3f5e6cd2e0ca0f2039980bbcd8a7000c81218638991ae61e9120158", unrolled_ast = "6a16cf7cc3f5e6cd2e0ca0f2039980bbcd8a7000c81218638991ae61e9120158", ssa_ast = "41442a44939815b4ade76fb5be562df569dc1193817b6d969c84eb2e6cc799b2", flattened_ast = "0f8f8d82a20fd81277b1bbfb9c40a7b317b314473d7462bd2b92e58e02f606dc", destructured_ast = "b60ec463d5c856243960ac13239c8d7a2b03e00ef89fb92155e037757e5d66ff", inlined_ast = "b60ec463d5c856243960ac13239c8d7a2b03e00ef89fb92155e037757e5d66ff", dce_ast = "759e698273752d2a8f32c024d26b27dfc3b839af7ab28c60f48606ce92c9111f", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "6a16cf7cc3f5e6cd2e0ca0f2039980bbcd8a7000c81218638991ae61e9120158", unrolled_ast = "a86228950a943a7fdf48ee1fcbf7a486123a576d6a1b2fa2aebfb3ece8062c48", ssa_ast = "91f33905d7cb860d2e0c9711a8897f9210c0f8f48d77e18157bf0b599d63041e", flattened_ast = "a5d64736f5eeede6c87cf1cb518e68bd5e3cd2565811223cb7d503f03b767b5c", destructured_ast = "b055344f679ba6ac720e22f335f432bab467144a9e2caf5c7e9ff4b4273b9d74", inlined_ast = "b055344f679ba6ac720e22f335f432bab467144a9e2caf5c7e9ff4b4273b9d74", dce_ast = "d57122048c648da5d9322c4f0d3ee0af4dce914f01318a73a9645198bc4bc0fa", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_group.out b/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_group.out index d5bfdeb2b6..07e87988c7 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_group.out +++ b/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "5992b1ae07a5add1200a974385f7125edb9f99dffd1ce13fd7e9d18bf340fcfd", unrolled_ast = "5992b1ae07a5add1200a974385f7125edb9f99dffd1ce13fd7e9d18bf340fcfd", ssa_ast = "1fef1340dc5f57d90abd8c50383442eab95182ec598c7e21928eac97f990a24c", flattened_ast = "5b86082f0fc6326e7a198f9cca9b50782eb04bfd8601622b9f36f26da9b883f2", destructured_ast = "a0e8b7d0584087c684f9683850cd0b088be08dc9bd76f9230174c5ffe066ab2b", inlined_ast = "a0e8b7d0584087c684f9683850cd0b088be08dc9bd76f9230174c5ffe066ab2b", dce_ast = "44520026be90509c38acce7d213a00c786333119b49d84731c7bd64a73ed6328", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "5992b1ae07a5add1200a974385f7125edb9f99dffd1ce13fd7e9d18bf340fcfd", unrolled_ast = "31833722e37ac6d56f68474cbce51d223806ff112f069ce38dcb9e9536ddd76b", ssa_ast = "fd0d0e3d0f61e6618ab6786accad7c79a493aad69da78d5f435e4076b6c0e427", flattened_ast = "c257126e03f9e768b82f2db80dc1926cb51fdddbebccc45f03fed2b162ae5b29", destructured_ast = "55eb4918b2177088a10104b0c52401aab0082ee2eb52f6cfecce6d1e57a6f07d", inlined_ast = "55eb4918b2177088a10104b0c52401aab0082ee2eb52f6cfecce6d1e57a6f07d", dce_ast = "b2a8f2e290f5a36e443e78a4c122dd1ca331a1639f23ea880fd4ec749902c500", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_scalar.out index cf82af556e..820c6b1347 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_scalar.out +++ b/tests/expectations/compiler/core/algorithms/poseidon2_hash_to_scalar.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "7a824d2a8ff52481397031e7ec23ecf3f9266da5525cd8de98ef30dbc1e852cb", unrolled_ast = "7a824d2a8ff52481397031e7ec23ecf3f9266da5525cd8de98ef30dbc1e852cb", ssa_ast = "b46182764d64e905e9d68e50cad2b55698cb017605f18e90e0869e93ce5748c1", flattened_ast = "f8f37329fcba405c7dfef053f42deee4b1cd7663f134f2d31de62c516f008379", destructured_ast = "ff538613ad67dbc98919937704c3413902ff2708ae94c40dbfd8d772a6b16e55", inlined_ast = "ff538613ad67dbc98919937704c3413902ff2708ae94c40dbfd8d772a6b16e55", dce_ast = "c59b70e0a3d81ff1dffc0eff6f277ff36e79c65a02a02110359c9a7e57d89cb8", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "7a824d2a8ff52481397031e7ec23ecf3f9266da5525cd8de98ef30dbc1e852cb", unrolled_ast = "429ad8ba9552fe515f1df43f208beb0d03ceb5b2ec442ee7792d5fc5267a2d5e", ssa_ast = "f63ef7d3a0ba00d6c23a66bb68d3f980130072762319e8b7e259c61ef4dda993", flattened_ast = "95a7f7313cca895b8d174a8c329a9fd99d3132c0b96997d89f787af92537e680", destructured_ast = "761c24a4815e9bba73c2354b2f14a086455e4b7833598ae1b96f69c36044bcab", inlined_ast = "761c24a4815e9bba73c2354b2f14a086455e4b7833598ae1b96f69c36044bcab", dce_ast = "bc21ec1b42b64079662e288ba663d0286c20ecb3908d9af81f7fbeaf81e715b6", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_address.out b/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_address.out index 6d21e49634..281988cfbf 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_address.out +++ b/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_address.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "be073c2c6aa0efd26395d5e0f901a53a2b2baed5ee71e9dc24c4e4ec1b61b9da", unrolled_ast = "be073c2c6aa0efd26395d5e0f901a53a2b2baed5ee71e9dc24c4e4ec1b61b9da", ssa_ast = "4f73eda59e3ac8ee7367f1309b4901b5d3dae206e92a7d08addc853f5108428a", flattened_ast = "4275e2a7fee44ea1ee1b91b9652fd39a7f6044e66cf206313ed786309d56786f", destructured_ast = "f58ac408b1179774c95e2a6b2230972c129309e293151752278d65bd36dc3caa", inlined_ast = "f58ac408b1179774c95e2a6b2230972c129309e293151752278d65bd36dc3caa", dce_ast = "55c12a97d35053d29f6d4210233920eb364c474383173cfecb07a89baad7d9eb", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "be073c2c6aa0efd26395d5e0f901a53a2b2baed5ee71e9dc24c4e4ec1b61b9da", unrolled_ast = "9c190620a910f9d7cb19692b6c5f885343fd56e130a1f9a7e5cc7a2be8273954", ssa_ast = "05ce6f35fdd3d81f4549164a5ed36b2930fe3307d10f8f91a221a90165cd86ce", flattened_ast = "52981935394f67e9e01857f5d6ca390de2d394e88439777f5b2d934f2da5ef07", destructured_ast = "d83219a388549983cbad9e82ed0da6edeff98988a6cab5734696ffbfb964f3ce", inlined_ast = "d83219a388549983cbad9e82ed0da6edeff98988a6cab5734696ffbfb964f3ce", dce_ast = "ffd7b8f5a92dd80aade8b795b0c50242872972604fa3173a7b000a98cffb2f30", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_field.out b/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_field.out index 9d15a92ba3..71e7445abd 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_field.out +++ b/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_field.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "df8873024addcd9ecc4bf08e44cddbec156c4d118be2ed101fa5ad966a7f3662", unrolled_ast = "df8873024addcd9ecc4bf08e44cddbec156c4d118be2ed101fa5ad966a7f3662", ssa_ast = "11723fc2c91d386ca939ae7bd59fc1ea23fd7d32fdc2d46a53506c261a15f5d3", flattened_ast = "5930124605a3e71405d3938924b6b3c24d06360059247b87e992b9b6486ed42c", destructured_ast = "d0aaaf28931eeddea81216269f5146e5bf97634c61020dc13a425ac34dff8c58", inlined_ast = "d0aaaf28931eeddea81216269f5146e5bf97634c61020dc13a425ac34dff8c58", dce_ast = "211ddf401c91aef1dd000f7d1c4b98761a2c7e5abca74d91a3bc77d5fa287388", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "df8873024addcd9ecc4bf08e44cddbec156c4d118be2ed101fa5ad966a7f3662", unrolled_ast = "a6e08b2b38b344557537dbe26343a7b55479d7dec2c754af2f6dce22a0fe25b3", ssa_ast = "0408ca8800109f5a39025d999cc0493d5d50330ae7873310c098382f7b83a8a0", flattened_ast = "e5cfa23aa14ea55a2b23bb4e14a12cfc7478382642fa8ab3ebfa0544d6cb70e0", destructured_ast = "8381559d255961696ab06a7ba096dc717c7ab4aff7665aa384ff6d3b8b2d1019", inlined_ast = "8381559d255961696ab06a7ba096dc717c7ab4aff7665aa384ff6d3b8b2d1019", dce_ast = "74d79e21b57acf5c56bb8e499c93bc9019528ba9c9a270ec5b6fb376a2640250", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_group.out b/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_group.out index 829c90a412..629f8307ae 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_group.out +++ b/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "5ffc727232ee9c8c3eac6ce88ac7f273bef966a71f34fdd74337178b4ffba922", unrolled_ast = "5ffc727232ee9c8c3eac6ce88ac7f273bef966a71f34fdd74337178b4ffba922", ssa_ast = "796d81d809d9f9806d275a1c14074228484c2b2ab17147649bfc8f9e2a8dd379", flattened_ast = "66e0fa510ac5303167929b60b7de69e7143981496d4e6f2671030fe758f37dc0", destructured_ast = "d027ab7d14f69b2537326838cb6212b92cd337c1ba8bfc740c907bd2dc256c31", inlined_ast = "d027ab7d14f69b2537326838cb6212b92cd337c1ba8bfc740c907bd2dc256c31", dce_ast = "fe4e4a9513882cd49e43cef66ce9f38da1dbcaba384413f668f80fb31f3914ad", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "5ffc727232ee9c8c3eac6ce88ac7f273bef966a71f34fdd74337178b4ffba922", unrolled_ast = "1e38b0851384411e3611124d246b2e1cacd5a6c9f32da14dcffa59e95e6dedec", ssa_ast = "4f219c0d933bed0dafa6c573b1e60d147d2593c02248a42209f64f367df06181", flattened_ast = "4ab080685233a94d7d8aa753e0d96ba8941e0fce768205ddd1cc5e96995fbc54", destructured_ast = "6288e5d3376f21710a38f907f2eaac5b512db76c9eca396465fa8599fe3ca85b", inlined_ast = "6288e5d3376f21710a38f907f2eaac5b512db76c9eca396465fa8599fe3ca85b", dce_ast = "cac79e052880e1f624ad302d285aff8cdf048919aa11b337eb9d9f5ddbe6bac8", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_scalar.out index 7976406d24..05b3479df8 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_scalar.out +++ b/tests/expectations/compiler/core/algorithms/poseidon4_hash_to_scalar.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "2afd35fbbf878455f16f020073ae8ecfdb064a65eda91d9fd09494494ed0f432", unrolled_ast = "2afd35fbbf878455f16f020073ae8ecfdb064a65eda91d9fd09494494ed0f432", ssa_ast = "5b51b0f856acfe839017ba25ec98053d4fdef159dda930786947933e6e69bce4", flattened_ast = "2843ee165c4cb16f9ed3a4cf84b0afe2c1896cbee7ec7aaf48727e41cb007808", destructured_ast = "64b2ad2ee264a0d5bf22af5314958484fe00328a233487b71a15d1857903eb0b", inlined_ast = "64b2ad2ee264a0d5bf22af5314958484fe00328a233487b71a15d1857903eb0b", dce_ast = "f383879836ce857c9b271ce1ea17fd956a48074a68dd9d6394fbff380a90f8e6", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "2afd35fbbf878455f16f020073ae8ecfdb064a65eda91d9fd09494494ed0f432", unrolled_ast = "0bd49f1f00000c62a8bed923763dea3c781fbf379a17264ea3786f72df579664", ssa_ast = "039a59f4c69b0555989aa5409d84464db3c261e70e239ab73bcfaa4c73152227", flattened_ast = "ba1d8a889ec7829b70298bfb06e2ac5167a0d83470cecbeec49d7b80cfeed647", destructured_ast = "a4b5f70082d1c945db05dd2f8c223d582343743beb9f6835ffc4026a7c221ebc", inlined_ast = "a4b5f70082d1c945db05dd2f8c223d582343743beb9f6835ffc4026a7c221ebc", dce_ast = "8f82f354c1b92ee1967437d30d76250720582c02e291ab375408299818cdd1b7", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_address.out b/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_address.out index 2e9b2e9bbc..5e43c200f2 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_address.out +++ b/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_address.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "296a2a744051d37632fe71b327a73e99b945f2c4d845f5904ce1e53572bc2088", unrolled_ast = "296a2a744051d37632fe71b327a73e99b945f2c4d845f5904ce1e53572bc2088", ssa_ast = "ef15113bc5088ee7ca144c57d23ed30a9b9f8a4ac0b1aa28b5cce959ca646c2c", flattened_ast = "3523e589592af0e598b64efaff56abc84a33af504a04c1f9eb361ba1792d36a4", destructured_ast = "8963eb06c3a0eac3851d36b1cd0cc9b53ed215663e51dd2553b5bf0fbb0cb91a", inlined_ast = "8963eb06c3a0eac3851d36b1cd0cc9b53ed215663e51dd2553b5bf0fbb0cb91a", dce_ast = "55c12a97d35053d29f6d4210233920eb364c474383173cfecb07a89baad7d9eb", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "296a2a744051d37632fe71b327a73e99b945f2c4d845f5904ce1e53572bc2088", unrolled_ast = "f3595e8dc68e136ee0164cb9e06c0d3b32872613a53f068e727d560a33511973", ssa_ast = "55009a040d9e4dd10fa7638d4705319171c2f7997da87263e0594432c819e722", flattened_ast = "92aaee4fe5801c3f93d8ab355e07d4bf37d18d6a46477a97b0a32b4dffa0ca52", destructured_ast = "de14a626c33767732f51ce124af0cb41c70bd30ffc291efceaa95572de4ff957", inlined_ast = "de14a626c33767732f51ce124af0cb41c70bd30ffc291efceaa95572de4ff957", dce_ast = "ffd7b8f5a92dd80aade8b795b0c50242872972604fa3173a7b000a98cffb2f30", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_field.out b/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_field.out index 72b8325579..bf6d89f401 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_field.out +++ b/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_field.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "4c6ddaed5a81b5ff34d2f58af2f7536ea312fb89df6b428ad3f1f1276fea65ae", unrolled_ast = "4c6ddaed5a81b5ff34d2f58af2f7536ea312fb89df6b428ad3f1f1276fea65ae", ssa_ast = "342ff3ead7521ef7761ef9e6f857ee8868fca98987e60c7bdf3b98a864f04cc8", flattened_ast = "dba65b923e7a65e01946abc6845914a6685cb024e70e0657035efbb1f763cc27", destructured_ast = "dc7433d4bdf86657d55eeb4406bf543e2c65028bb65c0b58cd0ef6838948a07c", inlined_ast = "dc7433d4bdf86657d55eeb4406bf543e2c65028bb65c0b58cd0ef6838948a07c", dce_ast = "8c6c44da92145bbc12a44703275d271fb83a62ae26c91c3af5b270cea13a839a", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "4c6ddaed5a81b5ff34d2f58af2f7536ea312fb89df6b428ad3f1f1276fea65ae", unrolled_ast = "c4b5978c1fa9bcf12505635f8aea4563c4caa76ac67f3929a93bbdcbc7b938cf", ssa_ast = "fb53e7d14903d9cb24883926414b6256b3080043cb19ee103d8c716fb6b7314f", flattened_ast = "627c12b715a335c4678ee449329388521ddf2d512692af9a88052365b17d965e", destructured_ast = "e5fd97ae9172e40987641035e578bcdddb7f1634420d1f1b474aa3eda8bce02b", inlined_ast = "e5fd97ae9172e40987641035e578bcdddb7f1634420d1f1b474aa3eda8bce02b", dce_ast = "6f0504c05743029a2b37336374ad5dbdd7d2f729e74c195408b379432825cd09", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_group.out b/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_group.out index d84ee7e5c8..2238bca2da 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_group.out +++ b/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "ed1710c505d851e9f849f438cad654e6fd0230ae540db8b7686fc7c67dae1c6d", unrolled_ast = "ed1710c505d851e9f849f438cad654e6fd0230ae540db8b7686fc7c67dae1c6d", ssa_ast = "5800c3250725bf1a1bf974162508a323486857d5eafdb7feb0a9cbf3f634610e", flattened_ast = "2b50666f63884c93b2fa4b1e33acf34e93c9e8f42c8a3cb59e9b400b126a4a2e", destructured_ast = "7091bde1bc4296974b1abc1a25887c006ce6ef74770377f0f9a8249707fd668d", inlined_ast = "7091bde1bc4296974b1abc1a25887c006ce6ef74770377f0f9a8249707fd668d", dce_ast = "7bc3c647e7d03edf6ac0bd0139097084e0cf67cd624de0351e3ad9afc6968a56", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "ed1710c505d851e9f849f438cad654e6fd0230ae540db8b7686fc7c67dae1c6d", unrolled_ast = "964b2e4c08c7b6ba6bb7bae2f9ddea317d2cffc8b04fb8a033e3c5fbd6c79b07", ssa_ast = "7b97bee0569ade255866d985a5c92413deccbba0e3cd9ba824227bee9925fee0", flattened_ast = "6adcaeb5608ad9b5cefba5a207f987c49db440abc6446079c3c73ce0dff6001a", destructured_ast = "12470ceae3d7617906b00f2d9a093f74170c4b3954427bfa9c93e5b46bd220e1", inlined_ast = "12470ceae3d7617906b00f2d9a093f74170c4b3954427bfa9c93e5b46bd220e1", dce_ast = "92bb79c631abce0af80ef808dcaee0588b9bf8876258f89f8f9cb9eaa59f516e", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_scalar.out index d2e08b6e32..a9d8a4055a 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_scalar.out +++ b/tests/expectations/compiler/core/algorithms/poseidon8_hash_to_scalar.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "43fe27f51fe84eab0f4a4a7b209e3d9802586ffef074b6ddff1b5ef5a5e659cb", unrolled_ast = "43fe27f51fe84eab0f4a4a7b209e3d9802586ffef074b6ddff1b5ef5a5e659cb", ssa_ast = "7ee49478c11209bfcd04624718643a0c3fa95e4a44fbd8d1258ba46bcbb21cff", flattened_ast = "814445cdbf2c8d9d4c8f53c9e00505fed4a489f8f5747a306b4f8364ac2c46c8", destructured_ast = "e578da50613bfc429eb23a0139e1566b67974be634a2f78dbfef645e9b4eb922", inlined_ast = "e578da50613bfc429eb23a0139e1566b67974be634a2f78dbfef645e9b4eb922", dce_ast = "8bcd655fe116e44a87ae2fbae917f13ef0683f44f232146e9c50782ba2f197c7", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "43fe27f51fe84eab0f4a4a7b209e3d9802586ffef074b6ddff1b5ef5a5e659cb", unrolled_ast = "a046f636cfdfe8440d0f1fe79149eae7d324d0147a98027118956f83f0683a3b", ssa_ast = "cff04be07ca50608d0f738bc5f0a006ea8279136f30932ffa1d0ae9b1a1c732c", flattened_ast = "e3aeb35d69060463fc02a859a2b3735614a8ca25119f3b1942a6b7524a425d86", destructured_ast = "6da9e07aceb9f04b651177625c9b58b0e399b2391388d75233295e8eaa72d9c2", inlined_ast = "6da9e07aceb9f04b651177625c9b58b0e399b2391388d75233295e8eaa72d9c2", dce_ast = "9436f3a54d93018fc65d31d7da37f16219273ed67ca4b6bbcf8813639dbbfb61", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_address.out b/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_address.out index d15f910741..15f71b1196 100644 --- a/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_address.out +++ b/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_address.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "9045f288dae19099f671ec84e85fe1252c1549d52fe5e5d2947f0f21d588a23e", unrolled_ast = "9045f288dae19099f671ec84e85fe1252c1549d52fe5e5d2947f0f21d588a23e", ssa_ast = "7d6c39d3b94412746e1f86f2073ffbcae6957accd6ed577616c148b1a54863cd", flattened_ast = "f66d6de1aabd387c26917941fb305f7ad8e40c2a52fc2f726fd4636e14fe4364", destructured_ast = "33b19c00070b0886259503529e61e80be9c4b560b4c60532286816cd167b1ec7", inlined_ast = "33b19c00070b0886259503529e61e80be9c4b560b4c60532286816cd167b1ec7", dce_ast = "d9f9b56a9b0c5cc6c33af9c6768eff1a47a2bb0e794b7f7f5eabdef13d19c420", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "9045f288dae19099f671ec84e85fe1252c1549d52fe5e5d2947f0f21d588a23e", unrolled_ast = "c72beeb5806222d6a1ffa85d9dd3ea4944bc5ac4622b43de1c147a578a573738", ssa_ast = "d607a35e1a77b28aeb05ce355dac40796f6d517794fbdfcc850b0fc1f14bdc17", flattened_ast = "9e17eb809ccd397e35529a8daf7457686e7e858fd2f14ab97ee5c8c8f93725c9", destructured_ast = "2b99ac4370f9c2321d1e517afc4ab779fd74527f7c0729daf69912193da7472d", inlined_ast = "2b99ac4370f9c2321d1e517afc4ab779fd74527f7c0729daf69912193da7472d", dce_ast = "d232666467342719701915c4dfef9882d8da75342f50fe359827619404ad6aa1", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_field.out b/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_field.out index 04dcf4db22..68d55cfe5c 100644 --- a/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_field.out +++ b/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_field.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "951813d08b17d74a2561da5d09a67c349fdbdb7a418890b056d6739305925089", unrolled_ast = "951813d08b17d74a2561da5d09a67c349fdbdb7a418890b056d6739305925089", ssa_ast = "73cc9f291df66351433fde47038cbf8588a0944f431fe1841bf89f2f25d158c5", flattened_ast = "c63eab9d325e838f674f26c8530c42ab275c6436bbcf51dfe61f15a2d3d96959", destructured_ast = "afb852896ead5ccd6d30cca139e2f4bae4462f00120e24c087008bfd5d96c201", inlined_ast = "afb852896ead5ccd6d30cca139e2f4bae4462f00120e24c087008bfd5d96c201", dce_ast = "fa54952bc3ffbce1acd59811c4242b89a5b93f2acdc8018da64a2c34757966b8", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "951813d08b17d74a2561da5d09a67c349fdbdb7a418890b056d6739305925089", unrolled_ast = "00537ec6ec080fa926623a677f6e2dd29d3373fcf7f9acbfb0150b697fb9ee69", ssa_ast = "b2bd45113213cd3b2f302bb9fe27ed7f274557cbbb5dfea1697a53ffc83c2d55", flattened_ast = "59f031083b2cba897b13556456e583a1cd2c4c8b65e63c825e1c7e00d22ec50e", destructured_ast = "9ae19d3be74a14949f5360af6b5fbf471e8b606fc6a6a1cbbc5b68b5e7681135", inlined_ast = "9ae19d3be74a14949f5360af6b5fbf471e8b606fc6a6a1cbbc5b68b5e7681135", dce_ast = "2a34d6f3a7a6d4c5b543bb06f3e1339478f5bc2ff5fff4da5b5b3c16ce7c3b6f", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_group.out b/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_group.out index 3211d6a442..36e5b863b2 100644 --- a/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_group.out +++ b/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "4fff1dad39ccdc2fac22bf0ebf842b65dd44bbe6ef8e7fddb408e040bdca9523", unrolled_ast = "4fff1dad39ccdc2fac22bf0ebf842b65dd44bbe6ef8e7fddb408e040bdca9523", ssa_ast = "a1bf4c60b88b5a15cf70525652804e0f0f23d35f3d45b389352de400f1472c32", flattened_ast = "ecbf1482e98ccfe72d5dd12c2d93ad24f278d7f71886535052cb81cfdefb9f9e", destructured_ast = "45051a22ddb9a72da96e77680d6776a742e8e331229eefa4927e8cc14568bcc4", inlined_ast = "45051a22ddb9a72da96e77680d6776a742e8e331229eefa4927e8cc14568bcc4", dce_ast = "609bae94813044edfb4f95926d16e30b618d0aebc7fee0c828cb05481c17f2aa", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "4fff1dad39ccdc2fac22bf0ebf842b65dd44bbe6ef8e7fddb408e040bdca9523", unrolled_ast = "4d383bc7eb726fca8152d8f5f0574ed656d3497780aa4acea0984fbdaebc3abd", ssa_ast = "a60b881a871d49571ce029340fae50255998df31f8ca87396e309e50f5752d0b", flattened_ast = "431f880c67a015fc5cd3ee907f242c4872afd6703e23eba8aacf4b053d06a1b4", destructured_ast = "29eb4fddecf1a6554bb409cbe59d5217f649c2f1b9fc2d57773b466bc45fb342", inlined_ast = "29eb4fddecf1a6554bb409cbe59d5217f649c2f1b9fc2d57773b466bc45fb342", dce_ast = "cb888630ecddd132f793da1c4cd72f0aba5c7be53e0ca817f5853480932522d8", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_scalar.out index 9240b1575f..a9618a12cc 100644 --- a/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_scalar.out +++ b/tests/expectations/compiler/core/algorithms/sha3_256_hash_to_scalar.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "87b8d8edc7a00d177a029050e01d894f99a1ec363c9653485bb2da10bba9a658", unrolled_ast = "87b8d8edc7a00d177a029050e01d894f99a1ec363c9653485bb2da10bba9a658", ssa_ast = "d9b9b7be826e78b07afed99b21c4a9fdf73db881746bbe4ef414233411bc9f0a", flattened_ast = "91e097aa0ca0f170d6e789b4f3c899d94d05b5abffd5dad9b999e303f95c4bb1", destructured_ast = "a4295edcdbdaf91119a6bdd92446bd0282b7988aa826f63d3d8175d7aecf14d9", inlined_ast = "a4295edcdbdaf91119a6bdd92446bd0282b7988aa826f63d3d8175d7aecf14d9", dce_ast = "7d6af3e7ed175bb968772e9188fa6671fe7717d9bc959b6c01c5cbf51dfac9bc", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "87b8d8edc7a00d177a029050e01d894f99a1ec363c9653485bb2da10bba9a658", unrolled_ast = "fe7ed73b9c6113032748d5ca861c383678fab7f5c18c709b9034018fb7d1f55b", ssa_ast = "a8ac3397f2696c5e7ba8825c869e6254c1dbf7862b89c590669acf20a1b0026a", flattened_ast = "1dea054e0e698790ed2b6247720baf60662fe45559e33ad1d046fe8ce53398fe", destructured_ast = "282e6da2a27ceae6a9439993a01e8f67ba6df268166fe680f4b728a088432acc", inlined_ast = "282e6da2a27ceae6a9439993a01e8f67ba6df268166fe680f4b728a088432acc", dce_ast = "acf81fa1404568589d918cff0e21c013a452a268d51cc42a44590bc925034432", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_address.out b/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_address.out index 01ae147973..96ffec5aae 100644 --- a/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_address.out +++ b/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_address.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "e53657649bce554807d8918a8f06709baceccb6959ef1211264dc051cb8c3d3a", unrolled_ast = "e53657649bce554807d8918a8f06709baceccb6959ef1211264dc051cb8c3d3a", ssa_ast = "0b88f7cf316ee152e912208fab7320145fe29c2bc0184debc79644011a14ac49", flattened_ast = "d7f4c296a399bee9989ec9324c22f51735b46430b45e1d569dd47691d8856d28", destructured_ast = "d320dc8735a93cbc969a7f4a13f84e97df074a1ff62f3ede685b591d15b2bb19", inlined_ast = "d320dc8735a93cbc969a7f4a13f84e97df074a1ff62f3ede685b591d15b2bb19", dce_ast = "d9f9b56a9b0c5cc6c33af9c6768eff1a47a2bb0e794b7f7f5eabdef13d19c420", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "e53657649bce554807d8918a8f06709baceccb6959ef1211264dc051cb8c3d3a", unrolled_ast = "86628a87ba03db9b4b804506408f6477fc9918c52320371d54c8a7af9e05fba1", ssa_ast = "c861ddce90df699e506a331e96a1bdeeea5475ec87958da303a15c98ffd2d69f", flattened_ast = "1fc13e7977e00310cf56eafa8eb2fe35b334759fc804fff09887b263ed547328", destructured_ast = "48e67183172fd54b426d351c40f1f1a344092b46825f8e92d72f38769037b13f", inlined_ast = "48e67183172fd54b426d351c40f1f1a344092b46825f8e92d72f38769037b13f", dce_ast = "d232666467342719701915c4dfef9882d8da75342f50fe359827619404ad6aa1", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_field.out b/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_field.out index 94198b647a..f9518f812b 100644 --- a/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_field.out +++ b/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_field.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "beee53c4cd112e3fe34b5ac6ccbdb75aa3d38725efdf995dec82999bfc6c452e", unrolled_ast = "beee53c4cd112e3fe34b5ac6ccbdb75aa3d38725efdf995dec82999bfc6c452e", ssa_ast = "3dd36ceecf52b350f972a7ebb1642e613a4365f2f5c9b2b865793e224496cb35", flattened_ast = "bf0b8e1bedc96e483eaede2f94e86b2a00c4e62dc8d755d484428d13785eb2ca", destructured_ast = "ad51bec828f4c32267c81a68d04d26946ebfe498f8b689a738bc16f55e8278ef", inlined_ast = "ad51bec828f4c32267c81a68d04d26946ebfe498f8b689a738bc16f55e8278ef", dce_ast = "ac9bd5b10febf9c3e44d28b2cc377891165ba5a3cc4f8754b4b111647c7d82a4", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "beee53c4cd112e3fe34b5ac6ccbdb75aa3d38725efdf995dec82999bfc6c452e", unrolled_ast = "8ceb9478ff7cf140ad551d2fe491e0ac3bb6a82bedbea17d782f0c787358f5eb", ssa_ast = "d25d576b5233e8c99648c01767836ca3b14321779a02879b161d6ecf8ea0966c", flattened_ast = "b45a1b0313faf1be8ebdae214e16a8eb6e5cbc9b3d022fdcc1ec9e8f8c6faf62", destructured_ast = "c4c3a1d607e708aae79717c2886850762fc1b15f808c64d1d52fd33f82004d30", inlined_ast = "c4c3a1d607e708aae79717c2886850762fc1b15f808c64d1d52fd33f82004d30", dce_ast = "2145caa3ad1d9e4413f0c664cfad876a4cc2f4b16346b8d0e74317564be82b2e", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_group.out b/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_group.out index cd788a2bab..8ae9ddd570 100644 --- a/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_group.out +++ b/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "82de0890b05877addbe0f7fa1e0f042ae94ba18fed6ca520c146f8abac917233", unrolled_ast = "82de0890b05877addbe0f7fa1e0f042ae94ba18fed6ca520c146f8abac917233", ssa_ast = "31e65ca01c531ea8acc6ec7674b66e1582858a42ca6e26aad4cb6838cd2baf63", flattened_ast = "e6ff1a62bb61627d7c6d6a189030ca91db3fc74d34eeae009545630cba209ff9", destructured_ast = "7fb58525b391920dcbd96b29a69bfdb5eff704cb6ee02c4a7eb4e9dd2e57e2e2", inlined_ast = "7fb58525b391920dcbd96b29a69bfdb5eff704cb6ee02c4a7eb4e9dd2e57e2e2", dce_ast = "af2332a27e15ba72e974ea746040a345d97f6459811c08c270426c0478814a7b", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "82de0890b05877addbe0f7fa1e0f042ae94ba18fed6ca520c146f8abac917233", unrolled_ast = "32599b0c0a869bef2465efbacafb9edad44af416ad9e06ad4909ef308275809c", ssa_ast = "7af64fea7a0b6e472e9bf6a87220dcef98867972f554c949d606294715747e49", flattened_ast = "8ec74df63ab8cd3e8bbb451758bb2c32dee4208403782be213a1a41888c0d81c", destructured_ast = "5b790de857c5030f941fb16dfa3d420ae19594df87960795e0e14644e543352f", inlined_ast = "5b790de857c5030f941fb16dfa3d420ae19594df87960795e0e14644e543352f", dce_ast = "0154b4a6540fc2974984f5b56cb993912f92e71757f01b04349a641d48bed365", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_scalar.out index 9fe83b0c1d..c8dac49bf5 100644 --- a/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_scalar.out +++ b/tests/expectations/compiler/core/algorithms/sha3_384_hash_to_scalar.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "eec80ed0918648ae40e69b769dc890f44d244d81c9b66c1dd95281d79b66e275", unrolled_ast = "eec80ed0918648ae40e69b769dc890f44d244d81c9b66c1dd95281d79b66e275", ssa_ast = "b0dd211a0b72f302d84026216439603e87cfef15874f2cd3802d64c1c193912a", flattened_ast = "ad367ca8813dc9aedf12813b3ca7f67434d023e0bc7467b003a0256d543c875a", destructured_ast = "0bdcfbf6622159aa1eafa36b18b54169e5f5c6afdcc1b14caa2bdcc8fa111f62", inlined_ast = "0bdcfbf6622159aa1eafa36b18b54169e5f5c6afdcc1b14caa2bdcc8fa111f62", dce_ast = "58f52c8c5849b3398c3db28b43dad291152a7e4d27aca6aa1f867135e3e62462", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "eec80ed0918648ae40e69b769dc890f44d244d81c9b66c1dd95281d79b66e275", unrolled_ast = "73a8e288878a3c262146449fd2994e8c37adfc7a20765962c1a14712a094e242", ssa_ast = "4839d8a18ecb149a438f122cd242a922c4829d2222a4385405a3d5ac8a6fdbd9", flattened_ast = "737dcb231dbf23bff78c7dce4ac775213e023bae385ee7d9cdc563e45d34cd08", destructured_ast = "bec5c97582f680ccda89939df476e5bc1b9ed7ccf4b72de18506fc172b61e92d", inlined_ast = "bec5c97582f680ccda89939df476e5bc1b9ed7ccf4b72de18506fc172b61e92d", dce_ast = "d34294f4ed7e8f83dccab5b3ce8221b68ce1523eedc8c321f736fbea52cb48cc", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_address.out b/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_address.out index 3070025328..9d82a55997 100644 --- a/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_address.out +++ b/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_address.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "ba0e4c9d6ce88ccc0e0307ad05c78e5e8d78aa099fc2bcceaacb4c461b997bf5", unrolled_ast = "ba0e4c9d6ce88ccc0e0307ad05c78e5e8d78aa099fc2bcceaacb4c461b997bf5", ssa_ast = "4a6d4613f02253ff76b878c387621d92e22d03ca1a086eefe493044e31f74037", flattened_ast = "edc80e4dd974582508ce142b4c3e92c86cb58b81d7c0a1b6a210349e8a153296", destructured_ast = "c3270c2c52bdbc6f3034142d801a0f6d75d99c27151bed8afe25a13a2883b827", inlined_ast = "c3270c2c52bdbc6f3034142d801a0f6d75d99c27151bed8afe25a13a2883b827", dce_ast = "d9f9b56a9b0c5cc6c33af9c6768eff1a47a2bb0e794b7f7f5eabdef13d19c420", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "ba0e4c9d6ce88ccc0e0307ad05c78e5e8d78aa099fc2bcceaacb4c461b997bf5", unrolled_ast = "c8d89f61f8ca9effc094bd778b93c6986711d038bc699c70ea8fb1fd7e541528", ssa_ast = "d3c74cfff299ee03829f392ab263dca8e278da3c3dcf5595f0ce760f3de5ef73", flattened_ast = "d92821004fa4f2e0cd802df711970f9285aa9a809295fc63d98a722db6998e5d", destructured_ast = "8d4f37d780db17f2c62bf85a0521c9fda7b4d646514968c35b84f2c5722cb67b", inlined_ast = "8d4f37d780db17f2c62bf85a0521c9fda7b4d646514968c35b84f2c5722cb67b", dce_ast = "d232666467342719701915c4dfef9882d8da75342f50fe359827619404ad6aa1", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_field.out b/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_field.out index d6cfc273fa..c86aad2539 100644 --- a/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_field.out +++ b/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_field.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "dd7bef8e08075a6a372765e6979b845ba5404f778e7ce7890b089f67d7fdf502", unrolled_ast = "dd7bef8e08075a6a372765e6979b845ba5404f778e7ce7890b089f67d7fdf502", ssa_ast = "9fd2bea716304e5f5fb158e0297cd0604aacef022f3f55956cda6a52f8ce30cb", flattened_ast = "b24e7acac78935c4014f47ef427aa28b300b63e18aecf0951a42eebb2cfbeb33", destructured_ast = "96cfdf15882e0b2392f5d904461abc89946de3ae609446b584e60747f8306b17", inlined_ast = "96cfdf15882e0b2392f5d904461abc89946de3ae609446b584e60747f8306b17", dce_ast = "ad4d6120fb44395631d65f8974cd77325fb2c9e01766796c708253b8e1776cc8", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "dd7bef8e08075a6a372765e6979b845ba5404f778e7ce7890b089f67d7fdf502", unrolled_ast = "f960c707a2c4e7711ba2a055915af7b0ac316449b8ec9ac3768c62db0527af65", ssa_ast = "0fb16af2f1b154634f475e2de837dc5a769173677f1cbba8f57ec6172bb6e840", flattened_ast = "ab42b9f745b7ba0f9b487e26288bd97f64170e9c768a2efbe3f06c3648b61520", destructured_ast = "9ddbac0be846f2fc6e46638b40671b99714b0d580fee506ebd06a98f353d4c3a", inlined_ast = "9ddbac0be846f2fc6e46638b40671b99714b0d580fee506ebd06a98f353d4c3a", dce_ast = "587dc38398e108c72c10e1669ac34d72cd6849f37096032751adf5fcbc048b71", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_group.out b/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_group.out index 5b12fc472e..eea8040bcc 100644 --- a/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_group.out +++ b/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_group.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "74f2b106148033859a4a34b5548cdbd4cdb87e2db64f36d9a2cf20b0a6d364b4", unrolled_ast = "74f2b106148033859a4a34b5548cdbd4cdb87e2db64f36d9a2cf20b0a6d364b4", ssa_ast = "73eb93150382a1c2bbf633581311461500550a9977f9f3909ff214fc0b7c24d6", flattened_ast = "957b737ca43e48fc45217f583b677c9b5848e687343df8356b5bb4f06add7162", destructured_ast = "438bb69dcddf8086453af4cbbed3fbecc9bd74afdd81162f90288d4cba1fcf5a", inlined_ast = "438bb69dcddf8086453af4cbbed3fbecc9bd74afdd81162f90288d4cba1fcf5a", dce_ast = "cd82ba7fbb4b95bd460518b39d36ef5476f5440a7426623c32db26a27a9a5242", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "74f2b106148033859a4a34b5548cdbd4cdb87e2db64f36d9a2cf20b0a6d364b4", unrolled_ast = "2ae412167354a34c39d4e03dc445701df3c4755f0319bb1759c990d40d183581", ssa_ast = "e33f6815f99d6730b151dc7e4418c786857c87b5b89c5206239c60726aa3898f", flattened_ast = "53cf9bf0bec502c7fc8b4919cec00103896d315526cedfb71cd7c025386e85d1", destructured_ast = "8f251038b89911bd5eb7ca7edeac53eb93aa8142ebef3fb5eb34d45f2b6311ca", inlined_ast = "8f251038b89911bd5eb7ca7edeac53eb93aa8142ebef3fb5eb34d45f2b6311ca", dce_ast = "147559f4928289e7130d3524d8f697d4448277124a0e60541ed4ac43dd71f081", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_scalar.out b/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_scalar.out index 0f925868f9..1c6dfc562d 100644 --- a/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_scalar.out +++ b/tests/expectations/compiler/core/algorithms/sha3_512_hash_to_scalar.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "7bbcf217bccf5513b4bc097816d3554cc4abdd52b729f65fab7cc256bf887797", unrolled_ast = "7bbcf217bccf5513b4bc097816d3554cc4abdd52b729f65fab7cc256bf887797", ssa_ast = "2e5c1e42bd0e260e7d0bde74b78ccf68b57ba4531bd2b0215898ff7a08c0d0f6", flattened_ast = "81712202b122a29df2350446b7add33ce0d458a95681b29db479e29e59d22333", destructured_ast = "a97b9a1067ae7b9249aba16ad0d8c1df7aaabfc4dc704ceaec19d5fbadb5e1d6", inlined_ast = "a97b9a1067ae7b9249aba16ad0d8c1df7aaabfc4dc704ceaec19d5fbadb5e1d6", dce_ast = "951899f2d2baf69aca2887011f9579e5426e167938a8c78523fdf750af867737", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "7bbcf217bccf5513b4bc097816d3554cc4abdd52b729f65fab7cc256bf887797", unrolled_ast = "4332da459b3eeb4f13db81f1bb2f3732b66477d1a1d32ee2fa8814aca6d71858", ssa_ast = "91bfe0c394ae4b809f2268ffce46c2f239a7999c50a38144d2d454dd7b51a355", flattened_ast = "5122d9f070bcfda7c134f9b3cfcaef2b27a02cc00fdda00de3b3ba955978e297", destructured_ast = "fe3c7b484a74ef694058c2ce411f5748b642887c82acca7e08debd2c688c5381", inlined_ast = "fe3c7b484a74ef694058c2ce411f5748b642887c82acca7e08debd2c688c5381", dce_ast = "9b2d83475e8bbdcc99ff90221e212be920311f32d0e754e4e77896d44c9acd19", bytecode = """ program test.aleo; struct Foo: diff --git a/tests/expectations/compiler/core/constants/group_gen.out b/tests/expectations/compiler/core/constants/group_gen.out index 91af2e45d6..de21455967 100644 --- a/tests/expectations/compiler/core/constants/group_gen.out +++ b/tests/expectations/compiler/core/constants/group_gen.out @@ -1,10 +1,10 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "8288afbe9d76576eebdb237192bb20545ee1da09c2b1ece78668c52e3dc4a134", unrolled_ast = "8288afbe9d76576eebdb237192bb20545ee1da09c2b1ece78668c52e3dc4a134", ssa_ast = "9241489c8fc198f0f595e7ff79e435fd9957931f30074e350e0c552eebc4c3d5", flattened_ast = "645cf6d4f48b5c2be4ff9db8d5076cd21302fe1beb14529231881da9b157d068", destructured_ast = "b47c897b226675531064e151374902183c6a0d3f306c7d44dec4e970fad2551a", inlined_ast = "b47c897b226675531064e151374902183c6a0d3f306c7d44dec4e970fad2551a", dce_ast = "b47c897b226675531064e151374902183c6a0d3f306c7d44dec4e970fad2551a", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "8288afbe9d76576eebdb237192bb20545ee1da09c2b1ece78668c52e3dc4a134", unrolled_ast = "33619471c52b311422e8aaf38009ac9f161e6d390a552645efa1b695da4b62d9", ssa_ast = "493b77fc5505366138656425a531c28bd416dcbb79a06535e597584246c626e9", flattened_ast = "6cd9e53f7214eb801046cdf3f02db6fc7f30164875cc159d4af403aa308c1480", destructured_ast = "79e0cf51f953f5325bd5b7e01be789a85aadcb70b5755074def193f73e111831", inlined_ast = "79e0cf51f953f5325bd5b7e01be789a85aadcb70b5755074def193f73e111831", dce_ast = "79e0cf51f953f5325bd5b7e01be789a85aadcb70b5755074def193f73e111831", bytecode = """ program test.aleo; function main: input r0 as group.private; - add r0 group::GEN into r1; + add r0 1540945439182663264862696551825005342995406165131907382295858612069623286213group into r1; output r1 as group.private; """, errors = "", warnings = "" }] }]] diff --git a/tests/expectations/compiler/examples/basic_bank.out b/tests/expectations/compiler/examples/basic_bank.out index 9e256e5937..1b97bc64cd 100644 --- a/tests/expectations/compiler/examples/basic_bank.out +++ b/tests/expectations/compiler/examples/basic_bank.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "afd0c43368595954066cc180e6d0a34219f99ffbf45ada7ddcb4321e0c2ef653", unrolled_ast = "7c416fb18117bd8173b1647d7199769659e300d3eecb48aaf76b24183dc65919", ssa_ast = "c751caf30473d8925ef799d66a0178d8a2ad2ca46166251f980d80a246337dfd", flattened_ast = "27b7cc648d0554ec907ded5a90410da7e99b88b9635d3f8aede540f3a5febaec", destructured_ast = "0807258ab0e848d88022a6c0a664c08a2b460edce49dde922f809319846eae31", inlined_ast = "74bda755b30d709b671a334f47a569881bb6a80dd200ea6aa1e8867970e85820", dce_ast = "551cbfc660ccdd3ece9c39ee455fb8fdbcfc2de6d869c0d96eca89834781e4cd", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "afd0c43368595954066cc180e6d0a34219f99ffbf45ada7ddcb4321e0c2ef653", unrolled_ast = "4c8547879c6f635ca2b501a26da5ffc4a7ffb24d259321a1d72cb0f877c2cca1", ssa_ast = "cd32c5f362d514e293e3044b76109fe447831d59505d8a214db89a2e2b1b96a7", flattened_ast = "154beceda8d3d90fbb818a9f6fdf84b956c9dd4be2882978fced952578e983d4", destructured_ast = "c1b63b7e5a7286cc2e226604c2b028ecace1749bef8539be40f009ff779c069e", inlined_ast = "7c910ff1c7ba9fa0432840b0fc9cb56b758eb16735cef1bd918328b8c7f956ea", dce_ast = "923ae41a22cf8fe06e11313af707d650b7a84b5e54e2ea4f5a82484e605ff48e", bytecode = """ program basic_bank.aleo; record Token: diff --git a/tests/expectations/compiler/examples/fibonacci.out b/tests/expectations/compiler/examples/fibonacci.out index c7fb8b9a54..ddc704f895 100644 --- a/tests/expectations/compiler/examples/fibonacci.out +++ b/tests/expectations/compiler/examples/fibonacci.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "117744a82db2c8ec3103bbc81dc52488131bafd739a4cf2b9ece1cd09072e0f8", unrolled_ast = "16d1ec1d6ae7eb499be23f600d797a9d6be7b9d754a254d38c6c7b6f26331329", ssa_ast = "443c53c125d8e8118d33e53c01c6091e20935c72b74513bcd663b3e00ece4ec0", flattened_ast = "20695e637a9667e9153ad46cca5cd720307bc5cfc982873abee3d135ca9f7f82", destructured_ast = "c0bb37fe91f62521d5dd7d41670f9522d56acbe8892ce6e1a799bb1ad4b3660c", inlined_ast = "41106acc23e0928862d69a46a79be7bd87f37252576748dd6d428280a2b4a3b2", dce_ast = "2b92c7f533dab405549f64219e1f7453871d416fc7650e747b08edcc2b49e42f", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "117744a82db2c8ec3103bbc81dc52488131bafd739a4cf2b9ece1cd09072e0f8", unrolled_ast = "c72b51a21cf5b8c54247fe1cc97ced684c05a3890b37d439f33f989cdd527934", ssa_ast = "68f8c7d00e7f1d78d34c0d665aae155f513afa0c537e6015c4db79a064c48c3c", flattened_ast = "20695e637a9667e9153ad46cca5cd720307bc5cfc982873abee3d135ca9f7f82", destructured_ast = "c0bb37fe91f62521d5dd7d41670f9522d56acbe8892ce6e1a799bb1ad4b3660c", inlined_ast = "41106acc23e0928862d69a46a79be7bd87f37252576748dd6d428280a2b4a3b2", dce_ast = "2b92c7f533dab405549f64219e1f7453871d416fc7650e747b08edcc2b49e42f", bytecode = """ program test.aleo; closure reverse_bits: diff --git a/tests/expectations/compiler/examples/groups.out b/tests/expectations/compiler/examples/groups.out index 3c6d319120..afe2410bb5 100644 --- a/tests/expectations/compiler/examples/groups.out +++ b/tests/expectations/compiler/examples/groups.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "316f17e78314ccc21c70c33178f93e42e621b2e5e18effd0e1232eaf45af5483", unrolled_ast = "316f17e78314ccc21c70c33178f93e42e621b2e5e18effd0e1232eaf45af5483", ssa_ast = "3783e557ca3b7a8c1f5d8898aed657bbf324dc033d589f50246291cd58cca4f8", flattened_ast = "24d23642f9b573e9d0f5a8db8c737cfaf08acb0b9ed87a43eacc487ec8059ebf", destructured_ast = "97af2e8aa5d1782eb7acc421724e65c4fd43e2fea7a9dec7c334a38daf4c0668", inlined_ast = "97af2e8aa5d1782eb7acc421724e65c4fd43e2fea7a9dec7c334a38daf4c0668", dce_ast = "97af2e8aa5d1782eb7acc421724e65c4fd43e2fea7a9dec7c334a38daf4c0668", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "316f17e78314ccc21c70c33178f93e42e621b2e5e18effd0e1232eaf45af5483", unrolled_ast = "26d20304a9f2002e619d126177bc2d96d3f2a835577123b9b31f45e31d1cab27", ssa_ast = "aa0fc14bd1075480f866f1dc69e66f43554599ac3788fa6a51f34c84dee3829f", flattened_ast = "3ef2f9478ad45bfbf3c3b4bada7c500cda4ed4a5773f767139707224bd1b19b9", destructured_ast = "ff6c4cddd64c33739985a5551489cada8812a2fb2d54f03d72aaf5406a614ff2", inlined_ast = "ff6c4cddd64c33739985a5551489cada8812a2fb2d54f03d72aaf5406a614ff2", dce_ast = "ff6c4cddd64c33739985a5551489cada8812a2fb2d54f03d72aaf5406a614ff2", bytecode = """ program test.aleo; function main: @@ -9,6 +9,6 @@ function main: neg r1 into r2; mul r0 2scalar into r3; add r3 r2 into r4; - add r4 group::GEN into r5; + add r4 1540945439182663264862696551825005342995406165131907382295858612069623286213group into r5; output r5 as group.private; """, errors = "", warnings = "" }] }]] diff --git a/tests/expectations/compiler/examples/interest.out b/tests/expectations/compiler/examples/interest.out index 9006650fc6..f6fe518335 100644 --- a/tests/expectations/compiler/examples/interest.out +++ b/tests/expectations/compiler/examples/interest.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "86a0d996309dda9eb9d5d8d1dd58275a442e24a4296e7761207f85ebc97b1ba1", unrolled_ast = "3fad38aa2c6a90b03addfaafaa77e297b5dcd85dabb2aeb84dd1099851da35fb", ssa_ast = "5d00c591ec6cc9c8410abd786311f3c4d9a40e3ccbc58422e820f01f2ad7da42", flattened_ast = "48cd845d7a0f970175694d8171419760c6e1e20c6f521e773ce8d132a4adbfb4", destructured_ast = "609649da9d397778a7d181e688b41248e98808b9cf262b4df98ffe3c062eb624", inlined_ast = "609649da9d397778a7d181e688b41248e98808b9cf262b4df98ffe3c062eb624", dce_ast = "5429329ebf3774268f4f8a418a2b02055a11d24930080498c3408a00d2f0e3d8", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "86a0d996309dda9eb9d5d8d1dd58275a442e24a4296e7761207f85ebc97b1ba1", unrolled_ast = "153f96fcbc0c0f45415da3085c406640815c852ad327c76d6e8d8fe3af9f2d09", ssa_ast = "1d04b66f057e99f5076d7e6816b47577f1d7f3407f0797467ab557fceeff6c64", flattened_ast = "3bc8b99426e5a6d95490c818d6cff99a74cd3db9c70187a19e7be759895d864e", destructured_ast = "7ee7756805874849eb37d344a527371984f76ae13165f9cbc9ab33f75cc801fc", inlined_ast = "7ee7756805874849eb37d344a527371984f76ae13165f9cbc9ab33f75cc801fc", dce_ast = "cac2fe278c366bd9ddfc1281b9dd5058c61b5a68c398f1da2bbc8314d2e4d155", bytecode = """ program test.aleo; function fixed_iteration_interest: @@ -49,350 +49,300 @@ function bounded_iteration_interest: div r5 100u32 into r6; add r0 r6 into r7; ternary r4 r7 r0 into r8; - is.eq 0u8 40u8 into r9; - lt 1u8 r2 into r10; - mul r8 r1 into r11; - div r11 100u32 into r12; - add r8 r12 into r13; - ternary r10 r13 r8 into r14; - is.eq 1u8 40u8 into r15; - lt 2u8 r2 into r16; - mul r14 r1 into r17; - div r17 100u32 into r18; - add r14 r18 into r19; - ternary r16 r19 r14 into r20; - is.eq 2u8 40u8 into r21; - lt 3u8 r2 into r22; - mul r20 r1 into r23; - div r23 100u32 into r24; - add r20 r24 into r25; - ternary r22 r25 r20 into r26; - is.eq 3u8 40u8 into r27; - lt 4u8 r2 into r28; - mul r26 r1 into r29; - div r29 100u32 into r30; - add r26 r30 into r31; - ternary r28 r31 r26 into r32; - is.eq 4u8 40u8 into r33; - lt 5u8 r2 into r34; - mul r32 r1 into r35; + lt 1u8 r2 into r9; + mul r8 r1 into r10; + div r10 100u32 into r11; + add r8 r11 into r12; + ternary r9 r12 r8 into r13; + lt 2u8 r2 into r14; + mul r13 r1 into r15; + div r15 100u32 into r16; + add r13 r16 into r17; + ternary r14 r17 r13 into r18; + lt 3u8 r2 into r19; + mul r18 r1 into r20; + div r20 100u32 into r21; + add r18 r21 into r22; + ternary r19 r22 r18 into r23; + lt 4u8 r2 into r24; + mul r23 r1 into r25; + div r25 100u32 into r26; + add r23 r26 into r27; + ternary r24 r27 r23 into r28; + lt 5u8 r2 into r29; + mul r28 r1 into r30; + div r30 100u32 into r31; + add r28 r31 into r32; + ternary r29 r32 r28 into r33; + lt 6u8 r2 into r34; + mul r33 r1 into r35; div r35 100u32 into r36; - add r32 r36 into r37; - ternary r34 r37 r32 into r38; - is.eq 5u8 40u8 into r39; - lt 6u8 r2 into r40; - mul r38 r1 into r41; - div r41 100u32 into r42; - add r38 r42 into r43; - ternary r40 r43 r38 into r44; - is.eq 6u8 40u8 into r45; - lt 7u8 r2 into r46; - mul r44 r1 into r47; - div r47 100u32 into r48; - add r44 r48 into r49; - ternary r46 r49 r44 into r50; - is.eq 7u8 40u8 into r51; - lt 8u8 r2 into r52; - mul r50 r1 into r53; - div r53 100u32 into r54; - add r50 r54 into r55; - ternary r52 r55 r50 into r56; - is.eq 8u8 40u8 into r57; - lt 9u8 r2 into r58; - mul r56 r1 into r59; - div r59 100u32 into r60; - add r56 r60 into r61; - ternary r58 r61 r56 into r62; - is.eq 9u8 40u8 into r63; - lt 10u8 r2 into r64; - mul r62 r1 into r65; + add r33 r36 into r37; + ternary r34 r37 r33 into r38; + lt 7u8 r2 into r39; + mul r38 r1 into r40; + div r40 100u32 into r41; + add r38 r41 into r42; + ternary r39 r42 r38 into r43; + lt 8u8 r2 into r44; + mul r43 r1 into r45; + div r45 100u32 into r46; + add r43 r46 into r47; + ternary r44 r47 r43 into r48; + lt 9u8 r2 into r49; + mul r48 r1 into r50; + div r50 100u32 into r51; + add r48 r51 into r52; + ternary r49 r52 r48 into r53; + lt 10u8 r2 into r54; + mul r53 r1 into r55; + div r55 100u32 into r56; + add r53 r56 into r57; + ternary r54 r57 r53 into r58; + lt 11u8 r2 into r59; + mul r58 r1 into r60; + div r60 100u32 into r61; + add r58 r61 into r62; + ternary r59 r62 r58 into r63; + lt 12u8 r2 into r64; + mul r63 r1 into r65; div r65 100u32 into r66; - add r62 r66 into r67; - ternary r64 r67 r62 into r68; - is.eq 10u8 40u8 into r69; - lt 11u8 r2 into r70; - mul r68 r1 into r71; - div r71 100u32 into r72; - add r68 r72 into r73; - ternary r70 r73 r68 into r74; - is.eq 11u8 40u8 into r75; - lt 12u8 r2 into r76; - mul r74 r1 into r77; - div r77 100u32 into r78; - add r74 r78 into r79; - ternary r76 r79 r74 into r80; - is.eq 12u8 40u8 into r81; - lt 13u8 r2 into r82; - mul r80 r1 into r83; - div r83 100u32 into r84; - add r80 r84 into r85; - ternary r82 r85 r80 into r86; - is.eq 13u8 40u8 into r87; - lt 14u8 r2 into r88; - mul r86 r1 into r89; - div r89 100u32 into r90; - add r86 r90 into r91; - ternary r88 r91 r86 into r92; - is.eq 14u8 40u8 into r93; - lt 15u8 r2 into r94; - mul r92 r1 into r95; + add r63 r66 into r67; + ternary r64 r67 r63 into r68; + lt 13u8 r2 into r69; + mul r68 r1 into r70; + div r70 100u32 into r71; + add r68 r71 into r72; + ternary r69 r72 r68 into r73; + lt 14u8 r2 into r74; + mul r73 r1 into r75; + div r75 100u32 into r76; + add r73 r76 into r77; + ternary r74 r77 r73 into r78; + lt 15u8 r2 into r79; + mul r78 r1 into r80; + div r80 100u32 into r81; + add r78 r81 into r82; + ternary r79 r82 r78 into r83; + lt 16u8 r2 into r84; + mul r83 r1 into r85; + div r85 100u32 into r86; + add r83 r86 into r87; + ternary r84 r87 r83 into r88; + lt 17u8 r2 into r89; + mul r88 r1 into r90; + div r90 100u32 into r91; + add r88 r91 into r92; + ternary r89 r92 r88 into r93; + lt 18u8 r2 into r94; + mul r93 r1 into r95; div r95 100u32 into r96; - add r92 r96 into r97; - ternary r94 r97 r92 into r98; - is.eq 15u8 40u8 into r99; - lt 16u8 r2 into r100; - mul r98 r1 into r101; - div r101 100u32 into r102; - add r98 r102 into r103; - ternary r100 r103 r98 into r104; - is.eq 16u8 40u8 into r105; - lt 17u8 r2 into r106; - mul r104 r1 into r107; - div r107 100u32 into r108; - add r104 r108 into r109; - ternary r106 r109 r104 into r110; - is.eq 17u8 40u8 into r111; - lt 18u8 r2 into r112; - mul r110 r1 into r113; - div r113 100u32 into r114; - add r110 r114 into r115; - ternary r112 r115 r110 into r116; - is.eq 18u8 40u8 into r117; - lt 19u8 r2 into r118; - mul r116 r1 into r119; - div r119 100u32 into r120; - add r116 r120 into r121; - ternary r118 r121 r116 into r122; - is.eq 19u8 40u8 into r123; - lt 20u8 r2 into r124; - mul r122 r1 into r125; + add r93 r96 into r97; + ternary r94 r97 r93 into r98; + lt 19u8 r2 into r99; + mul r98 r1 into r100; + div r100 100u32 into r101; + add r98 r101 into r102; + ternary r99 r102 r98 into r103; + lt 20u8 r2 into r104; + mul r103 r1 into r105; + div r105 100u32 into r106; + add r103 r106 into r107; + ternary r104 r107 r103 into r108; + lt 21u8 r2 into r109; + mul r108 r1 into r110; + div r110 100u32 into r111; + add r108 r111 into r112; + ternary r109 r112 r108 into r113; + lt 22u8 r2 into r114; + mul r113 r1 into r115; + div r115 100u32 into r116; + add r113 r116 into r117; + ternary r114 r117 r113 into r118; + lt 23u8 r2 into r119; + mul r118 r1 into r120; + div r120 100u32 into r121; + add r118 r121 into r122; + ternary r119 r122 r118 into r123; + lt 24u8 r2 into r124; + mul r123 r1 into r125; div r125 100u32 into r126; - add r122 r126 into r127; - ternary r124 r127 r122 into r128; - is.eq 20u8 40u8 into r129; - lt 21u8 r2 into r130; - mul r128 r1 into r131; - div r131 100u32 into r132; - add r128 r132 into r133; - ternary r130 r133 r128 into r134; - is.eq 21u8 40u8 into r135; - lt 22u8 r2 into r136; - mul r134 r1 into r137; - div r137 100u32 into r138; - add r134 r138 into r139; - ternary r136 r139 r134 into r140; - is.eq 22u8 40u8 into r141; - lt 23u8 r2 into r142; - mul r140 r1 into r143; - div r143 100u32 into r144; - add r140 r144 into r145; - ternary r142 r145 r140 into r146; - is.eq 23u8 40u8 into r147; - lt 24u8 r2 into r148; - mul r146 r1 into r149; - div r149 100u32 into r150; - add r146 r150 into r151; - ternary r148 r151 r146 into r152; - is.eq 24u8 40u8 into r153; - lt 25u8 r2 into r154; - mul r152 r1 into r155; + add r123 r126 into r127; + ternary r124 r127 r123 into r128; + lt 25u8 r2 into r129; + mul r128 r1 into r130; + div r130 100u32 into r131; + add r128 r131 into r132; + ternary r129 r132 r128 into r133; + lt 26u8 r2 into r134; + mul r133 r1 into r135; + div r135 100u32 into r136; + add r133 r136 into r137; + ternary r134 r137 r133 into r138; + lt 27u8 r2 into r139; + mul r138 r1 into r140; + div r140 100u32 into r141; + add r138 r141 into r142; + ternary r139 r142 r138 into r143; + lt 28u8 r2 into r144; + mul r143 r1 into r145; + div r145 100u32 into r146; + add r143 r146 into r147; + ternary r144 r147 r143 into r148; + lt 29u8 r2 into r149; + mul r148 r1 into r150; + div r150 100u32 into r151; + add r148 r151 into r152; + ternary r149 r152 r148 into r153; + lt 30u8 r2 into r154; + mul r153 r1 into r155; div r155 100u32 into r156; - add r152 r156 into r157; - ternary r154 r157 r152 into r158; - is.eq 25u8 40u8 into r159; - lt 26u8 r2 into r160; - mul r158 r1 into r161; - div r161 100u32 into r162; - add r158 r162 into r163; - ternary r160 r163 r158 into r164; - is.eq 26u8 40u8 into r165; - lt 27u8 r2 into r166; - mul r164 r1 into r167; - div r167 100u32 into r168; - add r164 r168 into r169; - ternary r166 r169 r164 into r170; - is.eq 27u8 40u8 into r171; - lt 28u8 r2 into r172; - mul r170 r1 into r173; - div r173 100u32 into r174; - add r170 r174 into r175; - ternary r172 r175 r170 into r176; - is.eq 28u8 40u8 into r177; - lt 29u8 r2 into r178; - mul r176 r1 into r179; - div r179 100u32 into r180; - add r176 r180 into r181; - ternary r178 r181 r176 into r182; - is.eq 29u8 40u8 into r183; - lt 30u8 r2 into r184; - mul r182 r1 into r185; + add r153 r156 into r157; + ternary r154 r157 r153 into r158; + lt 31u8 r2 into r159; + mul r158 r1 into r160; + div r160 100u32 into r161; + add r158 r161 into r162; + ternary r159 r162 r158 into r163; + lt 32u8 r2 into r164; + mul r163 r1 into r165; + div r165 100u32 into r166; + add r163 r166 into r167; + ternary r164 r167 r163 into r168; + lt 33u8 r2 into r169; + mul r168 r1 into r170; + div r170 100u32 into r171; + add r168 r171 into r172; + ternary r169 r172 r168 into r173; + lt 34u8 r2 into r174; + mul r173 r1 into r175; + div r175 100u32 into r176; + add r173 r176 into r177; + ternary r174 r177 r173 into r178; + lt 35u8 r2 into r179; + mul r178 r1 into r180; + div r180 100u32 into r181; + add r178 r181 into r182; + ternary r179 r182 r178 into r183; + lt 36u8 r2 into r184; + mul r183 r1 into r185; div r185 100u32 into r186; - add r182 r186 into r187; - ternary r184 r187 r182 into r188; - is.eq 30u8 40u8 into r189; - lt 31u8 r2 into r190; - mul r188 r1 into r191; - div r191 100u32 into r192; - add r188 r192 into r193; - ternary r190 r193 r188 into r194; - is.eq 31u8 40u8 into r195; - lt 32u8 r2 into r196; - mul r194 r1 into r197; - div r197 100u32 into r198; - add r194 r198 into r199; - ternary r196 r199 r194 into r200; - is.eq 32u8 40u8 into r201; - lt 33u8 r2 into r202; - mul r200 r1 into r203; - div r203 100u32 into r204; - add r200 r204 into r205; - ternary r202 r205 r200 into r206; - is.eq 33u8 40u8 into r207; - lt 34u8 r2 into r208; - mul r206 r1 into r209; - div r209 100u32 into r210; - add r206 r210 into r211; - ternary r208 r211 r206 into r212; - is.eq 34u8 40u8 into r213; - lt 35u8 r2 into r214; - mul r212 r1 into r215; + add r183 r186 into r187; + ternary r184 r187 r183 into r188; + lt 37u8 r2 into r189; + mul r188 r1 into r190; + div r190 100u32 into r191; + add r188 r191 into r192; + ternary r189 r192 r188 into r193; + lt 38u8 r2 into r194; + mul r193 r1 into r195; + div r195 100u32 into r196; + add r193 r196 into r197; + ternary r194 r197 r193 into r198; + lt 39u8 r2 into r199; + mul r198 r1 into r200; + div r200 100u32 into r201; + add r198 r201 into r202; + ternary r199 r202 r198 into r203; + lt 40u8 r2 into r204; + mul r203 r1 into r205; + div r205 100u32 into r206; + add r203 r206 into r207; + ternary r204 r207 r203 into r208; + lt 41u8 r2 into r209; + mul r208 r1 into r210; + div r210 100u32 into r211; + add r208 r211 into r212; + ternary r209 r212 r208 into r213; + lt 42u8 r2 into r214; + mul r213 r1 into r215; div r215 100u32 into r216; - add r212 r216 into r217; - ternary r214 r217 r212 into r218; - is.eq 35u8 40u8 into r219; - lt 36u8 r2 into r220; - mul r218 r1 into r221; - div r221 100u32 into r222; - add r218 r222 into r223; - ternary r220 r223 r218 into r224; - is.eq 36u8 40u8 into r225; - lt 37u8 r2 into r226; - mul r224 r1 into r227; - div r227 100u32 into r228; - add r224 r228 into r229; - ternary r226 r229 r224 into r230; - is.eq 37u8 40u8 into r231; - lt 38u8 r2 into r232; - mul r230 r1 into r233; - div r233 100u32 into r234; - add r230 r234 into r235; - ternary r232 r235 r230 into r236; - is.eq 38u8 40u8 into r237; - lt 39u8 r2 into r238; - mul r236 r1 into r239; - div r239 100u32 into r240; - add r236 r240 into r241; - ternary r238 r241 r236 into r242; - is.eq 39u8 40u8 into r243; - lt 40u8 r2 into r244; - mul r242 r1 into r245; + add r213 r216 into r217; + ternary r214 r217 r213 into r218; + lt 43u8 r2 into r219; + mul r218 r1 into r220; + div r220 100u32 into r221; + add r218 r221 into r222; + ternary r219 r222 r218 into r223; + lt 44u8 r2 into r224; + mul r223 r1 into r225; + div r225 100u32 into r226; + add r223 r226 into r227; + ternary r224 r227 r223 into r228; + lt 45u8 r2 into r229; + mul r228 r1 into r230; + div r230 100u32 into r231; + add r228 r231 into r232; + ternary r229 r232 r228 into r233; + lt 46u8 r2 into r234; + mul r233 r1 into r235; + div r235 100u32 into r236; + add r233 r236 into r237; + ternary r234 r237 r233 into r238; + lt 47u8 r2 into r239; + mul r238 r1 into r240; + div r240 100u32 into r241; + add r238 r241 into r242; + ternary r239 r242 r238 into r243; + lt 48u8 r2 into r244; + mul r243 r1 into r245; div r245 100u32 into r246; - add r242 r246 into r247; - ternary r244 r247 r242 into r248; - is.eq 40u8 40u8 into r249; - lt 41u8 r2 into r250; - mul r248 r1 into r251; - div r251 100u32 into r252; - add r248 r252 into r253; - ternary r250 r253 r248 into r254; - is.eq 41u8 40u8 into r255; - lt 42u8 r2 into r256; - mul r254 r1 into r257; - div r257 100u32 into r258; - add r254 r258 into r259; - ternary r256 r259 r254 into r260; - is.eq 42u8 40u8 into r261; - lt 43u8 r2 into r262; - mul r260 r1 into r263; - div r263 100u32 into r264; - add r260 r264 into r265; - ternary r262 r265 r260 into r266; - is.eq 43u8 40u8 into r267; - lt 44u8 r2 into r268; - mul r266 r1 into r269; - div r269 100u32 into r270; - add r266 r270 into r271; - ternary r268 r271 r266 into r272; - is.eq 44u8 40u8 into r273; - lt 45u8 r2 into r274; - mul r272 r1 into r275; - div r275 100u32 into r276; - add r272 r276 into r277; - ternary r274 r277 r272 into r278; - is.eq 45u8 40u8 into r279; - lt 46u8 r2 into r280; - mul r278 r1 into r281; - div r281 100u32 into r282; - add r278 r282 into r283; - ternary r280 r283 r278 into r284; - is.eq 46u8 40u8 into r285; - lt 47u8 r2 into r286; - mul r284 r1 into r287; - div r287 100u32 into r288; - add r284 r288 into r289; - ternary r286 r289 r284 into r290; - is.eq 47u8 40u8 into r291; - lt 48u8 r2 into r292; - mul r290 r1 into r293; - div r293 100u32 into r294; - add r290 r294 into r295; - ternary r292 r295 r290 into r296; - is.eq 48u8 40u8 into r297; - lt 49u8 r2 into r298; - mul r296 r1 into r299; - div r299 100u32 into r300; - add r296 r300 into r301; - ternary r298 r301 r296 into r302; - is.eq 49u8 40u8 into r303; - ternary r303 r302 r302 into r304; - ternary r297 r296 r304 into r305; - ternary r291 r290 r305 into r306; - ternary r285 r284 r306 into r307; - ternary r279 r278 r307 into r308; - ternary r273 r272 r308 into r309; - ternary r267 r266 r309 into r310; - ternary r261 r260 r310 into r311; - ternary r255 r254 r311 into r312; - ternary r249 r248 r312 into r313; - ternary r243 r242 r313 into r314; - ternary r237 r236 r314 into r315; - ternary r231 r230 r315 into r316; - ternary r225 r224 r316 into r317; - ternary r219 r218 r317 into r318; - ternary r213 r212 r318 into r319; - ternary r207 r206 r319 into r320; - ternary r201 r200 r320 into r321; - ternary r195 r194 r321 into r322; - ternary r189 r188 r322 into r323; - ternary r183 r182 r323 into r324; - ternary r177 r176 r324 into r325; - ternary r171 r170 r325 into r326; - ternary r165 r164 r326 into r327; - ternary r159 r158 r327 into r328; - ternary r153 r152 r328 into r329; - ternary r147 r146 r329 into r330; - ternary r141 r140 r330 into r331; - ternary r135 r134 r331 into r332; - ternary r129 r128 r332 into r333; - ternary r123 r122 r333 into r334; - ternary r117 r116 r334 into r335; - ternary r111 r110 r335 into r336; - ternary r105 r104 r336 into r337; - ternary r99 r98 r337 into r338; - ternary r93 r92 r338 into r339; - ternary r87 r86 r339 into r340; - ternary r81 r80 r340 into r341; - ternary r75 r74 r341 into r342; - ternary r69 r68 r342 into r343; - ternary r63 r62 r343 into r344; - ternary r57 r56 r344 into r345; - ternary r51 r50 r345 into r346; - ternary r45 r44 r346 into r347; - ternary r39 r38 r347 into r348; - ternary r33 r32 r348 into r349; - ternary r27 r26 r349 into r350; - ternary r21 r20 r350 into r351; - ternary r15 r14 r351 into r352; - ternary r9 r8 r352 into r353; - output r353 as u32.private; + add r243 r246 into r247; + ternary r244 r247 r243 into r248; + lt 49u8 r2 into r249; + mul r248 r1 into r250; + div r250 100u32 into r251; + add r248 r251 into r252; + ternary r249 r252 r248 into r253; + ternary false r253 r253 into r254; + ternary false r248 r254 into r255; + ternary false r243 r255 into r256; + ternary false r238 r256 into r257; + ternary false r233 r257 into r258; + ternary false r228 r258 into r259; + ternary false r223 r259 into r260; + ternary false r218 r260 into r261; + ternary false r213 r261 into r262; + ternary true r208 r262 into r263; + ternary false r203 r263 into r264; + ternary false r198 r264 into r265; + ternary false r193 r265 into r266; + ternary false r188 r266 into r267; + ternary false r183 r267 into r268; + ternary false r178 r268 into r269; + ternary false r173 r269 into r270; + ternary false r168 r270 into r271; + ternary false r163 r271 into r272; + ternary false r158 r272 into r273; + ternary false r153 r273 into r274; + ternary false r148 r274 into r275; + ternary false r143 r275 into r276; + ternary false r138 r276 into r277; + ternary false r133 r277 into r278; + ternary false r128 r278 into r279; + ternary false r123 r279 into r280; + ternary false r118 r280 into r281; + ternary false r113 r281 into r282; + ternary false r108 r282 into r283; + ternary false r103 r283 into r284; + ternary false r98 r284 into r285; + ternary false r93 r285 into r286; + ternary false r88 r286 into r287; + ternary false r83 r287 into r288; + ternary false r78 r288 into r289; + ternary false r73 r289 into r290; + ternary false r68 r290 into r291; + ternary false r63 r291 into r292; + ternary false r58 r292 into r293; + ternary false r53 r293 into r294; + ternary false r48 r294 into r295; + ternary false r43 r295 into r296; + ternary false r38 r296 into r297; + ternary false r33 r297 into r298; + ternary false r28 r298 into r299; + ternary false r23 r299 into r300; + ternary false r18 r300 into r301; + ternary false r13 r301 into r302; + ternary false r8 r302 into r303; + output r303 as u32.private; """, errors = "", warnings = "" }] }]] diff --git a/tests/expectations/compiler/examples/ntzloops.out b/tests/expectations/compiler/examples/ntzloops.out index cc47e98192..01c42585c0 100644 --- a/tests/expectations/compiler/examples/ntzloops.out +++ b/tests/expectations/compiler/examples/ntzloops.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "fddba4f56016625454f5d5da3fa81487ea9b30358b35269f8bf700976590cfb9", unrolled_ast = "32d30829fe994d8c56da79be82a9bb9089f355ae96a974d7a33f36d52fc8938c", ssa_ast = "9deba5759fab37d54fafccb68ea6fb6adefddfe6c67ac31d7a5896f7cbe926c8", flattened_ast = "5b5968f827acf8676c9f05647ca42a3d4dc6365d1085bd75cecaa80beced8c37", destructured_ast = "23f45540faf8ef2c2bb55c947467d6b1292a9169cddc3cb4daac4db8a84d0dd0", inlined_ast = "23f45540faf8ef2c2bb55c947467d6b1292a9169cddc3cb4daac4db8a84d0dd0", dce_ast = "2e6dffb270489b83cccccf61c112c5aca5c20517604863d10a6303047b0c6ea4", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "fddba4f56016625454f5d5da3fa81487ea9b30358b35269f8bf700976590cfb9", unrolled_ast = "7836b25daf715713e524bae5b97f386467a56800e9cf2c1bf82fb8b325bf0453", ssa_ast = "4722f28fe8337f0caffc634cfb981611b3faed19ce7ee7111cc5d277cab4b6a6", flattened_ast = "fd044d9bb1d58a268f7bcb4224e4c77b709fe2a0263b28c840038ad7baf4e171", destructured_ast = "a2e4de10850323722717fbffc555c0b88bb23e74fdc94edfdc0215c6b8b5f6e8", inlined_ast = "a2e4de10850323722717fbffc555c0b88bb23e74fdc94edfdc0215c6b8b5f6e8", dce_ast = "f502188e6c59fe28b5d0176b4a620ac983706a16e74eebdc323bbd815e644cea", bytecode = """ program test.aleo; function main: diff --git a/tests/expectations/compiler/examples/ntzsearchtree.out b/tests/expectations/compiler/examples/ntzsearchtree.out index e8d393d7c7..7304823b2c 100644 --- a/tests/expectations/compiler/examples/ntzsearchtree.out +++ b/tests/expectations/compiler/examples/ntzsearchtree.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "22e5ae5968afbbe73a278a85fbbe7839c91f8a6ae8b2a2ebc47b0f7c27b7b32c", unrolled_ast = "22e5ae5968afbbe73a278a85fbbe7839c91f8a6ae8b2a2ebc47b0f7c27b7b32c", ssa_ast = "1d4d764ebef58dd5f4ffa0fec746dc14ac6511394399d099ef901774cb23e687", flattened_ast = "22bf54b3fd741c5d4c7c41f0f029e3c5e3fe476dcb7a69b7f96e891a94cd7ab8", destructured_ast = "c8340275d74390e77c3fc70512a9cafaa704b2a9a05d3163e8617bc601e50026", inlined_ast = "c8340275d74390e77c3fc70512a9cafaa704b2a9a05d3163e8617bc601e50026", dce_ast = "6afbd919c00857be865c40edd9079d02dd02d7051f568bfe45d1baccfc4b4bf7", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "22e5ae5968afbbe73a278a85fbbe7839c91f8a6ae8b2a2ebc47b0f7c27b7b32c", unrolled_ast = "d5df0b6698433a199efdf2ad61f3acb9e9fc5ed9e25e2919b68466369d7b0921", ssa_ast = "f0e5aa5152676afacef28c77dec3e7360d19aa8b61192b13a6f22f3ce369a060", flattened_ast = "7c61564221aac1eb77c18f5c668750b07331386e961dec98598d57bb66d92910", destructured_ast = "272f6715fa323c113226d14fa02b163f25cf82335912a389d7807064eb90d70a", inlined_ast = "272f6715fa323c113226d14fa02b163f25cf82335912a389d7807064eb90d70a", dce_ast = "00ed940bf82e4c317136be3a889e7aaa00ed071a6a3d405a25a74ab5bb59833c", bytecode = """ program test.aleo; function main: @@ -83,129 +83,114 @@ function main: not r73 into r76; and r74 r76 into r77; not r2 into r78; - mul 255u32 65536u32 into r79; - and r0 r79 into r80; - is.neq r80 0u32 into r81; - mul 15u32 65536u32 into r82; - and r0 r82 into r83; + and r0 16711680u32 into r79; + is.neq r79 0u32 into r80; + and r0 983040u32 into r81; + is.neq r81 0u32 into r82; + and r0 196608u32 into r83; is.neq r83 0u32 into r84; - mul 3u32 65536u32 into r85; - and r0 r85 into r86; - is.neq r86 0u32 into r87; - mul 1u32 65536u32 into r88; - and r0 r88 into r89; - is.neq r89 0u32 into r90; - and r78 r81 into r91; - and r91 r84 into r92; - and r92 r87 into r93; - and r93 r90 into r94; - not r90 into r95; - and r93 r95 into r96; - not r87 into r97; - mul 4u32 65536u32 into r98; - and r0 r98 into r99; - is.neq r99 0u32 into r100; - and r92 r97 into r101; - and r101 r100 into r102; - not r100 into r103; - and r101 r103 into r104; - not r84 into r105; - mul 48u32 65536u32 into r106; - and r0 r106 into r107; - is.neq r107 0u32 into r108; - mul 16u32 65536u32 into r109; - and r0 r109 into r110; - is.neq r110 0u32 into r111; - and r91 r105 into r112; - and r112 r108 into r113; - and r113 r111 into r114; - not r111 into r115; + and r0 65536u32 into r85; + is.neq r85 0u32 into r86; + and r78 r80 into r87; + and r87 r82 into r88; + and r88 r84 into r89; + and r89 r86 into r90; + not r86 into r91; + and r89 r91 into r92; + not r84 into r93; + and r0 262144u32 into r94; + is.neq r94 0u32 into r95; + and r88 r93 into r96; + and r96 r95 into r97; + not r95 into r98; + and r96 r98 into r99; + not r82 into r100; + and r0 3145728u32 into r101; + is.neq r101 0u32 into r102; + and r0 1048576u32 into r103; + is.neq r103 0u32 into r104; + and r87 r100 into r105; + and r105 r102 into r106; + and r106 r104 into r107; + not r104 into r108; + and r106 r108 into r109; + not r102 into r110; + and r0 4194304u32 into r111; + is.neq r111 0u32 into r112; + and r105 r110 into r113; + and r113 r112 into r114; + not r112 into r115; and r113 r115 into r116; - not r108 into r117; - mul 64u32 65536u32 into r118; - and r0 r118 into r119; - is.neq r119 0u32 into r120; - and r112 r117 into r121; - and r121 r120 into r122; - not r120 into r123; - and r121 r123 into r124; - not r81 into r125; - mul 3840u32 65536u32 into r126; - and r0 r126 into r127; - is.neq r127 0u32 into r128; - mul 768u32 65536u32 into r129; - and r0 r129 into r130; - is.neq r130 0u32 into r131; - mul 256u32 65536u32 into r132; - and r0 r132 into r133; - is.neq r133 0u32 into r134; - and r78 r125 into r135; - and r135 r128 into r136; - and r136 r131 into r137; - and r137 r134 into r138; - not r134 into r139; - and r137 r139 into r140; - not r131 into r141; - mul 1024u32 65536u32 into r142; - and r0 r142 into r143; - is.neq r143 0u32 into r144; - and r136 r141 into r145; - and r145 r144 into r146; - not r144 into r147; - and r145 r147 into r148; - not r128 into r149; - mul 12288u32 65536u32 into r150; - and r0 r150 into r151; - is.neq r151 0u32 into r152; - mul 4096u32 65536u32 into r153; - and r0 r153 into r154; - is.neq r154 0u32 into r155; - and r135 r149 into r156; - and r156 r152 into r157; - and r157 r155 into r158; - not r155 into r159; - and r157 r159 into r160; - not r152 into r161; - mul 16384u32 65536u32 into r162; - and r0 r162 into r163; - is.neq r163 0u32 into r164; - and r156 r161 into r165; - and r165 r164 into r166; - not r164 into r167; - is.neq r0 0u32 into r168; - and r165 r167 into r169; - and r169 r168 into r170; - ternary r170 31u8 32u8 into r171; - ternary r166 30u8 r171 into r172; - ternary r160 29u8 r172 into r173; - ternary r158 28u8 r173 into r174; - ternary r148 27u8 r174 into r175; - ternary r146 26u8 r175 into r176; - ternary r140 25u8 r176 into r177; - ternary r138 24u8 r177 into r178; - ternary r124 23u8 r178 into r179; - ternary r122 22u8 r179 into r180; - ternary r116 21u8 r180 into r181; - ternary r114 20u8 r181 into r182; - ternary r104 19u8 r182 into r183; - ternary r102 18u8 r183 into r184; - ternary r96 17u8 r184 into r185; - ternary r94 16u8 r185 into r186; - ternary r77 15u8 r186 into r187; - ternary r75 14u8 r187 into r188; - ternary r70 13u8 r188 into r189; - ternary r68 12u8 r189 into r190; - ternary r60 11u8 r190 into r191; - ternary r58 10u8 r191 into r192; - ternary r53 9u8 r192 into r193; - ternary r51 8u8 r193 into r194; - ternary r40 7u8 r194 into r195; - ternary r38 6u8 r195 into r196; - ternary r33 5u8 r196 into r197; - ternary r31 4u8 r197 into r198; - ternary r23 3u8 r198 into r199; - ternary r21 2u8 r199 into r200; - ternary r16 1u8 r200 into r201; - ternary r14 0u8 r201 into r202; - output r202 as u8.private; + not r80 into r117; + and r0 251658240u32 into r118; + is.neq r118 0u32 into r119; + and r0 50331648u32 into r120; + is.neq r120 0u32 into r121; + and r0 16777216u32 into r122; + is.neq r122 0u32 into r123; + and r78 r117 into r124; + and r124 r119 into r125; + and r125 r121 into r126; + and r126 r123 into r127; + not r123 into r128; + and r126 r128 into r129; + not r121 into r130; + and r0 67108864u32 into r131; + is.neq r131 0u32 into r132; + and r125 r130 into r133; + and r133 r132 into r134; + not r132 into r135; + and r133 r135 into r136; + not r119 into r137; + and r0 805306368u32 into r138; + is.neq r138 0u32 into r139; + and r0 268435456u32 into r140; + is.neq r140 0u32 into r141; + and r124 r137 into r142; + and r142 r139 into r143; + and r143 r141 into r144; + not r141 into r145; + and r143 r145 into r146; + not r139 into r147; + and r0 1073741824u32 into r148; + is.neq r148 0u32 into r149; + and r142 r147 into r150; + and r150 r149 into r151; + not r149 into r152; + is.neq r0 0u32 into r153; + and r150 r152 into r154; + and r154 r153 into r155; + ternary r155 31u8 32u8 into r156; + ternary r151 30u8 r156 into r157; + ternary r146 29u8 r157 into r158; + ternary r144 28u8 r158 into r159; + ternary r136 27u8 r159 into r160; + ternary r134 26u8 r160 into r161; + ternary r129 25u8 r161 into r162; + ternary r127 24u8 r162 into r163; + ternary r116 23u8 r163 into r164; + ternary r114 22u8 r164 into r165; + ternary r109 21u8 r165 into r166; + ternary r107 20u8 r166 into r167; + ternary r99 19u8 r167 into r168; + ternary r97 18u8 r168 into r169; + ternary r92 17u8 r169 into r170; + ternary r90 16u8 r170 into r171; + ternary r77 15u8 r171 into r172; + ternary r75 14u8 r172 into r173; + ternary r70 13u8 r173 into r174; + ternary r68 12u8 r174 into r175; + ternary r60 11u8 r175 into r176; + ternary r58 10u8 r176 into r177; + ternary r53 9u8 r177 into r178; + ternary r51 8u8 r178 into r179; + ternary r40 7u8 r179 into r180; + ternary r38 6u8 r180 into r181; + ternary r33 5u8 r181 into r182; + ternary r31 4u8 r182 into r183; + ternary r23 3u8 r183 into r184; + ternary r21 2u8 r184 into r185; + ternary r16 1u8 r185 into r186; + ternary r14 0u8 r186 into r187; + output r187 as u8.private; """, errors = "", warnings = "" }] }]] diff --git a/tests/expectations/compiler/examples/twoadicity.out b/tests/expectations/compiler/examples/twoadicity.out index 9d394d7809..e52c7bc39b 100644 --- a/tests/expectations/compiler/examples/twoadicity.out +++ b/tests/expectations/compiler/examples/twoadicity.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "47423bb725b42e8571e55829ae6784b52be84366628d4ac08716969cabca10ac", unrolled_ast = "70e629040be1a81079a5111b18220dc573fbb48d2822dec1786bfc2cf233080c", ssa_ast = "54cf08a0933dc4428e5cfd32e9d6716c4709151ac22b80a4da91d76e18822de3", flattened_ast = "ab730f4b6f8612a1283351d6e82056e7cdb07dbaf3c457b21d6edc82ea49a4c2", destructured_ast = "3199233a6f38eeafa455ff4e2807c6f4cb748abb95ded7b31702c1773b55a36f", inlined_ast = "7fbbea586430342abb901a566c9d7bd8283941b1519d0e84b0a36f2587cdf8c2", dce_ast = "6e5a3559ef076ca312df2b24c2e79fffd42a8f2bdaa431f259e701ea3ad2dd3e", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "47423bb725b42e8571e55829ae6784b52be84366628d4ac08716969cabca10ac", unrolled_ast = "831712a5291c978be4c8eae3631b08ad6efba79d1ebfeccf7bf0ca7181077f59", ssa_ast = "8dfed7103c10bb68184eedc20b7049a09cf941f7eea7403fa26719c431b7b434", flattened_ast = "e5b3f146cf74d360f0e4994d1debb8f5986e1494f515c2de3ea3fcdc8daf1a08", destructured_ast = "5c41c9a1c15a824a3ce66737793043403e744c5e407727b824141be69bdbc930", inlined_ast = "3fe47fa9b33ca03098f08fdee1c46407a1cc6575a66145f66c43da58da58da54", dce_ast = "8d1b7dd86ffec35ee5717223a55ca8f5e8f858a410d4b597e1d2a1c5a682087a", bytecode = """ program test.aleo; closure is_even_and_nonzero: diff --git a/tests/expectations/compiler/field/field.out b/tests/expectations/compiler/field/field.out index b530c6dce3..0ffc6cd9cd 100644 --- a/tests/expectations/compiler/field/field.out +++ b/tests/expectations/compiler/field/field.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "20224c51976c8d3f67c4ebdc5d68b7efefe6040aaee1f5049f8954ffa615bcfb", unrolled_ast = "20224c51976c8d3f67c4ebdc5d68b7efefe6040aaee1f5049f8954ffa615bcfb", ssa_ast = "ba10dad2c5d3b06b4228a01b1e6e634606497f77fcdc4b206c737df1f5be52b2", flattened_ast = "e04ab7960e4ae652ef3e4975ad3cd88d42982d444d09eee123ad11bbdf9b146f", destructured_ast = "9e41181621ba11f59a99eb5bc39bf4263cbee376e9497f00e10328ea2881a27e", inlined_ast = "9e41181621ba11f59a99eb5bc39bf4263cbee376e9497f00e10328ea2881a27e", dce_ast = "2e8804c04d07e872cacff71b9a8200c2300aeebe3bc8eeae67a71165518262ed", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "20224c51976c8d3f67c4ebdc5d68b7efefe6040aaee1f5049f8954ffa615bcfb", unrolled_ast = "476f0c9fedb472a591e19dbbb7c2c6836d9588a9a84f354fdc34fa4dfcbcfde7", ssa_ast = "c459026078c6f684154949c187670b96a0b8515eece696fef5b3e6b06e8bc3a2", flattened_ast = "0b95ce9d1364e40be2d7348ae02d5b749a1ccf7f97ee7c69bfaf65e6ea7da630", destructured_ast = "1cf615d09c64773968d57d00a953fcbf48df9d694302070eff1caacb8facf000", inlined_ast = "1cf615d09c64773968d57d00a953fcbf48df9d694302070eff1caacb8facf000", dce_ast = "d72b5c4422655b486c0d70b85db8e3fa9b2cad7cfeb4a66374a80f67c7d645c8", bytecode = """ program test.aleo; function main: diff --git a/tests/expectations/compiler/function/helper_function_with_interface.out b/tests/expectations/compiler/function/helper_function_with_interface.out index 9d439d404c..53e2207ad1 100644 --- a/tests/expectations/compiler/function/helper_function_with_interface.out +++ b/tests/expectations/compiler/function/helper_function_with_interface.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "aa4a1a0f9e75a5b4b8af1232b601a8901b54421c041d5745df979cb9e668e18c", unrolled_ast = "aa4a1a0f9e75a5b4b8af1232b601a8901b54421c041d5745df979cb9e668e18c", ssa_ast = "1010eb033d528e2c47d8f0f815ab72366470696d8be0597b8134fee5d3f20967", flattened_ast = "a3d6e47fd24d2de910f133f9f10b6059d231a61244d5ac24508c7b21df083283", destructured_ast = "50e3a564e7551ffa6f7c6eb6866dfc556a0dfaeb1b60ba7588d476b652ca4ffd", inlined_ast = "50e3a564e7551ffa6f7c6eb6866dfc556a0dfaeb1b60ba7588d476b652ca4ffd", dce_ast = "50e3a564e7551ffa6f7c6eb6866dfc556a0dfaeb1b60ba7588d476b652ca4ffd", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "aa4a1a0f9e75a5b4b8af1232b601a8901b54421c041d5745df979cb9e668e18c", unrolled_ast = "2b192cc806585ee29c96682a51968a21d90b252e39f2356b0853c096a562c69c", ssa_ast = "81851ac38a2b0a211459f9437788b71da5ae414c3395970238988d3078194bb1", flattened_ast = "0cd789febe780d49d7d86b41784497252eaabcb10dfba7c644726b25f9a5a195", destructured_ast = "1306d11f7c6b8fc2c0b5efc41e0baaa183950f4163ad9ca96b29b2e176cf1cf2", inlined_ast = "1306d11f7c6b8fc2c0b5efc41e0baaa183950f4163ad9ca96b29b2e176cf1cf2", dce_ast = "1306d11f7c6b8fc2c0b5efc41e0baaa183950f4163ad9ca96b29b2e176cf1cf2", bytecode = """ program test.aleo; struct Board: @@ -15,6 +15,6 @@ function main: closure win: input r0 as Board; input r1 as u8; - and false true into r2; - output r2 as boolean; + assert.eq true true; + output false as boolean; """, errors = "", warnings = "" }] }]] diff --git a/tests/expectations/compiler/function/program_function_any_number_of_inputs_and_outputs.out b/tests/expectations/compiler/function/program_function_any_number_of_inputs_and_outputs.out index 44117c0796..121f5ab12f 100644 --- a/tests/expectations/compiler/function/program_function_any_number_of_inputs_and_outputs.out +++ b/tests/expectations/compiler/function/program_function_any_number_of_inputs_and_outputs.out @@ -1,13 +1,12 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "aacfba037ccc2e33dd2317a82e4957173f0d46f7c6ca8f875d96f0ddee2c01c7", unrolled_ast = "aacfba037ccc2e33dd2317a82e4957173f0d46f7c6ca8f875d96f0ddee2c01c7", ssa_ast = "f58475b28ba41d3bb5707ff5f4fb714013dcaad7557b926105b7e0ffd06c3df5", flattened_ast = "76b3378bab85a9c02cd68bee7e9abcf48cbeee20dc76f97a98a54217ef628126", destructured_ast = "5125cda9a601ef5b91120c9e627e5f6ec2e29e27aaf6fbcf73375605968cd4f8", inlined_ast = "5125cda9a601ef5b91120c9e627e5f6ec2e29e27aaf6fbcf73375605968cd4f8", dce_ast = "5125cda9a601ef5b91120c9e627e5f6ec2e29e27aaf6fbcf73375605968cd4f8", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "aacfba037ccc2e33dd2317a82e4957173f0d46f7c6ca8f875d96f0ddee2c01c7", unrolled_ast = "c698ed1eae4cab538f1cf5e1b8a12f48c011f3ac02a197272a7ed6198cabddb8", ssa_ast = "78349fbc4b9ed6d8fbbecd21c75f9de3b7995da85da61b7a1f381b30c07b1ceb", flattened_ast = "553aec5dfe82afc7ebef2efb4daa534f7932cbc56cca1a1c4e81b5a96823ec42", destructured_ast = "8536e31be219dcccacc450f513363ccab848d6851a368780b1e8e6ca3c67d0c5", inlined_ast = "8536e31be219dcccacc450f513363ccab848d6851a368780b1e8e6ca3c67d0c5", dce_ast = "8536e31be219dcccacc450f513363ccab848d6851a368780b1e8e6ca3c67d0c5", bytecode = """ program test.aleo; function foo0_to_0: function foo0_to_1: - add 1u8 1u8 into r0; - output r0 as u8.private; + output 2u8 as u8.private; function foo1_to_0: input r0 as u8.private; diff --git a/tests/expectations/compiler/group/ternary.out b/tests/expectations/compiler/group/ternary.out index 5d8fd1b171..973ee73214 100644 --- a/tests/expectations/compiler/group/ternary.out +++ b/tests/expectations/compiler/group/ternary.out @@ -1,15 +1,14 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "3a4b5cc4267b6b323c4cc6b14e86694165e066133bc1fc2709d2bbf1036d0def", unrolled_ast = "3a4b5cc4267b6b323c4cc6b14e86694165e066133bc1fc2709d2bbf1036d0def", ssa_ast = "62d476da8c7d7e6e4dcdee879f591954c4f32812b473eebfff9a949d6ce6bbe6", flattened_ast = "f1ba9eaf698f1e2fc703b9ac7e158837cc7636667fe82e135f7350421e47d0c0", destructured_ast = "66ed03637c8aef4acaa5b1c735f1550d898faafe0b5999708a6d75cb02166b6a", inlined_ast = "66ed03637c8aef4acaa5b1c735f1550d898faafe0b5999708a6d75cb02166b6a", dce_ast = "66ed03637c8aef4acaa5b1c735f1550d898faafe0b5999708a6d75cb02166b6a", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "3a4b5cc4267b6b323c4cc6b14e86694165e066133bc1fc2709d2bbf1036d0def", unrolled_ast = "b3bbd5a9a9ef59a9416a6a3eeb6301e0950f369b9cd2dcd5ddebb78eaa4d57e3", ssa_ast = "a65a5017b5735bb03003c5c84a0fb70a59d916974f1e1784a060cb726f14ee20", flattened_ast = "6c9233fa64db058ea7ca02adab36d1a1d0b07ac857f912fe77afa242c3858eec", destructured_ast = "9ae745648854a5770095be937eda3635c80bcf63cbd9bcae210e889ce6d3133b", inlined_ast = "9ae745648854a5770095be937eda3635c80bcf63cbd9bcae210e889ce6d3133b", dce_ast = "9ae745648854a5770095be937eda3635c80bcf63cbd9bcae210e889ce6d3133b", bytecode = """ program test.aleo; function main: input r0 as group.private; input r1 as group.private; input r2 as group.private; - ternary true r0 r1 into r3; - is.eq r3 r2 into r4; - assert.eq r4 true; - is.eq r3 r2 into r5; - output r5 as boolean.private; + is.eq r0 r2 into r3; + assert.eq r3 true; + is.eq r0 r2 into r4; + output r4 as boolean.private; """, errors = "", warnings = "" }] }]] diff --git a/tests/expectations/compiler/group/to_x_coordinate.out b/tests/expectations/compiler/group/to_x_coordinate.out index ec5329af92..e71c8ce463 100644 --- a/tests/expectations/compiler/group/to_x_coordinate.out +++ b/tests/expectations/compiler/group/to_x_coordinate.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "676d71376bf2a1df04b89f06274de446d2e28b3036ffd0bb11140ab52503d3c8", unrolled_ast = "676d71376bf2a1df04b89f06274de446d2e28b3036ffd0bb11140ab52503d3c8", ssa_ast = "c7221fce1a07017b44db28e701c14fd1046de2272e2ef49333db2eb2e10f6a6a", flattened_ast = "a932fc45f884624db67fe5948600384c7aa5bff863a181bc13f06c4ca4f79b66", destructured_ast = "4216762e4492a408c2809e521eba457d96d3b7cd7b6093cde3cbeab06a43fd07", inlined_ast = "4216762e4492a408c2809e521eba457d96d3b7cd7b6093cde3cbeab06a43fd07", dce_ast = "8762ebc07b19bbcb9961fc23acb584cb91daf52787426b6bcf55a9cbdee8ce10", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "676d71376bf2a1df04b89f06274de446d2e28b3036ffd0bb11140ab52503d3c8", unrolled_ast = "607a7d7d1ebf1f6feb9f6828b5c9566416e860464db279e5ece3788962ac6811", ssa_ast = "ee986f6dd838d3fb73360071b8157f2a027f2ce71c7eb583d8461b24289843ff", flattened_ast = "2aa8f99a92291907a63c62d7b5f01fb9c0350ef644129223ab9e0b9419a395eb", destructured_ast = "780900ce9f4c8dcc6af7363988b9403f34c2c7706c4440fd30d1c616591b42a4", inlined_ast = "780900ce9f4c8dcc6af7363988b9403f34c2c7706c4440fd30d1c616591b42a4", dce_ast = "7acb9a767c34b75c34e6510e97fc2648af1f1cfdc18d44938cb208b6a673ad0c", bytecode = """ program test.aleo; function main: diff --git a/tests/expectations/compiler/group/to_y_coordinate.out b/tests/expectations/compiler/group/to_y_coordinate.out index fa8fe351b8..142452c030 100644 --- a/tests/expectations/compiler/group/to_y_coordinate.out +++ b/tests/expectations/compiler/group/to_y_coordinate.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "d483d7fd3eb931e6224542daa0b8d86b7241c1e96a3ef5a28a91a4c4839753c1", unrolled_ast = "d483d7fd3eb931e6224542daa0b8d86b7241c1e96a3ef5a28a91a4c4839753c1", ssa_ast = "5dc07267a99edfc008039448a461c2a86120afcdcc1f358987169ae1fbe920cb", flattened_ast = "a791fe154beb662ea85c3180b5960fa7764bccdcd350f34043fa4d75dc85c344", destructured_ast = "c73f8fb9324fd05759a6b7231f4263a2ddef0df3cd42144472813dee671f87d8", inlined_ast = "c73f8fb9324fd05759a6b7231f4263a2ddef0df3cd42144472813dee671f87d8", dce_ast = "89b21f088c668c849c8c4050663108f46b964cc81cad4f243ccb844150ee1d3e", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "d483d7fd3eb931e6224542daa0b8d86b7241c1e96a3ef5a28a91a4c4839753c1", unrolled_ast = "53035b557902f9b6c22dbef184415d782dafd6a1a04a4a55aa42577bb2a59b3c", ssa_ast = "af49bff7fe8192826ba4c021ca0a86d704ca0996367b08efd7c47efd6a754108", flattened_ast = "ab1efe3d7a80434ab22f03d33b33e25de78229d85c275fdf3abe51983b2b4e97", destructured_ast = "c4da49b54a39e041b840c480a8bfb735a59e92716f910585dba064522f1c1f5a", inlined_ast = "c4da49b54a39e041b840c480a8bfb735a59e92716f910585dba064522f1c1f5a", dce_ast = "fe4bdee5522cab0898484d13acd4f315e9dbdf0ded37b73d190a362adf7d05c0", bytecode = """ program test.aleo; function main: diff --git a/tests/expectations/compiler/mappings/max_mappings.out b/tests/expectations/compiler/mappings/max_mappings.out index a62cc5747b..7544392ab3 100644 --- a/tests/expectations/compiler/mappings/max_mappings.out +++ b/tests/expectations/compiler/mappings/max_mappings.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "dab4c349df7b581a19b258e289107e94355ce3d848801372999cacc807ddeb7b", unrolled_ast = "dab4c349df7b581a19b258e289107e94355ce3d848801372999cacc807ddeb7b", ssa_ast = "01a69ccd470b48c3d60c9928922b5c2ed2f0fe0405ab3d0ce95ea64d80155027", flattened_ast = "ec2b075dc39d494b448c04fd5bbd19e8a7503cfea823da12ee33464d8e67d0a1", destructured_ast = "28d0ece5659e9c3d8dae3bc9f5e2181730dd52d4d00575553fb62879c2252c4c", inlined_ast = "28d0ece5659e9c3d8dae3bc9f5e2181730dd52d4d00575553fb62879c2252c4c", dce_ast = "28d0ece5659e9c3d8dae3bc9f5e2181730dd52d4d00575553fb62879c2252c4c", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "dab4c349df7b581a19b258e289107e94355ce3d848801372999cacc807ddeb7b", unrolled_ast = "13d211b18aca0b119525c43e6979cd6e128f78bd56ab8c8140668596700a5e2d", ssa_ast = "3657b6b6ce4fe735b62c3b29a3197c0e2da26bb8bab9431abf136937740859ee", flattened_ast = "25f6388562ac7a84a85af100253a8473320d4419d587943e6fea6101ce59d90c", destructured_ast = "1a8979d9846d82856804dbaacfc03d1073a3ca6b5ac3f11ebe788462be299715", inlined_ast = "1a8979d9846d82856804dbaacfc03d1073a3ca6b5ac3f11ebe788462be299715", dce_ast = "1a8979d9846d82856804dbaacfc03d1073a3ca6b5ac3f11ebe788462be299715", bytecode = """ program test.aleo; mapping one: @@ -128,6 +128,5 @@ mapping thirtyone: value as field.public; function foo: - add 1u8 1u8 into r0; - output r0 as u8.private; + output 2u8 as u8.private; """, errors = "", warnings = "" }] }]] diff --git a/tests/expectations/compiler/statements/iteration_basic.out b/tests/expectations/compiler/statements/iteration_basic.out index 95c789d741..ab55f39b1e 100644 --- a/tests/expectations/compiler/statements/iteration_basic.out +++ b/tests/expectations/compiler/statements/iteration_basic.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "c853d211f0b9902b1978a581b79719747d48e271dc56f1a73237ff53581f6375", unrolled_ast = "868bce3c6fa51fbfced8fca04fde42c31077481c97627522e67ecd9ccba9ec19", ssa_ast = "ac9cbefc140c01764377b5d177116fcd7d40f24b07717e2c8c8f5c1401181752", flattened_ast = "3388ff4cffa6270f23cd4233675a3f43eb482090f9d25d0ed6049a4046a4cfc7", destructured_ast = "4cb448add32540e68ea85573ce46d7807c33430959d27564251c9b57d7cd9113", inlined_ast = "4cb448add32540e68ea85573ce46d7807c33430959d27564251c9b57d7cd9113", dce_ast = "4cb448add32540e68ea85573ce46d7807c33430959d27564251c9b57d7cd9113", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "c853d211f0b9902b1978a581b79719747d48e271dc56f1a73237ff53581f6375", unrolled_ast = "d72555c77add223b02cd8223638dc0bc7000fbef14c9a1c70b42bd94963cf279", ssa_ast = "8d8e42f62857383a8835d67e3620671e753702f6f97d9c1494a2b11f6e027de4", flattened_ast = "ff8bde1f011ef7733a899388521ddac8f0f557efd1a02c987b73a0abc6089025", destructured_ast = "0b14361e6ead30039338a26e7b1bc07dd377bdc7b5d25459f31a339e8f7aaefc", inlined_ast = "0b14361e6ead30039338a26e7b1bc07dd377bdc7b5d25459f31a339e8f7aaefc", dce_ast = "0b14361e6ead30039338a26e7b1bc07dd377bdc7b5d25459f31a339e8f7aaefc", bytecode = """ program test.aleo; function main: diff --git a/tests/expectations/compiler/statements/iteration_nested.out b/tests/expectations/compiler/statements/iteration_nested.out index 7797517b6e..f345017dd0 100644 --- a/tests/expectations/compiler/statements/iteration_nested.out +++ b/tests/expectations/compiler/statements/iteration_nested.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "7c9468d2e25b8d770277e8ae01d776a99c2fe1b2b3cc5a26fa45924fbb255629", unrolled_ast = "d4a96858fdd3ab265dac8357df39a0e2b263c585e83d24c87c06e124ae76a148", ssa_ast = "4cc7289076c8a1d3b59906c43bf9ed563e173b544fec79730fc26ca55852e256", flattened_ast = "530e2138bdaed1ac6c1b217b24e79589181a896a413933a5f28e1129031f4707", destructured_ast = "f498e1178ef35e3b0b5f579b0aff6f4d757dffd86aa71443272fcbd64836db91", inlined_ast = "f498e1178ef35e3b0b5f579b0aff6f4d757dffd86aa71443272fcbd64836db91", dce_ast = "f498e1178ef35e3b0b5f579b0aff6f4d757dffd86aa71443272fcbd64836db91", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "7c9468d2e25b8d770277e8ae01d776a99c2fe1b2b3cc5a26fa45924fbb255629", unrolled_ast = "3b4b3113999cd2a62c901c8d0ac510d750d0d768a137080a0d2e77da9255d17a", ssa_ast = "195c6e31b76a8414507d45fb71232978dae91eccf80de918047f2eeea5e47136", flattened_ast = "91d0b5a856ee5ed39d2fbbbb7f4d80075ec64cc4faec001184b56ab55faa6566", destructured_ast = "4b1c5e844cbbc3747162ce710ee2eebace63fb7a5aa74bded0ac4875f33c502a", inlined_ast = "4b1c5e844cbbc3747162ce710ee2eebace63fb7a5aa74bded0ac4875f33c502a", dce_ast = "4b1c5e844cbbc3747162ce710ee2eebace63fb7a5aa74bded0ac4875f33c502a", bytecode = """ program test.aleo; function main: diff --git a/tests/expectations/compiler/statements/loop_non_literal_bound_fail.out b/tests/expectations/compiler/statements/loop_non_literal_bound_fail.out index 3e05c1fd55..fc3253bb00 100644 --- a/tests/expectations/compiler/statements/loop_non_literal_bound_fail.out +++ b/tests/expectations/compiler/statements/loop_non_literal_bound_fail.out @@ -1,9 +1,8 @@ namespace = "Compile" expectation = "Fail" outputs = [""" -Error [ETYC0372071]: The loop bound must be a literal or a const +Error [ECMP0376008]: This loop bound could not be determined at compile time. --> compiler-test:11:28 | 11 | for i:u64 in 0u64..amount { - | ^^^^^^ -"""] + | ^^^^^^"""] diff --git a/tests/expectations/compiler/statements/underscore_for_loop.out b/tests/expectations/compiler/statements/underscore_for_loop.out index f9e05e8467..e8ba540f15 100644 --- a/tests/expectations/compiler/statements/underscore_for_loop.out +++ b/tests/expectations/compiler/statements/underscore_for_loop.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "8edaf2a23a7e65051bf3e4ced5eece2f6de1339ca084d363c33b9c91930ae403", unrolled_ast = "9fe32b371c825fd6c4e4b912f8dfd58db777f2fece85a46adb809f551d6bdbd0", ssa_ast = "cd4394cc072e7ac063d2afe871c1cbac83902b9366b09363548b008543b6f882", flattened_ast = "0c86ef91bf8d982c95219baad68a52007420a7d66a8374da94c7753d702bf20b", destructured_ast = "07cb482a3b29245b6a89fdf9e701102fe8e1448dd9a4b22b8a8e23a800e4b630", inlined_ast = "07cb482a3b29245b6a89fdf9e701102fe8e1448dd9a4b22b8a8e23a800e4b630", dce_ast = "58e36619926cc6c8b17a8fdbb6a83214a577e3f61132e52e35795bdcdbb3e35b", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "8edaf2a23a7e65051bf3e4ced5eece2f6de1339ca084d363c33b9c91930ae403", unrolled_ast = "5d0bb16eb0b04e3e7418a7700cc4190b6c47e45b1c89858115ff5b2ddd914db0", ssa_ast = "1e4e339fa57793789d2ef89d095dc0e1e3306d5ac9d523275513c4c551ec4465", flattened_ast = "41a5925ee1724a58cffc52c57ea08bc7b4980b89e0fb44e960d1545f72901cbf", destructured_ast = "0f57dd814c3e34c08cf72208aca84412a5fb49a165e54ef01cf594574ef1561b", inlined_ast = "0f57dd814c3e34c08cf72208aca84412a5fb49a165e54ef01cf594574ef1561b", dce_ast = "5da4ef27a35af7218b646b9aac18a57bf0b7574bb669cfa8fa9494ea3a80d198", bytecode = """ program test.aleo; function main: diff --git a/tests/expectations/compiler/tuple/tuple_in_assignment.out b/tests/expectations/compiler/tuple/tuple_in_assignment.out index 9ad03dfb05..3d866b1b56 100644 --- a/tests/expectations/compiler/tuple/tuple_in_assignment.out +++ b/tests/expectations/compiler/tuple/tuple_in_assignment.out @@ -1,11 +1,10 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "58135ff261cc746b5900469ced400c8dce6e30f753a4ab6b0b93cf928119b9e4", unrolled_ast = "58135ff261cc746b5900469ced400c8dce6e30f753a4ab6b0b93cf928119b9e4", ssa_ast = "f9ac72939415349c29b89bfaaece6ca54cebb8d167f3417fc0ca4503c7ae6d0e", flattened_ast = "e6ee7eebf86689080af2a309eda4eb0ea070312960247705e1f35229945148f0", destructured_ast = "669ed6d76abd9b2c27cd5b02ae9e26a22b83a820e41f9f1b92434cd411905906", inlined_ast = "669ed6d76abd9b2c27cd5b02ae9e26a22b83a820e41f9f1b92434cd411905906", dce_ast = "f42036031402eb4b732c6f15ab92ae64b18d8bbf2541ac13713bc38fcbf90af7", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "58135ff261cc746b5900469ced400c8dce6e30f753a4ab6b0b93cf928119b9e4", unrolled_ast = "298c03892360a8ceb8e9a5209eca649c64f0fdf27b9affbdfc3aff3e60808a1f", ssa_ast = "1a4528a956106400bd4da863b064f9d4bb2a40eeb60c50aba31d08e38f85948f", flattened_ast = "1670638977c12d5f29453b038b6c9390de50ecdd577838fe7e95e44af3c09c83", destructured_ast = "641d1e5da60578d412c420923a2c2fdc937ebf59ae344925b9e456812a0f14a3", inlined_ast = "641d1e5da60578d412c420923a2c2fdc937ebf59ae344925b9e456812a0f14a3", dce_ast = "fbc41309658507cb21b6f31a5fc50a92a0ff67416e5e64ce8eca9835e1a4a0f0", bytecode = """ program test.aleo; function baz: input r0 as u8.private; input r1 as u16.private; - add 1u8 1u8 into r2; - output r2 as u8.private; + output 2u8 as u8.private; """, errors = "", warnings = "" }] }]] diff --git a/tests/expectations/compiler/tuple/tuple_in_definition.out b/tests/expectations/compiler/tuple/tuple_in_definition.out index 011499e14c..ecd2a288a0 100644 --- a/tests/expectations/compiler/tuple/tuple_in_definition.out +++ b/tests/expectations/compiler/tuple/tuple_in_definition.out @@ -1,9 +1,8 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "4b63efd197346a9a4d3cd8a15e9f94dfd4c42f82af5434c1ededede49af2d6b2", unrolled_ast = "4b63efd197346a9a4d3cd8a15e9f94dfd4c42f82af5434c1ededede49af2d6b2", ssa_ast = "219654cedb5bde80cb3fd95f5d0b4f131cb84931ad848b35ea96d0d7eccea397", flattened_ast = "c3b9e5220dfbd1a2a90ae353884f520e13eda51da01a96e9f87b0d8557bf2cc8", destructured_ast = "33d7533144d6449afcf0685632abedbab432bfe11b19e63adc1bc708947a185b", inlined_ast = "33d7533144d6449afcf0685632abedbab432bfe11b19e63adc1bc708947a185b", dce_ast = "05f72ceba4a6170af107ea6f04c61d026da39ac3044b302e482782058714f74c", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "4b63efd197346a9a4d3cd8a15e9f94dfd4c42f82af5434c1ededede49af2d6b2", unrolled_ast = "414f3fe7283cfb66663f41fe66868a3fddf3ff71d76dbba377ff47f2c2b89245", ssa_ast = "b5679b48ef00446f8f09dbd7ee3dd2498f2a8e1cce3752d5dd96f92b38cc9724", flattened_ast = "39b156836f3d43899564b8c7edf523da3b4a0878b444bc2cb95fe05c0c307a94", destructured_ast = "2a44e25ea9ee350a14fb1dce639f1beefbbf98a8d5c5d9a02ae1b51236838480", inlined_ast = "2a44e25ea9ee350a14fb1dce639f1beefbbf98a8d5c5d9a02ae1b51236838480", dce_ast = "9b316de8cfa229be01859989c7b0e58339d79fef790596e21147c3f25bbd6701", bytecode = """ program test.aleo; function baz: - add 1u8 1u8 into r0; - output r0 as u8.private; + output 2u8 as u8.private; """, errors = "", warnings = "" }] }]] diff --git a/tests/expectations/compiler/tuple/tuple_in_loop.out b/tests/expectations/compiler/tuple/tuple_in_loop.out index b8518356a9..5d5deaae5e 100644 --- a/tests/expectations/compiler/tuple/tuple_in_loop.out +++ b/tests/expectations/compiler/tuple/tuple_in_loop.out @@ -1,6 +1,6 @@ namespace = "Compile" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "de829a425dc7ff52193bcf9f28a646050bc86ef38c2f9ebb5b994cbc0ce47fe5", unrolled_ast = "71a810bb6ec5173fcdcdd3219947a7688f4693c91e6f1389f1297f14caf0e5db", ssa_ast = "665dc1eeebe494f2578981d00931daf6a41812e5290a0e07fd9352868407fa14", flattened_ast = "a191d8a6b8bd90e5787a4add090889402b8b20b4fa558db2f02c26b1d86758a9", destructured_ast = "e6de9ae9bed47b84452e63e49548d48868d504ef84b659e5a7c9c0e08382a9c5", inlined_ast = "e6de9ae9bed47b84452e63e49548d48868d504ef84b659e5a7c9c0e08382a9c5", dce_ast = "e342935a11012287fb0816a5c6b0caa3fd4028e35da123f6d07e21f01078fc89", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "de829a425dc7ff52193bcf9f28a646050bc86ef38c2f9ebb5b994cbc0ce47fe5", unrolled_ast = "774cc4ff2148f70776bef2717260221547e222a06a2e7833b152d9c63c52765e", ssa_ast = "f4fbaedc4174eb919894b6301ca1d0f3f7a757599b6e41da07f26044a64e4ec9", flattened_ast = "03a6751435c840651d38d4010cac5547529dc6770105057291c3f4266edf550c", destructured_ast = "5d156c0a4f5ff331fed516e114e5ab35d6dba9363f793e6b0deb9c0d2ed32300", inlined_ast = "5d156c0a4f5ff331fed516e114e5ab35d6dba9363f793e6b0deb9c0d2ed32300", dce_ast = "6aa1b030e8acdd3f6afd03e0a33c414a03389b6f23e2e911dadd67405243851d", bytecode = """ program test.aleo; function foo: diff --git a/tests/expectations/execution/array_sum.out b/tests/expectations/execution/array_sum.out index 594c1306ae..6b56ff2ca6 100644 --- a/tests/expectations/execution/array_sum.out +++ b/tests/expectations/execution/array_sum.out @@ -1,6 +1,6 @@ namespace = "Execute" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "55b89c0a219d048aa18bdd9daabb476975ccc90a470bae25c22cbad29cf85725", unrolled_ast = "4e1d9d2015097b65f86654ff364e5643b1d5a5175ebef32d744c04889997abea", ssa_ast = "cff859b0ede85b859243630028ad2725ecf27c257c62abdae68a8aaef5c82277", flattened_ast = "4f95ebd915930d7d3a3e99a6ecfe24e0e0471b6dc9d2be5451478c122ca84ea2", destructured_ast = "120adac5778f9f6b002f394e128c9a968d57208bc2c9e95559e43631c9769048", inlined_ast = "120adac5778f9f6b002f394e128c9a968d57208bc2c9e95559e43631c9769048", dce_ast = "120adac5778f9f6b002f394e128c9a968d57208bc2c9e95559e43631c9769048", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "55b89c0a219d048aa18bdd9daabb476975ccc90a470bae25c22cbad29cf85725", unrolled_ast = "ffc29beff29532363877b002afece8ca3f34840ac8093d3480d48ca0b067682b", ssa_ast = "6b377a391394daabba2da6292af8f532cc523d836c0bdbdda5652d800eadd372", flattened_ast = "f119f867e8f31549c05ec9833a5b583451d85b915be94031c495f757146cf241", destructured_ast = "7c9656fc6a2a1f8563f7b4b0a0e2bd3e189fc093479640c43dbeac8acda0e0d4", inlined_ast = "7c9656fc6a2a1f8563f7b4b0a0e2bd3e189fc093479640c43dbeac8acda0e0d4", dce_ast = "7c9656fc6a2a1f8563f7b4b0a0e2bd3e189fc093479640c43dbeac8acda0e0d4", bytecode = """ program test.aleo; function sum_manually: diff --git a/tests/expectations/execution/counter.out b/tests/expectations/execution/counter.out index ad39831511..9425dca853 100644 --- a/tests/expectations/execution/counter.out +++ b/tests/expectations/execution/counter.out @@ -1,6 +1,6 @@ namespace = "Execute" expectation = "Pass" -outputs = [[{ compile = [{ initial_ast = "19721e772e221eb97e37f1c93467922f709e85ce513f52509ada17ee6d772f43", unrolled_ast = "bf98c020b55ec42149bbebccd94fc4472393f136396a6e0f9f4de668e3a929a8", ssa_ast = "4cdb461c03b67dd1116b5ba10fe79ea1275c6a50a23865a37181a8bc525efc65", flattened_ast = "7763d804c2926a3c1e032a8729421ec31f659db3e614f4714a7e369a6748464a", destructured_ast = "ed3275214bc2c59c628cd54521cd017a6876c34fd2ac96bde750c050cc565cda", inlined_ast = "6f7b0819d5bc9087f7c973618450f0cd67300f4f58ccf8ae279d8193332617a0", dce_ast = "6f7b0819d5bc9087f7c973618450f0cd67300f4f58ccf8ae279d8193332617a0", bytecode = """ +outputs = [[{ compile = [{ initial_ast = "19721e772e221eb97e37f1c93467922f709e85ce513f52509ada17ee6d772f43", unrolled_ast = "79dfae454e56fefdd3427fa5e7a8d669959311278c6a044a00a250c935a9618e", ssa_ast = "c7596ddbc331604cd16694ccad6ef2ddb97121f605e7d345792833d4ad26e0ce", flattened_ast = "19e9d6a184bde839d70cd1bc805b508194d0c648daf5998e25e14375b88a18b3", destructured_ast = "5344f1eb7c6c48b96a995f0e2cb730fb07eab759a1d630541a3846312841f04e", inlined_ast = "bb742af09e8388e5402b2ec6ef5b32f19f57fb7d4cf07da4fb8c61bad267c9b6", dce_ast = "bb742af09e8388e5402b2ec6ef5b32f19f57fb7d4cf07da4fb8c61bad267c9b6", bytecode = """ program test.aleo; mapping counter: @@ -13,14 +13,12 @@ function dubble: finalize dubble: input r0 as address.public; - add 0_0u64 234u64 into r1; - add r1 0_1u64 into r2; - get.or_use counter[r0] r2 into r3; - add r3 1__u64 into r4; + get.or_use counter[r0] 235u64 into r1; + add r1 1__u64 into r2; + set r2 into counter[r0]; + get counter[r0] into r3; + add r3 0___1u64 into r4; set r4 into counter[r0]; - get counter[r0] into r5; - add r5 0___1u64 into r6; - set r6 into counter[r0]; function unsafe_increment: async unsafe_increment self.caller into r0; diff --git a/tests/test-framework/benches/leo_compiler.rs b/tests/test-framework/benches/leo_compiler.rs index 3634a07e54..81c9ce8805 100644 --- a/tests/test-framework/benches/leo_compiler.rs +++ b/tests/test-framework/benches/leo_compiler.rs @@ -190,9 +190,9 @@ impl Sample { fn bench_type_checker(&self, c: &mut Criterion) { self.bencher_after_parse(c, "type checker pass", |compiler| { - let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); + let mut symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); let start = Instant::now(); - let out = compiler.type_checker_pass(symbol_table); + let out = compiler.type_checker_pass(&mut symbol_table); let time = start.elapsed(); out.expect("failed to run type check pass"); time @@ -201,11 +201,11 @@ impl Sample { fn bench_loop_unroller(&self, c: &mut Criterion) { self.bencher_after_parse(c, "loop unrolling pass", |mut compiler| { - let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); - let (symbol_table, _struct_graph, _call_graph) = - compiler.type_checker_pass(symbol_table).expect("failed to run type check pass"); + let mut symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); + let (_struct_graph, _call_graph) = + compiler.type_checker_pass(&mut symbol_table).expect("failed to run type check pass"); let start = Instant::now(); - let out = compiler.loop_unrolling_pass(symbol_table); + let out = compiler.loop_unrolling_pass(&mut symbol_table); let time = start.elapsed(); out.expect("failed to run loop unrolling pass"); time @@ -214,10 +214,10 @@ impl Sample { fn bench_ssa(&self, c: &mut Criterion) { self.bencher_after_parse(c, "full", |mut compiler| { - let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); - let (symbol_table, _struct_graph, _call_graph) = - compiler.type_checker_pass(symbol_table).expect("failed to run type check pass"); - let symbol_table = compiler.loop_unrolling_pass(symbol_table).expect("failed to run loop unrolling pass"); + let mut symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); + let (_struct_graph, _call_graph) = + compiler.type_checker_pass(&mut symbol_table).expect("failed to run type check pass"); + compiler.loop_unrolling_pass(&mut symbol_table).expect("failed to run loop unrolling pass"); let start = Instant::now(); let out = compiler.static_single_assignment_pass(&symbol_table); let time = start.elapsed(); @@ -228,10 +228,10 @@ impl Sample { fn bench_flattener(&self, c: &mut Criterion) { self.bencher_after_parse(c, "flattener pass", |mut compiler| { - let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); - let (symbol_table, _struct_graph, _call_graph) = - compiler.type_checker_pass(symbol_table).expect("failed to run type check pass"); - let symbol_table = compiler.loop_unrolling_pass(symbol_table).expect("failed to run loop unrolling pass"); + let mut symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); + let (_struct_graph, _call_graph) = + compiler.type_checker_pass(&mut symbol_table).expect("failed to run type check pass"); + compiler.loop_unrolling_pass(&mut symbol_table).expect("failed to run loop unrolling pass"); compiler.static_single_assignment_pass(&symbol_table).expect("failed to run ssa pass"); let start = Instant::now(); let out = compiler.flattening_pass(&symbol_table); @@ -243,10 +243,10 @@ impl Sample { fn bench_destructurer(&self, c: &mut Criterion) { self.bencher_after_parse(c, "destructurer pass", |mut compiler| { - let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); - let (symbol_table, _struct_graph, _call_graph) = - compiler.type_checker_pass(symbol_table).expect("failed to run type check pass"); - let symbol_table = compiler.loop_unrolling_pass(symbol_table).expect("failed to run loop unrolling pass"); + let mut symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); + let (_struct_graph, _call_graph) = + compiler.type_checker_pass(&mut symbol_table).expect("failed to run type check pass"); + compiler.loop_unrolling_pass(&mut symbol_table).expect("failed to run loop unrolling pass"); compiler.static_single_assignment_pass(&symbol_table).expect("failed to run ssa pass"); compiler.flattening_pass(&symbol_table).expect("failed to run flattener pass"); let start = Instant::now(); @@ -259,10 +259,10 @@ impl Sample { fn bench_inline(&self, c: &mut Criterion) { self.bencher_after_parse(c, "inliner pass", |mut compiler| { - let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); - let (symbol_table, _struct_graph, call_graph) = - compiler.type_checker_pass(symbol_table).expect("failed to run type check pass"); - let symbol_table = compiler.loop_unrolling_pass(symbol_table).expect("failed to run loop unrolling pass"); + let mut symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); + let (_struct_graph, call_graph) = + compiler.type_checker_pass(&mut symbol_table).expect("failed to run type check pass"); + compiler.loop_unrolling_pass(&mut symbol_table).expect("failed to run loop unrolling pass"); compiler.static_single_assignment_pass(&symbol_table).expect("failed to run ssa pass"); compiler.flattening_pass(&symbol_table).expect("failed to run flattener pass"); compiler.destructuring_pass().expect("failed to run destructurer pass"); @@ -276,10 +276,10 @@ impl Sample { fn bench_dce(&self, c: &mut Criterion) { self.bencher_after_parse(c, "inliner pass", |mut compiler| { - let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); - let (symbol_table, _struct_graph, call_graph) = - compiler.type_checker_pass(symbol_table).expect("failed to run type check pass"); - let symbol_table = compiler.loop_unrolling_pass(symbol_table).expect("failed to run loop unrolling pass"); + let mut symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); + let (_struct_graph, call_graph) = + compiler.type_checker_pass(&mut symbol_table).expect("failed to run type check pass"); + compiler.loop_unrolling_pass(&mut symbol_table).expect("failed to run loop unrolling pass"); compiler.static_single_assignment_pass(&symbol_table).expect("failed to run ssa pass"); compiler.flattening_pass(&symbol_table).expect("failed to run flattener pass"); compiler.destructuring_pass().expect("failed to run destructurer pass"); @@ -294,10 +294,10 @@ impl Sample { fn bench_codegen(&self, c: &mut Criterion) { self.bencher_after_parse(c, "inliner pass", |mut compiler| { - let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); - let (symbol_table, struct_graph, call_graph) = - compiler.type_checker_pass(symbol_table).expect("failed to run type check pass"); - let symbol_table = compiler.loop_unrolling_pass(symbol_table).expect("failed to run loop unrolling pass"); + let mut symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); + let (struct_graph, call_graph) = + compiler.type_checker_pass(&mut symbol_table).expect("failed to run type check pass"); + compiler.loop_unrolling_pass(&mut symbol_table).expect("failed to run loop unrolling pass"); compiler.static_single_assignment_pass(&symbol_table).expect("failed to run ssa pass"); compiler.flattening_pass(&symbol_table).expect("failed to run flattener pass"); compiler.destructuring_pass().expect("failed to run destructurer pass"); @@ -316,10 +316,10 @@ impl Sample { let (input, name) = self.data(); let start = Instant::now(); compiler.parse_program_from_string(input, name).expect("Failed to parse program"); - let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); - let (symbol_table, struct_graph, call_graph) = - compiler.type_checker_pass(symbol_table).expect("failed to run type check pass"); - let symbol_table = compiler.loop_unrolling_pass(symbol_table).expect("failed to run loop unrolling pass"); + let mut symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); + let (struct_graph, call_graph) = + compiler.type_checker_pass(&mut symbol_table).expect("failed to run type check pass"); + compiler.loop_unrolling_pass(&mut symbol_table).expect("failed to run loop unrolling pass"); compiler.static_single_assignment_pass(&symbol_table).expect("failed to run ssa pass"); compiler.flattening_pass(&symbol_table).expect("failed to run flattening pass"); compiler.destructuring_pass().expect("failed to run destructuring pass"); diff --git a/tests/tests/compiler/const_prop/big_const_prop.leo b/tests/tests/compiler/const_prop/big_const_prop.leo new file mode 100644 index 0000000000..6e69c4b895 --- /dev/null +++ b/tests/tests/compiler/const_prop/big_const_prop.leo @@ -0,0 +1,20 @@ +/* +namespace = "Compile" +expectation = "Pass" +*/ + +program test.aleo { + const A: i32 = 1i32 * 3i32; + + const B: i32 = A + 2i32; + + const C: i32 = 0xFFFFFFi32 ^ B; + + const D: i32 = A * 7i32 + C; + + transition main() -> i32 { + const E: i32 = (C ^ D) + A; + + return E; + } +} diff --git a/tests/tests/compiler/const_prop/compile_time_const_fail.leo b/tests/tests/compiler/const_prop/compile_time_const_fail.leo new file mode 100644 index 0000000000..f666788462 --- /dev/null +++ b/tests/tests/compiler/const_prop/compile_time_const_fail.leo @@ -0,0 +1,16 @@ +/* +namespace = "Compile" +expectation = "Fail" +*/ + +program test.aleo { + const A: i32 = 1i32 / 0i32; + + const B: u8 = 255u8 + 1u8; + + const C: field = 0field.inv(); + + transition main() -> i32 { + return 0i32; + } +} diff --git a/tests/tests/compiler/const_prop/core_functions.leo b/tests/tests/compiler/const_prop/core_functions.leo new file mode 100644 index 0000000000..4a4de92aeb --- /dev/null +++ b/tests/tests/compiler/const_prop/core_functions.leo @@ -0,0 +1,29 @@ +/* +namespace = "Compile" +expectation = "Pass" +*/ + +program test.aleo { + mapping mfield: field => field; + mapping mgroup: group => group; + mapping mu32: u32 => u32; + + async function foo() { + mfield.set( + BHP512::hash_to_field(1234567u128), + BHP512::hash_to_field(12field), + ); + mgroup.set( + BHP512::hash_to_group(12u32), + BHP512::hash_to_group(123123scalar), + ); + mu32.set( + BHP512::hash_to_u32(98765field), + BHP512::hash_to_u32(BHP512::hash_to_group(168field)), + ); + } + + async transition main() -> Future { + return foo(); + } +} diff --git a/tests/tests/compiler/const_prop/evaluate_const_fail.leo b/tests/tests/compiler/const_prop/evaluate_const_fail.leo new file mode 100644 index 0000000000..86999d08f1 --- /dev/null +++ b/tests/tests/compiler/const_prop/evaluate_const_fail.leo @@ -0,0 +1,24 @@ +/* +namespace = "Compile" +expectation = "Fail" +*/ + +program test.aleo { + const START: u32 = 0u32; + const STOP: u32 = 6u32; + + mapping m: u32 => u32; + + async function foo(a: u32) { + for i: u32 in START+1u32..STOP-2u32 { + const SOME: u32 = a + 1u32; + for j: u32 in SOME+1u32..STOP { + m.set(i, j); + } + } + } + + async transition main(a: u32) -> Future { + return foo(a); + } +} diff --git a/tests/tests/compiler/const_prop/loop_bounds_fail.leo b/tests/tests/compiler/const_prop/loop_bounds_fail.leo new file mode 100644 index 0000000000..1eff65fe36 --- /dev/null +++ b/tests/tests/compiler/const_prop/loop_bounds_fail.leo @@ -0,0 +1,24 @@ +/* +namespace = "Compile" +expectation = "Fail" +*/ + +program test.aleo { + const START: u32 = 0u32; + const STOP: u32 = 6u32; + + mapping m: u32 => u32; + + async function foo(a: u32) { + for i: u32 in START+1u32..STOP-2u32 { + const SOME: u32 = i + 1u32; + for j: u32 in SOME+1u32..STOP+a { + m.set(i, j); + } + } + } + + async transition main(a: u32) -> Future { + return foo(a); + } +} diff --git a/tests/tests/compiler/const_prop/some_loop_bounds.leo b/tests/tests/compiler/const_prop/some_loop_bounds.leo new file mode 100644 index 0000000000..4a1649d2bc --- /dev/null +++ b/tests/tests/compiler/const_prop/some_loop_bounds.leo @@ -0,0 +1,24 @@ +/* +namespace = "Compile" +expectation = "Pass" +*/ + +program test.aleo { + const START: u32 = 0u32; + const STOP: u32 = 6u32; + + mapping m: u32 => u32; + + async function foo() { + for i: u32 in START+1u32..STOP-2u32 { + const SOME: u32 = i + 1u32; + for j: u32 in SOME+1u32..STOP { + m.set(i, j); + } + } + } + + async transition main() -> Future { + return foo(); + } +} diff --git a/tests/tests/compiler/const_prop/tuples.leo b/tests/tests/compiler/const_prop/tuples.leo new file mode 100644 index 0000000000..fed1c560e6 --- /dev/null +++ b/tests/tests/compiler/const_prop/tuples.leo @@ -0,0 +1,16 @@ +/* +namespace = "Compile" +expectation = "Pass" +*/ + +program test.aleo { + transition main() -> i32 { + const A: i32 = 1i32; + + const B: i32 = 12i32; + + const C: (i32, i32) = (1i32 + A, A * B); + + return C.1; + } +} diff --git a/tests/tests/compiler/constants/loop_unrolling.leo b/tests/tests/compiler/constants/loop_unrolling.leo index f76d32166e..590fed5610 100644 --- a/tests/tests/compiler/constants/loop_unrolling.leo +++ b/tests/tests/compiler/constants/loop_unrolling.leo @@ -25,4 +25,4 @@ program test.aleo { } return c; } -} \ No newline at end of file +}