Merge pull request #2172 from AleoHQ/feat/then-finalize

Introduces a new syntax for invoking the finalize block.

compiler/ast/src/passes/consumer.rs

@@ -77,7 +77,6 @@ pub trait StatementConsumer {
             Statement::Decrement(stmt) => self.consume_decrement(stmt),
             Statement::Definition(stmt) => self.consume_definition(stmt),
             Statement::Expression(stmt) => self.consume_expression_statement(stmt),
-            Statement::Finalize(stmt) => self.consume_finalize(stmt),
             Statement::Increment(stmt) => self.consume_increment(stmt),
             Statement::Iteration(stmt) => self.consume_iteration(*stmt),
             Statement::Return(stmt) => self.consume_return(stmt),
@@ -98,8 +97,6 @@ pub trait StatementConsumer {
 
     fn consume_expression_statement(&mut self, input: ExpressionStatement) -> Self::Output;
 
-    fn consume_finalize(&mut self, input: FinalizeStatement) -> Self::Output;
-
     fn consume_increment(&mut self, input: IncrementStatement) -> Self::Output;
 
     fn consume_iteration(&mut self, input: IterationStatement) -> Self::Output;

compiler/ast/src/passes/reconstructor.rs

@@ -171,7 +171,6 @@ pub trait StatementReconstructor: ExpressionReconstructor {
             Statement::Decrement(stmt) => self.reconstruct_decrement(stmt),
             Statement::Definition(stmt) => self.reconstruct_definition(stmt),
             Statement::Expression(stmt) => self.reconstruct_expression_statement(stmt),
-            Statement::Finalize(stmt) => self.reconstruct_finalize(stmt),
             Statement::Increment(stmt) => self.reconstruct_increment(stmt),
             Statement::Iteration(stmt) => self.reconstruct_iteration(*stmt),
             Statement::Return(stmt) => self.reconstruct_return(stmt),
@@ -270,20 +269,6 @@ pub trait StatementReconstructor: ExpressionReconstructor {
         )
     }
 
-    fn reconstruct_finalize(&mut self, input: FinalizeStatement) -> (Statement, Self::AdditionalOutput) {
-        (
-            Statement::Finalize(FinalizeStatement {
-                arguments: input
-                    .arguments
-                    .into_iter()
-                    .map(|arg| self.reconstruct_expression(arg).0)
-                    .collect(),
-                span: input.span,
-            }),
-            Default::default(),
-        )
-    }
-
     fn reconstruct_increment(&mut self, input: IncrementStatement) -> (Statement, Self::AdditionalOutput) {
         (
             Statement::Increment(IncrementStatement {
@@ -317,6 +302,12 @@ pub trait StatementReconstructor: ExpressionReconstructor {
         (
             Statement::Return(ReturnStatement {
                 expression: self.reconstruct_expression(input.expression).0,
+                finalize_arguments: input.finalize_arguments.map(|arguments| {
+                    arguments
+                        .into_iter()
+                        .map(|argument| self.reconstruct_expression(argument).0)
+                        .collect()
+                }),
                 span: input.span,
             }),
             Default::default(),

compiler/ast/src/passes/visitor.rs

@@ -124,7 +124,6 @@ pub trait StatementVisitor<'a>: ExpressionVisitor<'a> {
             Statement::Decrement(stmt) => self.visit_decrement(stmt),
             Statement::Definition(stmt) => self.visit_definition(stmt),
             Statement::Expression(stmt) => self.visit_expression_statement(stmt),
-            Statement::Finalize(stmt) => self.visit_finalize(stmt),
             Statement::Increment(stmt) => self.visit_increment(stmt),
             Statement::Iteration(stmt) => self.visit_iteration(stmt),
             Statement::Return(stmt) => self.visit_return(stmt),
@@ -177,12 +176,6 @@ pub trait StatementVisitor<'a>: ExpressionVisitor<'a> {
         self.visit_expression(&input.expression, &Default::default());
     }
 
-    fn visit_finalize(&mut self, input: &'a FinalizeStatement) {
-        input.arguments.iter().for_each(|expr| {
-            self.visit_expression(expr, &Default::default());
-        });
-    }
-
     fn visit_increment(&mut self, input: &'a IncrementStatement) {
         self.visit_expression(&input.amount, &Default::default());
         self.visit_expression(&input.index, &Default::default());
@@ -197,6 +190,11 @@ pub trait StatementVisitor<'a>: ExpressionVisitor<'a> {
 
     fn visit_return(&mut self, input: &'a ReturnStatement) {
         self.visit_expression(&input.expression, &Default::default());
+        if let Some(arguments) = &input.finalize_arguments {
+            arguments.iter().for_each(|argument| {
+                self.visit_expression(argument, &Default::default());
+            })
+        }
     }
 }
 

compiler/ast/src/statement/finalize.rs

@@ -1,46 +0,0 @@
-// Copyright (C) 2019-2022 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 <https://www.gnu.org/licenses/>.
-
-use crate::{Expression, Node};
-
-use leo_span::Span;
-
-use core::fmt;
-use serde::{Deserialize, Serialize};
-
-/// A return statement `finalize(arg1, ..., argN);`.
-#[derive(Clone, PartialEq, Eq, Serialize, Deserialize, Debug)]
-pub struct FinalizeStatement {
-    /// The arguments to pass to the finalize block.
-    pub arguments: Vec<Expression>,
-    /// The span of `finalize(arg1, ..., argN)` excluding the semicolon.
-    pub span: Span,
-}
-
-impl fmt::Display for FinalizeStatement {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        write!(f, "finalize(")?;
-        for (i, param) in self.arguments.iter().enumerate() {
-            write!(f, "{param}")?;
-            if i < self.arguments.len() - 1 {
-                write!(f, ", ")?;
-            }
-        }
-        write!(f, ");")
-    }
-}
-
-crate::simple_node_impl!(FinalizeStatement);

compiler/ast/src/statement/mod.rs

@@ -35,9 +35,6 @@ pub use definition::*;
 pub mod expression;
 pub use expression::*;
 
-pub mod finalize;
-pub use finalize::*;
-
 pub mod increment;
 pub use increment::*;
 
@@ -71,8 +68,6 @@ pub enum Statement {
     Definition(DefinitionStatement),
     /// An expression statement
     Expression(ExpressionStatement),
-    /// A finalize statement.
-    Finalize(FinalizeStatement),
     /// An increment statement.
     Increment(IncrementStatement),
     /// A `for` statement.
@@ -101,7 +96,6 @@ impl fmt::Display for Statement {
             Statement::Decrement(x) => x.fmt(f),
             Statement::Definition(x) => x.fmt(f),
             Statement::Expression(x) => x.fmt(f),
-            Statement::Finalize(x) => x.fmt(f),
             Statement::Increment(x) => x.fmt(f),
             Statement::Iteration(x) => x.fmt(f),
             Statement::Return(x) => x.fmt(f),
@@ -120,7 +114,6 @@ impl Node for Statement {
             Decrement(n) => n.span(),
             Definition(n) => n.span(),
             Expression(n) => n.span(),
-            Finalize(n) => n.span(),
             Increment(n) => n.span(),
             Iteration(n) => n.span(),
             Return(n) => n.span(),
@@ -137,7 +130,6 @@ impl Node for Statement {
             Decrement(n) => n.set_span(span),
             Definition(n) => n.set_span(span),
             Expression(n) => n.set_span(span),
-            Finalize(n) => n.set_span(span),
             Increment(n) => n.set_span(span),
             Iteration(n) => n.set_span(span),
             Return(n) => n.set_span(span),

compiler/ast/src/statement/return_.rs

@@ -25,6 +25,8 @@ use std::fmt;
 pub struct ReturnStatement {
     /// The expression to return to the function caller.
     pub expression: Expression,
+    /// Arguments to the finalize block.
+    pub finalize_arguments: Option<Vec<Expression>>,
     /// The span of `return expression` excluding the semicolon.
     pub span: Span,
 }

compiler/parser/src/parser/statement.rs

@@ -41,9 +41,6 @@ impl ParserContext<'_> {
     pub(crate) fn parse_statement(&mut self) -> Result<Statement> {
         match &self.token.token {
             Token::Return => Ok(Statement::Return(self.parse_return_statement()?)),
-            Token::Async => Ok(Statement::Finalize(self.parse_finalize_statement()?)),
-            // If a finalize token is found without a preceding async token, return an error.
-            Token::Finalize => Err(ParserError::finalize_without_async(self.token.span).into()),
             Token::Increment => Ok(Statement::Increment(self.parse_increment_statement()?)),
             Token::Decrement => Ok(Statement::Decrement(self.parse_decrement_statement()?)),
             Token::If => Ok(Statement::Conditional(self.parse_conditional_statement()?)),
@@ -51,6 +48,8 @@ impl ParserContext<'_> {
             Token::Console => Ok(Statement::Console(self.parse_console_statement()?)),
             Token::Let | Token::Const => Ok(Statement::Definition(self.parse_definition_statement()?)),
             Token::LeftCurly => Ok(Statement::Block(self.parse_block()?)),
+            Token::Async => Err(ParserError::async_finalize_is_deprecated(self.token.span).into()),
+            Token::Finalize => Err(ParserError::finalize_statements_are_deprecated(self.token.span).into()),
             _ => Ok(self.parse_assign_statement()?),
         }
     }
@@ -117,25 +116,36 @@ impl ParserContext<'_> {
     /// Returns a [`ReturnStatement`] AST node if the next tokens represent a return statement.
     fn parse_return_statement(&mut self) -> Result<ReturnStatement> {
         let start = self.expect(&Token::Return)?;
+
         let expression = match self.token.token {
             // If the next token is a semicolon, implicitly return a unit expression, `()`.
-            Token::Semicolon => Expression::Unit(UnitExpression { span: self.token.span }),
+            Token::Semicolon | Token::Then => Expression::Unit(UnitExpression { span: self.token.span }),
             // Otherwise, attempt to parse an expression.
             _ => self.parse_expression()?,
         };
-        self.expect(&Token::Semicolon)?;
-        let span = start + expression.span();
-        Ok(ReturnStatement { span, expression })
-    }
 
-    /// Returns a [`FinalizeStatement`] AST node if the next tokens represent a finalize statement.
+        let finalize_args = match self.token.token {
-    fn parse_finalize_statement(&mut self) -> Result<FinalizeStatement> {
+            Token::Then => {
-        self.expect(&Token::Async)?;
+                // Parse `then`.
-        let start = self.expect(&Token::Finalize)?;
+                self.expect(&Token::Then)?;
-        let (arguments, _, span) = self.parse_paren_comma_list(|p| p.parse_expression().map(Some))?;
+                // Parse `finalize`.
-        self.expect(&Token::Semicolon)?;
+                self.expect(&Token::Finalize)?;
-        let span = start + span;
+                // Parse finalize arguments if they exist.
-        Ok(FinalizeStatement { span, arguments })
+                match self.token.token {
+                    Token::Semicolon => Some(vec![]),
+                    Token::LeftParen => Some(self.parse_paren_comma_list(|p| p.parse_expression().map(Some))?.0),
+                    _ => Some(vec![self.parse_expression()?]),
+                }
+            }
+            _ => None,
+        };
+        let end = self.expect(&Token::Semicolon)?;
+        let span = start + end;
+        Ok(ReturnStatement {
+            span,
+            expression,
+            finalize_arguments: finalize_args,
+        })
     }
 
     /// Returns a [`DecrementStatement`] AST node if the next tokens represent a decrement statement.

compiler/parser/src/tokenizer/lexer.rs

@@ -429,6 +429,7 @@ impl Token {
                     "self" => Token::SelfLower,
                     "string" => Token::String,
                     "struct" => Token::Struct,
+                    "then" => Token::Then,
                     "transition" => Token::Transition,
                     "true" => Token::True,
                     "u8" => Token::U8,

compiler/parser/src/tokenizer/mod.rs

@@ -112,6 +112,7 @@ mod tests {
     string
     struct
     test
+    then
     transition
     true
     u128
@@ -163,7 +164,7 @@ mod tests {
 
             assert_eq!(
                 output,
-                r#""test" "test{}test" "test{}" "{}test" "test{" "test}" "test{test" "test}test" "te{{}}" test_ident 12345 address async bool const else false field finalize for function group i128 i64 i32 i16 i8 if in input let mut private program public return scalar self string struct test transition true u128 u64 u32 u16 u8 console ! != && ( ) * ** + , - -> => _ . .. / : ; < <= = == > >= [ ] { { } } || ? @ // test
+                r#""test" "test{}test" "test{}" "{}test" "test{" "test}" "test{test" "test}test" "te{{}}" test_ident 12345 address async bool const else false field finalize for function group i128 i64 i32 i16 i8 if in input let mut private program public return scalar self string struct test then transition true u128 u64 u32 u16 u8 console ! != && ( ) * ** + , - -> => _ . .. / : ; < <= = == > >= [ ] { { } } || ? @ // test
  /* test */ // "#
             );
         });

compiler/parser/src/tokenizer/token.rs

@@ -134,6 +134,7 @@ pub enum Token {
     SelfLower,
     Static,
     Struct,
+    Then,
     Transition,
     // For imports.
     Leo,
@@ -182,6 +183,7 @@ pub const KEYWORD_TOKENS: &[Token] = &[
     Token::Static,
     Token::String,
     Token::Struct,
+    Token::Then,
     Token::Transition,
     Token::True,
     Token::U8,
@@ -236,6 +238,7 @@ impl Token {
             Token::Static => sym::Static,
             Token::String => sym::string,
             Token::Struct => sym::Struct,
+            Token::Then => sym::then,
             Token::Transition => sym::transition,
             Token::True => sym::True,
             Token::U8 => sym::u8,
@@ -355,6 +358,7 @@ impl fmt::Display for Token {
             SelfLower => write!(f, "self"),
             Static => write!(f, "static"),
             Struct => write!(f, "struct"),
+            Then => write!(f, "then"),
             Transition => write!(f, "transition"),
             Leo => write!(f, "leo"),
             Eof => write!(f, "<eof>"),

compiler/passes/src/code_generation/visit_statements.rs

@@ -18,8 +18,8 @@ use crate::CodeGenerator;
 
 use leo_ast::{
     AssignStatement, Block, ConditionalStatement, ConsoleFunction, ConsoleStatement, DecrementStatement,
-    DefinitionStatement, Expression, ExpressionStatement, FinalizeStatement, IncrementStatement, IterationStatement,
+    DefinitionStatement, Expression, ExpressionStatement, IncrementStatement, IterationStatement, Mode, Output,
-    Mode, Output, ReturnStatement, Statement,
+    ReturnStatement, Statement,
 };
 
 use itertools::Itertools;
@@ -35,7 +35,6 @@ impl<'a> CodeGenerator<'a> {
             Statement::Decrement(stmt) => self.visit_decrement(stmt),
             Statement::Definition(stmt) => self.visit_definition(stmt),
             Statement::Expression(stmt) => self.visit_expression_statement(stmt),
-            Statement::Finalize(stmt) => self.visit_finalize(stmt),
             Statement::Increment(stmt) => self.visit_increment(stmt),
             Statement::Iteration(stmt) => self.visit_iteration(stmt),
             Statement::Return(stmt) => self.visit_return(stmt),
@@ -43,7 +42,7 @@ impl<'a> CodeGenerator<'a> {
     }
 
     fn visit_return(&mut self, input: &'a ReturnStatement) -> String {
-        match input.expression {
+        let mut instructions = match input.expression {
             // Skip empty return statements.
             Expression::Unit(_) => String::new(),
             _ => {
@@ -100,7 +99,24 @@ impl<'a> CodeGenerator<'a> {
 
                 expression_instructions
             }
+        };
+
+        // Output a finalize instruction if needed.
+        // TODO: Check formatting.
+        if let Some(arguments) = &input.finalize_arguments {
+            let mut finalize_instruction = "\n    finalize".to_string();
+
+            for argument in arguments.iter() {
+                let (argument, argument_instructions) = self.visit_expression(argument);
+                write!(finalize_instruction, " {}", argument).expect("failed to write to string");
+                instructions.push_str(&argument_instructions);
             }
+            writeln!(finalize_instruction, ";").expect("failed to write to string");
+
+            instructions.push_str(&finalize_instruction);
+        }
+
+        instructions
     }
 
     fn visit_definition(&mut self, _input: &'a DefinitionStatement) -> String {
@@ -137,20 +153,6 @@ impl<'a> CodeGenerator<'a> {
         instructions
     }
 
-    fn visit_finalize(&mut self, input: &'a FinalizeStatement) -> String {
-        let mut instructions = String::new();
-        let mut finalize_instruction = "    finalize".to_string();
-
-        for argument in input.arguments.iter() {
-            let (argument, argument_instructions) = self.visit_expression(argument);
-            write!(finalize_instruction, " {argument}").expect("failed to write to string");
-            instructions.push_str(&argument_instructions);
-        }
-        writeln!(finalize_instruction, ";").expect("failed to write to string");
-
-        finalize_instruction
-    }
-
     fn visit_assign(&mut self, input: &'a AssignStatement) -> String {
         match (&input.place, &input.value) {
             (Expression::Identifier(identifier), _) => {

compiler/passes/src/flattening/flatten_program.rs

@@ -16,7 +16,7 @@
 
 use crate::Flattener;
 
-use leo_ast::{Finalize, FinalizeStatement, Function, ProgramReconstructor, Statement, StatementReconstructor, Type};
+use leo_ast::{Finalize, Function, ProgramReconstructor, StatementReconstructor, Type};
 
 impl ProgramReconstructor for Flattener<'_> {
     /// Flattens a function's body and finalize block, if it exists.
@@ -37,12 +37,9 @@ impl ProgramReconstructor for Flattener<'_> {
             // Get all of the guards and return expression.
             let returns = self.clear_early_returns();
 
-            // If the finalize block contains return statements, then we fold them into a single return statement.
+            // Fold the return statements into the block.
             self.fold_returns(&mut block, returns);
 
-            // Initialize `self.finalizes` with the appropriate number of vectors.
-            self.finalizes = vec![vec![]; finalize.input.len()];
-
             Finalize {
                 identifier: finalize.identifier,
                 input: finalize.input,
@@ -67,42 +64,9 @@ impl ProgramReconstructor for Flattener<'_> {
         // Get all of the guards and return expression.
         let returns = self.clear_early_returns();
 
-        // If the function contains return statements, then we fold them into a single return statement.
+        // Fold the return statements into the block.
         self.fold_returns(&mut block, returns);
 
-        // If the function has a finalize block, then type checking guarantees that it has at least one finalize statement.
-        if finalize.is_some() {
-            // Get all of the guards and finalize expression.
-            let finalize_arguments = self.clear_early_finalizes();
-            let arguments = match finalize_arguments.iter().all(|component| component.is_empty()) {
-                // If the finalize statement takes no arguments, then output an empty vector.
-                true => vec![],
-                // If the function contains finalize statements with at least one argument, then we fold them into a vector of arguments.
-                // Note that `finalizes` is always initialized to the appropriate number of vectors.
-                false => {
-                    // Construct an expression for each argument to the finalize statement.
-                    finalize_arguments
-                        .into_iter()
-                        .enumerate()
-                        .map(|(i, component)| {
-                            let (expression, stmts) = self.fold_guards(format!("fin${i}$").as_str(), component);
-
-                            // Add all of the accumulated statements to the end of the block.
-                            block.statements.extend(stmts);
-
-                            expression
-                        })
-                        .collect()
-                }
-            };
-
-            // Add the `FinalizeStatement` to the end of the block.
-            block.statements.push(Statement::Finalize(FinalizeStatement {
-                arguments,
-                span: Default::default(),
-            }));
-        }
-
         Function {
             annotations: function.annotations,
             call_type: function.call_type,

compiler/passes/src/flattening/flatten_statement.rs

@@ -20,8 +20,8 @@ use std::borrow::Borrow;
 
 use leo_ast::{
     AssignStatement, BinaryExpression, BinaryOperation, Block, ConditionalStatement, ConsoleFunction, ConsoleStatement,
-    DefinitionStatement, Expression, ExpressionReconstructor, FinalizeStatement, Identifier, IterationStatement, Node,
+    DefinitionStatement, Expression, ExpressionReconstructor, Identifier, IterationStatement, Node, ReturnStatement,
-    ReturnStatement, Statement, StatementReconstructor, TupleExpression, Type, UnaryExpression, UnaryOperation,
+    Statement, StatementReconstructor, TupleExpression, Type, UnaryExpression, UnaryOperation,
 };
 
 impl StatementReconstructor for Flattener<'_> {
@@ -367,23 +367,6 @@ impl StatementReconstructor for Flattener<'_> {
         unreachable!("`DefinitionStatement`s should not exist in the AST at this phase of compilation.")
     }
 
-    /// Replaces a finalize statement with an empty block statement.
-    /// Stores the arguments to the finalize statement, which are later folded into a single finalize statement at the end of the function.
-    fn reconstruct_finalize(&mut self, input: FinalizeStatement) -> (Statement, Self::AdditionalOutput) {
-        // Construct the associated guard.
-        let guard = self.construct_guard();
-
-        // For each finalize argument, add it and its associated guard to the appropriate list of finalize arguments.
-        // Note that type checking guarantees that the number of arguments in a finalize statement is equal to the number of arguments in to the finalize block.
-        for (i, argument) in input.arguments.into_iter().enumerate() {
-            // Note that the argument is not reconstructed.
-            // Note that this unwrap is safe since we initialize `self.finalizes` with a number of vectors equal to the number of finalize arguments.
-            self.finalizes.get_mut(i).unwrap().push((guard.clone(), argument));
-        }
-
-        (Statement::dummy(Default::default()), Default::default())
-    }
-
     // TODO: Error message requesting the user to enable loop-unrolling.
     fn reconstruct_iteration(&mut self, _input: IterationStatement) -> (Statement, Self::AdditionalOutput) {
         unreachable!("`IterationStatement`s should not be in the AST at this phase of compilation.");
@@ -398,14 +381,22 @@ impl StatementReconstructor for Flattener<'_> {
         // Add it to `self.returns`.
         // Note that SSA guarantees that `input.expression` is either a literal or identifier.
         match input.expression {
-            // If the input is an identifier that maps to a tuple, add the corresponding tuple to `self.returns`
+            // If the input is an identifier that maps to a tuple,
+            // construct a `ReturnStatement` with the tuple and add it to `self.returns`
             Expression::Identifier(identifier) if self.tuples.contains_key(&identifier.name) => {
                 // Note that the `unwrap` is safe since the match arm checks that the entry exists in `self.tuples`.
                 let tuple = self.tuples.get(&identifier.name).unwrap().clone();
-                self.returns.push((guard, Expression::Tuple(tuple)))
+                self.returns.push((
+                    guard,
+                    ReturnStatement {
+                        span: input.span,
+                        expression: Expression::Tuple(tuple),
+                        finalize_arguments: input.finalize_arguments,
+                    },
+                ));
             }
             // Otherwise, add the expression directly.
-            _ => self.returns.push((guard, input.expression)),
+            _ => self.returns.push((guard, input)),
         };
 
         (Statement::dummy(Default::default()), Default::default())

compiler/passes/src/flattening/flattener.rs

@@ -37,12 +37,7 @@ pub struct Flattener<'a> {
     /// A guard is an expression that evaluates to true on the execution path of the `ReturnStatement`.
     /// Note that returns are inserted in the order they are encountered during a pre-order traversal of the AST.
     /// Note that type checking guarantees that there is at most one return in a basic block.
-    pub(crate) returns: Vec<(Option<Expression>, Expression)>,
+    pub(crate) returns: Vec<(Option<Expression>, ReturnStatement)>,
-    /// A list containing tuples of guards and expressions associated with `FinalizeStatement`s.
-    /// A guard is an expression that evaluates to true on the execution path of the `FinalizeStatement`.
-    /// Note that finalizes are inserted in the order they are encountered during a pre-order traversal of the AST.
-    /// Note that type checking guarantees that there is at most one finalize in a basic block.
-    pub(crate) finalizes: Vec<Vec<(Option<Expression>, Expression)>>,
     /// A mapping between variables and flattened tuple expressions.
     pub(crate) tuples: IndexMap<Symbol, TupleExpression>,
 }
@@ -55,21 +50,15 @@ impl<'a> Flattener<'a> {
             structs: IndexMap::new(),
             condition_stack: Vec::new(),
             returns: Vec::new(),
-            finalizes: Vec::new(),
             tuples: IndexMap::new(),
         }
     }
 
     /// Clears the state associated with `ReturnStatements`, returning the ones that were previously stored.
-    pub(crate) fn clear_early_returns(&mut self) -> Vec<(Option<Expression>, Expression)> {
+    pub(crate) fn clear_early_returns(&mut self) -> Vec<(Option<Expression>, ReturnStatement)> {
         core::mem::take(&mut self.returns)
     }
 
-    /// Clears the state associated with `FinalizeStatements`, returning the ones that were previously stored.
-    pub(crate) fn clear_early_finalizes(&mut self) -> Vec<Vec<(Option<Expression>, Expression)>> {
-        core::mem::take(&mut self.finalizes)
-    }
-
     /// Constructs a guard from the current state of the condition stack.
     pub(crate) fn construct_guard(&mut self) -> Option<Expression> {
         match self.condition_stack.is_empty() {
@@ -197,18 +186,56 @@ impl<'a> Flattener<'a> {
     }
 
     /// Folds a list of return statements into a single return statement and adds the produced statements to the block.
-    pub(crate) fn fold_returns(&mut self, block: &mut Block, returns: Vec<(Option<Expression>, Expression)>) {
+    pub(crate) fn fold_returns(&mut self, block: &mut Block, returns: Vec<(Option<Expression>, ReturnStatement)>) {
         if !returns.is_empty() {
-            let (expression, stmts) = self.fold_guards("ret$", returns);
+            let mut return_expressions = Vec::with_capacity(returns.len());
 
-            // TODO: Flatten tuples in the return statements.
+            // Construct a vector for each argument position.
+            // Note that the indexing is safe since we check that `returns` is not empty.
+            let (has_finalize, number_of_finalize_arguments) = match &returns[0].1.finalize_arguments {
+                None => (false, 0),
+                Some(args) => (true, args.len()),
+            };
+            let mut finalize_arguments: Vec<Vec<(Option<Expression>, Expression)>> =
+                vec![Vec::with_capacity(returns.len()); number_of_finalize_arguments];
+
+            // Aggregate the return expressions and finalize arguments and their respective guards.
+            for (guard, return_statement) in returns {
+                return_expressions.push((guard.clone(), return_statement.expression));
+                if let Some(arguments) = return_statement.finalize_arguments {
+                    for (i, argument) in arguments.into_iter().enumerate() {
+                        // Note that the indexing is safe since we initialize `finalize_arguments` with the correct length.
+                        finalize_arguments[i].push((guard.clone(), argument));
+                    }
+                }
+            }
+
+            // Fold the return expressions into a single expression.
+            let (expression, stmts) = self.fold_guards("$ret", return_expressions);
 
             // Add all of the accumulated statements to the end of the block.
             block.statements.extend(stmts);
 
+            // For each position in the finalize call, fold the corresponding arguments into a single expression.
+            let finalize_arguments = match has_finalize {
+                false => None,
+                true => Some(
+                    finalize_arguments
+                        .into_iter()
+                        .enumerate()
+                        .map(|(i, arguments)| {
+                            let (expression, stmts) = self.fold_guards(&format!("finalize${i}$"), arguments);
+                            block.statements.extend(stmts);
+                            expression
+                        })
+                        .collect(),
+                ),
+            };
+
             // Add the `ReturnStatement` to the end of the block.
             block.statements.push(Statement::Return(ReturnStatement {
                 expression,
+                finalize_arguments,
                 span: Default::default(),
             }));
         }

compiler/passes/src/static_single_assignment/rename_statement.rs

@@ -18,9 +18,9 @@ use crate::{RenameTable, StaticSingleAssigner};
 
 use leo_ast::{
     AssignStatement, Block, CallExpression, ConditionalStatement, ConsoleFunction, ConsoleStatement,
-    DecrementStatement, DefinitionStatement, Expression, ExpressionConsumer, ExpressionStatement, FinalizeStatement,
+    DecrementStatement, DefinitionStatement, Expression, ExpressionConsumer, ExpressionStatement, Identifier,
-    Identifier, IncrementStatement, IterationStatement, ReturnStatement, Statement, StatementConsumer,
+    IncrementStatement, IterationStatement, ReturnStatement, Statement, StatementConsumer, TernaryExpression,
-    TernaryExpression, TupleExpression,
+    TupleExpression,
 };
 use leo_span::Symbol;
 
@@ -297,30 +297,6 @@ impl StatementConsumer for StaticSingleAssigner<'_> {
         statements
     }
 
-    /// Consumes the expressions associated with the `FinalizeStatement`, returning the simplified `FinalizeStatement`.
-    fn consume_finalize(&mut self, input: FinalizeStatement) -> Self::Output {
-        let mut statements = Vec::new();
-
-        // Process the arguments, accumulating any statements produced.
-        let arguments = input
-            .arguments
-            .into_iter()
-            .map(|argument| {
-                let (argument, stmts) = self.consume_expression(argument);
-                statements.extend(stmts);
-                argument
-            })
-            .collect();
-
-        // Construct and accumulate a simplified finalize statement.
-        statements.push(Statement::Finalize(FinalizeStatement {
-            arguments,
-            span: input.span,
-        }));
-
-        statements
-    }
-
     /// Consumes the expressions associated with the `IncrementStatement`, returning a simplified `IncrementStatement`.
     fn consume_increment(&mut self, input: IncrementStatement) -> Self::Output {
         // First consume the expression associated with the amount.
@@ -351,9 +327,23 @@ impl StatementConsumer for StaticSingleAssigner<'_> {
         // Consume the return expression.
         let (expression, mut statements) = self.consume_expression(input.expression);
 
+        // Consume the finalize arguments if they exist.
+        // Process the arguments, accumulating any statements produced.
+        let finalize_args = input.finalize_arguments.map(|arguments| {
+            arguments
+                .into_iter()
+                .map(|argument| {
+                    let (argument, stmts) = self.consume_expression(argument);
+                    statements.extend(stmts);
+                    argument
+                })
+                .collect()
+        });
+
         // Add the simplified return statement to the list of produced statements.
         statements.push(Statement::Return(ReturnStatement {
             expression,
+            finalize_arguments: finalize_args,
             span: input.span,
         }));
 

compiler/passes/src/type_checking/check_statements.rs

@@ -37,7 +37,6 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
             Statement::Decrement(stmt) => self.visit_decrement(stmt),
             Statement::Definition(stmt) => self.visit_definition(stmt),
             Statement::Expression(stmt) => self.visit_expression_statement(stmt),
-            Statement::Finalize(stmt) => self.visit_finalize(stmt),
             Statement::Increment(stmt) => self.visit_increment(stmt),
             Statement::Iteration(stmt) => self.visit_iteration(stmt),
             Statement::Return(stmt) => self.visit_return(stmt),
@@ -273,54 +272,6 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
         }
     }
 
-    fn visit_finalize(&mut self, input: &'a FinalizeStatement) {
-        if self.is_finalize {
-            self.emit_err(TypeCheckerError::finalize_in_finalize(input.span()));
-        }
-
-        // Set the `has_finalize` flag.
-        self.has_finalize = true;
-
-        // Check that the function has a finalize block.
-        // Note that `self.function.unwrap()` is safe since every `self.function` is set for every function.
-        // Note that `(self.function.unwrap()).unwrap()` is safe since all functions have been checked to exist.
-        let finalize = self
-            .symbol_table
-            .borrow()
-            .lookup_fn_symbol(self.function.unwrap())
-            .unwrap()
-            .finalize
-            .clone();
-        match finalize {
-            None => self.emit_err(TypeCheckerError::finalize_without_finalize_block(input.span())),
-            Some(finalize) => {
-                // Check number of function arguments.
-                if finalize.input.len() != input.arguments.len() {
-                    self.emit_err(TypeCheckerError::incorrect_num_args_to_finalize(
-                        finalize.input.len(),
-                        input.arguments.len(),
-                        input.span(),
-                    ));
-                }
-
-                // Check function argument types.
-                finalize
-                    .input
-                    .iter()
-                    .zip(input.arguments.iter())
-                    .for_each(|(expected, argument)| {
-                        // Check that none of the arguments are tuple expressions.
-                        if matches!(argument, Expression::Tuple(_)) {
-                            self.emit_err(TypeCheckerError::finalize_statement_cannot_contain_tuples(
-                                argument.span(),
-                            ));
-                        }
-                        self.visit_expression(argument, &Some(expected.type_()));
-                    });
-            }
-        }
-    }
-
     fn visit_increment(&mut self, input: &'a IncrementStatement) {
         if !self.is_finalize {
             self.emit_err(TypeCheckerError::increment_or_decrement_outside_finalize(input.span()));
@@ -413,7 +364,7 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
     }
 
     fn visit_return(&mut self, input: &'a ReturnStatement) {
-        // we can safely unwrap all self.parent instances because
+        // We can safely unwrap all self.parent instances because
         // statements should always have some parent block
         let parent = self.function.unwrap();
         let return_type = &self
@@ -439,11 +390,53 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
             }
         }
 
-        // Set the `is_return` flag.
+        // Set the `is_return` flag. This is necessary to allow unit expressions in the return statement.
         self.is_return = true;
         // Type check the associated expression.
         self.visit_expression(&input.expression, return_type);
         // Unset the `is_return` flag.
         self.is_return = false;
+
+        if let Some(arguments) = &input.finalize_arguments {
+            if self.is_finalize {
+                self.emit_err(TypeCheckerError::finalize_in_finalize(input.span()));
+            }
+
+            // Set the `has_finalize` flag.
+            self.has_finalize = true;
+
+            // Check that the function has a finalize block.
+            // Note that `self.function.unwrap()` is safe since every `self.function` is set for every function.
+            // Note that `(self.function.unwrap()).unwrap()` is safe since all functions have been checked to exist.
+            let finalize = self
+                .symbol_table
+                .borrow()
+                .lookup_fn_symbol(self.function.unwrap())
+                .unwrap()
+                .finalize
+                .clone();
+            match finalize {
+                None => self.emit_err(TypeCheckerError::finalize_without_finalize_block(input.span())),
+                Some(finalize) => {
+                    // Check number of function arguments.
+                    if finalize.input.len() != arguments.len() {
+                        self.emit_err(TypeCheckerError::incorrect_num_args_to_finalize(
+                            finalize.input.len(),
+                            arguments.len(),
+                            input.span(),
+                        ));
+                    }
+
+                    // Check function argument types.
+                    finalize
+                        .input
+                        .iter()
+                        .zip(arguments.iter())
+                        .for_each(|(expected, argument)| {
+                            self.visit_expression(argument, &Some(expected.type_()));
+                        });
+                }
+            }
+        }
     }
 }

compiler/passes/src/type_checking/checker.rs

@@ -33,7 +33,7 @@ pub struct TypeChecker<'a> {
     pub(crate) function: Option<Symbol>,
     /// Whether or not the function that we are currently traversing has a return statement.
     pub(crate) has_return: bool,
-    /// Whether or not the function that we are currently traversing has a finalize statement.
+    /// Whether or not the function that we are currently traversing invokes the finalize block.
     pub(crate) has_finalize: bool,
     /// Whether or not we are currently traversing a transition function.
     pub(crate) is_transition_function: bool,

compiler/span/src/symbol.rs

@@ -214,6 +214,7 @@ symbols! {
     std,
     Struct: "struct",
     test,
+    then,
     transition,
     Type: "type",
 

errors/src/errors/parser/parser_errors.rs

@@ -228,13 +228,6 @@ create_messages!(
         help: Some("Remove whitespace between the `@` symbol and the identifier.".to_string()),
     }
 
-    @formatted
-    finalize_without_async {
-        args: (),
-        msg: "A finalize statement must be preceded by the `async` keyword.",
-        help: Some("Add the `async` keyword before the `finalize` keyword.".to_string()),
-    }
-
     @formatted
     circuit_is_deprecated {
         args: (),
@@ -269,4 +262,18 @@ create_messages!(
         msg: format!("A tuple {kind} must have at least two elements."),
         help: None,
     }
+
+    @formatted
+    async_finalize_is_deprecated {
+        args: (),
+        msg: format!("`async finalize` is deprecated."),
+        help: Some("Use `return <expr> then finalize(<args>)` instead.".to_string()),
+    }
+
+    @formatted
+    finalize_statements_are_deprecated {
+        args: (),
+        msg: format!("`finalize` statements are deprecated."),
+        help: Some("Use `return <expr> then finalize(<args>)` instead.".to_string()),
+    }
 );

examples/basic_bank/src/main.leo

@@ -43,9 +43,7 @@ program basic_bank.aleo {
         // Compute the hash of the token owner.
         let hash: field = BHP256::hash(token.owner);
 
-        async finalize(hash, amount);
+        return remaining then finalize(hash, amount);
-
-        return remaining;
     }
 
     // Updates on-chain state by the amount of tokens deposited.
@@ -73,9 +71,7 @@ program basic_bank.aleo {
             amount: total,
         };
 
-        async finalize(hash, amount);
+        return token then finalize(hash, amount);
-
-        return token;
     }
 
     // Updates on-chain state by the amount of tokens withdrawn.

examples/token/src/main.leo

@@ -17,7 +17,7 @@ program token.aleo {
     // The function `mint_public` issues the specified token amount for the token receiver publicly on the network.
     transition mint_public(public receiver: address, public amount: u64) {
         // Mint the tokens publicly by invoking the computation on-chain.
-        async finalize(receiver, amount);
+        return then finalize(receiver, amount);
     }
 
     finalize mint_public(public receiver: address, public amount: u64) {
@@ -39,7 +39,7 @@ program token.aleo {
     /* Transfer */
     transition transfer_public(public receiver: address, public amount: u64) {
         // Transfer the tokens publicly, by invoking the computation on-chain.
-        async finalize(self.caller, receiver, amount);
+        return then finalize(self.caller, receiver, amount);
     }
 
     finalize transfer_public(public sender: address, public receiver: address, public amount: u64) {
@@ -93,11 +93,9 @@ program token.aleo {
             amount: difference,
         };
 
-        // Increment the token amount publicly for the token receiver.
-        async finalize(receiver, amount);
-
         // Output the sender's change record.
-        return remaining;
+        // Increment the token amount publicly for the token receiver.
+        return remaining then finalize(receiver, amount);
     }
 
     finalize transfer_private_to_public(public receiver: address, public amount: u64) {
@@ -117,11 +115,9 @@ program token.aleo {
             amount: amount,
         };
 
-        // Decrement the token amount of the caller publicly.
-        async finalize(self.caller, amount);
-
         // Output the receiver's record.
-        return transferred;
+        // Decrement the token amount of the caller publicly.
+        return transferred then finalize(self.caller, amount);
     }
 
     finalize transfer_public_to_private(public sender: address, public amount: u64) {

examples/vote/src/main.leo

@@ -40,16 +40,15 @@ program vote.aleo {
         // Generate a new proposal id.
         let id: field = BHP256::hash(info.title);
 
-        // Finalize the proposal id.
-        async finalize(id);
 
         // Return a new record for the proposal.
+        // Finalize the proposal id.
         return Proposal {
             owner: self.caller,
             gates: 0u64,
             id,
             info,
-        };
+        } then finalize(id);
     }
     // Create a new proposal in the "tickets" mapping.
     finalize propose(public id: field) {
@@ -61,14 +60,13 @@ program vote.aleo {
         public pid: field,
         public voter: address,
     ) -> Ticket {
-        // Finalize the proposal id for the ticket.
-        async finalize(pid);
 
+        // Finalize the proposal id for the ticket.
         return Ticket {
             owner: voter,
             gates: 0u64,
             pid,
-        };
+        } then finalize(pid);
     }
     // Create a new ticket on a proposal in the "tickets" mapping.
     finalize new_ticket(public pid: field) {
@@ -78,7 +76,7 @@ program vote.aleo {
     // Vote privately to agree with a proposal.
     transition agree(ticket: Ticket) {
         // Finalize this vote.
-        async finalize(ticket.pid);
+        return then finalize(ticket.pid);
     }
     finalize agree(public pid: field) {
         // Publicly increment the number of agree votes.
@@ -88,7 +86,7 @@ program vote.aleo {
     // Vote privately to disagree with a proposal.
     transition disagree(ticket: Ticket) {
         // Finalize this vote.
-        async finalize(ticket.pid);
+        return then finalize(ticket.pid);
     }
     finalize disagree(pid: field) {
         // Publicly increment the number of disagree votes.

tests/compiler/finalize/closure_with_finalize_fail.leo

@@ -5,8 +5,7 @@ expectation: Fail
 
 program test.aleo {    
     function foo(a: u8, b: u8) -> u8 {
-        async finalize(a, b);
+        return a + b then finalize(a, b);
-        return a + b;
     }
     
     function bar(a: u8, b: u8) -> u8 {
@@ -19,7 +18,7 @@ program test.aleo {
     
     
     function mint_public(receiver: address, amount: u64) {
-        async finalize(receiver, amount);
+        return then finalize(receiver, amount);
     }
     
     finalize mint_public(receiver: address, amount: u64) {

tests/compiler/finalize/decrement.leo

@@ -7,7 +7,7 @@ program test.aleo {
     mapping amounts: address => u128;
     
     transition decrease_self(amount: u128) {
-        async finalize(self.caller, amount);
+        return then finalize(self.caller, amount);
     }
     
     finalize decrease_self(addr: address, amount: u128) {

tests/compiler/finalize/decrement_incorrect_type.leo

@@ -14,7 +14,7 @@ program test.aleo {
     mapping tokens: address => Token;
     
     transition decrease_self(amount: u128) {
-        async finalize(self.caller, amount);
+        return then finalize(self.caller, amount);
     }
     
     finalize decrease_self(addr: address, amount: u128) {

tests/compiler/finalize/empty_finalize_fail.leo

@@ -6,7 +6,7 @@ expectation: Fail
 program test.aleo {    
     
     transition mint_public(public receiver: address, public amount: u64) {
-        async finalize(receiver, amount);
+        return then finalize(receiver, amount);
     }
     
     finalize mint_public (public receiver: address, public amount: u64) {}

tests/compiler/finalize/finalize.leo

@@ -8,15 +8,23 @@ program test.aleo {
     mapping values: u8 => u8;
     
     transition mint_public(public receiver: address, public amount: u64) {
-        async finalize(receiver, amount);
+        return then finalize(receiver, amount);
     }
     
     finalize mint_public (public receiver: address, public amount: u64) {
         increment(account, receiver, amount);
     }
     
+    transition public_adder(public a: u8, public b: u8) {
+        return then finalize(a, b);
+    }
+
+    finalize public_adder(a: u8, b: u8) -> public u8 {
+        return a + b;
+    }
+    
     transition finalize_no_params() {
-        async finalize();
+        return then finalize();
     }
     
     finalize finalize_no_params() {

tests/compiler/finalize/finalize_incorrect_modes_fail.leo

@@ -7,7 +7,7 @@ program test.aleo {
     mapping account: address => u64;
     
     transition mint_public(public receiver: address, public amount: u64) {
-        async finalize(receiver, amount);
+        return then finalize(receiver, amount);
     }
     
     finalize mint_public (public receiver: address, constant amount: u64) -> constant u64 {
@@ -15,7 +15,7 @@ program test.aleo {
     }
     
     transition mint_public2(public receiver: address, public amount: u64) {
-        async finalize(receiver, amount);
+        return then finalize(receiver, amount);
     }
     
     finalize mint_public2(public receiver: address, amount: u64) -> u64 {

tests/compiler/finalize/finalize_incorrect_return_fail.leo

@@ -7,7 +7,7 @@ program test.aleo {
     mapping account: address => u64;
     
     transition mint_public(public receiver: address, public amount: u64) {
-        async finalize(receiver, amount);
+        return then finalize(receiver, amount);
     }
     
     finalize mint_public(public receiver: address, public amount: u64) -> u64 {

tests/compiler/finalize/finalize_missing_return_fail.leo

@@ -8,7 +8,7 @@ program test.aleo {
     mapping account: address => u64;
     
     transition mint_public(public receiver: address, public amount: u64) {
-        async finalize(receiver, amount);
+        return then finalize(receiver, amount);
     }
     
     finalize mint_public (public receiver: address, public amount: u64) -> u64 {

tests/compiler/finalize/finalize_name_mismatch_fail.leo

@@ -8,7 +8,7 @@ program test.aleo {
     mapping values: u8 => u8;
     
     transition mint_public(public receiver: address, public amount: u64) {
-        async finalize(receiver, amount);
+        return then finalize(receiver, amount);
     }
     
     finalize mint_private (public receiver: address, public amount: u64) {

tests/compiler/finalize/finalize_statement_incorrect_args_fail.leo

@@ -8,7 +8,7 @@ program test.aleo {
     mapping account: address => u64;
     
     transition mint_public(public receiver: address, public amount: u64) {
-        async finalize(receiver, amount, amount);
+        return then finalize(receiver, amount, amount);
     }
     
     finalize mint_public (public receiver: address, public amount: u64) {

tests/compiler/finalize/finalize_with_return.leo

@@ -8,7 +8,7 @@ program test.aleo {
     mapping values: u8 => u8;
     
     transition mint_public(public receiver: address, public amount: u64) {
-        async finalize(receiver, amount);
+        return then finalize(receiver, amount);
     }
     
     finalize mint_public (public receiver: address, public amount: u64) -> u64 {
@@ -17,7 +17,7 @@ program test.aleo {
     }
     
     transition public_adder(public a: u8, public b: u8) {
-        async finalize(a, b);
+        return then finalize(a, b);
     } finalize public_adder(a: u8, b: u8) -> public u8 {
         return a + b;
     }

tests/compiler/finalize/increment.leo

@@ -7,7 +7,7 @@ program test.aleo {
     mapping amounts: address => u128;
     
     transition increase_self(amount: u128) {
-        async finalize(self.caller, amount);
+        return then finalize(self.caller, amount);
     }
     
     finalize increase_self(addr: address, amount: u128) {

tests/compiler/finalize/increment_incorrect_type.leo

@@ -14,7 +14,7 @@ program test.aleo {
     mapping tokens: address => Token;
     
     transition increase_self(amount: u128) {
-        async finalize(self.caller, amount);
+        return then finalize(self.caller, amount);
     }
     
     finalize increase_self(addr: address, amount: u128) {

tests/compiler/finalize/read_write_mapping_fail.leo

@@ -23,7 +23,7 @@ program test.aleo {
     }
     
     function write_in_finalize(public addr: address, public amount: u128) {
-        async finalize(addr, amount);
+        return then finalize(addr, amount);
     }
     
     finalize write_in_finalize(public: addr: address, public amount: u128) {

tests/compiler/function/self.leo

@@ -5,8 +5,7 @@ expectation: Pass
 
 program test.aleo {    
     transition matches(addr: address) -> bool {
-        async finalize(self.caller);
+        return self.caller == addr then finalize(self.caller);
-        return self.caller == addr;
     } finalize matches(addr: address) -> bool {
         return addr == self.caller;
     }

tests/expectations/compiler/address/binary.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 30ff54da2da7a73c10f6cc96ea951755d57840fe3bcd0c9d6c68b8ed6c4024e2
-    initial_ast: 328cfc8f311133cb9f2622be2f93a1b624ff7f290dae03c0c4fedd6a139770ff
+    initial_ast: 6a1cec2a4840e7dd92fd8e1c0f19bf0f4c973cecd56c20bbed6af57969d2bd1e
-    unrolled_ast: 328cfc8f311133cb9f2622be2f93a1b624ff7f290dae03c0c4fedd6a139770ff
+    unrolled_ast: 6a1cec2a4840e7dd92fd8e1c0f19bf0f4c973cecd56c20bbed6af57969d2bd1e
-    ssa_ast: 798b6c449008ed6a38d603593dd3edf53aa30827e4ad2e0db6ef754999d1d807
+    ssa_ast: dfcc60600fd4bab6efc11e75a295421123b78c8db7047dc80b40b202b3dba991
-    flattened_ast: 305593c39dc0c26ccccb1ed5f1e4fdb932af847cab04990449c0193bc7a2c20f
+    flattened_ast: 9f34fa2659a0989b9156cb71ed559b825d7123475715f030f47dd8ab8be4d4fb

tests/expectations/compiler/address/branch.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 613969730f6ac4ff47e6975f79edf83ac2d5398d029657cbe28d53dd74847d1c
-    initial_ast: 002375784372b4d6b83e0e181998cebd7e25dca957d1c935a08f9227d21ba373
+    initial_ast: 4e26bd74ec1a90ea8923c648196e906a3ccad3572790b466eee11382c47e1713
-    unrolled_ast: 002375784372b4d6b83e0e181998cebd7e25dca957d1c935a08f9227d21ba373
+    unrolled_ast: 4e26bd74ec1a90ea8923c648196e906a3ccad3572790b466eee11382c47e1713
-    ssa_ast: f128dc2ee3b1a636526c27b196e0b755b244cd9d8e52067541214b7909f38cf0
+    ssa_ast: 7433b8afd385c2d81233ab525e1fc9ca1fbd7387461c4de0aedfbafd9b1149fb
-    flattened_ast: 1675206b4e0435049515729daa4468b6d4aab041812bf20758f74b79c40259aa
+    flattened_ast: 6378f55000d09e2cdeed1c1eec71d37fd6ecadc4d618ebb700143f4a5f454632

tests/expectations/compiler/address/equal.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 508ac917fe0d0779f2d43ae7695945dbe1fd00c457f08716dc51bbb2fe14e452
-    initial_ast: f3e09111dcb009c66349bd98ad3ff8bebf753a184e2dafff711a521a43b3b2fc
+    initial_ast: 9404c479dc278c16e5f0e5496373395102f5ab600bb9bce0c183d5e82349e00f
-    unrolled_ast: f3e09111dcb009c66349bd98ad3ff8bebf753a184e2dafff711a521a43b3b2fc
+    unrolled_ast: 9404c479dc278c16e5f0e5496373395102f5ab600bb9bce0c183d5e82349e00f
-    ssa_ast: fda8333d6142536467e05fb5129198882eb028e6a2c0c6ed1d2339b9a716aba1
+    ssa_ast: 405c2bca8b120380bd652f9cb0138dccdb46c02044075c15d38ad7290761e38d
-    flattened_ast: ab7783ad36c7540c555836b66e7c6b07f7681824dfcb58d5bbd3f0ea5fbf6bbd
+    flattened_ast: 4c47ad8af1479770aca65ac434c59955993bff9f085b08b1a3cb774bde711247

tests/expectations/compiler/address/ternary.out

@@ -5,7 +5,7 @@ outputs:
   - output:
       - initial_input_ast: 64247a73944a1639b17e3fd8ae0777b6725a754160afb476f9b0b6b8495d9884
       - initial_input_ast: 9546ede7c01cbe3a4cbedf2296fbc6605f657c2e1843e8f50ef683bc3eedd18a
-    initial_ast: 1baa54d7c29ab84a48f3d52359d0a7c64a3929fd6c3975afe375d8c7c8420da7
+    initial_ast: 8bce21628196fd8ba4aee1242405a3ad388e6a1134ed0cdb1bacef88e6466dce
-    unrolled_ast: 1baa54d7c29ab84a48f3d52359d0a7c64a3929fd6c3975afe375d8c7c8420da7
+    unrolled_ast: 8bce21628196fd8ba4aee1242405a3ad388e6a1134ed0cdb1bacef88e6466dce
-    ssa_ast: 38d2140f8bc0308859260c927be943d2671ce80eb9ef4c22b42a4090ffab9728
+    ssa_ast: 7c511088daa0755fff5f8b6ae6eb472aa38b51ae645e757fdeb24db29c8d2eef
-    flattened_ast: a0e0a2c74ebd61346d568368f55cacaa7417070467925dbfc10754b5c1fa4437
+    flattened_ast: 2e31550270897fd3931ab4040568d12b79ea100e9cbf37d0f43de038788cc072

tests/expectations/compiler/boolean/and.out

@@ -7,7 +7,7 @@ outputs:
       - initial_input_ast: 37716c2fa42ffae9077a4a85bb1efeb2f57ea313defd50fd490884db90feab9f
       - initial_input_ast: 97d29f6252adc86e152adf3bfde485a50154cdefa8ec4ffcd70dfe7c86a8ce10
       - initial_input_ast: 31529bed8d853012affec3525b28f05d69a8f3398e75efed74e49709ff89e5d0
-    initial_ast: 9269fac5a002cab579fa96fba2683e139480f7cb36e17e1a97ad0f978bc41d2c
+    initial_ast: 3d39d634c198d80d62ac0d93e7446df62ee49ea2a50328a171184bd71acb56d0
-    unrolled_ast: 9269fac5a002cab579fa96fba2683e139480f7cb36e17e1a97ad0f978bc41d2c
+    unrolled_ast: 3d39d634c198d80d62ac0d93e7446df62ee49ea2a50328a171184bd71acb56d0
-    ssa_ast: 055c1482321089f1c84759b6fb827627ccd6f4e8f460912850409523a551f1b2
+    ssa_ast: dd42b8af78c61a2a922b5d39713610f503898b0407499c90a5fc8d08b29a3d1c
-    flattened_ast: da73712d568e808ed59b4fde16e169cd93c37785d2b108a23f896b115ad8b080
+    flattened_ast: 1684fd357114961933aa2047ae0a430b5821f53a7e0fc3162f4a2ac35dc5aeec

tests/expectations/compiler/boolean/conditional.out

@@ -7,7 +7,7 @@ outputs:
       - initial_input_ast: 878da6994882b56aa391034af5c1076219b172a8ba22273a2d467636644cfdad
       - initial_input_ast: 83d4066d6132815226ebd5db047fa658f136075c99ec054064109c9becb1c82c
       - initial_input_ast: 6ce34942fbaaedb6bba77dbe80723ee803508964445ca437e600b5868e1ed4fd
-    initial_ast: 891b9ffdd456bb562967d74ad2afdd8066450ef63fdca4f234a60435dcd0296a
+    initial_ast: 3f5971e3fdd89e5600c7f0ac4f41fa919661c5b861aea38ac55ddbc38f2c865b
-    unrolled_ast: 891b9ffdd456bb562967d74ad2afdd8066450ef63fdca4f234a60435dcd0296a
+    unrolled_ast: 3f5971e3fdd89e5600c7f0ac4f41fa919661c5b861aea38ac55ddbc38f2c865b
-    ssa_ast: 0e38a8a2cbb256836bd031ef65135645f2a5a531ca199cab96d569009ed89fa7
+    ssa_ast: 5308162ac930d71cef23608546eccf84389db548743bb9a1c9b90483c73dd853
-    flattened_ast: 3503363a685653128309a3f28e24df051b8fd66bdb8d287db26bfd182fbb576b
+    flattened_ast: c2b13812ef8ac64f04bc29b7481e6a7be7c8916ba2f5fd71e1d1856a9e13a165

tests/expectations/compiler/boolean/equal.out

@@ -7,7 +7,7 @@ outputs:
       - initial_input_ast: 37716c2fa42ffae9077a4a85bb1efeb2f57ea313defd50fd490884db90feab9f
       - initial_input_ast: 97d29f6252adc86e152adf3bfde485a50154cdefa8ec4ffcd70dfe7c86a8ce10
       - initial_input_ast: 31529bed8d853012affec3525b28f05d69a8f3398e75efed74e49709ff89e5d0
-    initial_ast: cd14a221e3a2df0159db5218598bf1c511a28be47dd74200aaa8f1d6250ea4c7
+    initial_ast: b075d566065215a06239a0cebf5357fa5a3aec72aad1482463bc15cedf59ad03
-    unrolled_ast: cd14a221e3a2df0159db5218598bf1c511a28be47dd74200aaa8f1d6250ea4c7
+    unrolled_ast: b075d566065215a06239a0cebf5357fa5a3aec72aad1482463bc15cedf59ad03
-    ssa_ast: da168bc2b396c6c0f76ddf29b2ee5993a40bf35921fcd7f61afe29fdaca734e9
+    ssa_ast: d8e64b87fce6bafb3e3307be1db69bb6aabc3f6182785239486bb654a5831af3
-    flattened_ast: 9ee5708390c3f6902822fd4da5e891c0adf565a4c62978f65a1c33a4ef9c3dbc
+    flattened_ast: 210e6a2f43a69a7e16e9df95814cc7a1611d414e4f1ade4bd260fbb590ce1897

tests/expectations/compiler/boolean/not_equal.out

@@ -7,7 +7,7 @@ outputs:
       - initial_input_ast: 37716c2fa42ffae9077a4a85bb1efeb2f57ea313defd50fd490884db90feab9f
       - initial_input_ast: 97d29f6252adc86e152adf3bfde485a50154cdefa8ec4ffcd70dfe7c86a8ce10
       - initial_input_ast: 31529bed8d853012affec3525b28f05d69a8f3398e75efed74e49709ff89e5d0
-    initial_ast: 4fff7b86b673dd71d0221173551ac8221806ed7092a06a0bd196beaeb9465de8
+    initial_ast: 02b35b82c1711ac2482a87546725b7cc40e4676061bd75b8d93204465e522ed0
-    unrolled_ast: 4fff7b86b673dd71d0221173551ac8221806ed7092a06a0bd196beaeb9465de8
+    unrolled_ast: 02b35b82c1711ac2482a87546725b7cc40e4676061bd75b8d93204465e522ed0
-    ssa_ast: a1ab719005fb5c32680c96ac814bf6d1918e403d487e943a73e0a4e6a1875604
+    ssa_ast: b5f750fba34b3a5500319a1dac182c1ab9235201eae2037d10910b5058570ace
-    flattened_ast: 1d6cbbabe9abfec1c515e82160f90f5251a48115b0eb12b02cd8432d01ea38f6
+    flattened_ast: 5d8c52a51c52d5ed0db67bbbf42ba18c3c76df30c79c0eb5fd58e140f73701bc

tests/expectations/compiler/boolean/operator_methods.out

@@ -7,7 +7,7 @@ outputs:
       - initial_input_ast: 0451346a1d2b8c41fd8d6e016a3fc18a61229489550227f58f359ff06332e7b7
       - initial_input_ast: 5ccafdeac9624b759f4fd6897adbec48d73986d63247fbbadbffa3cf84470674
       - initial_input_ast: ff196123ef62fc63cd552315d870c2407c085734c28fd440be7a1a0bb0dc114e
-    initial_ast: 1c81e28b5e127045508de4847ae63f322bbe7099d259e517dca07468873a19e3
+    initial_ast: 446cad7ff440d890616980bcf51f61f682b9d119dde689742d944374cef11f63
-    unrolled_ast: 1c81e28b5e127045508de4847ae63f322bbe7099d259e517dca07468873a19e3
+    unrolled_ast: 446cad7ff440d890616980bcf51f61f682b9d119dde689742d944374cef11f63
-    ssa_ast: 8d96cba8107bd0d1a71cd355a9b1aa46f18b5ed45ee874315ef97e29e305bb2d
+    ssa_ast: 3112eb3c83c6e1c56ff2603b13affbafc51f22cbfcc07973e60996c5aeb93c4f
-    flattened_ast: 4dce24b3f5f0df6010c894eda15c02dcef029a04bd0048b30ff70e6647b986d1
+    flattened_ast: 10d25a049502c4a07a66385a1dec39cc8011cd71d1da056362254c665c5b6274

tests/expectations/compiler/boolean/or.out

@@ -7,7 +7,7 @@ outputs:
       - initial_input_ast: 37716c2fa42ffae9077a4a85bb1efeb2f57ea313defd50fd490884db90feab9f
       - initial_input_ast: 97d29f6252adc86e152adf3bfde485a50154cdefa8ec4ffcd70dfe7c86a8ce10
       - initial_input_ast: 31529bed8d853012affec3525b28f05d69a8f3398e75efed74e49709ff89e5d0
-    initial_ast: c004484db4a7dd5dc0b2c764cf61b140e86955ffcd079a59951dfbfd504e269d
+    initial_ast: 6dcb15aecd651c1fe3e54b258a474f866067d2240899f35cfdf0a381ffc5614b
-    unrolled_ast: c004484db4a7dd5dc0b2c764cf61b140e86955ffcd079a59951dfbfd504e269d
+    unrolled_ast: 6dcb15aecd651c1fe3e54b258a474f866067d2240899f35cfdf0a381ffc5614b
-    ssa_ast: 3185c86f842257ed17cd1b6111d5c6fb7fcd125fc1382b491913228fe37a1aa4
+    ssa_ast: d30b8b1b3203860632f76c62f03cda1674b2c583ab7948bd7435a055fdae1582
-    flattened_ast: af518c0d1c4b8b25c6deffa6976ba54d48e92ac71f6920b9373bc0f009341099
+    flattened_ast: e838bbd63a6e65aac01aaf825e181aa8ee66dcf85ac05a5e1ceb122d9bc33a25

tests/expectations/compiler/console/assert.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: e7874e1d569eadaa5313be245f71202463aef0100ae21305a8212812f2881555
-    initial_ast: 3de295c355d0f2ddff68a436df6e4455752e69a7f956dfb3d8dabb0d83080c93
+    initial_ast: 3a6f935c5ca129da9caece4c27c5c32b7b8588fab4ee6f7446ef88b41f13e2a6
-    unrolled_ast: 3de295c355d0f2ddff68a436df6e4455752e69a7f956dfb3d8dabb0d83080c93
+    unrolled_ast: 3a6f935c5ca129da9caece4c27c5c32b7b8588fab4ee6f7446ef88b41f13e2a6
-    ssa_ast: 932ec44b122ddf173798d31be23c176f72c1eee03d7cecfdce17242977ca75b4
+    ssa_ast: 6c3f28ee2ba2a54c325e82bfa0c1ca032f16cb5d86e70f376d3185adc9a07578
-    flattened_ast: 385b716fa95d33eb36179087b85ffe4d15c0fd9e294174f88bcd61d834473147
+    flattened_ast: 45cc072f14c0bb07ef7e78e7973aee0ebaf767a3921f13e62065eb40b7ae3960

tests/expectations/compiler/console/conditional_assert.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: no input
-    initial_ast: aa1777f90d189c4127edc7419efa3134969a6db3e138bcde36095377d22452a3
+    initial_ast: 8a02943ec06fdce6dbaa8629e3d69a2f6aabaa62af4379cd38bf05336e5b33f3
-    unrolled_ast: aa1777f90d189c4127edc7419efa3134969a6db3e138bcde36095377d22452a3
+    unrolled_ast: 8a02943ec06fdce6dbaa8629e3d69a2f6aabaa62af4379cd38bf05336e5b33f3
-    ssa_ast: 672c4dd4f4eca31c458b8a55d2af1cd46fda4261578993f353b6cdf1818256de
+    ssa_ast: ef8e0d6155b97f72a62f02038d180cfa251de925d2d2fbce410db7a560d77231
-    flattened_ast: 5eacb46ae48246907ab7d5cda2b33d5e49504cccc22b04c9b3c48a4b939679b3
+    flattened_ast: ae328dab873969a1194a18b519934915927d6d5fa1d190f6d74f8d4ad3c8c89a

tests/expectations/compiler/core/algorithms/bhp1024_commit.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: a30505e4422e13fcbf395f44b70bfd5fbe3a59c5328814405df5cfeaab639d55
-    initial_ast: a7d914dc1bcd9c5db46a6c8eca1210a5fbe19634f5d753aceac23d498679d3d2
+    initial_ast: 51bee86cfd13ccdadfc8e7a107931669aa8b2aa31b544b8f5503562c4d21df56
-    unrolled_ast: a7d914dc1bcd9c5db46a6c8eca1210a5fbe19634f5d753aceac23d498679d3d2
+    unrolled_ast: 51bee86cfd13ccdadfc8e7a107931669aa8b2aa31b544b8f5503562c4d21df56
-    ssa_ast: 3bf4465fa7037bae8c4ddf07fd4a1a67e72558865b22fe4e1108a6d00d11fa75
+    ssa_ast: f5f80624539e00f53712cd5d50b7f5518d2fba21e0156d18652bea1e0330350e
-    flattened_ast: efd6c65caf99fb00467b08626d3aaa8bc93186e8424fc5c23610ecf6a9c7dae2
+    flattened_ast: d3cd4422f4864509a4813e8cc7174e9e091c653177f97a5067bdb05c6a1d5fe0

tests/expectations/compiler/core/algorithms/bhp1024_hash.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 9df63ce5d0366e8ba31fb07e696dc2e67f64371f629c66d3a9ddb715c923692e
-    initial_ast: 69b992df47acf68e90bd8b613e60212d16172e8edeedb0f4b4b39353c38adc61
+    initial_ast: c9f090b3af2fc56bbeb69cec425e6dfe482593abcad1ab4f731c5743274fd283
-    unrolled_ast: 69b992df47acf68e90bd8b613e60212d16172e8edeedb0f4b4b39353c38adc61
+    unrolled_ast: c9f090b3af2fc56bbeb69cec425e6dfe482593abcad1ab4f731c5743274fd283
-    ssa_ast: 04ed79c5f4a1faf52032b353d8f8297a467d8e02ed447f7f81e393b3ddf24ed3
+    ssa_ast: 3b9a7a868bd19cdfbe1494f12fe0032bcb02bc7ae082b236f33d90df043342cd
-    flattened_ast: 0c95bcbb644f61776a20fb9b885b6cb48f9adb552192d7acf5a80670ccde21e0
+    flattened_ast: 561be660fd0b0cbf9ed5e7f5d82f435b2fba59cd877246ff95b45af350d19d21

tests/expectations/compiler/core/algorithms/bhp256_commit.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 81e7b4b48e21c631f656aa65b6d19ebb7d784b43229356b918f908a046734261
-    initial_ast: 953d5e9d7689faeea239ad13c6653805e1a13281f3ac3f37dbea106449d23a5f
+    initial_ast: e2377ecd37c2f0b183f1454303672052ece1a8e7e7e954a94342203df7f5f329
-    unrolled_ast: 953d5e9d7689faeea239ad13c6653805e1a13281f3ac3f37dbea106449d23a5f
+    unrolled_ast: e2377ecd37c2f0b183f1454303672052ece1a8e7e7e954a94342203df7f5f329
-    ssa_ast: 232eaa57f15cacf6dc99d9a0599915b1adee632e5de070dfa6c5aa9e117e5d61
+    ssa_ast: 95ba4a9b09a33c21a1dd06780c4ef8eed6292aafbb02e13b06d677d5efbaa367
-    flattened_ast: 0e223b52044c42ab29c340998ee76946a5ebcab27b7311c19b26b2072276b3c5
+    flattened_ast: c63e28436e87504045b9d590b1b471242bee6cd86b2b2ce9cfc76609b5c78b23

tests/expectations/compiler/core/algorithms/bhp256_hash.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3cb982a5d4144e548fca897ceb686ad1f638971bb22fff7b935363eacc1b3473
-    initial_ast: 4407c172fe97be9aa387a6fd94549386e803dfd7b8a83ca0936279b853fd1312
+    initial_ast: 0994f824a3bdd2f3e29d54d135facae3ba9e36350e75bc91e21b6c5d3d9c568d
-    unrolled_ast: 4407c172fe97be9aa387a6fd94549386e803dfd7b8a83ca0936279b853fd1312
+    unrolled_ast: 0994f824a3bdd2f3e29d54d135facae3ba9e36350e75bc91e21b6c5d3d9c568d
-    ssa_ast: 7801e83d9bc93fa26a769c94cc7a08b8676f761869da8e6ca4523e5d144cb5e6
+    ssa_ast: 0087332023f8ab478c0572a26572463e770988bb5e062248d739aca8ef2e3336
-    flattened_ast: 2bbafd8b601c9475cb180e254dabbf08a2d9da07c63cadd6b21252a38e4129c5
+    flattened_ast: 7998493d9573a436176f7cb35328da317912df328c54642816ddc5e3609172d1

tests/expectations/compiler/core/algorithms/bhp512_commit.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 81e7b4b48e21c631f656aa65b6d19ebb7d784b43229356b918f908a046734261
-    initial_ast: ad1967ac1c839fae18c5c7a46a3f1a038d7f6379662ce73b5ff81838e9fecb06
+    initial_ast: a8d610455116580be112280b5438fd9679198227bc35ab58ceab00aaea39caf8
-    unrolled_ast: ad1967ac1c839fae18c5c7a46a3f1a038d7f6379662ce73b5ff81838e9fecb06
+    unrolled_ast: a8d610455116580be112280b5438fd9679198227bc35ab58ceab00aaea39caf8
-    ssa_ast: 3d812d01adde60b0a3201ecea2ac6e3b8589ed5b9a00994522835a579c11af55
+    ssa_ast: 1c40d4b3a659d539b7617e62a0b56d9034c8ad8d5dd4e17394407fc285ae57a6
-    flattened_ast: 2ad8be7ffefae31b19fbb3cddc9f7c3615225185b54d2c20e6456fe9d8502614
+    flattened_ast: 4a0bea548a4bfaf7c9ae74b3a712915cfc5f0ce69ef101d28235738693cc7568

tests/expectations/compiler/core/algorithms/bhp512_hash.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3cb982a5d4144e548fca897ceb686ad1f638971bb22fff7b935363eacc1b3473
-    initial_ast: d2dc132a022976ed2e21401d332b4ea766426097eb1be7e33082473ade6e4d95
+    initial_ast: aa474e9742098330a73f3ce9d518bb011813b824f89c98076edb5470630c8368
-    unrolled_ast: d2dc132a022976ed2e21401d332b4ea766426097eb1be7e33082473ade6e4d95
+    unrolled_ast: aa474e9742098330a73f3ce9d518bb011813b824f89c98076edb5470630c8368
-    ssa_ast: fd34527ae5871a81df9dc16df2e5030f0195cffdf6dea4f78ed19aedea6da621
+    ssa_ast: fcba4c87b89c60a7ffb8ccbbee4f034f2cc1d0058093c92d4f4c84f594119749
-    flattened_ast: 151a5163d81bdd8d15ad4af804e3a8b6e8ed6e5c97fd7470a13c83b68f979d6c
+    flattened_ast: 42abcfb46266c272e847a082999135b6e089a21097055431c6694c601ebef57e

tests/expectations/compiler/core/algorithms/bhp768_commit.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 81e7b4b48e21c631f656aa65b6d19ebb7d784b43229356b918f908a046734261
-    initial_ast: b8c180b1cead8f5d3aa420e03dc135e2c82220c31e3d46cb31a3a3377d8322ab
+    initial_ast: 06785b5dd9fa53974e527c121b0daf180fd5ffc3c4479b7b242d2635556c5e6e
-    unrolled_ast: b8c180b1cead8f5d3aa420e03dc135e2c82220c31e3d46cb31a3a3377d8322ab
+    unrolled_ast: 06785b5dd9fa53974e527c121b0daf180fd5ffc3c4479b7b242d2635556c5e6e
-    ssa_ast: 70f05a3e659eb20d8e605e1c9b91338ee90c123f7453a240bf1a3950e5815042
+    ssa_ast: 10aa2cac1ce759f62cc59b6f800dd483aaf9b15524d91469031a2c6c51270293
-    flattened_ast: d54cbd75ce1a0d7e6dd679659ccd4307f77bffc19f6234415225df9bcef09879
+    flattened_ast: dfbba5676cd15c17ebc8fa2c3073a97ad769c80249ccdbf5db12b70df9410f03

tests/expectations/compiler/core/algorithms/bhp768_hash.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3cb982a5d4144e548fca897ceb686ad1f638971bb22fff7b935363eacc1b3473
-    initial_ast: aaa2271be04607379f94fb121c50c8990d4a0b68ba5257220102db26b91a0f14
+    initial_ast: f6a77b77e366cecaddc7dbed12b51d83f7c6f434ba24cc885437f74bec8c457c
-    unrolled_ast: aaa2271be04607379f94fb121c50c8990d4a0b68ba5257220102db26b91a0f14
+    unrolled_ast: f6a77b77e366cecaddc7dbed12b51d83f7c6f434ba24cc885437f74bec8c457c
-    ssa_ast: de05aeb7675088006960519444a10897077b9080ebe1ce5e6e3f2439536101c5
+    ssa_ast: 9fe73b365687cc0f948cef5b7d66197a17ae028957042a0a806c886824b2ac4d
-    flattened_ast: ba2389349ba5155169389732da800d08def0aa26882c6a0a93e8fab257dc9a2b
+    flattened_ast: aaf5a0f6ab6b87fd765ea4f6652dd802d06bbf25eaa7f9f50fa4a9f0d0860989

tests/expectations/compiler/core/algorithms/pedersen128_commit.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 46d3cef7b6dd6e951fe93d550206bdd658d6d435f71c776a39ae3b443770d33d
-    initial_ast: cad5c306b9b28181bd6b0c6b2eed216219ebcb60b96554c11bdd241b226aaf73
+    initial_ast: 6af9e875a38f0b512b91aab4d1e603780820382abd651d509ad90f0375bf061f
-    unrolled_ast: cad5c306b9b28181bd6b0c6b2eed216219ebcb60b96554c11bdd241b226aaf73
+    unrolled_ast: 6af9e875a38f0b512b91aab4d1e603780820382abd651d509ad90f0375bf061f
-    ssa_ast: 1b2af30d0034ea32bd630884142157796f6c8f8f9e2ef7e9701ed62a2f92424b
+    ssa_ast: 11b9a590dd9823c00b607e8162ee79b720eb632a46a4760d9dd57b35e463e4f2
-    flattened_ast: c100fdd0403a9d8d6a38609d37f4e36ce54e3d6257db1d19d1e973274326906b
+    flattened_ast: 81fb5a95971a3ccb8182dbe23e501b12d71ea62e89067e166f3361fa0a757d1e

tests/expectations/compiler/core/algorithms/pedersen128_hash.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 7155146c3f0887e6298bfabe9cad16d78c150419e8d0d584616d5dd76c5c3bac
-    initial_ast: 9a4877e6514d54a55c8a76dbd4de9e27d43d137477c7d93470d45a61f6017861
+    initial_ast: 5518b3f856748100a951db7b5807e67ebc8648c38e1b10f60519984ffe8127a6
-    unrolled_ast: 9a4877e6514d54a55c8a76dbd4de9e27d43d137477c7d93470d45a61f6017861
+    unrolled_ast: 5518b3f856748100a951db7b5807e67ebc8648c38e1b10f60519984ffe8127a6
-    ssa_ast: 44237ce1986b38c34c5d2a624676e64c53257648436d82b9d333d6ab0c37102d
+    ssa_ast: 764817f9c5341fd4d7d8279d43674bce492289d9f353091face9fbec653df967
-    flattened_ast: c5d401aa71f99eabd1db84264069cb3a904019b93282296020a4e2db537cbcba
+    flattened_ast: 8e222bd26b9887f0df4aa002031cdd41652090a0778af0f535b6867a5c854b6b

tests/expectations/compiler/core/algorithms/pedersen64_commit.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 591fe9942b59bad76b636a1c9e6ebe93ad85df562b09b7a900acfe12a9caffe2
-    initial_ast: 3c9a4fde69b75a022863bb1f29026bc4fdac5eca0ad0ec5e3ecb7364e7a17499
+    initial_ast: ad2bc892f24b971eff231aa2d53047e5129cdd510c689f21235d51601c04670b
-    unrolled_ast: 3c9a4fde69b75a022863bb1f29026bc4fdac5eca0ad0ec5e3ecb7364e7a17499
+    unrolled_ast: ad2bc892f24b971eff231aa2d53047e5129cdd510c689f21235d51601c04670b
-    ssa_ast: 4f51f745379cb8078a6512104b27f778d6a36cd4bc92e6e06b74f95d8204ba37
+    ssa_ast: 5fda4bee03a6d82641305659fb244ffd043c0f1f87114944c25677e7eebfc36b
-    flattened_ast: 1fd5c458c8f61a818f6409f20e430c37d7a9d4a1aceae7a96b370fa9dca03c94
+    flattened_ast: 1e32d226f9c5ee5a753d110feae1bfdee8098b3da5a37417f8e408dcee52a244

tests/expectations/compiler/core/algorithms/pedersen64_hash.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 6b64b3a4fd7cafc2ead15efb8a91f8fc102947ccf4c091e4b6e54df82811fe82
-    initial_ast: 2ef0225f6f5b08bec4cbac785f486c667251c285c2e3e221c63cd2d9d8c4d240
+    initial_ast: 28e9fcadb32adc57ef9208090d348a06bbd067b0c82325a6eb55932f9e369edf
-    unrolled_ast: 2ef0225f6f5b08bec4cbac785f486c667251c285c2e3e221c63cd2d9d8c4d240
+    unrolled_ast: 28e9fcadb32adc57ef9208090d348a06bbd067b0c82325a6eb55932f9e369edf
-    ssa_ast: 406dfc7b88282780532453da30e06d04fb6398fbb5f8934aa6951bc57e785af2
+    ssa_ast: 09bc0a1171087290f79bea4cb6d93225b6a1c750090cf48724e221f1e1e5c6e0
-    flattened_ast: 0ab17f84c7bb560a48f49bce7e29384f3439028f2fcb55f93649fa7e615a66fa
+    flattened_ast: 371c62b8b4edfc10dbaf5084046b357e2f946876286c5f6e081a7e8ce90759bf

tests/expectations/compiler/core/algorithms/poseidon2_hash.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 1e9c68e82f6c0dc9eaa4babbc5cb9e46d79f8f0661607b48efd2e9870a636f33
-    initial_ast: a5f32b136e224ace47e695dacb7d481975a343cdcd5b822652b8ce4bace9bdc4
+    initial_ast: d30016b42bba9fc40ee73874091f2723b01ddb6a5b791df4b04ba2ce680b2946
-    unrolled_ast: a5f32b136e224ace47e695dacb7d481975a343cdcd5b822652b8ce4bace9bdc4
+    unrolled_ast: d30016b42bba9fc40ee73874091f2723b01ddb6a5b791df4b04ba2ce680b2946
-    ssa_ast: cfbd02fec7cde8cb7de3cabe033207e0aa025d0c1eadf5b27f4aeff4b2f48c30
+    ssa_ast: 572f3cd4c99615c1604342153c9d3dc90f2c5402d2f61e4769682079805957db
-    flattened_ast: c86be4a932e4a91d25b8cca98ebadb1875d30a7409585b1cbeab3c7bf511e7fa
+    flattened_ast: 9d98960549f8f4d508c24165a9bd05e584928ba1eeed9e66acc6c7a0008cb096

tests/expectations/compiler/core/algorithms/poseidon4_hash.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 1e9c68e82f6c0dc9eaa4babbc5cb9e46d79f8f0661607b48efd2e9870a636f33
-    initial_ast: 95f0769ebd6f1f6170771b5b4a2a8f333577f285531e64a3c2899e022d83b26c
+    initial_ast: c532bfa484a2a0c12ea025d201de40ac81ddeefe80c8154c508899fffdc7a675
-    unrolled_ast: 95f0769ebd6f1f6170771b5b4a2a8f333577f285531e64a3c2899e022d83b26c
+    unrolled_ast: c532bfa484a2a0c12ea025d201de40ac81ddeefe80c8154c508899fffdc7a675
-    ssa_ast: 535712b468cd7472f115e1a3a4edd8e8e57ab80afb8fbb5922fcf0e41af9c6ee
+    ssa_ast: 8328857553e07d4d8004dceb6959f2beaae6f8719336939acb1029d9fed7d53b
-    flattened_ast: 3843c47a4d735398cbdda45f1815a14fce9e83dcab0cc318b1f11b5b21d95a39
+    flattened_ast: e9e9fd440ef59a6bf6fe76baae6931fbd5a09d354d69b926225d954cb23c66d6

tests/expectations/compiler/core/algorithms/poseidon8_hash.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 1e9c68e82f6c0dc9eaa4babbc5cb9e46d79f8f0661607b48efd2e9870a636f33
-    initial_ast: 08935ec63b16ea46fdc71ecf009d17664e1df123a7b8927933ecb8b6ebcc84d3
+    initial_ast: 5984da88411c8e2714e7d63161f25c28f8a305eba351e64f89e8917dd13557c2
-    unrolled_ast: 08935ec63b16ea46fdc71ecf009d17664e1df123a7b8927933ecb8b6ebcc84d3
+    unrolled_ast: 5984da88411c8e2714e7d63161f25c28f8a305eba351e64f89e8917dd13557c2
-    ssa_ast: 05f1c0703a0987f866b19bcbc72a1e1cf4d7253a1fc75b1474b9f49aafb26cc4
+    ssa_ast: 431258ae9c7498b7a27aa436b04f28754d5bfe6b46d6638ac867c2dde37eae55
-    flattened_ast: 699fdee0dcb831f86fb19c14b4f0387aec3ddfe4c6658a77e3cc7b450cc30e15
+    flattened_ast: 391928fcf3f5c2cadf774db9c81ef6582d679e25ee6c1c9f77e5f21aa4aa1de6

tests/expectations/compiler/definition/out_of_order.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: b7b12742359f67e9b9fcd6772715e2a972f8462844bd97dbb4e54265935166b2
-    initial_ast: 60a5b01bf0103928fdb728241663fc40e0ddf3d8c3ccbbed32b659053d2d16bb
+    initial_ast: 0ad159e7d8fd72976f8585e7e34700e67c4a812a648639dc8fb889def7c412c4
-    unrolled_ast: 60a5b01bf0103928fdb728241663fc40e0ddf3d8c3ccbbed32b659053d2d16bb
+    unrolled_ast: 0ad159e7d8fd72976f8585e7e34700e67c4a812a648639dc8fb889def7c412c4
-    ssa_ast: 76f9c60d9da5a01a1cbfc1ae2b117ac774022a19445c8ce1cd265997f91d8c0a
+    ssa_ast: 0a5046714f68182853e30930820d66463e5f2799e7ee5dc9d889e05f812b543b
-    flattened_ast: f1c6685559a001f403e04a21f2b334dbd2124540f5816f22f0995ae4af104aeb
+    flattened_ast: 8f043480d5c6c19bf2f8de2fa152e207034bffd8d6a9c32cd5f2a22374ead720

tests/expectations/compiler/field/add.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 61129a0f8f768e3b6ac64a3108c250edac7bc6d2166c8682959ed70d087c9ea8
-    initial_ast: b2cb62aebdc589f0966d653b8e27e87bc364dfe968f2cb3b1b4e2529f6ec3bbd
+    initial_ast: 88a3dddd66376118f389f910861f4f6cfc46740ed40b169cc06d9fa92af09140
-    unrolled_ast: b2cb62aebdc589f0966d653b8e27e87bc364dfe968f2cb3b1b4e2529f6ec3bbd
+    unrolled_ast: 88a3dddd66376118f389f910861f4f6cfc46740ed40b169cc06d9fa92af09140
-    ssa_ast: 4ddd554ed231cde10acb5603d8ca51d4d97e6b140ea4a7bba580d3db79261f43
+    ssa_ast: ffa51dedbb3dea08a06a6b4808aba102bf7cf5af49d2dc48495d22810e310e9d
-    flattened_ast: 815c3628e9d39f378168bb34b5c656a9f1ef9d4a95d4e30c25896d5df41f5032
+    flattened_ast: 12e49541f288f033d7921c8ad2a1e0e164a5ba81b0e972ce556d6acbc508e3d3

tests/expectations/compiler/field/div.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: f7a296977806330a0ba3de16adf46a59c32560a0035c9f386122943126382502
-    initial_ast: 4890275fa885093609199d0128f194a81cc28582c7b56bec2fa8667047234b87
+    initial_ast: fddbfe97b40bac54feb9cf5cf2b77d6da1bc156c9227b978ec35d6b3b5d2de41
-    unrolled_ast: 4890275fa885093609199d0128f194a81cc28582c7b56bec2fa8667047234b87
+    unrolled_ast: fddbfe97b40bac54feb9cf5cf2b77d6da1bc156c9227b978ec35d6b3b5d2de41
-    ssa_ast: fe5de537242393614910d4cfe9a7a83c48a7c068d7ca4bf691e96b7ca57ca10e
+    ssa_ast: 35d8bbee0dea7bd7890799a2dfc232af17179dd969483db120c5abb45c2ec64a
-    flattened_ast: 25f16dbb4bd3f76160184f05b1b062bfc320b8f01e617873cf8994c5f12fe798
+    flattened_ast: 99bbe3ebee47595fc161f1d0c5b10b494f503bf20b0ca7609d470d5c7a6683f2

tests/expectations/compiler/field/eq.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: f88034cbb0521ef299913fc7f13280ea5af4cf984cb54c476c9860d9f93a5cba
-    initial_ast: e49a3434e8a50a36fb49fc00585b778f49ebdd3809323ca5b5895286d56b7f52
+    initial_ast: b67df589c94d44bb00b9a4106ff233f6b354f49192fe1cb142395d4f1596c0ee
-    unrolled_ast: e49a3434e8a50a36fb49fc00585b778f49ebdd3809323ca5b5895286d56b7f52
+    unrolled_ast: b67df589c94d44bb00b9a4106ff233f6b354f49192fe1cb142395d4f1596c0ee
-    ssa_ast: de1ad7586a39f888f09c8ff00954a4dcac8ad842249d6102f08cc27979b8ae52
+    ssa_ast: 65ea2b9296a8fdd8edaa5b661aeaa02bb6e35dfc80f645a8cf55490d0a41e977
-    flattened_ast: 12d3dc425871612d7b8804d64c6abf93a9591979a84eeed535f65d6774e1e0ce
+    flattened_ast: 8be0a35fda73e4bc735b7b23aad3d62cd53f82e57f6acb60a4962d804d6cff5e

tests/expectations/compiler/field/field.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 9dff7172de13bf9c5c1bf0e225ebb3132da11ea695a97692edacd36b18e5d86c
-    initial_ast: efb41e70f83aa7e2d78fe401a2515f43840c2679c46dd8556315a736414c68d8
+    initial_ast: efdec55ecb58ec494410121b123550ac5876155959c360755fc59f2d2bd0b604
-    unrolled_ast: efb41e70f83aa7e2d78fe401a2515f43840c2679c46dd8556315a736414c68d8
+    unrolled_ast: efdec55ecb58ec494410121b123550ac5876155959c360755fc59f2d2bd0b604
-    ssa_ast: 03c6805324171292b0291c7578681fa9a4c69e06a5463693ffc12984806e0e29
+    ssa_ast: 3da729b3437544aedef4b8e301094a78c384db937ed3c8d817f15abfb59285f2
-    flattened_ast: 45786b6a26579552c3b7142eec3cd0dc87d7c703ad250b7811bfdd269fc3c073
+    flattened_ast: e9b63b047f4236ed311a337a773fea9ff8c1375ea889ca3d2ec38457973fb65b

tests/expectations/compiler/field/mul.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 61129a0f8f768e3b6ac64a3108c250edac7bc6d2166c8682959ed70d087c9ea8
-    initial_ast: 38aa3123bf3a04cefe13cab572fe4d5655fa253899c06ec2ff00063147c71adf
+    initial_ast: 8d24c47b478ed7893e5fd98b9ad429e7a9900adad2eba1d4a487e0df6b8cfe19
-    unrolled_ast: 38aa3123bf3a04cefe13cab572fe4d5655fa253899c06ec2ff00063147c71adf
+    unrolled_ast: 8d24c47b478ed7893e5fd98b9ad429e7a9900adad2eba1d4a487e0df6b8cfe19
-    ssa_ast: c912349b3dba6986ad724166f15fc4130a8258bbc1f4a343ba6fb9beb5fd3ca2
+    ssa_ast: 0bd6b1b066ae93e561968bacc3f2dc292e3ada8fe9320b628a077079d9544e8e
-    flattened_ast: be364827c618105c97d59dc8fa3b1a6dfe9abcd553af8754123d6bcf5224b3c2
+    flattened_ast: a3e9bc665ad0ce68dc606fe1f61b8bce4bbaef6b840baf7c575c3b1852cef39d

tests/expectations/compiler/field/negate.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 429366c4335599a16406a6ffffe140ff35a28c8129327477a23a692792ab630a
-    initial_ast: a835b88d353dfe064d68aa517c09da7caf0ffe9bcaece973463c98637e19f15d
+    initial_ast: ee710a8058b825eb3f249674f01d5a04324e5b64f4bbeb1afdaf232329caadf5
-    unrolled_ast: a835b88d353dfe064d68aa517c09da7caf0ffe9bcaece973463c98637e19f15d
+    unrolled_ast: ee710a8058b825eb3f249674f01d5a04324e5b64f4bbeb1afdaf232329caadf5
-    ssa_ast: d62bc50f6421bece080cb58bfcf996c04d91b5eaf2e4145765ca61f82c76e97b
+    ssa_ast: 49d572ab521f3daa2a2d71a8268194ffb6afe5122335d2e2fdc49de2f1ee4975
-    flattened_ast: f8d267d7f537f6b14b752dbbef59709e7c04027a2dc1116f347f14e5c66ada06
+    flattened_ast: fae4dd8da32e14b67f913a1e011bc16f9decc2c7ef020d448cd07d9caf8dd1e8

tests/expectations/compiler/field/operator_methods.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: a6d4afdd7375c43967b7a3be380ac83f7b1a351203a2f521ca8ce9824f29df71
-    initial_ast: fae67b0524629123386d97abe3d416217bf3603fa7e80d7fff171188b7a9cd92
+    initial_ast: d909483caa7307035bd2831480efa736e788977504e39ed275ed1488d06dec11
-    unrolled_ast: fae67b0524629123386d97abe3d416217bf3603fa7e80d7fff171188b7a9cd92
+    unrolled_ast: d909483caa7307035bd2831480efa736e788977504e39ed275ed1488d06dec11
-    ssa_ast: 9f1ccb67dd1845e23cc51eaa7de1fa1de0ab2035d4a14ef6290f24e8b890511b
+    ssa_ast: 7c142706e7ff0c21752402c3275e53e2676c5d7cec24260a4fea463d7b1c2908
-    flattened_ast: 2858a14218cb5f670950c60b32dae9c579fe73638553ea3eb56cae7073fc2039
+    flattened_ast: 4f6a9c0153ed4b45e105c1965841ff91197bb0609504ddb4aa9115ee8ebf3e81

tests/expectations/compiler/field/pow.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 4e24333952c4eaea2c19106c9651e0bef29519e51632cc17f3ba1d07123306eb
-    initial_ast: e545f85a38342de5173ef77a87c688a1ec6ad9964d48731c167925f68693c62e
+    initial_ast: 26d8cb81f797d805fa60abfbd405f61daf75a4b64c64f43624f665a61bbc76dd
-    unrolled_ast: e545f85a38342de5173ef77a87c688a1ec6ad9964d48731c167925f68693c62e
+    unrolled_ast: 26d8cb81f797d805fa60abfbd405f61daf75a4b64c64f43624f665a61bbc76dd
-    ssa_ast: 61769373206b7e2a87db43b9c6e35657749a373910584e137ceee4cf175ae9b6
+    ssa_ast: 0892667d1d18cc77f14e7e736e4f3fc6b531c3a551ca868e28ee9b1ecaea834a
-    flattened_ast: af9344ccab440497931207afc1d7efca6f5f6591b00f468848fc6296bfa1dc89
+    flattened_ast: c663f4078038a39ab5f54c902f290a22a20c70ca7df659a84bf59bcd9baceb93

tests/expectations/compiler/field/sub.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: f7a296977806330a0ba3de16adf46a59c32560a0035c9f386122943126382502
-    initial_ast: 18a724022cab3f33e4be21d338c0494d827abb82da6f25e7f2bcd4bdf2d1aabe
+    initial_ast: 881b05ee550d8ab9ec459e25f0796c9a2f60db7625c584583cc4a99fb8af61bc
-    unrolled_ast: 18a724022cab3f33e4be21d338c0494d827abb82da6f25e7f2bcd4bdf2d1aabe
+    unrolled_ast: 881b05ee550d8ab9ec459e25f0796c9a2f60db7625c584583cc4a99fb8af61bc
-    ssa_ast: 3e10be6d2154ae4c7457a6560aa1b1449423f80d4e135b9340205ec28c691508
+    ssa_ast: a753111137a46a4f02cbd62e0771b4d50c3003c8ef8de58e9e7e183f4c65fb1b
-    flattened_ast: 1982adc0014172bf8a3479f03631e586c7841533286dc9174ce5575b774eca1f
+    flattened_ast: 3327b8379cf39a5b2afeb2a6783ccc0d6c8070ca19a8d6fe9a19e26a6889fcc2

tests/expectations/compiler/field/ternary.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 4b32cb2874e8e59815b3b0bdcad1a5e5732de23853d85d2feb4bd3cecb1c594d
-    initial_ast: cacf29acb24375c88d221d7026eaa7b06a944388c56804b70dcc61c7396afc6e
+    initial_ast: ce48445a0fd3e3a2fc896b2e65e4b31211b3f619b39f4d4b4afca301a76ca132
-    unrolled_ast: cacf29acb24375c88d221d7026eaa7b06a944388c56804b70dcc61c7396afc6e
+    unrolled_ast: ce48445a0fd3e3a2fc896b2e65e4b31211b3f619b39f4d4b4afca301a76ca132
-    ssa_ast: cbef14d834982c0dd4e63f501381cd89d6c3131e44fb8410a7d99e9cd8ef810d
+    ssa_ast: 62a71834912baf0a62d777d120ffd1ca0ba73621cc1bc9ff2074c3b09114b708
-    flattened_ast: 39a261879a26158b2c9590c381dd4f6a9cc8813cee959e231b5b3cb96a2f7d3c
+    flattened_ast: 5b69475b25e876a0e04402e75c76a41b83c94cdf4fddc5202b8e3191681ad05f

tests/expectations/compiler/finalize/closure_with_finalize_fail.out

@@ -2,4 +2,4 @@
 namespace: Compile
 expectation: Fail
 outputs:
-  - "Error [ETYC0372036]: Cannot use a `finalize` statement without a `finalize` block.\n    --> compiler-test:5:15\n     |\n   5 |         async finalize(a, b);\n     |               ^^^^^^^^^^^^^^\nError [ETYC0372044]: Function must contain a `finalize` statement on all execution paths.\n    --> compiler-test:9:5\n     |\n   9 |     function bar(a: u8, b: u8) -> u8 {\n  10 |         return a + b;\n  11 |     }\n     |     ^\nError [ETYC0372031]: Only transition functions can have a `finalize` block.\n    --> compiler-test:13:5\n     |\n  13 |     finalize bar(a: u8, b: u8) -> u8 {\n  14 |         return a + b;\n  15 |     }\n     |     ^\n     |\n     = Remove the `finalize` block or use the keyword `transition` instead of `function`.\nError [ETYC0372031]: Only transition functions can have a `finalize` block.\n    --> compiler-test:22:5\n     |\n  22 |     finalize mint_public(receiver: address, amount: u64) {\n  23 |         increment(account, receiver, amount);\n  24 |     }\n     |     ^\n     |\n     = Remove the `finalize` block or use the keyword `transition` instead of `function`.\nError [ETYC0372005]: Unknown variable `account`\n    --> compiler-test:23:19\n     |\n  23 |         increment(account, receiver, amount);\n     |                   ^^^^^^^\nError [ETYC0372004]: Could not determine the type of `account`\n    --> compiler-test:23:19\n     |\n  23 |         increment(account, receiver, amount);\n     |                   ^^^^^^^\n"
+  - "Error [ETYC0372036]: Cannot use a `finalize` statement without a `finalize` block.\n    --> compiler-test:5:9\n     |\n   5 |         return a + b then finalize(a, b);\n     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\nError [ETYC0372044]: Function must contain a `finalize` statement on all execution paths.\n    --> compiler-test:8:5\n     |\n   8 |     function bar(a: u8, b: u8) -> u8 {\n   9 |         return a + b;\n  10 |     }\n     |     ^\nError [ETYC0372031]: Only transition functions can have a `finalize` block.\n    --> compiler-test:12:5\n     |\n  12 |     finalize bar(a: u8, b: u8) -> u8 {\n  13 |         return a + b;\n  14 |     }\n     |     ^\n     |\n     = Remove the `finalize` block or use the keyword `transition` instead of `function`.\nError [ETYC0372031]: Only transition functions can have a `finalize` block.\n    --> compiler-test:21:5\n     |\n  21 |     finalize mint_public(receiver: address, amount: u64) {\n  22 |         increment(account, receiver, amount);\n  23 |     }\n     |     ^\n     |\n     = Remove the `finalize` block or use the keyword `transition` instead of `function`.\nError [ETYC0372005]: Unknown variable `account`\n    --> compiler-test:22:19\n     |\n  22 |         increment(account, receiver, amount);\n     |                   ^^^^^^^\nError [ETYC0372004]: Could not determine the type of `account`\n    --> compiler-test:22:19\n     |\n  22 |         increment(account, receiver, amount);\n     |                   ^^^^^^^\n"

tests/expectations/compiler/finalize/decrement.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: no input
-    initial_ast: 9e0977be23e1c4d1abdf9c225bb751bb8ae83afb8c764c4ac7b8a128c1a5c793
+    initial_ast: 6f19e4683ac93b36545b090aea64539b0d84c14bbed076b93c2147aab6444c40
-    unrolled_ast: 9e0977be23e1c4d1abdf9c225bb751bb8ae83afb8c764c4ac7b8a128c1a5c793
+    unrolled_ast: 6f19e4683ac93b36545b090aea64539b0d84c14bbed076b93c2147aab6444c40
-    ssa_ast: 9e0977be23e1c4d1abdf9c225bb751bb8ae83afb8c764c4ac7b8a128c1a5c793
+    ssa_ast: 6f19e4683ac93b36545b090aea64539b0d84c14bbed076b93c2147aab6444c40
-    flattened_ast: 51634dc9946dfdb2ece132702f717235d56f844ed73301a19b6f448b81f3a8ea
+    flattened_ast: d41473230bc3d5d3bb3e2a998208c2f03ae4fc96736cf1e130b6b20e07505bbc

tests/expectations/compiler/finalize/finalize.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: no input
-    initial_ast: f5ac590daecc996e9cc6cdc278f00f98d1e3dccf206cafcdb650b7c035869730
+    initial_ast: 4648d4abd6aef6af1581e4a856e6f9b5d4c61d85d86b655b0c487048bfc89af7
-    unrolled_ast: f5ac590daecc996e9cc6cdc278f00f98d1e3dccf206cafcdb650b7c035869730
+    unrolled_ast: 4648d4abd6aef6af1581e4a856e6f9b5d4c61d85d86b655b0c487048bfc89af7
-    ssa_ast: f5ac590daecc996e9cc6cdc278f00f98d1e3dccf206cafcdb650b7c035869730
+    ssa_ast: e8f33cd116010f7c19711f774efa0a29d35cdd1666c6d07889b5d492f1d5183b
-    flattened_ast: 6201d1691c08db31c77cc24c1ef5e53dd6c34fa22a33e149b3ab1f7368492009
+    flattened_ast: 8d548287d221c6abbfa464faf4e328845344e9f6e6e653870d877a97acdb115f

tests/expectations/compiler/finalize/finalize_statement_incorrect_args_fail.out

@@ -2,4 +2,4 @@
 namespace: Compile
 expectation: Fail
 outputs:
-  - "Error [ETYC0372042]: `finalize` expected `2` args, but got `3`\n    --> compiler-test:8:15\n     |\n   8 |         async finalize(receiver, amount, amount);\n     |               ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n"
+  - "Error [ETYC0372042]: `finalize` expected `2` args, but got `3`\n    --> compiler-test:8:9\n     |\n   8 |         return then finalize(receiver, amount, amount);\n     |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\n"

tests/expectations/compiler/finalize/finalize_with_return.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: no input
-    initial_ast: 111c640307a93403153d58afb9d7bc49f010b5d37f9aab4076d204700f90cf99
+    initial_ast: 69722b0e9daaa18f4fe5c358a3c538af7aa0c35b16db7131984e2f02e46fb795
-    unrolled_ast: 111c640307a93403153d58afb9d7bc49f010b5d37f9aab4076d204700f90cf99
+    unrolled_ast: 69722b0e9daaa18f4fe5c358a3c538af7aa0c35b16db7131984e2f02e46fb795
-    ssa_ast: 33ba61ddd5299b3d69276f0c63bbb7fda9d62875df2ad51b989800dbbe46d25a
+    ssa_ast: 5f9584e7a982be19514b7498a260eb7b257c8ca3d44e924085bdb5f741c619af
-    flattened_ast: a4321379b8e6055256632271d5121fae5cfe6f55d5a92f7453b92b889aa7e2fc
+    flattened_ast: 0ce0d191c165e1472307818cd9d4cfa756afd61b0f77659a5b58d01e4431ae79

tests/expectations/compiler/finalize/increment.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: no input
-    initial_ast: 143e4deb6fc26d2d03e40ac8ea558349a84b264bec1889a014fb45ad4858e43b
+    initial_ast: d19c6388ab50f93bd5c9b19bda875ea266ad70c24d7c0bfa78fd23babca2860b
-    unrolled_ast: 143e4deb6fc26d2d03e40ac8ea558349a84b264bec1889a014fb45ad4858e43b
+    unrolled_ast: d19c6388ab50f93bd5c9b19bda875ea266ad70c24d7c0bfa78fd23babca2860b
-    ssa_ast: 143e4deb6fc26d2d03e40ac8ea558349a84b264bec1889a014fb45ad4858e43b
+    ssa_ast: d19c6388ab50f93bd5c9b19bda875ea266ad70c24d7c0bfa78fd23babca2860b
-    flattened_ast: ca2ac65da9477f693168dd0074c56a000d7885cb4e2ad355e52e57d09e13e35c
+    flattened_ast: 229c446ca9561d69b1edaf42ffbb50c308a9e00563d468886ad9ab6a0613e8cf

tests/expectations/compiler/finalize/private_input_ouput_fail.out

@@ -2,4 +2,4 @@
 namespace: Compile
 expectation: Fail
 outputs:
-  - "Error [ETYC0372032]: An input to a finalize block must be public.\n    --> compiler-test:9:26\n     |\n   9 |     finalize foo(private a: u8) -> u8 {\n     |                          ^\n     |\n     = Use a `public` modifier to the input variable declaration or remove the visibility modifier entirely.\nError [ETYC0372033]: An output from a finalize block must be public.\n    --> compiler-test:18:36\n     |\n  18 |     finalize bar(a: u8) -> private u8 {\n     |                                    ^^\n     |\n     = Use a `public` modifier to the output type declaration or remove the visibility modifier entirely.\n"
+  - "Error [EPAR0370030]: `async finalize` is deprecated.\n    --> compiler-test:5:9\n     |\n   5 |         async finalize(a);\n     |         ^^^^^\n     |\n     = Use `return <expr> then finalize(<args>)` instead."

tests/expectations/compiler/function/conditional_return.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: d46e926534142e72937a9b027c015ad4e6bfcb57a31df002fec021493f1ca2f6
-    initial_ast: 8d324b6caf600f7134b94cd4dbd45268c83fc7238b8d58f7439b4ad0b033870d
+    initial_ast: cfccac97b2c99262ce17f8a7ac04f4b4987f5e10dece4851796980822898f991
-    unrolled_ast: 8d324b6caf600f7134b94cd4dbd45268c83fc7238b8d58f7439b4ad0b033870d
+    unrolled_ast: cfccac97b2c99262ce17f8a7ac04f4b4987f5e10dece4851796980822898f991
-    ssa_ast: 6e17f05581caed4aae8d81f4d14172f11795a23d8f809fe5d6ac468b6200ec44
+    ssa_ast: 082ab3a4c0e059df4537603bc3e88bce9584e9fcefcef3366a889106aff40204
-    flattened_ast: 5b1c3043b3550252adddf9c8b43a19ddc6378b4f6296388ad225b9b48b8efca5
+    flattened_ast: aac645b2874d56f102459c44e086175e2a7b0f02b4d4427f54e9dbc26c926cfe

tests/expectations/compiler/function/flatten_test.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: no input
-    initial_ast: f237855e5889c18d9a87c930f1e0087adee8df4fdda005f0228e2c5524efd2d3
+    initial_ast: a046762e99c8b06ab3cd6ea197005557df29c2d60dfb925ec11f8895b16b9361
-    unrolled_ast: f237855e5889c18d9a87c930f1e0087adee8df4fdda005f0228e2c5524efd2d3
+    unrolled_ast: a046762e99c8b06ab3cd6ea197005557df29c2d60dfb925ec11f8895b16b9361
-    ssa_ast: 878d0180bd4671c1e316e78199016833a6d526e99e26d333d9ad9c4ab1d0bcba
+    ssa_ast: fde0d410518f71452bd7b5b3815ff0529a7c5bb6e0e96d0cd5b2d9461ce6a442
-    flattened_ast: 66e1626e6349f9bbc258e5703e44e8b5e94bb0ae9f35846114a276e764bff2b7
+    flattened_ast: 7d22212a4419929db03ee78de65e186d6ee5baf76ccfc0bfc3e9005a498b348b

tests/expectations/compiler/function/flatten_tuples_of_structs.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: no input
-    initial_ast: 072b212443dbc525313d0fd0ee5944d9c844e0b94f99df30f3c69272d4309099
+    initial_ast: 35a8333e1fa4b48c5a73f66ed7d765cb053bb170b78161ad8803e47b895b257c
-    unrolled_ast: 072b212443dbc525313d0fd0ee5944d9c844e0b94f99df30f3c69272d4309099
+    unrolled_ast: 35a8333e1fa4b48c5a73f66ed7d765cb053bb170b78161ad8803e47b895b257c
-    ssa_ast: 11c9c41d1950c2a3ae95b454a63e8caccccbe598f8d87c086241f77413e53416
+    ssa_ast: d7bd58882bb00dcff7620b2952edb0245ac6c860ed31a5c8291132e56d692ad8
-    flattened_ast: fec064665269c22dd99c30949b759fbfb6c55b7b6042a1fc08aaa7fbdcb28913
+    flattened_ast: 2ab2f9acdc7b09955259d5beacbb752653803d0d375a14b8d08f1d1f190bfc68

tests/expectations/compiler/function/function_call.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: ab443a59dfbb4fc7a32e5ba2731ea20fc956e86b33ceb2595cf8cfe04b2f3397
-    initial_ast: 79c81fda32648f5f221cb72f879eb88edf26a92362546fde7260600b7191fb7b
+    initial_ast: 307a506409f04951b09cee16a44a16b9a789998827183f4726c46271a3f4f9ba
-    unrolled_ast: 79c81fda32648f5f221cb72f879eb88edf26a92362546fde7260600b7191fb7b
+    unrolled_ast: 307a506409f04951b09cee16a44a16b9a789998827183f4726c46271a3f4f9ba
-    ssa_ast: 2538ae66568fbaa469d07794bc3342551374f502d1c3ed88647faac5a2ab320f
+    ssa_ast: 3a3675ba279a58a82e7ab2d480565bc647179ff7040eb234ad3ed884537a3f79
-    flattened_ast: e4d830146bf658ac87f3ace2a383a6d6c0f10954f8285371bf539e8183e3fe08
+    flattened_ast: f2fdfd7f2cf84dc81c3d77fd394bd4a7f149be1b44612a876d42e56a37df864d

tests/expectations/compiler/function/helper_function_with_interface.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: no input
-    initial_ast: 9994f0cbf43eec59fd9dc734b1a4d69417e51c1351c2e03d57da4996b735da43
+    initial_ast: 622320e0d77b239b59f67e1b80b30ae98e8941e213640c2597153766d03aa0c3
-    unrolled_ast: 9994f0cbf43eec59fd9dc734b1a4d69417e51c1351c2e03d57da4996b735da43
+    unrolled_ast: 622320e0d77b239b59f67e1b80b30ae98e8941e213640c2597153766d03aa0c3
-    ssa_ast: 5f0508c0a5d301e7c5e39848ed5ca004d1ed40ee616613517a0fc110773e8123
+    ssa_ast: f0d60e26a07a63ba70c4cea1ec588fc154a2657cf6b8f8965273066754d7e12f
-    flattened_ast: 626e995bfa1c8c5ff62a4702b128a5b7fa6d200fdaa9e45ad349c06a49d92103
+    flattened_ast: 49f069b59649da3ff41a9454f623a00d2ae72037ddf2f51832264c74af694f88

tests/expectations/compiler/function/private_input_output.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: no input
-    initial_ast: 00876dc82eebb31770a764870febc684d709ed7cee2af94e31f2fb9136f53851
+    initial_ast: b5c5ae7110c20b2fa7949b853a1a5b0a43b94667901da28ce759b3df3639145c
-    unrolled_ast: 00876dc82eebb31770a764870febc684d709ed7cee2af94e31f2fb9136f53851
+    unrolled_ast: b5c5ae7110c20b2fa7949b853a1a5b0a43b94667901da28ce759b3df3639145c
-    ssa_ast: 5ed955521e64a449c4ba62fb64faf60c789d50e7423bb6e37507e28920d1a2f7
+    ssa_ast: 34a50a879f1b146118035e5d19e022d857c9bdab0853d3eb1e826487b5805671
-    flattened_ast: 6f997f51d4761d3bb869cf13ad2580e43ba9f3dfd5edf744774eb4fea918ae1d
+    flattened_ast: 2c89be5251a0f6f950735e04cbdbff7d32e6105c7d23cd78abed8301eeb062b0

tests/expectations/compiler/function/program_function_any_number_of_inputs_and_outputs.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: no input
-    initial_ast: 77b497487a2ddcfe141273f833a5a21192189675e3680727121f7c860e83acec
+    initial_ast: 0d58956714cf72fd972a6121b0bee9322bd9606e49a2f158c90fe41aa103d432
-    unrolled_ast: 77b497487a2ddcfe141273f833a5a21192189675e3680727121f7c860e83acec
+    unrolled_ast: 0d58956714cf72fd972a6121b0bee9322bd9606e49a2f158c90fe41aa103d432
-    ssa_ast: 0d56dbc6ea78dfb0138bc0830755f7f6fc80bcfc2e0fdac97e5755dfec4b7e32
+    ssa_ast: 4510de0cb4ec419f81090874be53f3a568c2c7b37ed92768950a78058382f62f
-    flattened_ast: 7329ac0372ee5a92b3f8a04eaefc1ce7ab2c3c227828bb2be45c85c74e3d03a0
+    flattened_ast: 2f00534e4c8438ede4f7f984c647c73195a87e64764a739cf942e2364fa0ea30

tests/expectations/compiler/function/program_function_with_mode.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: no input
-    initial_ast: f9ad661659d861ca0fd8f49e67b46898ae3e755960df7e0337ca71572a17faa8
+    initial_ast: 89ebe3cb796af0bad47a3ac18061b4687d15f94a7464bad4dc96f81646a5bfb2
-    unrolled_ast: f9ad661659d861ca0fd8f49e67b46898ae3e755960df7e0337ca71572a17faa8
+    unrolled_ast: 89ebe3cb796af0bad47a3ac18061b4687d15f94a7464bad4dc96f81646a5bfb2
-    ssa_ast: 2420ac392de56c8b906e9b2c6d66107f78c51d2238a437fa9e3c4c4369f2d716
+    ssa_ast: f9d3dbf065342961525b64b3c3b9ed0a350a5df449e9bb797aff0e1c88d8e57c
-    flattened_ast: ad8473d6a6870141e47c2733ba29d9ba5d6d3b7ace772f54e4b27484fffd70f4
+    flattened_ast: 2b5980c571cde3a7d7679dbe8828b68b8aff7a7e48218c5b2219431bdbe0a31a

tests/expectations/compiler/function/record_in_conditional_return.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: no input
-    initial_ast: 65ef0a8f08605b9b607d7b32712b3683f141b387d0e97b23e251e847b30684f7
+    initial_ast: a7ffbb58b2da3419ca250f31c2209ad621be47f40aaa98cb2a61c946d92abc48
-    unrolled_ast: 65ef0a8f08605b9b607d7b32712b3683f141b387d0e97b23e251e847b30684f7
+    unrolled_ast: a7ffbb58b2da3419ca250f31c2209ad621be47f40aaa98cb2a61c946d92abc48
-    ssa_ast: f3434ad7e0ced5cbe25012bbcfaca888c159deb5173e148e7a851dfc0a554c90
+    ssa_ast: 9b3e74541ccb9cc5e9ff638697ee19455fa6a7eb8d90422bec6b4d950d6a1ec6
-    flattened_ast: 9149b476ec91c59d8bc1d9bb9c94bc143bf9c807d831c93eeaf6f5dae7c813d0
+    flattened_ast: cd44776ff8dd73d6951f00c994b7d81b0c6099bafa6a52dcf0d97eb459cc0a3f

tests/expectations/compiler/function/self.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: no input
-    initial_ast: 84f4c62ad2cabcb64bf52b9b76f90f4f54fa792617dbded292a7c9764c88393f
+    initial_ast: 4bb02d03cf06259f1d12dad50de6eadda16fb801598fa5f608b9b051731b80d2
-    unrolled_ast: 84f4c62ad2cabcb64bf52b9b76f90f4f54fa792617dbded292a7c9764c88393f
+    unrolled_ast: 4bb02d03cf06259f1d12dad50de6eadda16fb801598fa5f608b9b051731b80d2
-    ssa_ast: 3f691dfa2f0630b5515b3806240cfb2429cfa2a128d1b80e06d642a8f92cd721
+    ssa_ast: c5eeb210de41836977aad08dec424d6d17fb5817119eb15a6ef0c70337d47ec4
-    flattened_ast: 86366e160eacc314c1f8b054cb88970c6d249f95d713a605e8afef9472f0a32f
+    flattened_ast: 4615ed246a11e44b36b058cf2287a7f18ef2b11db0a00c3799cced8bb5cb346e

tests/expectations/compiler/group/add.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 24452096d9adcaa859a76f761fb9abdc61400486eaf37d62a77c6e2896c77afb
-    initial_ast: 0facc88c123a32aa96e8fc97907f676ef7e2f854e8cc8858d7ffb49fc2e413f1
+    initial_ast: db4d6c45319c9d110a370a27a5cddf8f6c47a83fa0f785e36cf60d86edd9a3f2
-    unrolled_ast: 0facc88c123a32aa96e8fc97907f676ef7e2f854e8cc8858d7ffb49fc2e413f1
+    unrolled_ast: db4d6c45319c9d110a370a27a5cddf8f6c47a83fa0f785e36cf60d86edd9a3f2
-    ssa_ast: 14e14b60785a74b90ce1c428a04d0a41a9c84cc5657aa87a66e8ada9af0d0e42
+    ssa_ast: 845dda94bb6db83627618bf4103870115460eb549b6881b9922315624dc93905
-    flattened_ast: 9b481b4769faa100fa5cea2ecf410ad7750b5a637c2dc5f02e76d75515f2d7ff
+    flattened_ast: 356c83c7783c4147e511f7754db74d54a674129675ca761f4316e3eaa45b9d96

tests/expectations/compiler/group/assert_eq.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3797d2bdbc9f4815d1ef88b8becca656f3840b170094ddbb1bdfade4d8e567a1
-    initial_ast: e20d2a0f7bb0586e4baceb6a6b0d6af267afc3817292805dcb5956bbb27a044f
+    initial_ast: 57ff3d335cb0583f22172636c81c415de383b507fe6b17b8a894551a91deee0d
-    unrolled_ast: e20d2a0f7bb0586e4baceb6a6b0d6af267afc3817292805dcb5956bbb27a044f
+    unrolled_ast: 57ff3d335cb0583f22172636c81c415de383b507fe6b17b8a894551a91deee0d
-    ssa_ast: 5752e475f7afe62a2770eecf2d93ac05081d50174e39357c672e6f3a4531d6e5
+    ssa_ast: 419ae5ce3ad3092e27bc5c4edcc0036c044e9b7976de8d722b9af0784379042e
-    flattened_ast: ddd5e2b680c238226e37ca548c51d1a2f4d783b7e0257c42acf7b883aaad5ff7
+    flattened_ast: d6e6d1b1020e0102ef00ba895ce4560798c983965f36e27496fc3f23537ac0a9

tests/expectations/compiler/group/eq.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3797d2bdbc9f4815d1ef88b8becca656f3840b170094ddbb1bdfade4d8e567a1
-    initial_ast: e20d2a0f7bb0586e4baceb6a6b0d6af267afc3817292805dcb5956bbb27a044f
+    initial_ast: 57ff3d335cb0583f22172636c81c415de383b507fe6b17b8a894551a91deee0d
-    unrolled_ast: e20d2a0f7bb0586e4baceb6a6b0d6af267afc3817292805dcb5956bbb27a044f
+    unrolled_ast: 57ff3d335cb0583f22172636c81c415de383b507fe6b17b8a894551a91deee0d
-    ssa_ast: 5752e475f7afe62a2770eecf2d93ac05081d50174e39357c672e6f3a4531d6e5
+    ssa_ast: 419ae5ce3ad3092e27bc5c4edcc0036c044e9b7976de8d722b9af0784379042e
-    flattened_ast: ddd5e2b680c238226e37ca548c51d1a2f4d783b7e0257c42acf7b883aaad5ff7
+    flattened_ast: d6e6d1b1020e0102ef00ba895ce4560798c983965f36e27496fc3f23537ac0a9

tests/expectations/compiler/group/group_mul.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: d530d7963eff5ef7d1c2c2f40e26ed585da3391244bd857a61da42576e2368fd
-    initial_ast: 9f981f58d9a87cb82c93b86cebfa2a14ca36c60037739ce04c1394df44d1ac5b
+    initial_ast: ae52b8228a51e9a1f37e40c6af89499260095c79b0f39c5b60496f2659944064
-    unrolled_ast: 9f981f58d9a87cb82c93b86cebfa2a14ca36c60037739ce04c1394df44d1ac5b
+    unrolled_ast: ae52b8228a51e9a1f37e40c6af89499260095c79b0f39c5b60496f2659944064
-    ssa_ast: 6a1473291566c71f843bb638c40e183339c66ec80172502802ac21995d0997c7
+    ssa_ast: 7aa53473237d2f68f063c1891b207fef9964120b13446de8f2365abcfcf86598
-    flattened_ast: 22877c98b9eee66969876c2b1b2823c850e122cd0397fbb3409ee0fcce9867db
+    flattened_ast: 315e1021f4a951bbb312efc6d447206a8976ad99cbcdb94a06e4a31fd32419be

tests/expectations/compiler/group/input.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 4d621b6b23f3eba436c7e0131354e4a260b8a98e15914e752c4839d7f5c4d25c
-    initial_ast: e20d2a0f7bb0586e4baceb6a6b0d6af267afc3817292805dcb5956bbb27a044f
+    initial_ast: 57ff3d335cb0583f22172636c81c415de383b507fe6b17b8a894551a91deee0d
-    unrolled_ast: e20d2a0f7bb0586e4baceb6a6b0d6af267afc3817292805dcb5956bbb27a044f
+    unrolled_ast: 57ff3d335cb0583f22172636c81c415de383b507fe6b17b8a894551a91deee0d
-    ssa_ast: 5752e475f7afe62a2770eecf2d93ac05081d50174e39357c672e6f3a4531d6e5
+    ssa_ast: 419ae5ce3ad3092e27bc5c4edcc0036c044e9b7976de8d722b9af0784379042e
-    flattened_ast: ddd5e2b680c238226e37ca548c51d1a2f4d783b7e0257c42acf7b883aaad5ff7
+    flattened_ast: d6e6d1b1020e0102ef00ba895ce4560798c983965f36e27496fc3f23537ac0a9

tests/expectations/compiler/group/mul.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: a220b4ebad69e490bf4a2471e4c4ecde9207f9806df90c3ba99f7f77d99eb97f
-    initial_ast: 07e7a71b7727ee073776cfd1ed51a79876d23d184e75300fc2feb849933da9c4
+    initial_ast: e3028937ba7dfb58b2a8a4ac978baca1090a98d9a943c6b6b3168c10b9fd16f8
-    unrolled_ast: 07e7a71b7727ee073776cfd1ed51a79876d23d184e75300fc2feb849933da9c4
+    unrolled_ast: e3028937ba7dfb58b2a8a4ac978baca1090a98d9a943c6b6b3168c10b9fd16f8
-    ssa_ast: 7a84373c29876e8797f468dbc48d665754ea74df79b50087f4ebacd98a8702d6
+    ssa_ast: b6b8e348b2f574d0fb0a56e83459e9b98a91af82ffdef01f755ea57ed26f169e
-    flattened_ast: c28de0f4c552bc47c7eb80f1d98d091764fe1857ef65b74e1dfb3d8d38a22664
+    flattened_ast: cf38ed372b392dbf4ead61401834f5e94c56d19aefaea73246c70c034f8d2513

tests/expectations/compiler/group/mult_by_scalar.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: c2f733a31bdf7f6f91fa96d411c99f2d702abb6bbaf9b00d35886aa51e8cbe8e
-    initial_ast: 8c705a012e5e2ebebcf25fc75dc467d5927f2663239d6781a97ef4611958df03
+    initial_ast: ede4f280e5249a103e3dc9604c8416df74c60f91d93f5623f8c30b1a8b4b64b5
-    unrolled_ast: 8c705a012e5e2ebebcf25fc75dc467d5927f2663239d6781a97ef4611958df03
+    unrolled_ast: ede4f280e5249a103e3dc9604c8416df74c60f91d93f5623f8c30b1a8b4b64b5
-    ssa_ast: 0053a47f7b3a9c3c41e2daff0705dfd4ae188c765c0cf6c438203a56832b19a7
+    ssa_ast: f278aec9f71a28010c810f7ba54fa9d264422a2a1a9f84f377e5567214cb9e4b
-    flattened_ast: 179a612b5543307588a7c21e26f7ebbf37a1b82d071b604b879228cfeec897ff
+    flattened_ast: 14a41f65a7a36e8d710933113b23fc183e1f87ff79615187790a26cc48b75c5f

tests/expectations/compiler/group/negate.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 1abe61a3267b558b08f1911f02c0845d05f7480beda9f84ee7111785e465cd15
-    initial_ast: ebfc2a6a99cb7ad2566aea5efcf5c5fd07ccb26ec9e15c738d95d98043197dd1
+    initial_ast: 033e2f9fcabfc61279492afd3e58fa88182095b62b4dec2754121254d3add393
-    unrolled_ast: ebfc2a6a99cb7ad2566aea5efcf5c5fd07ccb26ec9e15c738d95d98043197dd1
+    unrolled_ast: 033e2f9fcabfc61279492afd3e58fa88182095b62b4dec2754121254d3add393
-    ssa_ast: da468b7574c8abd9c2b4176d61a687189ba04c00ce88eb3d5c59bc05f563ed87
+    ssa_ast: c50d671af3ba4cc2963955005bb8a222c2b3c0ae61d81e73f9700041d44e0944
-    flattened_ast: d44a85bb1e59c944d9d37bd42bf5678926b1f42538e921e470bc837675683462
+    flattened_ast: dcd4d56f5a3ca387732df40629789e5dc98d42e2b3bd5f81f76c60ff879950ba