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

Introduces a new syntax for invoking the finalize block.
2024-12-24 02:31:44 +03:00 · 2022-11-23 02:55:58 -05:00 · 2022-11-23 02:55:58 -05:00 · ae18c6198c
commit ae18c6198c
parent 74bd06ba62 f6f286ac8a
428 changed files with 1816 additions and 1820 deletions
--- a/compiler/ast/src/passes/consumer.rs
+++ b/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;
--- a/compiler/ast/src/passes/reconstructor.rs
+++ b/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(),
--- a/compiler/ast/src/passes/visitor.rs
+++ b/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());
+            })
+        }
    }
 }

--- a/compiler/ast/src/statement/finalize.rs
+++ b/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);
--- a/compiler/ast/src/statement/mod.rs
+++ b/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),
--- a/compiler/ast/src/statement/return_.rs
+++ b/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,
 }
--- a/compiler/parser/src/parser/statement.rs
+++ b/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.
-    fn parse_finalize_statement(&mut self) -> Result<FinalizeStatement> {
-        self.expect(&Token::Async)?;
-        let start = self.expect(&Token::Finalize)?;
-        let (arguments, _, span) = self.parse_paren_comma_list(|p| p.parse_expression().map(Some))?;
-        self.expect(&Token::Semicolon)?;
-        let span = start + span;
-        Ok(FinalizeStatement { span, arguments })
+        let finalize_args = match self.token.token {
+            Token::Then => {
+                // Parse `then`.
+                self.expect(&Token::Then)?;
+                // Parse `finalize`.
+                self.expect(&Token::Finalize)?;
+                // Parse finalize arguments if they exist.
+                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.
--- a/compiler/parser/src/tokenizer/lexer.rs
+++ b/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,
--- a/compiler/parser/src/tokenizer/mod.rs
+++ b/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 */ // "#
            );
        });
--- a/compiler/parser/src/tokenizer/token.rs
+++ b/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>"),
--- a/compiler/passes/src/code_generation/visit_statements.rs
+++ b/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,
-    Mode, Output, ReturnStatement, Statement,
+    DefinitionStatement, Expression, ExpressionStatement, IncrementStatement, IterationStatement, Mode, Output,
+    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), _) => {
--- a/compiler/passes/src/flattening/flatten_program.rs
+++ b/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,
--- a/compiler/passes/src/flattening/flatten_statement.rs
+++ b/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,
-    ReturnStatement, Statement, StatementReconstructor, TupleExpression, Type, UnaryExpression, UnaryOperation,
+    DefinitionStatement, Expression, ExpressionReconstructor, Identifier, IterationStatement, Node, ReturnStatement,
+    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())
--- a/compiler/passes/src/flattening/flattener.rs
+++ b/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)>,
-    /// 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)>>,
+    pub(crate) returns: Vec<(Option<Expression>, ReturnStatement)>,
    /// 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(),
            }));
        }
--- a/compiler/passes/src/static_single_assignment/rename_statement.rs
+++ b/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,
-    Identifier, IncrementStatement, IterationStatement, ReturnStatement, Statement, StatementConsumer,
-    TernaryExpression, TupleExpression,
+    DecrementStatement, DefinitionStatement, Expression, ExpressionConsumer, ExpressionStatement, Identifier,
+    IncrementStatement, IterationStatement, ReturnStatement, Statement, StatementConsumer, TernaryExpression,
+    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,
        }));

--- a/compiler/passes/src/type_checking/check_statements.rs
+++ b/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_()));
+                        });
+                }
+            }
+        }
    }
 }
--- a/compiler/passes/src/type_checking/checker.rs
+++ b/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,
--- a/compiler/span/src/symbol.rs
+++ b/compiler/span/src/symbol.rs
@ -214,6 +214,7 @@ symbols! {
    std,
    Struct: "struct",
    test,
+    then,
    transition,
    Type: "type",

--- a/errors/src/errors/parser/parser_errors.rs
+++ b/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()),
+    }
 );
--- a/examples/basic_bank/src/main.leo
+++ b/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;
+        return remaining then finalize(hash, amount);
    }

    // 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;
+        return token then finalize(hash, amount);
    }

    // Updates on-chain state by the amount of tokens withdrawn.
--- a/examples/token/src/main.leo
+++ b/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) {
--- a/examples/vote/src/main.leo
+++ b/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.
--- a/tests/compiler/finalize/closure_with_finalize_fail.leo
+++ b/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;
+        return a + b then finalize(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) {
--- a/tests/compiler/finalize/decrement.leo
+++ b/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) {
--- a/tests/compiler/finalize/decrement_incorrect_type.leo
+++ b/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) {
--- a/tests/compiler/finalize/empty_finalize_fail.leo
+++ b/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) {}
--- a/tests/compiler/finalize/finalize.leo
+++ b/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() {
--- a/tests/compiler/finalize/finalize_incorrect_modes_fail.leo
+++ b/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 {
--- a/tests/compiler/finalize/finalize_incorrect_return_fail.leo
+++ b/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 {
--- a/tests/compiler/finalize/finalize_missing_return_fail.leo
+++ b/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 {
--- a/tests/compiler/finalize/finalize_name_mismatch_fail.leo
+++ b/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) {
--- a/tests/compiler/finalize/finalize_statement_incorrect_args_fail.leo
+++ b/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) {
--- a/tests/compiler/finalize/finalize_with_return.leo
+++ b/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;
    }
--- a/tests/compiler/finalize/increment.leo
+++ 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) {
--- a/tests/compiler/finalize/increment_incorrect_type.leo
+++ b/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) {
--- a/tests/compiler/finalize/read_write_mapping_fail.leo
+++ b/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) {
--- a/tests/compiler/function/self.leo
+++ b/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;
+        return self.caller == addr then finalize(self.caller);
    } finalize matches(addr: address) -> bool {
        return addr == self.caller;
    }
--- a/tests/expectations/compiler/address/binary.out
+++ b/tests/expectations/compiler/address/binary.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 30ff54da2da7a73c10f6cc96ea951755d57840fe3bcd0c9d6c68b8ed6c4024e2
-    initial_ast: 328cfc8f311133cb9f2622be2f93a1b624ff7f290dae03c0c4fedd6a139770ff
-    unrolled_ast: 328cfc8f311133cb9f2622be2f93a1b624ff7f290dae03c0c4fedd6a139770ff
-    ssa_ast: 798b6c449008ed6a38d603593dd3edf53aa30827e4ad2e0db6ef754999d1d807
-    flattened_ast: 305593c39dc0c26ccccb1ed5f1e4fdb932af847cab04990449c0193bc7a2c20f
+    initial_ast: 6a1cec2a4840e7dd92fd8e1c0f19bf0f4c973cecd56c20bbed6af57969d2bd1e
+    unrolled_ast: 6a1cec2a4840e7dd92fd8e1c0f19bf0f4c973cecd56c20bbed6af57969d2bd1e
+    ssa_ast: dfcc60600fd4bab6efc11e75a295421123b78c8db7047dc80b40b202b3dba991
+    flattened_ast: 9f34fa2659a0989b9156cb71ed559b825d7123475715f030f47dd8ab8be4d4fb
--- a/tests/expectations/compiler/address/branch.out
+++ b/tests/expectations/compiler/address/branch.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 613969730f6ac4ff47e6975f79edf83ac2d5398d029657cbe28d53dd74847d1c
-    initial_ast: 002375784372b4d6b83e0e181998cebd7e25dca957d1c935a08f9227d21ba373
-    unrolled_ast: 002375784372b4d6b83e0e181998cebd7e25dca957d1c935a08f9227d21ba373
-    ssa_ast: f128dc2ee3b1a636526c27b196e0b755b244cd9d8e52067541214b7909f38cf0
-    flattened_ast: 1675206b4e0435049515729daa4468b6d4aab041812bf20758f74b79c40259aa
+    initial_ast: 4e26bd74ec1a90ea8923c648196e906a3ccad3572790b466eee11382c47e1713
+    unrolled_ast: 4e26bd74ec1a90ea8923c648196e906a3ccad3572790b466eee11382c47e1713
+    ssa_ast: 7433b8afd385c2d81233ab525e1fc9ca1fbd7387461c4de0aedfbafd9b1149fb
+    flattened_ast: 6378f55000d09e2cdeed1c1eec71d37fd6ecadc4d618ebb700143f4a5f454632
--- a/tests/expectations/compiler/address/equal.out
+++ b/tests/expectations/compiler/address/equal.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 508ac917fe0d0779f2d43ae7695945dbe1fd00c457f08716dc51bbb2fe14e452
-    initial_ast: f3e09111dcb009c66349bd98ad3ff8bebf753a184e2dafff711a521a43b3b2fc
-    unrolled_ast: f3e09111dcb009c66349bd98ad3ff8bebf753a184e2dafff711a521a43b3b2fc
-    ssa_ast: fda8333d6142536467e05fb5129198882eb028e6a2c0c6ed1d2339b9a716aba1
-    flattened_ast: ab7783ad36c7540c555836b66e7c6b07f7681824dfcb58d5bbd3f0ea5fbf6bbd
+    initial_ast: 9404c479dc278c16e5f0e5496373395102f5ab600bb9bce0c183d5e82349e00f
+    unrolled_ast: 9404c479dc278c16e5f0e5496373395102f5ab600bb9bce0c183d5e82349e00f
+    ssa_ast: 405c2bca8b120380bd652f9cb0138dccdb46c02044075c15d38ad7290761e38d
+    flattened_ast: 4c47ad8af1479770aca65ac434c59955993bff9f085b08b1a3cb774bde711247
--- a/tests/expectations/compiler/address/ternary.out
+++ b/tests/expectations/compiler/address/ternary.out
@ -5,7 +5,7 @@ outputs:
  - output:
      - initial_input_ast: 64247a73944a1639b17e3fd8ae0777b6725a754160afb476f9b0b6b8495d9884
      - initial_input_ast: 9546ede7c01cbe3a4cbedf2296fbc6605f657c2e1843e8f50ef683bc3eedd18a
-    initial_ast: 1baa54d7c29ab84a48f3d52359d0a7c64a3929fd6c3975afe375d8c7c8420da7
-    unrolled_ast: 1baa54d7c29ab84a48f3d52359d0a7c64a3929fd6c3975afe375d8c7c8420da7
-    ssa_ast: 38d2140f8bc0308859260c927be943d2671ce80eb9ef4c22b42a4090ffab9728
-    flattened_ast: a0e0a2c74ebd61346d568368f55cacaa7417070467925dbfc10754b5c1fa4437
+    initial_ast: 8bce21628196fd8ba4aee1242405a3ad388e6a1134ed0cdb1bacef88e6466dce
+    unrolled_ast: 8bce21628196fd8ba4aee1242405a3ad388e6a1134ed0cdb1bacef88e6466dce
+    ssa_ast: 7c511088daa0755fff5f8b6ae6eb472aa38b51ae645e757fdeb24db29c8d2eef
+    flattened_ast: 2e31550270897fd3931ab4040568d12b79ea100e9cbf37d0f43de038788cc072
--- a/tests/expectations/compiler/boolean/and.out
+++ b/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
-    unrolled_ast: 9269fac5a002cab579fa96fba2683e139480f7cb36e17e1a97ad0f978bc41d2c
-    ssa_ast: 055c1482321089f1c84759b6fb827627ccd6f4e8f460912850409523a551f1b2
-    flattened_ast: da73712d568e808ed59b4fde16e169cd93c37785d2b108a23f896b115ad8b080
+    initial_ast: 3d39d634c198d80d62ac0d93e7446df62ee49ea2a50328a171184bd71acb56d0
+    unrolled_ast: 3d39d634c198d80d62ac0d93e7446df62ee49ea2a50328a171184bd71acb56d0
+    ssa_ast: dd42b8af78c61a2a922b5d39713610f503898b0407499c90a5fc8d08b29a3d1c
+    flattened_ast: 1684fd357114961933aa2047ae0a430b5821f53a7e0fc3162f4a2ac35dc5aeec
--- a/tests/expectations/compiler/boolean/conditional.out
+++ b/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
-    unrolled_ast: 891b9ffdd456bb562967d74ad2afdd8066450ef63fdca4f234a60435dcd0296a
-    ssa_ast: 0e38a8a2cbb256836bd031ef65135645f2a5a531ca199cab96d569009ed89fa7
-    flattened_ast: 3503363a685653128309a3f28e24df051b8fd66bdb8d287db26bfd182fbb576b
+    initial_ast: 3f5971e3fdd89e5600c7f0ac4f41fa919661c5b861aea38ac55ddbc38f2c865b
+    unrolled_ast: 3f5971e3fdd89e5600c7f0ac4f41fa919661c5b861aea38ac55ddbc38f2c865b
+    ssa_ast: 5308162ac930d71cef23608546eccf84389db548743bb9a1c9b90483c73dd853
+    flattened_ast: c2b13812ef8ac64f04bc29b7481e6a7be7c8916ba2f5fd71e1d1856a9e13a165
--- a/tests/expectations/compiler/boolean/equal.out
+++ b/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
-    unrolled_ast: cd14a221e3a2df0159db5218598bf1c511a28be47dd74200aaa8f1d6250ea4c7
-    ssa_ast: da168bc2b396c6c0f76ddf29b2ee5993a40bf35921fcd7f61afe29fdaca734e9
-    flattened_ast: 9ee5708390c3f6902822fd4da5e891c0adf565a4c62978f65a1c33a4ef9c3dbc
+    initial_ast: b075d566065215a06239a0cebf5357fa5a3aec72aad1482463bc15cedf59ad03
+    unrolled_ast: b075d566065215a06239a0cebf5357fa5a3aec72aad1482463bc15cedf59ad03
+    ssa_ast: d8e64b87fce6bafb3e3307be1db69bb6aabc3f6182785239486bb654a5831af3
+    flattened_ast: 210e6a2f43a69a7e16e9df95814cc7a1611d414e4f1ade4bd260fbb590ce1897
--- a/tests/expectations/compiler/boolean/not_equal.out
+++ b/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
-    unrolled_ast: 4fff7b86b673dd71d0221173551ac8221806ed7092a06a0bd196beaeb9465de8
-    ssa_ast: a1ab719005fb5c32680c96ac814bf6d1918e403d487e943a73e0a4e6a1875604
-    flattened_ast: 1d6cbbabe9abfec1c515e82160f90f5251a48115b0eb12b02cd8432d01ea38f6
+    initial_ast: 02b35b82c1711ac2482a87546725b7cc40e4676061bd75b8d93204465e522ed0
+    unrolled_ast: 02b35b82c1711ac2482a87546725b7cc40e4676061bd75b8d93204465e522ed0
+    ssa_ast: b5f750fba34b3a5500319a1dac182c1ab9235201eae2037d10910b5058570ace
+    flattened_ast: 5d8c52a51c52d5ed0db67bbbf42ba18c3c76df30c79c0eb5fd58e140f73701bc
--- a/tests/expectations/compiler/boolean/operator_methods.out
+++ b/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
-    unrolled_ast: 1c81e28b5e127045508de4847ae63f322bbe7099d259e517dca07468873a19e3
-    ssa_ast: 8d96cba8107bd0d1a71cd355a9b1aa46f18b5ed45ee874315ef97e29e305bb2d
-    flattened_ast: 4dce24b3f5f0df6010c894eda15c02dcef029a04bd0048b30ff70e6647b986d1
+    initial_ast: 446cad7ff440d890616980bcf51f61f682b9d119dde689742d944374cef11f63
+    unrolled_ast: 446cad7ff440d890616980bcf51f61f682b9d119dde689742d944374cef11f63
+    ssa_ast: 3112eb3c83c6e1c56ff2603b13affbafc51f22cbfcc07973e60996c5aeb93c4f
+    flattened_ast: 10d25a049502c4a07a66385a1dec39cc8011cd71d1da056362254c665c5b6274
--- a/tests/expectations/compiler/boolean/or.out
+++ b/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
-    unrolled_ast: c004484db4a7dd5dc0b2c764cf61b140e86955ffcd079a59951dfbfd504e269d
-    ssa_ast: 3185c86f842257ed17cd1b6111d5c6fb7fcd125fc1382b491913228fe37a1aa4
-    flattened_ast: af518c0d1c4b8b25c6deffa6976ba54d48e92ac71f6920b9373bc0f009341099
+    initial_ast: 6dcb15aecd651c1fe3e54b258a474f866067d2240899f35cfdf0a381ffc5614b
+    unrolled_ast: 6dcb15aecd651c1fe3e54b258a474f866067d2240899f35cfdf0a381ffc5614b
+    ssa_ast: d30b8b1b3203860632f76c62f03cda1674b2c583ab7948bd7435a055fdae1582
+    flattened_ast: e838bbd63a6e65aac01aaf825e181aa8ee66dcf85ac05a5e1ceb122d9bc33a25
--- a/tests/expectations/compiler/console/assert.out
+++ b/tests/expectations/compiler/console/assert.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: e7874e1d569eadaa5313be245f71202463aef0100ae21305a8212812f2881555
-    initial_ast: 3de295c355d0f2ddff68a436df6e4455752e69a7f956dfb3d8dabb0d83080c93
-    unrolled_ast: 3de295c355d0f2ddff68a436df6e4455752e69a7f956dfb3d8dabb0d83080c93
-    ssa_ast: 932ec44b122ddf173798d31be23c176f72c1eee03d7cecfdce17242977ca75b4
-    flattened_ast: 385b716fa95d33eb36179087b85ffe4d15c0fd9e294174f88bcd61d834473147
+    initial_ast: 3a6f935c5ca129da9caece4c27c5c32b7b8588fab4ee6f7446ef88b41f13e2a6
+    unrolled_ast: 3a6f935c5ca129da9caece4c27c5c32b7b8588fab4ee6f7446ef88b41f13e2a6
+    ssa_ast: 6c3f28ee2ba2a54c325e82bfa0c1ca032f16cb5d86e70f376d3185adc9a07578
+    flattened_ast: 45cc072f14c0bb07ef7e78e7973aee0ebaf767a3921f13e62065eb40b7ae3960
--- a/tests/expectations/compiler/console/conditional_assert.out
+++ b/tests/expectations/compiler/console/conditional_assert.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: no input
-    initial_ast: aa1777f90d189c4127edc7419efa3134969a6db3e138bcde36095377d22452a3
-    unrolled_ast: aa1777f90d189c4127edc7419efa3134969a6db3e138bcde36095377d22452a3
-    ssa_ast: 672c4dd4f4eca31c458b8a55d2af1cd46fda4261578993f353b6cdf1818256de
-    flattened_ast: 5eacb46ae48246907ab7d5cda2b33d5e49504cccc22b04c9b3c48a4b939679b3
+    initial_ast: 8a02943ec06fdce6dbaa8629e3d69a2f6aabaa62af4379cd38bf05336e5b33f3
+    unrolled_ast: 8a02943ec06fdce6dbaa8629e3d69a2f6aabaa62af4379cd38bf05336e5b33f3
+    ssa_ast: ef8e0d6155b97f72a62f02038d180cfa251de925d2d2fbce410db7a560d77231
+    flattened_ast: ae328dab873969a1194a18b519934915927d6d5fa1d190f6d74f8d4ad3c8c89a
--- a/tests/expectations/compiler/core/algorithms/bhp1024_commit.out
+++ b/tests/expectations/compiler/core/algorithms/bhp1024_commit.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: a30505e4422e13fcbf395f44b70bfd5fbe3a59c5328814405df5cfeaab639d55
-    initial_ast: a7d914dc1bcd9c5db46a6c8eca1210a5fbe19634f5d753aceac23d498679d3d2
-    unrolled_ast: a7d914dc1bcd9c5db46a6c8eca1210a5fbe19634f5d753aceac23d498679d3d2
-    ssa_ast: 3bf4465fa7037bae8c4ddf07fd4a1a67e72558865b22fe4e1108a6d00d11fa75
-    flattened_ast: efd6c65caf99fb00467b08626d3aaa8bc93186e8424fc5c23610ecf6a9c7dae2
+    initial_ast: 51bee86cfd13ccdadfc8e7a107931669aa8b2aa31b544b8f5503562c4d21df56
+    unrolled_ast: 51bee86cfd13ccdadfc8e7a107931669aa8b2aa31b544b8f5503562c4d21df56
+    ssa_ast: f5f80624539e00f53712cd5d50b7f5518d2fba21e0156d18652bea1e0330350e
+    flattened_ast: d3cd4422f4864509a4813e8cc7174e9e091c653177f97a5067bdb05c6a1d5fe0
--- a/tests/expectations/compiler/core/algorithms/bhp1024_hash.out
+++ b/tests/expectations/compiler/core/algorithms/bhp1024_hash.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 9df63ce5d0366e8ba31fb07e696dc2e67f64371f629c66d3a9ddb715c923692e
-    initial_ast: 69b992df47acf68e90bd8b613e60212d16172e8edeedb0f4b4b39353c38adc61
-    unrolled_ast: 69b992df47acf68e90bd8b613e60212d16172e8edeedb0f4b4b39353c38adc61
-    ssa_ast: 04ed79c5f4a1faf52032b353d8f8297a467d8e02ed447f7f81e393b3ddf24ed3
-    flattened_ast: 0c95bcbb644f61776a20fb9b885b6cb48f9adb552192d7acf5a80670ccde21e0
+    initial_ast: c9f090b3af2fc56bbeb69cec425e6dfe482593abcad1ab4f731c5743274fd283
+    unrolled_ast: c9f090b3af2fc56bbeb69cec425e6dfe482593abcad1ab4f731c5743274fd283
+    ssa_ast: 3b9a7a868bd19cdfbe1494f12fe0032bcb02bc7ae082b236f33d90df043342cd
+    flattened_ast: 561be660fd0b0cbf9ed5e7f5d82f435b2fba59cd877246ff95b45af350d19d21
--- a/tests/expectations/compiler/core/algorithms/bhp256_commit.out
+++ b/tests/expectations/compiler/core/algorithms/bhp256_commit.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 81e7b4b48e21c631f656aa65b6d19ebb7d784b43229356b918f908a046734261
-    initial_ast: 953d5e9d7689faeea239ad13c6653805e1a13281f3ac3f37dbea106449d23a5f
-    unrolled_ast: 953d5e9d7689faeea239ad13c6653805e1a13281f3ac3f37dbea106449d23a5f
-    ssa_ast: 232eaa57f15cacf6dc99d9a0599915b1adee632e5de070dfa6c5aa9e117e5d61
-    flattened_ast: 0e223b52044c42ab29c340998ee76946a5ebcab27b7311c19b26b2072276b3c5
+    initial_ast: e2377ecd37c2f0b183f1454303672052ece1a8e7e7e954a94342203df7f5f329
+    unrolled_ast: e2377ecd37c2f0b183f1454303672052ece1a8e7e7e954a94342203df7f5f329
+    ssa_ast: 95ba4a9b09a33c21a1dd06780c4ef8eed6292aafbb02e13b06d677d5efbaa367
+    flattened_ast: c63e28436e87504045b9d590b1b471242bee6cd86b2b2ce9cfc76609b5c78b23
--- a/tests/expectations/compiler/core/algorithms/bhp256_hash.out
+++ b/tests/expectations/compiler/core/algorithms/bhp256_hash.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 3cb982a5d4144e548fca897ceb686ad1f638971bb22fff7b935363eacc1b3473
-    initial_ast: 4407c172fe97be9aa387a6fd94549386e803dfd7b8a83ca0936279b853fd1312
-    unrolled_ast: 4407c172fe97be9aa387a6fd94549386e803dfd7b8a83ca0936279b853fd1312
-    ssa_ast: 7801e83d9bc93fa26a769c94cc7a08b8676f761869da8e6ca4523e5d144cb5e6
-    flattened_ast: 2bbafd8b601c9475cb180e254dabbf08a2d9da07c63cadd6b21252a38e4129c5
+    initial_ast: 0994f824a3bdd2f3e29d54d135facae3ba9e36350e75bc91e21b6c5d3d9c568d
+    unrolled_ast: 0994f824a3bdd2f3e29d54d135facae3ba9e36350e75bc91e21b6c5d3d9c568d
+    ssa_ast: 0087332023f8ab478c0572a26572463e770988bb5e062248d739aca8ef2e3336
+    flattened_ast: 7998493d9573a436176f7cb35328da317912df328c54642816ddc5e3609172d1
--- a/tests/expectations/compiler/core/algorithms/bhp512_commit.out
+++ b/tests/expectations/compiler/core/algorithms/bhp512_commit.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 81e7b4b48e21c631f656aa65b6d19ebb7d784b43229356b918f908a046734261
-    initial_ast: ad1967ac1c839fae18c5c7a46a3f1a038d7f6379662ce73b5ff81838e9fecb06
-    unrolled_ast: ad1967ac1c839fae18c5c7a46a3f1a038d7f6379662ce73b5ff81838e9fecb06
-    ssa_ast: 3d812d01adde60b0a3201ecea2ac6e3b8589ed5b9a00994522835a579c11af55
-    flattened_ast: 2ad8be7ffefae31b19fbb3cddc9f7c3615225185b54d2c20e6456fe9d8502614
+    initial_ast: a8d610455116580be112280b5438fd9679198227bc35ab58ceab00aaea39caf8
+    unrolled_ast: a8d610455116580be112280b5438fd9679198227bc35ab58ceab00aaea39caf8
+    ssa_ast: 1c40d4b3a659d539b7617e62a0b56d9034c8ad8d5dd4e17394407fc285ae57a6
+    flattened_ast: 4a0bea548a4bfaf7c9ae74b3a712915cfc5f0ce69ef101d28235738693cc7568
--- a/tests/expectations/compiler/core/algorithms/bhp512_hash.out
+++ b/tests/expectations/compiler/core/algorithms/bhp512_hash.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 3cb982a5d4144e548fca897ceb686ad1f638971bb22fff7b935363eacc1b3473
-    initial_ast: d2dc132a022976ed2e21401d332b4ea766426097eb1be7e33082473ade6e4d95
-    unrolled_ast: d2dc132a022976ed2e21401d332b4ea766426097eb1be7e33082473ade6e4d95
-    ssa_ast: fd34527ae5871a81df9dc16df2e5030f0195cffdf6dea4f78ed19aedea6da621
-    flattened_ast: 151a5163d81bdd8d15ad4af804e3a8b6e8ed6e5c97fd7470a13c83b68f979d6c
+    initial_ast: aa474e9742098330a73f3ce9d518bb011813b824f89c98076edb5470630c8368
+    unrolled_ast: aa474e9742098330a73f3ce9d518bb011813b824f89c98076edb5470630c8368
+    ssa_ast: fcba4c87b89c60a7ffb8ccbbee4f034f2cc1d0058093c92d4f4c84f594119749
+    flattened_ast: 42abcfb46266c272e847a082999135b6e089a21097055431c6694c601ebef57e
--- a/tests/expectations/compiler/core/algorithms/bhp768_commit.out
+++ b/tests/expectations/compiler/core/algorithms/bhp768_commit.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 81e7b4b48e21c631f656aa65b6d19ebb7d784b43229356b918f908a046734261
-    initial_ast: b8c180b1cead8f5d3aa420e03dc135e2c82220c31e3d46cb31a3a3377d8322ab
-    unrolled_ast: b8c180b1cead8f5d3aa420e03dc135e2c82220c31e3d46cb31a3a3377d8322ab
-    ssa_ast: 70f05a3e659eb20d8e605e1c9b91338ee90c123f7453a240bf1a3950e5815042
-    flattened_ast: d54cbd75ce1a0d7e6dd679659ccd4307f77bffc19f6234415225df9bcef09879
+    initial_ast: 06785b5dd9fa53974e527c121b0daf180fd5ffc3c4479b7b242d2635556c5e6e
+    unrolled_ast: 06785b5dd9fa53974e527c121b0daf180fd5ffc3c4479b7b242d2635556c5e6e
+    ssa_ast: 10aa2cac1ce759f62cc59b6f800dd483aaf9b15524d91469031a2c6c51270293
+    flattened_ast: dfbba5676cd15c17ebc8fa2c3073a97ad769c80249ccdbf5db12b70df9410f03
--- a/tests/expectations/compiler/core/algorithms/bhp768_hash.out
+++ b/tests/expectations/compiler/core/algorithms/bhp768_hash.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 3cb982a5d4144e548fca897ceb686ad1f638971bb22fff7b935363eacc1b3473
-    initial_ast: aaa2271be04607379f94fb121c50c8990d4a0b68ba5257220102db26b91a0f14
-    unrolled_ast: aaa2271be04607379f94fb121c50c8990d4a0b68ba5257220102db26b91a0f14
-    ssa_ast: de05aeb7675088006960519444a10897077b9080ebe1ce5e6e3f2439536101c5
-    flattened_ast: ba2389349ba5155169389732da800d08def0aa26882c6a0a93e8fab257dc9a2b
+    initial_ast: f6a77b77e366cecaddc7dbed12b51d83f7c6f434ba24cc885437f74bec8c457c
+    unrolled_ast: f6a77b77e366cecaddc7dbed12b51d83f7c6f434ba24cc885437f74bec8c457c
+    ssa_ast: 9fe73b365687cc0f948cef5b7d66197a17ae028957042a0a806c886824b2ac4d
+    flattened_ast: aaf5a0f6ab6b87fd765ea4f6652dd802d06bbf25eaa7f9f50fa4a9f0d0860989
--- a/tests/expectations/compiler/core/algorithms/pedersen128_commit.out
+++ b/tests/expectations/compiler/core/algorithms/pedersen128_commit.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 46d3cef7b6dd6e951fe93d550206bdd658d6d435f71c776a39ae3b443770d33d
-    initial_ast: cad5c306b9b28181bd6b0c6b2eed216219ebcb60b96554c11bdd241b226aaf73
-    unrolled_ast: cad5c306b9b28181bd6b0c6b2eed216219ebcb60b96554c11bdd241b226aaf73
-    ssa_ast: 1b2af30d0034ea32bd630884142157796f6c8f8f9e2ef7e9701ed62a2f92424b
-    flattened_ast: c100fdd0403a9d8d6a38609d37f4e36ce54e3d6257db1d19d1e973274326906b
+    initial_ast: 6af9e875a38f0b512b91aab4d1e603780820382abd651d509ad90f0375bf061f
+    unrolled_ast: 6af9e875a38f0b512b91aab4d1e603780820382abd651d509ad90f0375bf061f
+    ssa_ast: 11b9a590dd9823c00b607e8162ee79b720eb632a46a4760d9dd57b35e463e4f2
+    flattened_ast: 81fb5a95971a3ccb8182dbe23e501b12d71ea62e89067e166f3361fa0a757d1e
--- a/tests/expectations/compiler/core/algorithms/pedersen128_hash.out
+++ b/tests/expectations/compiler/core/algorithms/pedersen128_hash.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 7155146c3f0887e6298bfabe9cad16d78c150419e8d0d584616d5dd76c5c3bac
-    initial_ast: 9a4877e6514d54a55c8a76dbd4de9e27d43d137477c7d93470d45a61f6017861
-    unrolled_ast: 9a4877e6514d54a55c8a76dbd4de9e27d43d137477c7d93470d45a61f6017861
-    ssa_ast: 44237ce1986b38c34c5d2a624676e64c53257648436d82b9d333d6ab0c37102d
-    flattened_ast: c5d401aa71f99eabd1db84264069cb3a904019b93282296020a4e2db537cbcba
+    initial_ast: 5518b3f856748100a951db7b5807e67ebc8648c38e1b10f60519984ffe8127a6
+    unrolled_ast: 5518b3f856748100a951db7b5807e67ebc8648c38e1b10f60519984ffe8127a6
+    ssa_ast: 764817f9c5341fd4d7d8279d43674bce492289d9f353091face9fbec653df967
+    flattened_ast: 8e222bd26b9887f0df4aa002031cdd41652090a0778af0f535b6867a5c854b6b
--- a/tests/expectations/compiler/core/algorithms/pedersen64_commit.out
+++ b/tests/expectations/compiler/core/algorithms/pedersen64_commit.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 591fe9942b59bad76b636a1c9e6ebe93ad85df562b09b7a900acfe12a9caffe2
-    initial_ast: 3c9a4fde69b75a022863bb1f29026bc4fdac5eca0ad0ec5e3ecb7364e7a17499
-    unrolled_ast: 3c9a4fde69b75a022863bb1f29026bc4fdac5eca0ad0ec5e3ecb7364e7a17499
-    ssa_ast: 4f51f745379cb8078a6512104b27f778d6a36cd4bc92e6e06b74f95d8204ba37
-    flattened_ast: 1fd5c458c8f61a818f6409f20e430c37d7a9d4a1aceae7a96b370fa9dca03c94
+    initial_ast: ad2bc892f24b971eff231aa2d53047e5129cdd510c689f21235d51601c04670b
+    unrolled_ast: ad2bc892f24b971eff231aa2d53047e5129cdd510c689f21235d51601c04670b
+    ssa_ast: 5fda4bee03a6d82641305659fb244ffd043c0f1f87114944c25677e7eebfc36b
+    flattened_ast: 1e32d226f9c5ee5a753d110feae1bfdee8098b3da5a37417f8e408dcee52a244
--- a/tests/expectations/compiler/core/algorithms/pedersen64_hash.out
+++ b/tests/expectations/compiler/core/algorithms/pedersen64_hash.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 6b64b3a4fd7cafc2ead15efb8a91f8fc102947ccf4c091e4b6e54df82811fe82
-    initial_ast: 2ef0225f6f5b08bec4cbac785f486c667251c285c2e3e221c63cd2d9d8c4d240
-    unrolled_ast: 2ef0225f6f5b08bec4cbac785f486c667251c285c2e3e221c63cd2d9d8c4d240
-    ssa_ast: 406dfc7b88282780532453da30e06d04fb6398fbb5f8934aa6951bc57e785af2
-    flattened_ast: 0ab17f84c7bb560a48f49bce7e29384f3439028f2fcb55f93649fa7e615a66fa
+    initial_ast: 28e9fcadb32adc57ef9208090d348a06bbd067b0c82325a6eb55932f9e369edf
+    unrolled_ast: 28e9fcadb32adc57ef9208090d348a06bbd067b0c82325a6eb55932f9e369edf
+    ssa_ast: 09bc0a1171087290f79bea4cb6d93225b6a1c750090cf48724e221f1e1e5c6e0
+    flattened_ast: 371c62b8b4edfc10dbaf5084046b357e2f946876286c5f6e081a7e8ce90759bf
--- a/tests/expectations/compiler/core/algorithms/poseidon2_hash.out
+++ b/tests/expectations/compiler/core/algorithms/poseidon2_hash.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 1e9c68e82f6c0dc9eaa4babbc5cb9e46d79f8f0661607b48efd2e9870a636f33
-    initial_ast: a5f32b136e224ace47e695dacb7d481975a343cdcd5b822652b8ce4bace9bdc4
-    unrolled_ast: a5f32b136e224ace47e695dacb7d481975a343cdcd5b822652b8ce4bace9bdc4
-    ssa_ast: cfbd02fec7cde8cb7de3cabe033207e0aa025d0c1eadf5b27f4aeff4b2f48c30
-    flattened_ast: c86be4a932e4a91d25b8cca98ebadb1875d30a7409585b1cbeab3c7bf511e7fa
+    initial_ast: d30016b42bba9fc40ee73874091f2723b01ddb6a5b791df4b04ba2ce680b2946
+    unrolled_ast: d30016b42bba9fc40ee73874091f2723b01ddb6a5b791df4b04ba2ce680b2946
+    ssa_ast: 572f3cd4c99615c1604342153c9d3dc90f2c5402d2f61e4769682079805957db
+    flattened_ast: 9d98960549f8f4d508c24165a9bd05e584928ba1eeed9e66acc6c7a0008cb096
--- a/tests/expectations/compiler/core/algorithms/poseidon4_hash.out
+++ b/tests/expectations/compiler/core/algorithms/poseidon4_hash.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 1e9c68e82f6c0dc9eaa4babbc5cb9e46d79f8f0661607b48efd2e9870a636f33
-    initial_ast: 95f0769ebd6f1f6170771b5b4a2a8f333577f285531e64a3c2899e022d83b26c
-    unrolled_ast: 95f0769ebd6f1f6170771b5b4a2a8f333577f285531e64a3c2899e022d83b26c
-    ssa_ast: 535712b468cd7472f115e1a3a4edd8e8e57ab80afb8fbb5922fcf0e41af9c6ee
-    flattened_ast: 3843c47a4d735398cbdda45f1815a14fce9e83dcab0cc318b1f11b5b21d95a39
+    initial_ast: c532bfa484a2a0c12ea025d201de40ac81ddeefe80c8154c508899fffdc7a675
+    unrolled_ast: c532bfa484a2a0c12ea025d201de40ac81ddeefe80c8154c508899fffdc7a675
+    ssa_ast: 8328857553e07d4d8004dceb6959f2beaae6f8719336939acb1029d9fed7d53b
+    flattened_ast: e9e9fd440ef59a6bf6fe76baae6931fbd5a09d354d69b926225d954cb23c66d6
--- a/tests/expectations/compiler/core/algorithms/poseidon8_hash.out
+++ b/tests/expectations/compiler/core/algorithms/poseidon8_hash.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 1e9c68e82f6c0dc9eaa4babbc5cb9e46d79f8f0661607b48efd2e9870a636f33
-    initial_ast: 08935ec63b16ea46fdc71ecf009d17664e1df123a7b8927933ecb8b6ebcc84d3
-    unrolled_ast: 08935ec63b16ea46fdc71ecf009d17664e1df123a7b8927933ecb8b6ebcc84d3
-    ssa_ast: 05f1c0703a0987f866b19bcbc72a1e1cf4d7253a1fc75b1474b9f49aafb26cc4
-    flattened_ast: 699fdee0dcb831f86fb19c14b4f0387aec3ddfe4c6658a77e3cc7b450cc30e15
+    initial_ast: 5984da88411c8e2714e7d63161f25c28f8a305eba351e64f89e8917dd13557c2
+    unrolled_ast: 5984da88411c8e2714e7d63161f25c28f8a305eba351e64f89e8917dd13557c2
+    ssa_ast: 431258ae9c7498b7a27aa436b04f28754d5bfe6b46d6638ac867c2dde37eae55
+    flattened_ast: 391928fcf3f5c2cadf774db9c81ef6582d679e25ee6c1c9f77e5f21aa4aa1de6
--- a/tests/expectations/compiler/definition/out_of_order.out
+++ b/tests/expectations/compiler/definition/out_of_order.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: b7b12742359f67e9b9fcd6772715e2a972f8462844bd97dbb4e54265935166b2
-    initial_ast: 60a5b01bf0103928fdb728241663fc40e0ddf3d8c3ccbbed32b659053d2d16bb
-    unrolled_ast: 60a5b01bf0103928fdb728241663fc40e0ddf3d8c3ccbbed32b659053d2d16bb
-    ssa_ast: 76f9c60d9da5a01a1cbfc1ae2b117ac774022a19445c8ce1cd265997f91d8c0a
-    flattened_ast: f1c6685559a001f403e04a21f2b334dbd2124540f5816f22f0995ae4af104aeb
+    initial_ast: 0ad159e7d8fd72976f8585e7e34700e67c4a812a648639dc8fb889def7c412c4
+    unrolled_ast: 0ad159e7d8fd72976f8585e7e34700e67c4a812a648639dc8fb889def7c412c4
+    ssa_ast: 0a5046714f68182853e30930820d66463e5f2799e7ee5dc9d889e05f812b543b
+    flattened_ast: 8f043480d5c6c19bf2f8de2fa152e207034bffd8d6a9c32cd5f2a22374ead720
--- a/tests/expectations/compiler/field/add.out
+++ b/tests/expectations/compiler/field/add.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 61129a0f8f768e3b6ac64a3108c250edac7bc6d2166c8682959ed70d087c9ea8
-    initial_ast: b2cb62aebdc589f0966d653b8e27e87bc364dfe968f2cb3b1b4e2529f6ec3bbd
-    unrolled_ast: b2cb62aebdc589f0966d653b8e27e87bc364dfe968f2cb3b1b4e2529f6ec3bbd
-    ssa_ast: 4ddd554ed231cde10acb5603d8ca51d4d97e6b140ea4a7bba580d3db79261f43
-    flattened_ast: 815c3628e9d39f378168bb34b5c656a9f1ef9d4a95d4e30c25896d5df41f5032
+    initial_ast: 88a3dddd66376118f389f910861f4f6cfc46740ed40b169cc06d9fa92af09140
+    unrolled_ast: 88a3dddd66376118f389f910861f4f6cfc46740ed40b169cc06d9fa92af09140
+    ssa_ast: ffa51dedbb3dea08a06a6b4808aba102bf7cf5af49d2dc48495d22810e310e9d
+    flattened_ast: 12e49541f288f033d7921c8ad2a1e0e164a5ba81b0e972ce556d6acbc508e3d3
--- a/tests/expectations/compiler/field/div.out
+++ b/tests/expectations/compiler/field/div.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: f7a296977806330a0ba3de16adf46a59c32560a0035c9f386122943126382502
-    initial_ast: 4890275fa885093609199d0128f194a81cc28582c7b56bec2fa8667047234b87
-    unrolled_ast: 4890275fa885093609199d0128f194a81cc28582c7b56bec2fa8667047234b87
-    ssa_ast: fe5de537242393614910d4cfe9a7a83c48a7c068d7ca4bf691e96b7ca57ca10e
-    flattened_ast: 25f16dbb4bd3f76160184f05b1b062bfc320b8f01e617873cf8994c5f12fe798
+    initial_ast: fddbfe97b40bac54feb9cf5cf2b77d6da1bc156c9227b978ec35d6b3b5d2de41
+    unrolled_ast: fddbfe97b40bac54feb9cf5cf2b77d6da1bc156c9227b978ec35d6b3b5d2de41
+    ssa_ast: 35d8bbee0dea7bd7890799a2dfc232af17179dd969483db120c5abb45c2ec64a
+    flattened_ast: 99bbe3ebee47595fc161f1d0c5b10b494f503bf20b0ca7609d470d5c7a6683f2
--- a/tests/expectations/compiler/field/eq.out
+++ b/tests/expectations/compiler/field/eq.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: f88034cbb0521ef299913fc7f13280ea5af4cf984cb54c476c9860d9f93a5cba
-    initial_ast: e49a3434e8a50a36fb49fc00585b778f49ebdd3809323ca5b5895286d56b7f52
-    unrolled_ast: e49a3434e8a50a36fb49fc00585b778f49ebdd3809323ca5b5895286d56b7f52
-    ssa_ast: de1ad7586a39f888f09c8ff00954a4dcac8ad842249d6102f08cc27979b8ae52
-    flattened_ast: 12d3dc425871612d7b8804d64c6abf93a9591979a84eeed535f65d6774e1e0ce
+    initial_ast: b67df589c94d44bb00b9a4106ff233f6b354f49192fe1cb142395d4f1596c0ee
+    unrolled_ast: b67df589c94d44bb00b9a4106ff233f6b354f49192fe1cb142395d4f1596c0ee
+    ssa_ast: 65ea2b9296a8fdd8edaa5b661aeaa02bb6e35dfc80f645a8cf55490d0a41e977
+    flattened_ast: 8be0a35fda73e4bc735b7b23aad3d62cd53f82e57f6acb60a4962d804d6cff5e
--- a/tests/expectations/compiler/field/field.out
+++ b/tests/expectations/compiler/field/field.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 9dff7172de13bf9c5c1bf0e225ebb3132da11ea695a97692edacd36b18e5d86c
-    initial_ast: efb41e70f83aa7e2d78fe401a2515f43840c2679c46dd8556315a736414c68d8
-    unrolled_ast: efb41e70f83aa7e2d78fe401a2515f43840c2679c46dd8556315a736414c68d8
-    ssa_ast: 03c6805324171292b0291c7578681fa9a4c69e06a5463693ffc12984806e0e29
-    flattened_ast: 45786b6a26579552c3b7142eec3cd0dc87d7c703ad250b7811bfdd269fc3c073
+    initial_ast: efdec55ecb58ec494410121b123550ac5876155959c360755fc59f2d2bd0b604
+    unrolled_ast: efdec55ecb58ec494410121b123550ac5876155959c360755fc59f2d2bd0b604
+    ssa_ast: 3da729b3437544aedef4b8e301094a78c384db937ed3c8d817f15abfb59285f2
+    flattened_ast: e9b63b047f4236ed311a337a773fea9ff8c1375ea889ca3d2ec38457973fb65b
--- a/tests/expectations/compiler/field/mul.out
+++ b/tests/expectations/compiler/field/mul.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 61129a0f8f768e3b6ac64a3108c250edac7bc6d2166c8682959ed70d087c9ea8
-    initial_ast: 38aa3123bf3a04cefe13cab572fe4d5655fa253899c06ec2ff00063147c71adf
-    unrolled_ast: 38aa3123bf3a04cefe13cab572fe4d5655fa253899c06ec2ff00063147c71adf
-    ssa_ast: c912349b3dba6986ad724166f15fc4130a8258bbc1f4a343ba6fb9beb5fd3ca2
-    flattened_ast: be364827c618105c97d59dc8fa3b1a6dfe9abcd553af8754123d6bcf5224b3c2
+    initial_ast: 8d24c47b478ed7893e5fd98b9ad429e7a9900adad2eba1d4a487e0df6b8cfe19
+    unrolled_ast: 8d24c47b478ed7893e5fd98b9ad429e7a9900adad2eba1d4a487e0df6b8cfe19
+    ssa_ast: 0bd6b1b066ae93e561968bacc3f2dc292e3ada8fe9320b628a077079d9544e8e
+    flattened_ast: a3e9bc665ad0ce68dc606fe1f61b8bce4bbaef6b840baf7c575c3b1852cef39d
--- a/tests/expectations/compiler/field/negate.out
+++ b/tests/expectations/compiler/field/negate.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 429366c4335599a16406a6ffffe140ff35a28c8129327477a23a692792ab630a
-    initial_ast: a835b88d353dfe064d68aa517c09da7caf0ffe9bcaece973463c98637e19f15d
-    unrolled_ast: a835b88d353dfe064d68aa517c09da7caf0ffe9bcaece973463c98637e19f15d
-    ssa_ast: d62bc50f6421bece080cb58bfcf996c04d91b5eaf2e4145765ca61f82c76e97b
-    flattened_ast: f8d267d7f537f6b14b752dbbef59709e7c04027a2dc1116f347f14e5c66ada06
+    initial_ast: ee710a8058b825eb3f249674f01d5a04324e5b64f4bbeb1afdaf232329caadf5
+    unrolled_ast: ee710a8058b825eb3f249674f01d5a04324e5b64f4bbeb1afdaf232329caadf5
+    ssa_ast: 49d572ab521f3daa2a2d71a8268194ffb6afe5122335d2e2fdc49de2f1ee4975
+    flattened_ast: fae4dd8da32e14b67f913a1e011bc16f9decc2c7ef020d448cd07d9caf8dd1e8
--- a/tests/expectations/compiler/field/operator_methods.out
+++ b/tests/expectations/compiler/field/operator_methods.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: a6d4afdd7375c43967b7a3be380ac83f7b1a351203a2f521ca8ce9824f29df71
-    initial_ast: fae67b0524629123386d97abe3d416217bf3603fa7e80d7fff171188b7a9cd92
-    unrolled_ast: fae67b0524629123386d97abe3d416217bf3603fa7e80d7fff171188b7a9cd92
-    ssa_ast: 9f1ccb67dd1845e23cc51eaa7de1fa1de0ab2035d4a14ef6290f24e8b890511b
-    flattened_ast: 2858a14218cb5f670950c60b32dae9c579fe73638553ea3eb56cae7073fc2039
+    initial_ast: d909483caa7307035bd2831480efa736e788977504e39ed275ed1488d06dec11
+    unrolled_ast: d909483caa7307035bd2831480efa736e788977504e39ed275ed1488d06dec11
+    ssa_ast: 7c142706e7ff0c21752402c3275e53e2676c5d7cec24260a4fea463d7b1c2908
+    flattened_ast: 4f6a9c0153ed4b45e105c1965841ff91197bb0609504ddb4aa9115ee8ebf3e81
--- a/tests/expectations/compiler/field/pow.out
+++ b/tests/expectations/compiler/field/pow.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 4e24333952c4eaea2c19106c9651e0bef29519e51632cc17f3ba1d07123306eb
-    initial_ast: e545f85a38342de5173ef77a87c688a1ec6ad9964d48731c167925f68693c62e
-    unrolled_ast: e545f85a38342de5173ef77a87c688a1ec6ad9964d48731c167925f68693c62e
-    ssa_ast: 61769373206b7e2a87db43b9c6e35657749a373910584e137ceee4cf175ae9b6
-    flattened_ast: af9344ccab440497931207afc1d7efca6f5f6591b00f468848fc6296bfa1dc89
+    initial_ast: 26d8cb81f797d805fa60abfbd405f61daf75a4b64c64f43624f665a61bbc76dd
+    unrolled_ast: 26d8cb81f797d805fa60abfbd405f61daf75a4b64c64f43624f665a61bbc76dd
+    ssa_ast: 0892667d1d18cc77f14e7e736e4f3fc6b531c3a551ca868e28ee9b1ecaea834a
+    flattened_ast: c663f4078038a39ab5f54c902f290a22a20c70ca7df659a84bf59bcd9baceb93
--- a/tests/expectations/compiler/field/sub.out
+++ b/tests/expectations/compiler/field/sub.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: f7a296977806330a0ba3de16adf46a59c32560a0035c9f386122943126382502
-    initial_ast: 18a724022cab3f33e4be21d338c0494d827abb82da6f25e7f2bcd4bdf2d1aabe
-    unrolled_ast: 18a724022cab3f33e4be21d338c0494d827abb82da6f25e7f2bcd4bdf2d1aabe
-    ssa_ast: 3e10be6d2154ae4c7457a6560aa1b1449423f80d4e135b9340205ec28c691508
-    flattened_ast: 1982adc0014172bf8a3479f03631e586c7841533286dc9174ce5575b774eca1f
+    initial_ast: 881b05ee550d8ab9ec459e25f0796c9a2f60db7625c584583cc4a99fb8af61bc
+    unrolled_ast: 881b05ee550d8ab9ec459e25f0796c9a2f60db7625c584583cc4a99fb8af61bc
+    ssa_ast: a753111137a46a4f02cbd62e0771b4d50c3003c8ef8de58e9e7e183f4c65fb1b
+    flattened_ast: 3327b8379cf39a5b2afeb2a6783ccc0d6c8070ca19a8d6fe9a19e26a6889fcc2
--- a/tests/expectations/compiler/field/ternary.out
+++ b/tests/expectations/compiler/field/ternary.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 4b32cb2874e8e59815b3b0bdcad1a5e5732de23853d85d2feb4bd3cecb1c594d
-    initial_ast: cacf29acb24375c88d221d7026eaa7b06a944388c56804b70dcc61c7396afc6e
-    unrolled_ast: cacf29acb24375c88d221d7026eaa7b06a944388c56804b70dcc61c7396afc6e
-    ssa_ast: cbef14d834982c0dd4e63f501381cd89d6c3131e44fb8410a7d99e9cd8ef810d
-    flattened_ast: 39a261879a26158b2c9590c381dd4f6a9cc8813cee959e231b5b3cb96a2f7d3c
+    initial_ast: ce48445a0fd3e3a2fc896b2e65e4b31211b3f619b39f4d4b4afca301a76ca132
+    unrolled_ast: ce48445a0fd3e3a2fc896b2e65e4b31211b3f619b39f4d4b4afca301a76ca132
+    ssa_ast: 62a71834912baf0a62d777d120ffd1ca0ba73621cc1bc9ff2074c3b09114b708
+    flattened_ast: 5b69475b25e876a0e04402e75c76a41b83c94cdf4fddc5202b8e3191681ad05f
--- a/tests/expectations/compiler/finalize/closure_with_finalize_fail.out
+++ b/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"
--- a/tests/expectations/compiler/finalize/decrement.out
+++ b/tests/expectations/compiler/finalize/decrement.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: no input
-    initial_ast: 9e0977be23e1c4d1abdf9c225bb751bb8ae83afb8c764c4ac7b8a128c1a5c793
-    unrolled_ast: 9e0977be23e1c4d1abdf9c225bb751bb8ae83afb8c764c4ac7b8a128c1a5c793
-    ssa_ast: 9e0977be23e1c4d1abdf9c225bb751bb8ae83afb8c764c4ac7b8a128c1a5c793
-    flattened_ast: 51634dc9946dfdb2ece132702f717235d56f844ed73301a19b6f448b81f3a8ea
+    initial_ast: 6f19e4683ac93b36545b090aea64539b0d84c14bbed076b93c2147aab6444c40
+    unrolled_ast: 6f19e4683ac93b36545b090aea64539b0d84c14bbed076b93c2147aab6444c40
+    ssa_ast: 6f19e4683ac93b36545b090aea64539b0d84c14bbed076b93c2147aab6444c40
+    flattened_ast: d41473230bc3d5d3bb3e2a998208c2f03ae4fc96736cf1e130b6b20e07505bbc
--- a/tests/expectations/compiler/finalize/finalize.out
+++ b/tests/expectations/compiler/finalize/finalize.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: no input
-    initial_ast: f5ac590daecc996e9cc6cdc278f00f98d1e3dccf206cafcdb650b7c035869730
-    unrolled_ast: f5ac590daecc996e9cc6cdc278f00f98d1e3dccf206cafcdb650b7c035869730
-    ssa_ast: f5ac590daecc996e9cc6cdc278f00f98d1e3dccf206cafcdb650b7c035869730
-    flattened_ast: 6201d1691c08db31c77cc24c1ef5e53dd6c34fa22a33e149b3ab1f7368492009
+    initial_ast: 4648d4abd6aef6af1581e4a856e6f9b5d4c61d85d86b655b0c487048bfc89af7
+    unrolled_ast: 4648d4abd6aef6af1581e4a856e6f9b5d4c61d85d86b655b0c487048bfc89af7
+    ssa_ast: e8f33cd116010f7c19711f774efa0a29d35cdd1666c6d07889b5d492f1d5183b
+    flattened_ast: 8d548287d221c6abbfa464faf4e328845344e9f6e6e653870d877a97acdb115f
--- a/tests/expectations/compiler/finalize/finalize_statement_incorrect_args_fail.out
+++ b/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"
--- a/tests/expectations/compiler/finalize/finalize_with_return.out
+++ b/tests/expectations/compiler/finalize/finalize_with_return.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: no input
-    initial_ast: 111c640307a93403153d58afb9d7bc49f010b5d37f9aab4076d204700f90cf99
-    unrolled_ast: 111c640307a93403153d58afb9d7bc49f010b5d37f9aab4076d204700f90cf99
-    ssa_ast: 33ba61ddd5299b3d69276f0c63bbb7fda9d62875df2ad51b989800dbbe46d25a
-    flattened_ast: a4321379b8e6055256632271d5121fae5cfe6f55d5a92f7453b92b889aa7e2fc
+    initial_ast: 69722b0e9daaa18f4fe5c358a3c538af7aa0c35b16db7131984e2f02e46fb795
+    unrolled_ast: 69722b0e9daaa18f4fe5c358a3c538af7aa0c35b16db7131984e2f02e46fb795
+    ssa_ast: 5f9584e7a982be19514b7498a260eb7b257c8ca3d44e924085bdb5f741c619af
+    flattened_ast: 0ce0d191c165e1472307818cd9d4cfa756afd61b0f77659a5b58d01e4431ae79
--- a/tests/expectations/compiler/finalize/increment.out
+++ b/tests/expectations/compiler/finalize/increment.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: no input
-    initial_ast: 143e4deb6fc26d2d03e40ac8ea558349a84b264bec1889a014fb45ad4858e43b
-    unrolled_ast: 143e4deb6fc26d2d03e40ac8ea558349a84b264bec1889a014fb45ad4858e43b
-    ssa_ast: 143e4deb6fc26d2d03e40ac8ea558349a84b264bec1889a014fb45ad4858e43b
-    flattened_ast: ca2ac65da9477f693168dd0074c56a000d7885cb4e2ad355e52e57d09e13e35c
+    initial_ast: d19c6388ab50f93bd5c9b19bda875ea266ad70c24d7c0bfa78fd23babca2860b
+    unrolled_ast: d19c6388ab50f93bd5c9b19bda875ea266ad70c24d7c0bfa78fd23babca2860b
+    ssa_ast: d19c6388ab50f93bd5c9b19bda875ea266ad70c24d7c0bfa78fd23babca2860b
+    flattened_ast: 229c446ca9561d69b1edaf42ffbb50c308a9e00563d468886ad9ab6a0613e8cf
--- a/tests/expectations/compiler/finalize/private_input_ouput_fail.out
+++ b/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."
--- a/tests/expectations/compiler/function/conditional_return.out
+++ b/tests/expectations/compiler/function/conditional_return.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: d46e926534142e72937a9b027c015ad4e6bfcb57a31df002fec021493f1ca2f6
-    initial_ast: 8d324b6caf600f7134b94cd4dbd45268c83fc7238b8d58f7439b4ad0b033870d
-    unrolled_ast: 8d324b6caf600f7134b94cd4dbd45268c83fc7238b8d58f7439b4ad0b033870d
-    ssa_ast: 6e17f05581caed4aae8d81f4d14172f11795a23d8f809fe5d6ac468b6200ec44
-    flattened_ast: 5b1c3043b3550252adddf9c8b43a19ddc6378b4f6296388ad225b9b48b8efca5
+    initial_ast: cfccac97b2c99262ce17f8a7ac04f4b4987f5e10dece4851796980822898f991
+    unrolled_ast: cfccac97b2c99262ce17f8a7ac04f4b4987f5e10dece4851796980822898f991
+    ssa_ast: 082ab3a4c0e059df4537603bc3e88bce9584e9fcefcef3366a889106aff40204
+    flattened_ast: aac645b2874d56f102459c44e086175e2a7b0f02b4d4427f54e9dbc26c926cfe
--- a/tests/expectations/compiler/function/flatten_test.out
+++ b/tests/expectations/compiler/function/flatten_test.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: no input
-    initial_ast: f237855e5889c18d9a87c930f1e0087adee8df4fdda005f0228e2c5524efd2d3
-    unrolled_ast: f237855e5889c18d9a87c930f1e0087adee8df4fdda005f0228e2c5524efd2d3
-    ssa_ast: 878d0180bd4671c1e316e78199016833a6d526e99e26d333d9ad9c4ab1d0bcba
-    flattened_ast: 66e1626e6349f9bbc258e5703e44e8b5e94bb0ae9f35846114a276e764bff2b7
+    initial_ast: a046762e99c8b06ab3cd6ea197005557df29c2d60dfb925ec11f8895b16b9361
+    unrolled_ast: a046762e99c8b06ab3cd6ea197005557df29c2d60dfb925ec11f8895b16b9361
+    ssa_ast: fde0d410518f71452bd7b5b3815ff0529a7c5bb6e0e96d0cd5b2d9461ce6a442
+    flattened_ast: 7d22212a4419929db03ee78de65e186d6ee5baf76ccfc0bfc3e9005a498b348b
--- a/tests/expectations/compiler/function/flatten_tuples_of_structs.out
+++ b/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
-    unrolled_ast: 072b212443dbc525313d0fd0ee5944d9c844e0b94f99df30f3c69272d4309099
-    ssa_ast: 11c9c41d1950c2a3ae95b454a63e8caccccbe598f8d87c086241f77413e53416
-    flattened_ast: fec064665269c22dd99c30949b759fbfb6c55b7b6042a1fc08aaa7fbdcb28913
+    initial_ast: 35a8333e1fa4b48c5a73f66ed7d765cb053bb170b78161ad8803e47b895b257c
+    unrolled_ast: 35a8333e1fa4b48c5a73f66ed7d765cb053bb170b78161ad8803e47b895b257c
+    ssa_ast: d7bd58882bb00dcff7620b2952edb0245ac6c860ed31a5c8291132e56d692ad8
+    flattened_ast: 2ab2f9acdc7b09955259d5beacbb752653803d0d375a14b8d08f1d1f190bfc68
--- a/tests/expectations/compiler/function/function_call.out
+++ b/tests/expectations/compiler/function/function_call.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: ab443a59dfbb4fc7a32e5ba2731ea20fc956e86b33ceb2595cf8cfe04b2f3397
-    initial_ast: 79c81fda32648f5f221cb72f879eb88edf26a92362546fde7260600b7191fb7b
-    unrolled_ast: 79c81fda32648f5f221cb72f879eb88edf26a92362546fde7260600b7191fb7b
-    ssa_ast: 2538ae66568fbaa469d07794bc3342551374f502d1c3ed88647faac5a2ab320f
-    flattened_ast: e4d830146bf658ac87f3ace2a383a6d6c0f10954f8285371bf539e8183e3fe08
+    initial_ast: 307a506409f04951b09cee16a44a16b9a789998827183f4726c46271a3f4f9ba
+    unrolled_ast: 307a506409f04951b09cee16a44a16b9a789998827183f4726c46271a3f4f9ba
+    ssa_ast: 3a3675ba279a58a82e7ab2d480565bc647179ff7040eb234ad3ed884537a3f79
+    flattened_ast: f2fdfd7f2cf84dc81c3d77fd394bd4a7f149be1b44612a876d42e56a37df864d
--- a/tests/expectations/compiler/function/helper_function_with_interface.out
+++ b/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
-    unrolled_ast: 9994f0cbf43eec59fd9dc734b1a4d69417e51c1351c2e03d57da4996b735da43
-    ssa_ast: 5f0508c0a5d301e7c5e39848ed5ca004d1ed40ee616613517a0fc110773e8123
-    flattened_ast: 626e995bfa1c8c5ff62a4702b128a5b7fa6d200fdaa9e45ad349c06a49d92103
+    initial_ast: 622320e0d77b239b59f67e1b80b30ae98e8941e213640c2597153766d03aa0c3
+    unrolled_ast: 622320e0d77b239b59f67e1b80b30ae98e8941e213640c2597153766d03aa0c3
+    ssa_ast: f0d60e26a07a63ba70c4cea1ec588fc154a2657cf6b8f8965273066754d7e12f
+    flattened_ast: 49f069b59649da3ff41a9454f623a00d2ae72037ddf2f51832264c74af694f88
--- a/tests/expectations/compiler/function/private_input_output.out
+++ b/tests/expectations/compiler/function/private_input_output.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: no input
-    initial_ast: 00876dc82eebb31770a764870febc684d709ed7cee2af94e31f2fb9136f53851
-    unrolled_ast: 00876dc82eebb31770a764870febc684d709ed7cee2af94e31f2fb9136f53851
-    ssa_ast: 5ed955521e64a449c4ba62fb64faf60c789d50e7423bb6e37507e28920d1a2f7
-    flattened_ast: 6f997f51d4761d3bb869cf13ad2580e43ba9f3dfd5edf744774eb4fea918ae1d
+    initial_ast: b5c5ae7110c20b2fa7949b853a1a5b0a43b94667901da28ce759b3df3639145c
+    unrolled_ast: b5c5ae7110c20b2fa7949b853a1a5b0a43b94667901da28ce759b3df3639145c
+    ssa_ast: 34a50a879f1b146118035e5d19e022d857c9bdab0853d3eb1e826487b5805671
+    flattened_ast: 2c89be5251a0f6f950735e04cbdbff7d32e6105c7d23cd78abed8301eeb062b0
--- a/tests/expectations/compiler/function/program_function_any_number_of_inputs_and_outputs.out
+++ b/tests/expectations/compiler/function/program_function_any_number_of_inputs_and_outputs.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: no input
-    initial_ast: 77b497487a2ddcfe141273f833a5a21192189675e3680727121f7c860e83acec
-    unrolled_ast: 77b497487a2ddcfe141273f833a5a21192189675e3680727121f7c860e83acec
-    ssa_ast: 0d56dbc6ea78dfb0138bc0830755f7f6fc80bcfc2e0fdac97e5755dfec4b7e32
-    flattened_ast: 7329ac0372ee5a92b3f8a04eaefc1ce7ab2c3c227828bb2be45c85c74e3d03a0
+    initial_ast: 0d58956714cf72fd972a6121b0bee9322bd9606e49a2f158c90fe41aa103d432
+    unrolled_ast: 0d58956714cf72fd972a6121b0bee9322bd9606e49a2f158c90fe41aa103d432
+    ssa_ast: 4510de0cb4ec419f81090874be53f3a568c2c7b37ed92768950a78058382f62f
+    flattened_ast: 2f00534e4c8438ede4f7f984c647c73195a87e64764a739cf942e2364fa0ea30
--- a/tests/expectations/compiler/function/program_function_with_mode.out
+++ b/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
-    unrolled_ast: f9ad661659d861ca0fd8f49e67b46898ae3e755960df7e0337ca71572a17faa8
-    ssa_ast: 2420ac392de56c8b906e9b2c6d66107f78c51d2238a437fa9e3c4c4369f2d716
-    flattened_ast: ad8473d6a6870141e47c2733ba29d9ba5d6d3b7ace772f54e4b27484fffd70f4
+    initial_ast: 89ebe3cb796af0bad47a3ac18061b4687d15f94a7464bad4dc96f81646a5bfb2
+    unrolled_ast: 89ebe3cb796af0bad47a3ac18061b4687d15f94a7464bad4dc96f81646a5bfb2
+    ssa_ast: f9d3dbf065342961525b64b3c3b9ed0a350a5df449e9bb797aff0e1c88d8e57c
+    flattened_ast: 2b5980c571cde3a7d7679dbe8828b68b8aff7a7e48218c5b2219431bdbe0a31a
--- a/tests/expectations/compiler/function/record_in_conditional_return.out
+++ b/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
-    unrolled_ast: 65ef0a8f08605b9b607d7b32712b3683f141b387d0e97b23e251e847b30684f7
-    ssa_ast: f3434ad7e0ced5cbe25012bbcfaca888c159deb5173e148e7a851dfc0a554c90
-    flattened_ast: 9149b476ec91c59d8bc1d9bb9c94bc143bf9c807d831c93eeaf6f5dae7c813d0
+    initial_ast: a7ffbb58b2da3419ca250f31c2209ad621be47f40aaa98cb2a61c946d92abc48
+    unrolled_ast: a7ffbb58b2da3419ca250f31c2209ad621be47f40aaa98cb2a61c946d92abc48
+    ssa_ast: 9b3e74541ccb9cc5e9ff638697ee19455fa6a7eb8d90422bec6b4d950d6a1ec6
+    flattened_ast: cd44776ff8dd73d6951f00c994b7d81b0c6099bafa6a52dcf0d97eb459cc0a3f
--- a/tests/expectations/compiler/function/self.out
+++ b/tests/expectations/compiler/function/self.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: no input
-    initial_ast: 84f4c62ad2cabcb64bf52b9b76f90f4f54fa792617dbded292a7c9764c88393f
-    unrolled_ast: 84f4c62ad2cabcb64bf52b9b76f90f4f54fa792617dbded292a7c9764c88393f
-    ssa_ast: 3f691dfa2f0630b5515b3806240cfb2429cfa2a128d1b80e06d642a8f92cd721
-    flattened_ast: 86366e160eacc314c1f8b054cb88970c6d249f95d713a605e8afef9472f0a32f
+    initial_ast: 4bb02d03cf06259f1d12dad50de6eadda16fb801598fa5f608b9b051731b80d2
+    unrolled_ast: 4bb02d03cf06259f1d12dad50de6eadda16fb801598fa5f608b9b051731b80d2
+    ssa_ast: c5eeb210de41836977aad08dec424d6d17fb5817119eb15a6ef0c70337d47ec4
+    flattened_ast: 4615ed246a11e44b36b058cf2287a7f18ef2b11db0a00c3799cced8bb5cb346e
--- a/tests/expectations/compiler/group/add.out
+++ b/tests/expectations/compiler/group/add.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 24452096d9adcaa859a76f761fb9abdc61400486eaf37d62a77c6e2896c77afb
-    initial_ast: 0facc88c123a32aa96e8fc97907f676ef7e2f854e8cc8858d7ffb49fc2e413f1
-    unrolled_ast: 0facc88c123a32aa96e8fc97907f676ef7e2f854e8cc8858d7ffb49fc2e413f1
-    ssa_ast: 14e14b60785a74b90ce1c428a04d0a41a9c84cc5657aa87a66e8ada9af0d0e42
-    flattened_ast: 9b481b4769faa100fa5cea2ecf410ad7750b5a637c2dc5f02e76d75515f2d7ff
+    initial_ast: db4d6c45319c9d110a370a27a5cddf8f6c47a83fa0f785e36cf60d86edd9a3f2
+    unrolled_ast: db4d6c45319c9d110a370a27a5cddf8f6c47a83fa0f785e36cf60d86edd9a3f2
+    ssa_ast: 845dda94bb6db83627618bf4103870115460eb549b6881b9922315624dc93905
+    flattened_ast: 356c83c7783c4147e511f7754db74d54a674129675ca761f4316e3eaa45b9d96
--- a/tests/expectations/compiler/group/assert_eq.out
+++ b/tests/expectations/compiler/group/assert_eq.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 3797d2bdbc9f4815d1ef88b8becca656f3840b170094ddbb1bdfade4d8e567a1
-    initial_ast: e20d2a0f7bb0586e4baceb6a6b0d6af267afc3817292805dcb5956bbb27a044f
-    unrolled_ast: e20d2a0f7bb0586e4baceb6a6b0d6af267afc3817292805dcb5956bbb27a044f
-    ssa_ast: 5752e475f7afe62a2770eecf2d93ac05081d50174e39357c672e6f3a4531d6e5
-    flattened_ast: ddd5e2b680c238226e37ca548c51d1a2f4d783b7e0257c42acf7b883aaad5ff7
+    initial_ast: 57ff3d335cb0583f22172636c81c415de383b507fe6b17b8a894551a91deee0d
+    unrolled_ast: 57ff3d335cb0583f22172636c81c415de383b507fe6b17b8a894551a91deee0d
+    ssa_ast: 419ae5ce3ad3092e27bc5c4edcc0036c044e9b7976de8d722b9af0784379042e
+    flattened_ast: d6e6d1b1020e0102ef00ba895ce4560798c983965f36e27496fc3f23537ac0a9
--- a/tests/expectations/compiler/group/eq.out
+++ b/tests/expectations/compiler/group/eq.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 3797d2bdbc9f4815d1ef88b8becca656f3840b170094ddbb1bdfade4d8e567a1
-    initial_ast: e20d2a0f7bb0586e4baceb6a6b0d6af267afc3817292805dcb5956bbb27a044f
-    unrolled_ast: e20d2a0f7bb0586e4baceb6a6b0d6af267afc3817292805dcb5956bbb27a044f
-    ssa_ast: 5752e475f7afe62a2770eecf2d93ac05081d50174e39357c672e6f3a4531d6e5
-    flattened_ast: ddd5e2b680c238226e37ca548c51d1a2f4d783b7e0257c42acf7b883aaad5ff7
+    initial_ast: 57ff3d335cb0583f22172636c81c415de383b507fe6b17b8a894551a91deee0d
+    unrolled_ast: 57ff3d335cb0583f22172636c81c415de383b507fe6b17b8a894551a91deee0d
+    ssa_ast: 419ae5ce3ad3092e27bc5c4edcc0036c044e9b7976de8d722b9af0784379042e
+    flattened_ast: d6e6d1b1020e0102ef00ba895ce4560798c983965f36e27496fc3f23537ac0a9
--- a/tests/expectations/compiler/group/group_mul.out
+++ b/tests/expectations/compiler/group/group_mul.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: d530d7963eff5ef7d1c2c2f40e26ed585da3391244bd857a61da42576e2368fd
-    initial_ast: 9f981f58d9a87cb82c93b86cebfa2a14ca36c60037739ce04c1394df44d1ac5b
-    unrolled_ast: 9f981f58d9a87cb82c93b86cebfa2a14ca36c60037739ce04c1394df44d1ac5b
-    ssa_ast: 6a1473291566c71f843bb638c40e183339c66ec80172502802ac21995d0997c7
-    flattened_ast: 22877c98b9eee66969876c2b1b2823c850e122cd0397fbb3409ee0fcce9867db
+    initial_ast: ae52b8228a51e9a1f37e40c6af89499260095c79b0f39c5b60496f2659944064
+    unrolled_ast: ae52b8228a51e9a1f37e40c6af89499260095c79b0f39c5b60496f2659944064
+    ssa_ast: 7aa53473237d2f68f063c1891b207fef9964120b13446de8f2365abcfcf86598
+    flattened_ast: 315e1021f4a951bbb312efc6d447206a8976ad99cbcdb94a06e4a31fd32419be
--- a/tests/expectations/compiler/group/input.out
+++ b/tests/expectations/compiler/group/input.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 4d621b6b23f3eba436c7e0131354e4a260b8a98e15914e752c4839d7f5c4d25c
-    initial_ast: e20d2a0f7bb0586e4baceb6a6b0d6af267afc3817292805dcb5956bbb27a044f
-    unrolled_ast: e20d2a0f7bb0586e4baceb6a6b0d6af267afc3817292805dcb5956bbb27a044f
-    ssa_ast: 5752e475f7afe62a2770eecf2d93ac05081d50174e39357c672e6f3a4531d6e5
-    flattened_ast: ddd5e2b680c238226e37ca548c51d1a2f4d783b7e0257c42acf7b883aaad5ff7
+    initial_ast: 57ff3d335cb0583f22172636c81c415de383b507fe6b17b8a894551a91deee0d
+    unrolled_ast: 57ff3d335cb0583f22172636c81c415de383b507fe6b17b8a894551a91deee0d
+    ssa_ast: 419ae5ce3ad3092e27bc5c4edcc0036c044e9b7976de8d722b9af0784379042e
+    flattened_ast: d6e6d1b1020e0102ef00ba895ce4560798c983965f36e27496fc3f23537ac0a9
--- a/tests/expectations/compiler/group/mul.out
+++ b/tests/expectations/compiler/group/mul.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: a220b4ebad69e490bf4a2471e4c4ecde9207f9806df90c3ba99f7f77d99eb97f
-    initial_ast: 07e7a71b7727ee073776cfd1ed51a79876d23d184e75300fc2feb849933da9c4
-    unrolled_ast: 07e7a71b7727ee073776cfd1ed51a79876d23d184e75300fc2feb849933da9c4
-    ssa_ast: 7a84373c29876e8797f468dbc48d665754ea74df79b50087f4ebacd98a8702d6
-    flattened_ast: c28de0f4c552bc47c7eb80f1d98d091764fe1857ef65b74e1dfb3d8d38a22664
+    initial_ast: e3028937ba7dfb58b2a8a4ac978baca1090a98d9a943c6b6b3168c10b9fd16f8
+    unrolled_ast: e3028937ba7dfb58b2a8a4ac978baca1090a98d9a943c6b6b3168c10b9fd16f8
+    ssa_ast: b6b8e348b2f574d0fb0a56e83459e9b98a91af82ffdef01f755ea57ed26f169e
+    flattened_ast: cf38ed372b392dbf4ead61401834f5e94c56d19aefaea73246c70c034f8d2513
--- a/tests/expectations/compiler/group/mult_by_scalar.out
+++ b/tests/expectations/compiler/group/mult_by_scalar.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: c2f733a31bdf7f6f91fa96d411c99f2d702abb6bbaf9b00d35886aa51e8cbe8e
-    initial_ast: 8c705a012e5e2ebebcf25fc75dc467d5927f2663239d6781a97ef4611958df03
-    unrolled_ast: 8c705a012e5e2ebebcf25fc75dc467d5927f2663239d6781a97ef4611958df03
-    ssa_ast: 0053a47f7b3a9c3c41e2daff0705dfd4ae188c765c0cf6c438203a56832b19a7
-    flattened_ast: 179a612b5543307588a7c21e26f7ebbf37a1b82d071b604b879228cfeec897ff
+    initial_ast: ede4f280e5249a103e3dc9604c8416df74c60f91d93f5623f8c30b1a8b4b64b5
+    unrolled_ast: ede4f280e5249a103e3dc9604c8416df74c60f91d93f5623f8c30b1a8b4b64b5
+    ssa_ast: f278aec9f71a28010c810f7ba54fa9d264422a2a1a9f84f377e5567214cb9e4b
+    flattened_ast: 14a41f65a7a36e8d710933113b23fc183e1f87ff79615187790a26cc48b75c5f
--- a/tests/expectations/compiler/group/negate.out
+++ b/tests/expectations/compiler/group/negate.out
@ -4,7 +4,7 @@ expectation: Pass
 outputs:
  - output:
      - initial_input_ast: 1abe61a3267b558b08f1911f02c0845d05f7480beda9f84ee7111785e465cd15
-    initial_ast: ebfc2a6a99cb7ad2566aea5efcf5c5fd07ccb26ec9e15c738d95d98043197dd1
-    unrolled_ast: ebfc2a6a99cb7ad2566aea5efcf5c5fd07ccb26ec9e15c738d95d98043197dd1
-    ssa_ast: da468b7574c8abd9c2b4176d61a687189ba04c00ce88eb3d5c59bc05f563ed87
-    flattened_ast: d44a85bb1e59c944d9d37bd42bf5678926b1f42538e921e470bc837675683462
+    initial_ast: 033e2f9fcabfc61279492afd3e58fa88182095b62b4dec2754121254d3add393
+    unrolled_ast: 033e2f9fcabfc61279492afd3e58fa88182095b62b4dec2754121254d3add393
+    ssa_ast: c50d671af3ba4cc2963955005bb8a222c2b3c0ae61d81e73f9700041d44e0944
+    flattened_ast: dcd4d56f5a3ca387732df40629789e5dc98d42e2b3bd5f81f76c60ff879950ba
--- a/Show More
+++ b/Show More