From 2c252f7878e958e8c34b1fc2c53ce2f3a5807176 Mon Sep 17 00:00:00 2001
From: gluax <16431709+gluax@users.noreply.github.com>
Date: Wed, 4 May 2022 13:37:53 -0700
Subject: [PATCH] all current compiler tests pass, need to add more

---
 compiler/ast/src/expression/binary.rs         |  28 ---
 .../src/type_checker/check_expressions.rs     | 172 ++++++++++++++----
 .../passes/src/type_checker/check_file.rs     |   2 +-
 .../src/type_checker/check_statements.rs      |  19 +-
 compiler/passes/src/type_checker/checker.rs   |  91 ++++++++-
 .../errors/type_checker/type_checker_error.rs |  42 ++++-
 .../integers/i16/{pow.leo => pow_fail.leo}    |   2 +-
 .../integers/i8/{pow.leo => pow_fail.leo}     |   2 +-
 .../compiler/compiler/address/branch.leo.out  |   2 +-
 .../compiler/definition/out_of_order.leo.out  |   2 +-
 .../function/conditional_return.leo.out       |   2 +-
 .../compiler/function/iteration.leo.out       |   2 +-
 .../function/iteration_repeated.leo.out       |   2 +-
 .../compiler/function/repeated.leo.out        |   2 +-
 .../compiler/compiler/function/return.leo.out |   2 +-
 .../input_files/program_input/main.leo.out    |   2 +-
 .../program_input/main_field.leo.out          |   2 +-
 .../program_input/main_group.leo.out          |   2 +-
 .../program_input_constants/main.leo.out      |   2 +-
 .../main_field.leo.out                        |   2 +-
 .../main_group.leo.out                        |   2 +-
 .../main_multiple.leo.out                     |   2 +-
 .../compiler/integers/i128/add.leo.out        |   2 +-
 .../integers/i128/console_assert.leo.out      |   2 +-
 .../compiler/integers/i128/div.leo.out        |   2 +-
 .../compiler/integers/i128/eq.leo.out         |   2 +-
 .../compiler/integers/i128/max.leo.out        |   2 +-
 .../compiler/integers/i128/min.leo.out        |   2 +-
 .../compiler/integers/i16/add.leo.out         |   2 +-
 .../integers/i16/console_assert.leo.out       |   2 +-
 .../compiler/integers/i16/div.leo.out         |   2 +-
 .../compiler/compiler/integers/i16/eq.leo.out |   2 +-
 .../compiler/integers/i16/max.leo.out         |   2 +-
 .../compiler/integers/i16/min.leo.out         |   2 +-
 .../compiler/integers/i16/pow_fail.leo.out    |   5 +
 .../compiler/integers/i32/add.leo.out         |   2 +-
 .../integers/i32/console_assert.leo.out       |   2 +-
 .../compiler/integers/i32/div.leo.out         |   2 +-
 .../compiler/compiler/integers/i32/eq.leo.out |   2 +-
 .../compiler/integers/i32/max.leo.out         |   2 +-
 .../compiler/integers/i32/min.leo.out         |   2 +-
 .../compiler/integers/i64/add.leo.out         |   2 +-
 .../integers/i64/console_assert.leo.out       |   2 +-
 .../compiler/integers/i64/div.leo.out         |   2 +-
 .../compiler/compiler/integers/i64/eq.leo.out |   2 +-
 .../compiler/integers/i64/max.leo.out         |   2 +-
 .../compiler/integers/i64/min.leo.out         |   2 +-
 .../compiler/compiler/integers/i8/add.leo.out |   2 +-
 .../integers/i8/console_assert.leo.out        |   2 +-
 .../compiler/compiler/integers/i8/div.leo.out |   2 +-
 .../compiler/compiler/integers/i8/eq.leo.out  |   2 +-
 .../compiler/compiler/integers/i8/max.leo.out |   2 +-
 .../compiler/compiler/integers/i8/min.leo.out |   2 +-
 .../compiler/integers/i8/pow_fail.leo.out     |   5 +
 .../compiler/integers/u128/add.leo.out        |   2 +-
 .../integers/u128/console_assert.leo.out      |   2 +-
 .../compiler/integers/u128/div.leo.out        |   2 +-
 .../compiler/integers/u128/eq.leo.out         |   2 +-
 .../compiler/integers/u128/max.leo.out        |   2 +-
 .../compiler/integers/u128/min.leo.out        |   2 +-
 .../compiler/integers/u16/add.leo.out         |   2 +-
 .../integers/u16/console_assert.leo.out       |   2 +-
 .../compiler/integers/u16/div.leo.out         |   2 +-
 .../compiler/compiler/integers/u16/eq.leo.out |   2 +-
 .../compiler/integers/u16/max.leo.out         |   2 +-
 .../compiler/integers/u16/min.leo.out         |   2 +-
 .../compiler/integers/u16/pow.leo.out         |   2 +-
 .../compiler/integers/u32/add.leo.out         |   2 +-
 .../integers/u32/console_assert.leo.out       |   2 +-
 .../compiler/integers/u32/div.leo.out         |   2 +-
 .../compiler/compiler/integers/u32/eq.leo.out |   2 +-
 .../compiler/integers/u32/max.leo.out         |   2 +-
 .../compiler/integers/u32/min.leo.out         |   2 +-
 .../compiler/integers/u64/add.leo.out         |   2 +-
 .../integers/u64/console_assert.leo.out       |   2 +-
 .../compiler/integers/u64/div.leo.out         |   2 +-
 .../compiler/compiler/integers/u64/eq.leo.out |   2 +-
 .../compiler/integers/u64/max.leo.out         |   2 +-
 .../compiler/integers/u64/min.leo.out         |   2 +-
 .../compiler/compiler/integers/u8/add.leo.out |   2 +-
 .../integers/u8/console_assert.leo.out        |   2 +-
 .../compiler/compiler/integers/u8/div.leo.out |   2 +-
 .../compiler/compiler/integers/u8/eq.leo.out  |   2 +-
 .../compiler/compiler/integers/u8/max.leo.out |   2 +-
 .../compiler/compiler/integers/u8/min.leo.out |   2 +-
 .../compiler/compiler/integers/u8/pow.leo.out |   2 +-
 .../compiler/mutability/cond_mut.leo.out      |   2 +-
 .../mutability/function_input_mut.leo.out     |   2 +-
 .../mutability/let_mut_nested.leo.out         |   2 +-
 .../ternary_explicit_and_implicit.leo.out     |   2 +-
 90 files changed, 364 insertions(+), 164 deletions(-)
 rename tests/compiler/integers/i16/{pow.leo => pow_fail.leo} (87%)
 rename tests/compiler/integers/i8/{pow.leo => pow_fail.leo} (87%)
 create mode 100644 tests/expectations/compiler/compiler/integers/i16/pow_fail.leo.out
 create mode 100644 tests/expectations/compiler/compiler/integers/i8/pow_fail.leo.out

diff --git a/compiler/ast/src/expression/binary.rs b/compiler/ast/src/expression/binary.rs
index 5be8b12901..f183626566 100644
--- a/compiler/ast/src/expression/binary.rs
+++ b/compiler/ast/src/expression/binary.rs
@@ -47,20 +47,6 @@ pub enum BinaryOperation {
     Le,
     /// Lesser-than relation, i.e. `<`.
     Lt,
-    /// Bitwise-or inclusive, i.e., `|`.
-    BitOr,
-    /// Bitwise-and, i.e., `&`.
-    BitAnd,
-    /// Bitwise-or exclusive, i.e., `^`.
-    BitXor,
-    /// Shift-right, i.e `>>`.
-    Shr,
-    /// Unsigned shift-right, i.e `>>>`.
-    ShrSigned,
-    /// Shift-left, i.e `<<`.
-    Shl,
-    /// Modulus or remainder operation, i.e., `%`.
-    Mod,
 }
 
 /// The category a binary operation belongs to.
@@ -88,13 +74,6 @@ impl AsRef<str> for BinaryOperation {
             BinaryOperation::Gt => ">",
             BinaryOperation::Le => "<=",
             BinaryOperation::Lt => "<",
-            BinaryOperation::BitOr => "|",
-            BinaryOperation::BitAnd => "&",
-            BinaryOperation::BitXor => "^",
-            BinaryOperation::Shr => ">>",
-            BinaryOperation::ShrSigned => ">>>",
-            BinaryOperation::Shl => "<<",
-            BinaryOperation::Mod => "%",
         }
     }
 }
@@ -108,13 +87,6 @@ impl BinaryOperation {
             | BinaryOperation::Sub
             | BinaryOperation::Mul
             | BinaryOperation::Div
-            | BinaryOperation::BitOr
-            | BinaryOperation::BitAnd
-            | BinaryOperation::BitXor
-            | BinaryOperation::Shr
-            | BinaryOperation::ShrSigned
-            | BinaryOperation::Shl
-            | BinaryOperation::Mod
             | BinaryOperation::Pow => BinaryOperationClass::Numeric,
             BinaryOperation::Or
             | BinaryOperation::And
diff --git a/compiler/passes/src/type_checker/check_expressions.rs b/compiler/passes/src/type_checker/check_expressions.rs
index b0ee74657b..4934b6495b 100644
--- a/compiler/passes/src/type_checker/check_expressions.rs
+++ b/compiler/passes/src/type_checker/check_expressions.rs
@@ -20,78 +20,175 @@ use leo_span::Span;
 
 use crate::TypeChecker;
 
+fn return_incorrect_type(t1: Option<Type>, t2: Option<Type>, expected: Option<Type>) -> Option<Type> {
+    match (t1, t2) {
+        (Some(t1), Some(t2)) if t1 == t2 => Some(t1),
+        (Some(t1), Some(t2)) => {
+            if let Some(expected) = expected {
+                if t1 != expected {
+                    Some(t1)
+                } else {
+                    Some(t2)
+                }
+            } else {
+                Some(t1)
+            }
+        }
+        (None, Some(_)) | (Some(_), None) | (None, None) => None,
+    }
+}
+
 impl<'a> TypeChecker<'a> {
-    pub(crate) fn compare_expr_type(&self, expr: &Expression, expected: Type, span: &Span) {
+    pub(crate) fn compare_expr_type(&self, expr: &Expression, expected: Option<Type>, span: &Span) -> Option<Type> {
         match expr {
             Expression::Identifier(ident) => {
                 if let Some(var) = self.symbol_table.lookup_variable(&ident.name) {
-                    self.assert_type(var.type_.clone(), expected, var.span);
+                    Some(self.assert_type(var.type_.clone(), expected, span))
                 } else {
                     self.handler
                         .emit_err(TypeCheckerError::unknown_sym("variable", ident.name, span).into());
+                    None
                 }
             }
             Expression::Value(value) => match value {
-                ValueExpression::Address(_, _) => self.assert_type(Type::Address, expected, value.span()),
-                ValueExpression::Boolean(_, _) => self.assert_type(Type::Boolean, expected, value.span()),
-                ValueExpression::Char(_) => self.assert_type(Type::Char, expected, value.span()),
-                ValueExpression::Field(_, _) => self.assert_type(Type::Field, expected, value.span()),
+                ValueExpression::Address(_, _) => Some(self.assert_type(Type::Address, expected, value.span())),
+                ValueExpression::Boolean(_, _) => Some(self.assert_type(Type::Boolean, expected, value.span())),
+                ValueExpression::Char(_) => Some(self.assert_type(Type::Char, expected, value.span())),
+                ValueExpression::Field(_, _) => Some(self.assert_type(Type::Field, expected, value.span())),
                 ValueExpression::Integer(type_, _, _) => {
-                    self.assert_type(Type::IntegerType(*type_), expected, value.span())
+                    Some(self.assert_type(Type::IntegerType(*type_), expected, value.span()))
                 }
-                ValueExpression::Group(_) => self.assert_type(Type::Group, expected, value.span()),
-                ValueExpression::String(_, _) => {}
+                ValueExpression::Group(_) => Some(self.assert_type(Type::Group, expected, value.span())),
+                ValueExpression::String(_, _) => None,
             },
-            Expression::Binary(binary) => match binary.op.class() {
-                // some ops support more types than listed here
-                BinaryOperationClass::Boolean => {
-                    self.assert_type(Type::Boolean, expected, span);
-                    self.compare_expr_type(&binary.left, Type::Boolean, binary.span());
-                    self.compare_expr_type(&binary.right, Type::Boolean, binary.span());
+            Expression::Binary(binary) => match binary.op {
+                BinaryOperation::And | BinaryOperation::Or => {
+                    self.assert_type(Type::Boolean, expected.clone(), binary.span());
+                    let t1 = self.compare_expr_type(&binary.left, expected.clone(), binary.left.span());
+                    let t2 = self.compare_expr_type(&binary.right, expected.clone(), binary.right.span());
+
+                    return_incorrect_type(t1, t2, expected)
                 }
-                BinaryOperationClass::Numeric => {
-                    // depending on operation could also be field or group
-                    if !matches!(expected, Type::IntegerType(_)) {
-                        self.handler
-                            .emit_err(TypeCheckerError::type_should_be_integer(binary.op, expected.clone(), span).into());
+                BinaryOperation::Add | BinaryOperation::Sub => {
+                    self.assert_arith_type(expected.clone(), binary.span());
+                    let t1 = self.compare_expr_type(&binary.left, expected.clone(), binary.left.span());
+                    let t2 = self.compare_expr_type(&binary.right, expected.clone(), binary.right.span());
+
+                    return_incorrect_type(t1, t2, expected)
+                }
+                BinaryOperation::Mul => {
+                    self.assert_arith_type(expected.clone(), binary.span());
+
+                    let t1 = self.compare_expr_type(&binary.left, None, binary.left.span());
+                    let t2 = self.compare_expr_type(&binary.right, None, binary.right.span());
+
+                    match (t1.as_ref(), t2.as_ref()) {
+                        (Some(Type::Group), Some(other)) | (Some(other), Some(Type::Group)) => {
+                            self.assert_int_type(Some(other.clone()), binary.span());
+                            Some(Type::Group)
+                        }
+                        _ => return_incorrect_type(t1, t2, expected),
+                    }
+                }
+                BinaryOperation::Div => {
+                    self.assert_field_or_int_type(expected.clone(), binary.span());
+
+                    let t1 = self.compare_expr_type(&binary.left, expected.clone(), binary.left.span());
+                    let t2 = self.compare_expr_type(&binary.right, expected.clone(), binary.right.span());
+                    return_incorrect_type(t1, t2, expected)
+                }
+                BinaryOperation::Pow => {
+                    let t1 = self.compare_expr_type(&binary.left, None, binary.left.span());
+                    let t2 = self.compare_expr_type(&binary.right, None, binary.right.span());
+
+                    match (t1.as_ref(), t2.as_ref()) {
+                        // Type A must be an int.
+                        // Type B must be a unsigned int.
+                        (Some(Type::IntegerType(_)), Some(Type::IntegerType(itype))) if !itype.is_signed() => {
+                            self.assert_type(t1.clone().unwrap(), expected, binary.span());
+                        }
+                        // Type A was an int.
+                        // But Type B was not a unsigned int.
+                        (Some(Type::IntegerType(_)), Some(t)) => {
+                            self.handler.emit_err(
+                                TypeCheckerError::incorrect_pow_exponent_type("unsigned int", t, binary.right.span())
+                                    .into(),
+                            );
+                        }
+                        // Type A must be a field.
+                        // Type B must be an int.
+                        (Some(Type::Field), Some(Type::IntegerType(_))) => {
+                            self.assert_type(Type::Field, expected, binary.span());
+                        }
+                        // Type A was a field.
+                        // But Type B was not an int.
+                        (Some(Type::Field), Some(t)) => {
+                            self.handler.emit_err(
+                                TypeCheckerError::incorrect_pow_exponent_type("int", t, binary.right.span()).into(),
+                            );
+                        }
+                        // The base is some type thats not an int or field.
+                        (Some(t), _) => {
+                            self.handler
+                                .emit_err(TypeCheckerError::incorrect_pow_base_type(t, binary.left.span()).into());
+                        }
+                        _ => {}
                     }
 
-                    self.compare_expr_type(&binary.left, expected.clone(), binary.span());
-                    self.compare_expr_type(&binary.right, expected, binary.span());
+                    t1
+                }
+                BinaryOperation::Eq | BinaryOperation::Ne => {
+                    self.assert_type(Type::Boolean, expected.clone(), binary.span());
+
+                    let t1 = self.compare_expr_type(&binary.left, None, binary.left.span());
+                    let t2 = self.compare_expr_type(&binary.right, None, binary.right.span());
+
+                    return_incorrect_type(t1, t2, expected)
+                }
+                BinaryOperation::Lt | BinaryOperation::Gt | BinaryOperation::Le | BinaryOperation::Ge => {
+                    self.assert_type(Type::Boolean, expected.clone(), binary.span());
+
+                    let t1 = self.compare_expr_type(&binary.left, None, binary.left.span());
+                    self.assert_int_type(t1.clone(), binary.left.span());
+
+                    let t2 = self.compare_expr_type(&binary.right, None, binary.right.span());
+                    self.assert_int_type(t2.clone(), binary.right.span());
+
+                    return_incorrect_type(t1, t2, expected)
                 }
             },
             Expression::Unary(unary) => match unary.op {
                 UnaryOperation::Not => {
-                    self.assert_type(Type::Boolean, expected, unary.span());
-                    self.compare_expr_type(&unary.inner, Type::Boolean, unary.inner.span());
+                    self.assert_type(Type::Boolean, expected.clone(), unary.span());
+                    self.compare_expr_type(&unary.inner, expected, unary.inner.span())
                 }
                 UnaryOperation::Negate => {
-                    match expected {
+                    /* match expected {
                         Type::IntegerType(
                             IntegerType::I8
                             | IntegerType::I16
                             | IntegerType::I32
                             | IntegerType::I64
                             | IntegerType::I128,
-                        )
-                        | Type::Field
-                        | Type::Group => {}
+                        ) => {},
+                        Type::Field | Type::Group => {}
                         _ => self.handler.emit_err(
                             TypeCheckerError::type_is_not_negatable(expected.clone(), unary.inner.span()).into(),
                         ),
-                    }
-                    self.compare_expr_type(&unary.inner, expected, unary.inner.span());
+                    } */
+                    self.compare_expr_type(&unary.inner, expected, unary.inner.span())
                 }
             },
             Expression::Ternary(ternary) => {
-                self.compare_expr_type(&ternary.condition, Type::Boolean, ternary.condition.span());
-                self.compare_expr_type(&ternary.if_true, expected.clone(), ternary.if_true.span());
-                self.compare_expr_type(&ternary.if_false, expected, ternary.if_false.span());
+                self.compare_expr_type(&ternary.condition, Some(Type::Boolean), ternary.condition.span());
+                let t1 = self.compare_expr_type(&ternary.if_true, expected.clone(), ternary.if_true.span());
+                let t2 = self.compare_expr_type(&ternary.if_false, expected.clone(), ternary.if_false.span());
+                return_incorrect_type(t1, t2, expected)
             }
             Expression::Call(call) => match &*call.function {
                 Expression::Identifier(ident) => {
                     if let Some(func) = self.symbol_table.lookup_fn(&ident.name) {
-                        self.assert_type(func.output.clone(), expected, ident.span());
+                        let ret = self.assert_type(func.output.clone(), expected, ident.span());
 
                         if func.input.len() != call.arguments.len() {
                             self.handler.emit_err(
@@ -110,18 +207,21 @@ impl<'a> TypeChecker<'a> {
                             .for_each(|(expected, argument)| {
                                 self.compare_expr_type(
                                     argument,
-                                    expected.get_variable().type_.clone(),
+                                    Some(expected.get_variable().type_.clone()),
                                     argument.span(),
                                 );
                             });
+
+                        Some(ret)
                     } else {
                         self.handler
                             .emit_err(TypeCheckerError::unknown_sym("function", &ident.name, ident.span()).into());
+                        None
                     }
                 }
                 expr => self.compare_expr_type(expr, expected, call.span()),
             },
-            Expression::Err(_) => {}
+            Expression::Err(_) => None,
         }
     }
 }
diff --git a/compiler/passes/src/type_checker/check_file.rs b/compiler/passes/src/type_checker/check_file.rs
index d46163d3a3..394079a211 100644
--- a/compiler/passes/src/type_checker/check_file.rs
+++ b/compiler/passes/src/type_checker/check_file.rs
@@ -29,7 +29,7 @@ impl<'a> ProgramVisitor<'a> for TypeChecker<'a> {
                 input_var.identifier.name,
                 VariableSymbol {
                     type_: &input_var.type_,
-                    span: input_var.span(),
+                    span: input_var.identifier.span(),
                     declaration: Declaration::Input(input_var.mode()),
                 },
             ) {
diff --git a/compiler/passes/src/type_checker/check_statements.rs b/compiler/passes/src/type_checker/check_statements.rs
index 3ca5b4394d..d17eb3f317 100644
--- a/compiler/passes/src/type_checker/check_statements.rs
+++ b/compiler/passes/src/type_checker/check_statements.rs
@@ -19,7 +19,6 @@ use leo_errors::TypeCheckerError;
 
 use crate::{Declaration, TypeChecker, VariableSymbol};
 
-
 impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
     fn visit_return(&mut self, input: &'a ReturnStatement) -> VisitResult {
         // we can safely unwrap all self.parent instances because
@@ -27,7 +26,7 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
         let parent = self.parent.unwrap();
 
         if let Some(func) = self.symbol_table.lookup_fn(&parent) {
-            self.compare_expr_type(&input.expression, func.output.clone(), input.expression.span());
+            self.compare_expr_type(&input.expression, Some(func.output.clone()), input.expression.span());
         }
 
         VisitResult::VisitChildren
@@ -52,7 +51,7 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
                 self.handler.emit_err(err);
             }
 
-            self.compare_expr_type(&input.value, input.type_.clone(), input.value.span());
+            self.compare_expr_type(&input.value, Some(input.type_.clone()), input.value.span());
         });
 
         VisitResult::VisitChildren
@@ -71,7 +70,7 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
                 _ => {}
             }
 
-            self.compare_expr_type(&input.value, var.type_.clone(), input.value.span())
+            self.compare_expr_type(&input.value, Some(var.type_.clone()), input.value.span());
         } else {
             self.handler.emit_err(
                 TypeCheckerError::unknown_sym("variable", &input.assignee.identifier.name, &input.assignee.span).into(),
@@ -82,7 +81,7 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
     }
 
     fn visit_conditional(&mut self, input: &'a ConditionalStatement) -> VisitResult {
-        self.compare_expr_type(&input.condition, Type::Boolean, input.condition.span());
+        self.compare_expr_type(&input.condition, Some(Type::Boolean), input.condition.span());
 
         VisitResult::VisitChildren
     }
@@ -99,8 +98,8 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
             self.handler.emit_err(err);
         }
 
-        self.compare_expr_type(&input.start, input.type_.clone(), input.start.span());
-        self.compare_expr_type(&input.stop, input.type_.clone(), input.stop.span());
+        self.compare_expr_type(&input.start, Some(input.type_.clone()), input.start.span());
+        self.compare_expr_type(&input.stop, Some(input.type_.clone()), input.stop.span());
 
         VisitResult::VisitChildren
     }
@@ -108,10 +107,10 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
     fn visit_console(&mut self, input: &'a ConsoleStatement) -> VisitResult {
         match &input.function {
             ConsoleFunction::Assert(expr) => {
-                self.compare_expr_type(expr, Type::Boolean, expr.span());
+                self.compare_expr_type(expr, Some(Type::Boolean), expr.span());
             }
             ConsoleFunction::Error(_) | ConsoleFunction::Log(_) => {
-                todo!("need to discuss this");
+                // TODO: undetermined
             }
         }
 
@@ -141,4 +140,4 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
 
         VisitResult::SkipChildren
     }
-}
\ No newline at end of file
+}
diff --git a/compiler/passes/src/type_checker/checker.rs b/compiler/passes/src/type_checker/checker.rs
index a22acf9d12..c4f8a29440 100644
--- a/compiler/passes/src/type_checker/checker.rs
+++ b/compiler/passes/src/type_checker/checker.rs
@@ -14,9 +14,9 @@
 // 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 leo_ast::Type;
+use leo_ast::{IntegerType, Type};
 use leo_errors::{emitter::Handler, TypeCheckerError};
-use leo_span::{Symbol, Span};
+use leo_span::{Span, Symbol};
 
 use crate::SymbolTable;
 
@@ -26,6 +26,48 @@ pub struct TypeChecker<'a> {
     pub(crate) parent: Option<Symbol>,
 }
 
+const ARITHMATIC_TYPES: &[Type] = &[
+    Type::Field,
+    Type::Group,
+    Type::IntegerType(IntegerType::I8),
+    Type::IntegerType(IntegerType::I16),
+    Type::IntegerType(IntegerType::I32),
+    Type::IntegerType(IntegerType::I64),
+    Type::IntegerType(IntegerType::I128),
+    Type::IntegerType(IntegerType::U8),
+    Type::IntegerType(IntegerType::U16),
+    Type::IntegerType(IntegerType::U32),
+    Type::IntegerType(IntegerType::U64),
+    Type::IntegerType(IntegerType::U128),
+];
+
+const FIELD_AND_INT_TYPES: &[Type] = &[
+    Type::Field,
+    Type::IntegerType(IntegerType::I8),
+    Type::IntegerType(IntegerType::I16),
+    Type::IntegerType(IntegerType::I32),
+    Type::IntegerType(IntegerType::I64),
+    Type::IntegerType(IntegerType::I128),
+    Type::IntegerType(IntegerType::U8),
+    Type::IntegerType(IntegerType::U16),
+    Type::IntegerType(IntegerType::U32),
+    Type::IntegerType(IntegerType::U64),
+    Type::IntegerType(IntegerType::U128),
+];
+
+const INT_TYPES: &[Type] = &[
+    Type::IntegerType(IntegerType::I8),
+    Type::IntegerType(IntegerType::I16),
+    Type::IntegerType(IntegerType::I32),
+    Type::IntegerType(IntegerType::I64),
+    Type::IntegerType(IntegerType::I128),
+    Type::IntegerType(IntegerType::U8),
+    Type::IntegerType(IntegerType::U16),
+    Type::IntegerType(IntegerType::U32),
+    Type::IntegerType(IntegerType::U64),
+    Type::IntegerType(IntegerType::U128),
+];
+
 impl<'a> TypeChecker<'a> {
     pub fn new(symbol_table: &'a mut SymbolTable<'a>, handler: &'a Handler) -> Self {
         Self {
@@ -35,10 +77,47 @@ impl<'a> TypeChecker<'a> {
         }
     }
 
-    pub(crate) fn assert_type(&self, type_: Type, expected: Type, span: &Span) {
-        if type_ != expected {
-            self.handler
-                .emit_err(TypeCheckerError::type_should_be(type_, expected, span).into());
+    pub(crate) fn assert_type(&self, type_: Type, expected: Option<Type>, span: &Span) -> Type {
+        if let Some(expected) = expected {
+            if type_ != expected {
+                self.handler
+                    .emit_err(TypeCheckerError::type_should_be(type_.clone(), expected, span).into());
+            }
         }
+
+        type_
+    }
+
+    pub(crate) fn assert_one_of_types(&self, type_: Option<Type>, expected: &[Type], span: &Span) -> Option<Type> {
+        if let Some(type_) = type_.clone() {
+            for t in expected.iter() {
+                if &type_ == t {
+                    return Some(type_);
+                }
+            }
+
+            self.handler.emit_err(
+                TypeCheckerError::expected_one_type_of(
+                    expected.iter().map(|t| t.to_string() + ",").collect::<String>(),
+                    type_,
+                    span,
+                )
+                .into(),
+            );
+        }
+
+        type_
+    }
+
+    pub(crate) fn assert_arith_type(&self, type_: Option<Type>, span: &Span) -> Option<Type> {
+        self.assert_one_of_types(type_, ARITHMATIC_TYPES, span)
+    }
+
+    pub(crate) fn assert_field_or_int_type(&self, type_: Option<Type>, span: &Span) -> Option<Type> {
+        self.assert_one_of_types(type_, FIELD_AND_INT_TYPES, span)
+    }
+
+    pub(crate) fn assert_int_type(&self, type_: Option<Type>, span: &Span) -> Option<Type> {
+        self.assert_one_of_types(type_, INT_TYPES, span)
     }
 }
diff --git a/leo/errors/src/errors/type_checker/type_checker_error.rs b/leo/errors/src/errors/type_checker/type_checker_error.rs
index 95cff62401..842e663c64 100644
--- a/leo/errors/src/errors/type_checker/type_checker_error.rs
+++ b/leo/errors/src/errors/type_checker/type_checker_error.rs
@@ -88,7 +88,47 @@ create_messages!(
     incorrect_num_args_to_call {
         args: (expected: impl Display, received: impl Display),
         msg: format!(
-            "Call expected `{expected}` args, got `{received}`",
+            "Call expected `{expected}` args, but got `{received}`",
+        ),
+        help: None,
+    }
+
+    /// For when one of the following types was expected.
+    @formatted
+    expected_one_type_of {
+        args: (expected: impl Display, received: impl Display),
+        msg: format!(
+            "Expected one type from `{expected}`, but got `{received}`",
+        ),
+        help: None,
+    }
+
+    /// For when the base of a power is not a valid type.
+    @formatted
+    incorrect_pow_base_type {
+        args: (type_: impl Display),
+        msg: format!(
+            "The first operand must be an integer or field but got type `{type_}`",
+        ),
+        help: None,
+    }
+
+    /// For when the exponent of a power is not a valid type.
+    @formatted
+    incorrect_pow_exponent_type {
+        args: (allowed: impl Display, type_: impl Display),
+        msg: format!(
+            "The second operand must be a {allowed} but got type `{type_}`",
+        ),
+        help: None,
+    }
+
+    /// For when a type is does not exist.
+    @formatted
+    unknown_type {
+        args: (),
+        msg: format!(
+            "The type",
         ),
         help: None,
     }
diff --git a/tests/compiler/integers/i16/pow.leo b/tests/compiler/integers/i16/pow_fail.leo
similarity index 87%
rename from tests/compiler/integers/i16/pow.leo
rename to tests/compiler/integers/i16/pow_fail.leo
index 6076e64601..5b89c8c83b 100644
--- a/tests/compiler/integers/i16/pow.leo
+++ b/tests/compiler/integers/i16/pow_fail.leo
@@ -1,6 +1,6 @@
 /*
 namespace: Compile
-expectation: Pass
+expectation: Fail
 input_file: inputs/pow.in
 */
 
diff --git a/tests/compiler/integers/i8/pow.leo b/tests/compiler/integers/i8/pow_fail.leo
similarity index 87%
rename from tests/compiler/integers/i8/pow.leo
rename to tests/compiler/integers/i8/pow_fail.leo
index 912199885c..a91751332a 100644
--- a/tests/compiler/integers/i8/pow.leo
+++ b/tests/compiler/integers/i8/pow_fail.leo
@@ -1,6 +1,6 @@
 /*
 namespace: Compile
-expectation: Pass
+expectation: Fail
 input_file: inputs/pow.in
 */
 
diff --git a/tests/expectations/compiler/compiler/address/branch.leo.out b/tests/expectations/compiler/compiler/address/branch.leo.out
index 5d73e12658..857ba59bd1 100644
--- a/tests/expectations/compiler/compiler/address/branch.leo.out
+++ b/tests/expectations/compiler/compiler/address/branch.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: bbe973798ab14152165455260924a0de60131d31da32d2e223228954365dc609
-        symbol_table: 48301928ee2c6e396e20c53b0b59a8e76dabe0f60e5f7544349665683db0eae5
+        symbol_table: 9d42b1d8f167826635e5169bc3a50c14f722fba8e5ce2480fbde3b8cf2e75237
     initial_ast: ddf5a3cdb4d2796c15e7c590647ef497e9c1e9dd876d35053b7d20e0327201f2
diff --git a/tests/expectations/compiler/compiler/definition/out_of_order.leo.out b/tests/expectations/compiler/compiler/definition/out_of_order.leo.out
index b27f67e4ca..88ef816435 100644
--- a/tests/expectations/compiler/compiler/definition/out_of_order.leo.out
+++ b/tests/expectations/compiler/compiler/definition/out_of_order.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: fe836874629cdc86427a1048352c6e75e7a2981ee5c9819df0fd946eb79d4d8b
+        symbol_table: 66779461e33acc9c5c732509637db91bd72aff3e9dae6aee0c137d0537446878
     initial_ast: 5ef5995607c9487bbba88bd6e2806f19ca1ef11bf6bb7507f75f6a5f32d39fb6
diff --git a/tests/expectations/compiler/compiler/function/conditional_return.leo.out b/tests/expectations/compiler/compiler/function/conditional_return.leo.out
index 895061ec42..d85f8be887 100644
--- a/tests/expectations/compiler/compiler/function/conditional_return.leo.out
+++ b/tests/expectations/compiler/compiler/function/conditional_return.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 26679d48a4f878012c9f9cacccf9d2d1ef568126030a21abf74a5a4d8e5116d4
-        symbol_table: 201ed1188a77438794f46c40fd317d61309595d6b8a6964db2391ea33194ba9c
+        symbol_table: 577abb859b2f33b9e81c5e94c82b559601f44025143fa7a6757561b47e78efa5
     initial_ast: 9e6a274bbf78b10fc2fe402fb5b75fec31690d4661259dec5695ee38520a9d6f
diff --git a/tests/expectations/compiler/compiler/function/iteration.leo.out b/tests/expectations/compiler/compiler/function/iteration.leo.out
index 0755ccac95..776b836b61 100644
--- a/tests/expectations/compiler/compiler/function/iteration.leo.out
+++ b/tests/expectations/compiler/compiler/function/iteration.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: e518f4721bb7a7b6c63e380710a5a8cf4e489ccf66461bf9a68dc4b369e16445
-        symbol_table: cff4db3f27fee6b775583fc702d4ca35863eba50454cc6427ea0b68df0918012
+        symbol_table: 6754c028b1d3793f022a7da93be8510a6844da8a2e45f5dcaa9566252e418ee2
     initial_ast: 09226f61bcbb3f65fab6d0609b39333bc31bdf51c3aec686894ffb502ca56b6a
diff --git a/tests/expectations/compiler/compiler/function/iteration_repeated.leo.out b/tests/expectations/compiler/compiler/function/iteration_repeated.leo.out
index 60cb740ae6..eb6eaa257d 100644
--- a/tests/expectations/compiler/compiler/function/iteration_repeated.leo.out
+++ b/tests/expectations/compiler/compiler/function/iteration_repeated.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: e518f4721bb7a7b6c63e380710a5a8cf4e489ccf66461bf9a68dc4b369e16445
-        symbol_table: 65959471601270dd1e0ccf004824d13cfe39c2681a462348d7d38c39cc185228
+        symbol_table: c45d23aa877641cbf1853709cc103d389f3e3105b5c873f8bb90c3a0c48bd2ff
     initial_ast: 559dc5437784316568a2e63a662f50940bf7fda5ae78ce338f328ebf816a4087
diff --git a/tests/expectations/compiler/compiler/function/repeated.leo.out b/tests/expectations/compiler/compiler/function/repeated.leo.out
index c90f7afe8f..4e71f69958 100644
--- a/tests/expectations/compiler/compiler/function/repeated.leo.out
+++ b/tests/expectations/compiler/compiler/function/repeated.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: e518f4721bb7a7b6c63e380710a5a8cf4e489ccf66461bf9a68dc4b369e16445
-        symbol_table: 891b34c1f12859f1265a787428e786500fb04041cc0fda38bb25fc65a14bae15
+        symbol_table: 7c82d098d4b483b968c5b928f68a4a6f040bf961bbf5192bf323ddabbe592da8
     initial_ast: 127164b1571c0f14ac66be72c670be93c0f04973e06564cd0a382cb99bb32e11
diff --git a/tests/expectations/compiler/compiler/function/return.leo.out b/tests/expectations/compiler/compiler/function/return.leo.out
index 46915c5eb6..e4de889589 100644
--- a/tests/expectations/compiler/compiler/function/return.leo.out
+++ b/tests/expectations/compiler/compiler/function/return.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: e518f4721bb7a7b6c63e380710a5a8cf4e489ccf66461bf9a68dc4b369e16445
-        symbol_table: b25c0ab70906c0cac81eca91609c3ad6201198c2f871147e455f0689d1222e6d
+        symbol_table: 8bddbedba52c66dc7a86530a2df470eb3222992c10b75842431a82afc7e936d4
     initial_ast: 3c9f874c442a8b41ff0e3f3f212d96690d2665022d7898045bec0b18495db1bc
diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main.leo.out
index ad763c111b..46dd89ecfd 100644
--- a/tests/expectations/compiler/compiler/input_files/program_input/main.leo.out
+++ b/tests/expectations/compiler/compiler/input_files/program_input/main.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: dcc83a9319d9784c4bed7596d95f4bb19e2f5db1122e17bfa37e3458ed69c4fd
-        symbol_table: aabee41c31620f09539e282b4e32b28bde056bd182c3866ffd9a095f1dd60c14
+        symbol_table: 00f652a7b8e969478d433c749951ee63b97343691ff9ade7e1e9288757814ef6
     initial_ast: 06f1b743bd89e797249d51660f05d3b53d8c3e5a55c00c414795059fdd194ca1
diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main_field.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main_field.leo.out
index b82e5fa919..1de70a62c4 100644
--- a/tests/expectations/compiler/compiler/input_files/program_input/main_field.leo.out
+++ b/tests/expectations/compiler/compiler/input_files/program_input/main_field.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 0c1be8e106149f3dbe5d151e6372f7d6acf3d0986643537ed9610c2f89eb9ed4
-        symbol_table: 5a73abac57c301567a8824e865c06c6e771418fb1b6aec0d7e5f598ccbcdfed0
+        symbol_table: a3dad989c81fa120b3092919ca6bd0cc90221424459f5691b7f172e5564ba1ae
     initial_ast: ffdacfde92b14a8fc1e7c53d51cf47345ba944ceac0340520122f64e80c0ab1e
diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main_group.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main_group.leo.out
index 46e4ac6ead..4ccc84795c 100644
--- a/tests/expectations/compiler/compiler/input_files/program_input/main_group.leo.out
+++ b/tests/expectations/compiler/compiler/input_files/program_input/main_group.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 723e9ab87822d7d8d793ca1611eabcebc684097a64f37a4cd246ff9e506a4865
-        symbol_table: dbaced3c15523197bc369f20cc57998cd430e95ac40c4030c9aad2b47dda86ec
+        symbol_table: 3b68eff86b45e4f940b0a1031e19a64178b0bf802acb59f3b743e664f3010876
     initial_ast: 5932c467cdf3a483848183af054e2ec2d256b1d8b6e01f9ac4209b400863c137
diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main.leo.out
index 3afe4bfd40..6411e1b777 100644
--- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main.leo.out
+++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: ce38ef1ec7bdaaf35b68d011803255589ed870002583000a76f137d7682bc3d6
-        symbol_table: 21f3e603be14808f79859aaf18a4b7da2a22a7aef7f4b758b0514b745bc52474
+        symbol_table: 031a91bf50d051b6ffb92f6853fa4bece1f5f8f0aa145a28abed6bd1d4cf7bdd
     initial_ast: 806f13e7c1584039d0f1aae5c8b4f8ed432d35770ec576610d6249afb88141bb
diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_field.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_field.leo.out
index 54e6f1120d..085a15b790 100644
--- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_field.leo.out
+++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_field.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3273de56f5b29e324e4f4ef3cc7c0c8d468962214728d611aeb4b788fd73aefb
-        symbol_table: e3a4953e1d858fcd09177faa813c5a4f70850a7fb3394ac3c6b32eb37d38931c
+        symbol_table: ec750d5d5f4a1e5b31a63e0bc8e12944eef200f2d71efcdb0fd85811ac6e2d31
     initial_ast: f64a7585251a99b5a711175263bf8bd39fa959a7f1488f9aa3a8ba40a5dc9247
diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_group.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_group.leo.out
index a8c87c40b6..b3d9ab183e 100644
--- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_group.leo.out
+++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_group.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: eebcd00b27aba004420d4f00da025325da9ff86d29162e54401fa55b5758ae39
-        symbol_table: 218ef310cf0f462d7729c17904f4abd6e7f1fb05a4de0ab0a80b1eba84f765e7
+        symbol_table: 14140f05d5fb8a85352940a67860fd36ed597f93ac882fdb76ef3d1ed89b5031
     initial_ast: 8b077463b76328b9a910bf0eaab51a74e7b69e1cddbcedc9226a5358f13b9bf0
diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multiple.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multiple.leo.out
index fa1dbe706f..77710ed876 100644
--- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multiple.leo.out
+++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multiple.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 81306ba48e4ea08106311612bfd5c1bce79242ca08695fda8584780329266063
-        symbol_table: 6680aaab1d739d10eb145876c05f90779c9888b98dce5eeb122517ef87fb4536
+        symbol_table: 9674d1e094af108a21c9a8f2e9c5b911f76504d728866f9b57b6e38318c52741
     initial_ast: 3c27f9f5dddfc4a5a036c33fd9bbbff4594bcdb188cff720d0e8ae7f171f6acf
diff --git a/tests/expectations/compiler/compiler/integers/i128/add.leo.out b/tests/expectations/compiler/compiler/integers/i128/add.leo.out
index 5974025612..c807b545f5 100644
--- a/tests/expectations/compiler/compiler/integers/i128/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/add.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 0eb1ad9d13a2a11ba96f8ae311f1f91922abd5316ec123f92be78864c33464b4
-        symbol_table: 54846553d446c2927d5ecb9ee1011ad792d4d1c40ea844401f2426b10715a680
+        symbol_table: 26e29ab43161625435a7de57fba18feffa2ca86b908d3720a652c8fabc1a6adf
     initial_ast: 4ba3f688a429a73f874a1c391a591e7155a4722ff99c339d0814eb903b3265db
diff --git a/tests/expectations/compiler/compiler/integers/i128/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i128/console_assert.leo.out
index 39487d44c1..3db6f36e86 100644
--- a/tests/expectations/compiler/compiler/integers/i128/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/console_assert.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 2b35d182059f5f8aea05705b54c7446011ee78919bbda9f163927613f924f100
-        symbol_table: 9c9e7151463a523fd4410f3bd700725a01f6a80c8c8dc3f1c993966c0de98c09
+        symbol_table: 6f25f2987af24695b2fb70fb856a108c3d185a98289e796f5af4cb60c0de946a
     initial_ast: 48e5e86ca0706ef02b3889899d4a0f4b8f33f95a4b93a1eef6f86c1e0a7699d7
diff --git a/tests/expectations/compiler/compiler/integers/i128/div.leo.out b/tests/expectations/compiler/compiler/integers/i128/div.leo.out
index 2f5d6c8ae6..4302234d86 100644
--- a/tests/expectations/compiler/compiler/integers/i128/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/div.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: a8d3b28b557b2c19b8bb0083c015f5f217971e856d0a5c2462e956bf55b68126
-        symbol_table: 261fff42cc71579a58e904653d48ba00de0882492824bceba53de8f7088f0022
+        symbol_table: 13298cf22dc30ccc0e18f787e657068fd0531e71e9b29155541503bf7209801b
     initial_ast: 22d811ec372bfcfa643f49485200451dc5fe2b928483cb9801cd10461100e3b1
diff --git a/tests/expectations/compiler/compiler/integers/i128/eq.leo.out b/tests/expectations/compiler/compiler/integers/i128/eq.leo.out
index da2702b948..1349beca96 100644
--- a/tests/expectations/compiler/compiler/integers/i128/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/eq.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 2b35d182059f5f8aea05705b54c7446011ee78919bbda9f163927613f924f100
-        symbol_table: 7742acd8e7ea62cf83f6f958bdff8ee3c97b8217e496ae97abb297a97e922ece
+        symbol_table: e354ff29052ba6cf646dc2a940fb2489c740245554aa81f4a9b71c314f431618
     initial_ast: da2b5ade996589a255e02d69a67f76814bb7ac0b0e685bf7e9776ceb4e0b9a7c
diff --git a/tests/expectations/compiler/compiler/integers/i128/max.leo.out b/tests/expectations/compiler/compiler/integers/i128/max.leo.out
index 9e0534fcd7..0ff3e0c76d 100644
--- a/tests/expectations/compiler/compiler/integers/i128/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/max.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: 9eebcbd9094f2ad4b0018bc13dfbe52a8214316004da92be68f57a1a2009dd2d
+        symbol_table: b9f23cb88072c4321465b95ec69bba96f8fb225616244266e05a9e6eeb99da5b
     initial_ast: 4d6fa010bac61cc40182ea755147c7f2aae2f8fc06329d2235318a6203d301c2
diff --git a/tests/expectations/compiler/compiler/integers/i128/min.leo.out b/tests/expectations/compiler/compiler/integers/i128/min.leo.out
index 6af907ac74..26205bf2ef 100644
--- a/tests/expectations/compiler/compiler/integers/i128/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i128/min.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: 84b433ec855332e3655b6e721ef94105e6abeb5c6391cb1ee02b8e13b62444c6
+        symbol_table: 6b54f07ea0046f948e794781960eb3df9271e7e2d10be3e278e2b02d4d810da7
     initial_ast: a6ef77091458c48187ba317d13ed659ca96c156f4cd6cc27b122474c8bb25c51
diff --git a/tests/expectations/compiler/compiler/integers/i16/add.leo.out b/tests/expectations/compiler/compiler/integers/i16/add.leo.out
index 51cd886f1a..ec001dcc65 100644
--- a/tests/expectations/compiler/compiler/integers/i16/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/add.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 52a0e922c0ada1f3302f3d4d7feb758ff3937a8615a2fd23325cffcb0c50cf45
-        symbol_table: 96a506d25fe727e53530eacbd3682793addcb7a84023076157685efc7b361094
+        symbol_table: c0f4ce3ef2a4953e653c50d9adbccfc069c2047c6adda1830646d92934d66726
     initial_ast: 9ebcf93a3a1c925cbda80ad0a4f715a975500a8a08698ef25e8c980bc5c074fc
diff --git a/tests/expectations/compiler/compiler/integers/i16/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i16/console_assert.leo.out
index 1a449abba0..9bc4481aed 100644
--- a/tests/expectations/compiler/compiler/integers/i16/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/console_assert.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: b12ba1759e7600fe50376c2dc04f2cc908cae643be6693583c167493b8b5064e
-        symbol_table: 8148993a56b823d1c3ed2b0091421bed32de7ee8e06e4675a634df7f26c11ed6
+        symbol_table: 4ba20f16852ff2fe7616b71c2d07aeadaed53777e2f304ded7c449948fe2f853
     initial_ast: f8796fe09d11eab12fb3fd4de7daff8179e542873a689874fcc85f61fe6f52eb
diff --git a/tests/expectations/compiler/compiler/integers/i16/div.leo.out b/tests/expectations/compiler/compiler/integers/i16/div.leo.out
index 89b46a36c6..d66fbc45e9 100644
--- a/tests/expectations/compiler/compiler/integers/i16/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/div.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: d60a59011ffd9b722482df1f60fecf4035905e7991faf3509dc956204e26dbdb
-        symbol_table: 8145a65338e36b50928ebf9b2abe5188f1c463bc8c7d3e81e32af1455dfab6c2
+        symbol_table: 0e193ca48f95a41e91fe8b791ba0bcee677e3fb5edf1af8659aaa4f16607c122
     initial_ast: 69e960fb1923255efda2ba99dc07c01cd2e8d38cbf63363f7112f9c4e9efc768
diff --git a/tests/expectations/compiler/compiler/integers/i16/eq.leo.out b/tests/expectations/compiler/compiler/integers/i16/eq.leo.out
index d64b132606..7a37635874 100644
--- a/tests/expectations/compiler/compiler/integers/i16/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/eq.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: b12ba1759e7600fe50376c2dc04f2cc908cae643be6693583c167493b8b5064e
-        symbol_table: 30b68abf213d0d951d5a152ffd42ea17a71908f6d9b33cefed8bfe51545e351c
+        symbol_table: 8f43f463b85046218c11afbd5aa39021ba131f2b7474f2f9e1743e5b4b617d49
     initial_ast: a6cb462814fae8bb80601fdc772c4ba3831c35b069b235e01f1ad8fe857d879d
diff --git a/tests/expectations/compiler/compiler/integers/i16/max.leo.out b/tests/expectations/compiler/compiler/integers/i16/max.leo.out
index 82edbd4345..187e64520e 100644
--- a/tests/expectations/compiler/compiler/integers/i16/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/max.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: c82cb31f1b713cc70c711897294d9d4bbe5e35785537467ab45969690350c7c9
+        symbol_table: bff54d1345b964af7d0d8caa2e69b103810988c8acdd599f7843498255b52d69
     initial_ast: 55dbbaccb9439eb1c53b6df0a9c02fb66a2b168ba4ec50df1f39f660551d8a06
diff --git a/tests/expectations/compiler/compiler/integers/i16/min.leo.out b/tests/expectations/compiler/compiler/integers/i16/min.leo.out
index 124cde0c2c..8c03daeb7a 100644
--- a/tests/expectations/compiler/compiler/integers/i16/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i16/min.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: f209efc7d5d09745fcf38517aa376f3aa6cdddf261e47345c9fd237084fcbe19
+        symbol_table: 9f669ef27076d235af9438e4a4732be0d93854a67b7e3df0e3a99f62bc9db684
     initial_ast: 7228343ff18271420a6aca3be6f76604abb0dcb795e88088d6c9dfcad6e6ed8e
diff --git a/tests/expectations/compiler/compiler/integers/i16/pow_fail.leo.out b/tests/expectations/compiler/compiler/integers/i16/pow_fail.leo.out
new file mode 100644
index 0000000000..e26b4183de
--- /dev/null
+++ b/tests/expectations/compiler/compiler/integers/i16/pow_fail.leo.out
@@ -0,0 +1,5 @@
+---
+namespace: Compile
+expectation: Fail
+outputs:
+  - "Error [ETYC0372009]: The second operand must be a unsigned int but got type `i16`\n    --> compiler-test:4:17\n     |\n   4 |     return a ** b == c;\n     |                 ^\nError [ETYC0372009]: The second operand must be a unsigned int but got type `i16`\n    --> compiler-test:4:17\n     |\n   4 |     return a ** b == c;\n     |                 ^"
diff --git a/tests/expectations/compiler/compiler/integers/i32/add.leo.out b/tests/expectations/compiler/compiler/integers/i32/add.leo.out
index c529517352..79ab5aee99 100644
--- a/tests/expectations/compiler/compiler/integers/i32/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/add.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 187821d38d4d6bee83ad16df121b4cd61453c250259cc88b5224cde2cb0f81bd
-        symbol_table: 456cb5f3b7f9a73ee28c016d041b322f5e72d5b8bdaf6eb6ead7799b3d6b3435
+        symbol_table: ae5ef5cfb1044cbd8c7efa5be8935eb1742fc65c72b7f8aba9d9f7fb72f8556b
     initial_ast: cf9129f53ff9903788b6c1dc51f1068af87f29e6ba40694f24648ef5c5e147b6
diff --git a/tests/expectations/compiler/compiler/integers/i32/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i32/console_assert.leo.out
index 1ac0afb6a7..97f074f17d 100644
--- a/tests/expectations/compiler/compiler/integers/i32/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/console_assert.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: a139a8bae62ab18b9235331f7dde3acb349c1445e807293c71235fd149b12c7a
-        symbol_table: 02813ad8615c1b4d489af2d0302fa220060d45ba5938d8fa5226f8d6c859e824
+        symbol_table: e7e8be510bca7adc0598527ef337c1938d3f5c8666448cafe2831594e553d39e
     initial_ast: af1f895a3ffd3c6b09bf785a7ba78085a828a7d267db27e39ceb0b5ebe6f1a98
diff --git a/tests/expectations/compiler/compiler/integers/i32/div.leo.out b/tests/expectations/compiler/compiler/integers/i32/div.leo.out
index 9cade3a791..28c34c39b8 100644
--- a/tests/expectations/compiler/compiler/integers/i32/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/div.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 5c4c17182ebea3e67d0b4f30c4c5541f039ff6d44914806b5358ae789fde1576
-        symbol_table: e07c9c8414f7a348d9b78f47e2c74e889afcded8c8ec4cc062e9cde4790021ff
+        symbol_table: 088e7adb11ab06a554256c44b806f86c2c1f13273e00be2a80b8c8e797e51eb2
     initial_ast: a163bed0fb5969ce86f5ee3f27097c710163519a79148e06354a7ae52f598687
diff --git a/tests/expectations/compiler/compiler/integers/i32/eq.leo.out b/tests/expectations/compiler/compiler/integers/i32/eq.leo.out
index 16eafa4302..a0a77eacc8 100644
--- a/tests/expectations/compiler/compiler/integers/i32/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/eq.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: a139a8bae62ab18b9235331f7dde3acb349c1445e807293c71235fd149b12c7a
-        symbol_table: bf48d3e21defc5b5e17968032fa47e3381d4dae35473bbaa9f0f548a31f5df50
+        symbol_table: 7a2619dfcf2d5f5132253f84196ad0d3ab6ee0ab95df55062240dd92cca23e0b
     initial_ast: ba62f96d9796deebf5cb8c68abe3265e0a0352a6ba500b3197a43ebc19436606
diff --git a/tests/expectations/compiler/compiler/integers/i32/max.leo.out b/tests/expectations/compiler/compiler/integers/i32/max.leo.out
index 350fc867c7..683c3f737d 100644
--- a/tests/expectations/compiler/compiler/integers/i32/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/max.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: 685c90b13a7165098cc79c186d8243b0985e54621b71b08d58c88a85db4ad829
+        symbol_table: e4eff856d1f884c746d9549c80e05a6d7ef3c23cab40a056f6be96cedcf093b5
     initial_ast: 325f4f22fdbc8d3f0b1cde27e60492870a4dfa137875e0a818d44d2ecd9dbbcb
diff --git a/tests/expectations/compiler/compiler/integers/i32/min.leo.out b/tests/expectations/compiler/compiler/integers/i32/min.leo.out
index 160240a206..eeda66a438 100644
--- a/tests/expectations/compiler/compiler/integers/i32/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i32/min.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: 2b8a11c1cacfb8051dfe754f83616693a63dd51d9b23f8e22d9d9aa403797962
+        symbol_table: fe289642ca33db01ce62474ee358f4cff826e221724cc5b4d28f0e878d4f08e6
     initial_ast: 4475c8e73b8a4d016c8487f18c33a319fb4b641cabbd1cfcee179fd7917082ec
diff --git a/tests/expectations/compiler/compiler/integers/i64/add.leo.out b/tests/expectations/compiler/compiler/integers/i64/add.leo.out
index 15fdc4611f..263ee7b3b0 100644
--- a/tests/expectations/compiler/compiler/integers/i64/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/add.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 4487891a65166322700df8b88e062dd55ba1ba1eab41086faeecb89866ce6353
-        symbol_table: cc01117c31fe70222e5dd9db208832e0f80f925b010474edca6c9d4e5ea377a6
+        symbol_table: d819410bf10134f81bb62eb4e11ff16ef2ee5d3aed52c328514db13cc79c9385
     initial_ast: 4c8ecc77fb85464f37ed6510270912bab6d7f59d34c906a47eee5eba72e18b84
diff --git a/tests/expectations/compiler/compiler/integers/i64/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i64/console_assert.leo.out
index 37a6ca9e95..1ae066e6f7 100644
--- a/tests/expectations/compiler/compiler/integers/i64/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/console_assert.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 9ac72a16994c4f4145cf0eaa23f0d58de951926f8b9cb500bc33644cc242d288
-        symbol_table: 3e3de362ea1f800858c664f4243266429d9bd8aae01e94365461312b195fa687
+        symbol_table: fbeac8715fd60fea0f3ef8db7373e8ec195887ff4ba92bb7af7346181db2164d
     initial_ast: 88f1001604765bde373b06ffb83c2d46bbc16548296178fc9ccb47eb49e0212b
diff --git a/tests/expectations/compiler/compiler/integers/i64/div.leo.out b/tests/expectations/compiler/compiler/integers/i64/div.leo.out
index 703c29dc83..953efd4fb3 100644
--- a/tests/expectations/compiler/compiler/integers/i64/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/div.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 0a764dba657d55d3997cad318c763d1bc29b3bd68e720c29bdb329e31544cfa2
-        symbol_table: 0723f77e60787bcbe32ff2b04e6c27188e455bc24962c67faecff9c6de960fb0
+        symbol_table: 00f270ed9ebe98ec0543be83c941aef7d465c6c79780eacac64a8b09120dd09b
     initial_ast: 1ac553449dbba81518d78f57a0728f69efc8040ac83ee09516a99b52812d0ce5
diff --git a/tests/expectations/compiler/compiler/integers/i64/eq.leo.out b/tests/expectations/compiler/compiler/integers/i64/eq.leo.out
index 3031703cc4..d02c5d6fb2 100644
--- a/tests/expectations/compiler/compiler/integers/i64/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/eq.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 9ac72a16994c4f4145cf0eaa23f0d58de951926f8b9cb500bc33644cc242d288
-        symbol_table: fa044d414491ad830416830c60667d80173594ff31bbb53a1cf2dc2d0b516ab7
+        symbol_table: fe562696dece608fab527d7894d61a1bbccbcdd2ddf7fcb5cc52a0d596fcaff3
     initial_ast: 9d96dab7f2cf21a2358200798a2689f722d388fe23c58bc00f13feefc05328e0
diff --git a/tests/expectations/compiler/compiler/integers/i64/max.leo.out b/tests/expectations/compiler/compiler/integers/i64/max.leo.out
index a4065cace5..3cc5809166 100644
--- a/tests/expectations/compiler/compiler/integers/i64/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/max.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: 1535e52514a734e56a9724400cd6e6db7c666052c3855ab4d5f7dd5d1cdbcfe7
+        symbol_table: d7d7a90af5b30ced5d014e0f7539fe023299e3050aac61c26ebfbffd00997991
     initial_ast: d4867119d1bfa7f5f65b1046e5a14178ce9fccd4e46036f5f9760f1bbbaa3a2a
diff --git a/tests/expectations/compiler/compiler/integers/i64/min.leo.out b/tests/expectations/compiler/compiler/integers/i64/min.leo.out
index 1ac3174277..7d19861cee 100644
--- a/tests/expectations/compiler/compiler/integers/i64/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i64/min.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: 6d623b8d0710870095158c39af63333fde476c595298d604d4f545ef2dd180c7
+        symbol_table: ac8a22d4c2415f3853d5d7220433fab10c5f91eab939302666a2224601209d19
     initial_ast: da6e4041a114d42150b9768cef5675545691f07f3949332a52a72156fa5bcd02
diff --git a/tests/expectations/compiler/compiler/integers/i8/add.leo.out b/tests/expectations/compiler/compiler/integers/i8/add.leo.out
index bfc6212d60..2af7096a51 100644
--- a/tests/expectations/compiler/compiler/integers/i8/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/add.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: a4cac5c153aca7bfef6dabb6cbf703d96938699bebce6f063d39011de78a5bd4
-        symbol_table: ebda3c79c3cef5c180c423066cfe7afb72f559e295b3b0650192b4b41acf97ab
+        symbol_table: 0d30cbd5adc20ac5b03559dcd90334ac82572a3d5a195325d49ee681b4597089
     initial_ast: e5b43164c337c686cc881208115e1bbadd1926c5fb388cb0d0592dd26c40bbb3
diff --git a/tests/expectations/compiler/compiler/integers/i8/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i8/console_assert.leo.out
index 387f0ad109..ac95589450 100644
--- a/tests/expectations/compiler/compiler/integers/i8/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/console_assert.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 387087e4e03168d09782d693bd8b288dd097f978e8470bf2d0fae6a18b0a5dba
-        symbol_table: ffefcd9198ba11e15d017d24ed65f0ff46563f3049221d37343c4698a85df0f9
+        symbol_table: 94888e7a3878be6164b483f223840d704e815d8f29e1d90d04130e0f363c21d0
     initial_ast: 7057b25d4c10f2cfb35c7c7897e1ce77eaf0ea00c5f13d5fe61be2db93f33e2d
diff --git a/tests/expectations/compiler/compiler/integers/i8/div.leo.out b/tests/expectations/compiler/compiler/integers/i8/div.leo.out
index 0f3cfb0e7f..c0f3176cae 100644
--- a/tests/expectations/compiler/compiler/integers/i8/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/div.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 2bb926ee08666d2f770b02d22884fb353d718b57ffd34c156dd70431c16b713c
-        symbol_table: ebcfabb92de4aca10e7fc6d1356b31611062fca8d9feb5b8a18c5bb9d20ba662
+        symbol_table: 856843c2915ab5599b921ca4c73e2be480e792d719ba89f86425195ece44a654
     initial_ast: df29046329d8b12827f7885dfafee8a88abb17450a6fef94f5c192d582c170a9
diff --git a/tests/expectations/compiler/compiler/integers/i8/eq.leo.out b/tests/expectations/compiler/compiler/integers/i8/eq.leo.out
index 6ef3a1af93..f57cc9ef37 100644
--- a/tests/expectations/compiler/compiler/integers/i8/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/eq.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 387087e4e03168d09782d693bd8b288dd097f978e8470bf2d0fae6a18b0a5dba
-        symbol_table: 9e8afe87541faf262a089029805a31c5377d0d9610c1e8e221ba386ea6c7b078
+        symbol_table: 7814b27104ef5de9ad3357bc67b519cf5642a0960e054e7419d46786fa6b4f08
     initial_ast: cb0fef3c670b24effcfe01867ad5997394daf09593f2e90f721070dcd88dbd6a
diff --git a/tests/expectations/compiler/compiler/integers/i8/max.leo.out b/tests/expectations/compiler/compiler/integers/i8/max.leo.out
index 2488ea18ab..4afec08028 100644
--- a/tests/expectations/compiler/compiler/integers/i8/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/max.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: 1e0904126bcb9810bea07c7c1b266e4add58d581ca95138fcfbae893eb94e296
+        symbol_table: 66106e69fbd949ea2dbfd4416f5d1c9227684eff438d1625c93d6bb4f8573ce9
     initial_ast: 85c93894bc0241a6d82bfeda8828d664c83bde70155e6a0eb21bfe01ca32602e
diff --git a/tests/expectations/compiler/compiler/integers/i8/min.leo.out b/tests/expectations/compiler/compiler/integers/i8/min.leo.out
index cb3455596c..709f374ac6 100644
--- a/tests/expectations/compiler/compiler/integers/i8/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/i8/min.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: f8a675e1fa5be6255425c9d60c42f17ce72d4bf99e507ab11df201a81c91ffbf
+        symbol_table: 98cceb8df5e7a49587ca9cd0c728a7ae7d31f69b41541d3f2463315c75d825eb
     initial_ast: 8745ea25fc61ad3db822e2fb1a4ca4098ef12bf2cf4477f4e7962ddf9f011cba
diff --git a/tests/expectations/compiler/compiler/integers/i8/pow_fail.leo.out b/tests/expectations/compiler/compiler/integers/i8/pow_fail.leo.out
new file mode 100644
index 0000000000..2ebf9503b5
--- /dev/null
+++ b/tests/expectations/compiler/compiler/integers/i8/pow_fail.leo.out
@@ -0,0 +1,5 @@
+---
+namespace: Compile
+expectation: Fail
+outputs:
+  - "Error [ETYC0372009]: The second operand must be a unsigned int but got type `i8`\n    --> compiler-test:4:17\n     |\n   4 |     return a ** b == c;\n     |                 ^\nError [ETYC0372009]: The second operand must be a unsigned int but got type `i8`\n    --> compiler-test:4:17\n     |\n   4 |     return a ** b == c;\n     |                 ^"
diff --git a/tests/expectations/compiler/compiler/integers/u128/add.leo.out b/tests/expectations/compiler/compiler/integers/u128/add.leo.out
index 79357fd6ac..a8a08e032d 100644
--- a/tests/expectations/compiler/compiler/integers/u128/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/add.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: d3082b5edd6d814cd5eba97f5cfee8cd6ac7c859b0bd6345152d07ff71c77704
-        symbol_table: d57b055bb6df31b13110ac1a7ca039216c5bea705df0258140cc5d840853c662
+        symbol_table: 94c3952749ff384b298cc1bddaae404acf571029e7f6489b4eef469f19f62238
     initial_ast: e4e1d70546dfe483ecf16d57945e3febbd19da7fc3f64c2d158e8c70b887c0b2
diff --git a/tests/expectations/compiler/compiler/integers/u128/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u128/console_assert.leo.out
index d3b1f648e9..d8df5de276 100644
--- a/tests/expectations/compiler/compiler/integers/u128/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/console_assert.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: b5c6120ae963f4518dfbcf01566c85e1414ed347b18ca65dcbc03ff3addfb8ea
-        symbol_table: 861bca327e9df1f188d2e6da784fd0bb468999c721457d55b418642eaad37b76
+        symbol_table: 505948f27498d87c22e63417f71cf1f3047085a4cdb257ef7aedf3c86b238ebe
     initial_ast: ecbc8484a3548fc10ab2e25aae6bca7b24b5010b972a161fb385ec0d7fbaca41
diff --git a/tests/expectations/compiler/compiler/integers/u128/div.leo.out b/tests/expectations/compiler/compiler/integers/u128/div.leo.out
index 90a0ec038f..895b2bffdf 100644
--- a/tests/expectations/compiler/compiler/integers/u128/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/div.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 55766cfb9cd3036356494aed386f6369a46eaa459e732b4b125adc71cc9487de
-        symbol_table: c3657fefe6f9a6c177da5817cb1eb47ba94b1a0cd2dc89838dfb0434d32da7ad
+        symbol_table: 678f356035aea39bec07a37d127fab99dfb8f8aaa118bf1454f3fb40e2943c2c
     initial_ast: 6d70edf319a5036a4004d3c3c6e8b01608b7e882d91f335b7c0dec725185641a
diff --git a/tests/expectations/compiler/compiler/integers/u128/eq.leo.out b/tests/expectations/compiler/compiler/integers/u128/eq.leo.out
index f8aea6143c..7b1178484c 100644
--- a/tests/expectations/compiler/compiler/integers/u128/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/eq.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: b5c6120ae963f4518dfbcf01566c85e1414ed347b18ca65dcbc03ff3addfb8ea
-        symbol_table: cd54572eeca90e6ebc795ff0f682c1edf27af71422545ded66f72026443ec213
+        symbol_table: 59a92879cd9e8632b6ad1780ce4f687f9b9b0b142c38b31586578918c41690e7
     initial_ast: e47f3796c64fdda060e19aa678de8af0a2956d41b9c88efc95276749bdb40c74
diff --git a/tests/expectations/compiler/compiler/integers/u128/max.leo.out b/tests/expectations/compiler/compiler/integers/u128/max.leo.out
index 1408fc1f84..a19ad87db0 100644
--- a/tests/expectations/compiler/compiler/integers/u128/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/max.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: efd8b8d0fd3a8ef0d7b7037674780c38c56b208883af547d1284f0e45efffcb0
+        symbol_table: 4edd22a9c1a03a2c2bd62bb1d7d907e8afe5cdae6dbe0f8ac4711fd69bb5407b
     initial_ast: 236d3017dfc1cf965041253c04fb854461b39448f3eae307be991d45c098d38f
diff --git a/tests/expectations/compiler/compiler/integers/u128/min.leo.out b/tests/expectations/compiler/compiler/integers/u128/min.leo.out
index dee7aee8c0..52eb4281d7 100644
--- a/tests/expectations/compiler/compiler/integers/u128/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u128/min.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: 839797470779b28c08f83b6b037d9441fe295dff9b1304a6147e219640e06704
+        symbol_table: bf6b5da28a9adbc7dfb1b3b5aef006a6c040bb8eb94e142262611a131fcbec5e
     initial_ast: 40d6ad0c2bd53551e19fd32809afd7392603641c6408c1bde1d53029b506d6c8
diff --git a/tests/expectations/compiler/compiler/integers/u16/add.leo.out b/tests/expectations/compiler/compiler/integers/u16/add.leo.out
index 7d71ef15bc..9adf8d7452 100644
--- a/tests/expectations/compiler/compiler/integers/u16/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/add.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 6f6d6764c925433e3966deefe74381d0fdd560c52a5cc48713e3c4dfb1c6c3a1
-        symbol_table: 25f1d9fe9e4fc26868f1edad4c25d613f4814d7b51fbc6bbf602c364a2df7389
+        symbol_table: b773a3747693ac625d3346f79cc3787d155e81da2eef74e8961fa5c0b6beda9c
     initial_ast: 20246e906b0724847c1f313e849ca183da6f2cb8f327ad52f6cad54eb612d9cb
diff --git a/tests/expectations/compiler/compiler/integers/u16/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u16/console_assert.leo.out
index b03ca1fdb2..61ea8dac09 100644
--- a/tests/expectations/compiler/compiler/integers/u16/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/console_assert.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: cb0e4f51087e3221ca9d60ad25194233446b1827dcbd3af17206be357599915b
-        symbol_table: 52f1f76db8301f361bc2511178f18d8269c20e7ee2a5e41350c7cd4b4294a9dd
+        symbol_table: 31ea54152de57df0f234b406c8f78d84cc20dc9b998f4712ce4ac733f22b9a45
     initial_ast: 129c0fd5a3df9124a00f91abc2ddcf228b5bd01b6ea2ac277a3cfc3e5c517021
diff --git a/tests/expectations/compiler/compiler/integers/u16/div.leo.out b/tests/expectations/compiler/compiler/integers/u16/div.leo.out
index 1e55e2a80e..66cbcfda26 100644
--- a/tests/expectations/compiler/compiler/integers/u16/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/div.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 366c095f1dc13d5327fec0236867df3dd4efed80fefc990b402455be221ae3ae
-        symbol_table: d3bb974805db7c028da81baa4afcb0a24c1b9b05fae97c60aeb0c27680bb9267
+        symbol_table: 52e163bd2142999e83b8c807c5f05d8f6dcff305472c4a4ad16c82d78be9823a
     initial_ast: c7f8663c2e35a240f8cd40af952012e44860be93cf691e97c2720cab99e29944
diff --git a/tests/expectations/compiler/compiler/integers/u16/eq.leo.out b/tests/expectations/compiler/compiler/integers/u16/eq.leo.out
index 873b4718f0..a749f6de2b 100644
--- a/tests/expectations/compiler/compiler/integers/u16/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/eq.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: cb0e4f51087e3221ca9d60ad25194233446b1827dcbd3af17206be357599915b
-        symbol_table: ad01930069124344e81b3d2104a8d65eff211c9d4cccfefdd0c8d81fc3bdd276
+        symbol_table: 2f35e5aa4269f54adddaa53477d4bd09d1e4a5d81068e61f5b6b5db001f5e316
     initial_ast: 3bba994afe74ff41813d814792c6bea23ce00b52eaf9c24f999d2a97d6333a63
diff --git a/tests/expectations/compiler/compiler/integers/u16/max.leo.out b/tests/expectations/compiler/compiler/integers/u16/max.leo.out
index 94bb368f3a..a27ef17f60 100644
--- a/tests/expectations/compiler/compiler/integers/u16/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/max.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: b6c2532a06245e8da2940be77fbef0f3a6f4f2a8e98049a3b56b1bd82811c555
+        symbol_table: 69f776332dcb4ed2daf222bb7796116d60df76d7bba3686891fa352fcfbe1fcc
     initial_ast: b3f1ab730f6a8bec88ce1684856a373bc98d574ec875352fd72d5c102161df92
diff --git a/tests/expectations/compiler/compiler/integers/u16/min.leo.out b/tests/expectations/compiler/compiler/integers/u16/min.leo.out
index 1ef816a8a8..2df2d3b5c9 100644
--- a/tests/expectations/compiler/compiler/integers/u16/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/min.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: 92e877fc934530476eaf8a8985c7a4f3b7be3acc65c93fe601ccf496de113c4c
+        symbol_table: 406df287bf9772b5916e8effb291efe4c4c7b182f25e9ffdc8d8a99abcd96d85
     initial_ast: 7ddde153ed675096ff4d17849c055eec4548abe098837fbbb2df25e3be9eed24
diff --git a/tests/expectations/compiler/compiler/integers/u16/pow.leo.out b/tests/expectations/compiler/compiler/integers/u16/pow.leo.out
index f5c99c0054..1b009a6d8f 100644
--- a/tests/expectations/compiler/compiler/integers/u16/pow.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u16/pow.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3454670db4ae2ae2274a879a456ea7b2ff6b89d119686417577495d5bc7a2d1a
-        symbol_table: 00785eb0f002a244cc196d4394fec5b0071d5ed7e4b6702e14938456b72cbb5f
+        symbol_table: 615d122bb3c4eabb96bb46044fde38d0ea81d56fe4ea0db9adbcdb74fab95258
     initial_ast: e50a17ea461e6bf067a2b2728f73104065b911e47766a959d444b4a5d50dcf9a
diff --git a/tests/expectations/compiler/compiler/integers/u32/add.leo.out b/tests/expectations/compiler/compiler/integers/u32/add.leo.out
index 317ad375ea..ef35492f3a 100644
--- a/tests/expectations/compiler/compiler/integers/u32/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/add.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 7900982a0b59b180658c9c973f14c0f43f64e6c26ccf3dc72ccabbe97e6f7c1c
-        symbol_table: 0d39fc8fb24c3a5abbf3196c391cd23590eab1dddbe670dff1ad3d7953e45d4a
+        symbol_table: 25778e3ab23f629380da9c2cdb6f1e865643e9361fd650eabdf6768375fc0717
     initial_ast: 6f17e86164961b0f5dd63f426dfe5a1c7097b7042ce9c80d9cd3e2b3c7918ab2
diff --git a/tests/expectations/compiler/compiler/integers/u32/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u32/console_assert.leo.out
index 4b967b0fab..cf2694c287 100644
--- a/tests/expectations/compiler/compiler/integers/u32/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/console_assert.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 0d8bd4140882c8076fc6f31339195bd136210fa8468de7232564be89d208c570
-        symbol_table: e1e1412dbb433d0f7456b6d00d7702d4487bc9e837abd1b6503aedbd71573310
+        symbol_table: 8f03b54e860293c2c5fd9b3bb1199e1691e582712f7f5e5f462c1f7a2fb0d5d1
     initial_ast: 910eb749b9f449162c71e28c281111b11a0eddd0b51a5c3ac925217620257d56
diff --git a/tests/expectations/compiler/compiler/integers/u32/div.leo.out b/tests/expectations/compiler/compiler/integers/u32/div.leo.out
index 1db95754b9..013c40d1c2 100644
--- a/tests/expectations/compiler/compiler/integers/u32/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/div.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 1899a411753778ecc51ee4565405c95f5dc93e7dfc084268332a034da1a4e22a
-        symbol_table: 5de00fad1a2c72b4dcc1abadc1b1cb0f494f94f5a4b8241759ec69856ad1e61d
+        symbol_table: 48c50aee2e6f9f2e525cb743866ce2fc9119566076cd63d30cdb0398f328a4ba
     initial_ast: f0756849f355e001af5182cb5b788cc796745499258548e421e5187e177f275f
diff --git a/tests/expectations/compiler/compiler/integers/u32/eq.leo.out b/tests/expectations/compiler/compiler/integers/u32/eq.leo.out
index ba20b94cf7..d8034bdfd0 100644
--- a/tests/expectations/compiler/compiler/integers/u32/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/eq.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 0d8bd4140882c8076fc6f31339195bd136210fa8468de7232564be89d208c570
-        symbol_table: 9cef6bc5907dc9578a6d19e2f9b56ccc4e06b522efc4a2277c4ed418a9985e72
+        symbol_table: e081f2d0bc92a375a18466c9298d728d8d2ae35a67fbedeb733ea4cd5a12409d
     initial_ast: 727e4ea81a78093866181fe291c97cc7dd006287a09f808402cb6c79d5ce1654
diff --git a/tests/expectations/compiler/compiler/integers/u32/max.leo.out b/tests/expectations/compiler/compiler/integers/u32/max.leo.out
index f912f92577..00bd10527a 100644
--- a/tests/expectations/compiler/compiler/integers/u32/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/max.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: de89c559ab8acfd3a5e5d3f55637b989d555c8f67d507b776ece16d3ab9d1585
+        symbol_table: 6cb33ae7380c96471000854378fc11a0ac0986e2f0cc82d0b67157ea1f66375e
     initial_ast: 3ee32e9424c5f287e7dcd311cd8962fa6da2506a9804b9358d828292152bf40a
diff --git a/tests/expectations/compiler/compiler/integers/u32/min.leo.out b/tests/expectations/compiler/compiler/integers/u32/min.leo.out
index d2da5c857a..39991d191b 100644
--- a/tests/expectations/compiler/compiler/integers/u32/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u32/min.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: 1a110d738c265a9fdca9772b4191e645c833df7d86e8f3c1a4c2a069d64b7637
+        symbol_table: ae53f8e2991eb6e1c5411e9323fe1f0a0362ed74ded446743ac7cc7b6472c685
     initial_ast: 9312408c86bd423f22addf6c9f8359743ce80ebe0f78be275cc533ded55b5a7a
diff --git a/tests/expectations/compiler/compiler/integers/u64/add.leo.out b/tests/expectations/compiler/compiler/integers/u64/add.leo.out
index 503beaabba..2a2a0ef2e2 100644
--- a/tests/expectations/compiler/compiler/integers/u64/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/add.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: e716ba579037b58227d1e433d4304f99f2b2eef51f88fdc8b3086a482ee7771e
-        symbol_table: 48a3b99e31105bcac10e57226f098c9b3462b6288683cc1ab1c86d6cf9d037ac
+        symbol_table: c1c13f861658664abf92e0a1fc7bdc65c51458a53b7bc3810fd624bc3893d5ff
     initial_ast: 437ed1d3a2f85fc715a4094f9336df301ee7fe1ba9d63e06a1662c97c3f07345
diff --git a/tests/expectations/compiler/compiler/integers/u64/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u64/console_assert.leo.out
index 2185ca4e64..847a3251a9 100644
--- a/tests/expectations/compiler/compiler/integers/u64/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/console_assert.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 0293b081f0efa060d6d6be2a41792af71a74b1a894832aef14166c5bbd242e2e
-        symbol_table: 2710b3b28bf4eb04445f205b07f4f573370c745cb858c2ffd82711d6a2422f47
+        symbol_table: 7753ab45670bf14beb7642f47b735da9c08b49839bc42ea6827bcdf965cfe1ed
     initial_ast: cc17de8b54b55ee1cd6dfe70cd0e4635899e1313611a73251266b81fe1d1f959
diff --git a/tests/expectations/compiler/compiler/integers/u64/div.leo.out b/tests/expectations/compiler/compiler/integers/u64/div.leo.out
index 0720047aef..9626dfc123 100644
--- a/tests/expectations/compiler/compiler/integers/u64/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/div.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 9f6987350c5148b7587ed453e96e575bb967b5115a1f0648764bce5b4d977c46
-        symbol_table: 642ee9396286a65734b8b0ab826706fca67bdf5ac1d39903a7d398182f27e715
+        symbol_table: 96d922c665c2723cb7ca22f4f416dbf9d2d76f07ce2d4ce7b3c1becc41ebc9b6
     initial_ast: b1506f24dec921f4767cad398fb94c42ad773be1a034427e8377a4ffca6fd5cd
diff --git a/tests/expectations/compiler/compiler/integers/u64/eq.leo.out b/tests/expectations/compiler/compiler/integers/u64/eq.leo.out
index 6cf5eea937..efa39f4a61 100644
--- a/tests/expectations/compiler/compiler/integers/u64/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/eq.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 0293b081f0efa060d6d6be2a41792af71a74b1a894832aef14166c5bbd242e2e
-        symbol_table: 91b81bbb60572c2ab26ca90a2008ec67795620c4eded2c865f552ca26826a8da
+        symbol_table: 89b3e14b1880e4d3ce547087df3229f7c0b20a40c6c55130b9af3f17af90fc01
     initial_ast: 0895f12f7a9102ae711b05156078d0c06db88469c1134f1afaae1571f6d55dd6
diff --git a/tests/expectations/compiler/compiler/integers/u64/max.leo.out b/tests/expectations/compiler/compiler/integers/u64/max.leo.out
index 39e6ce0449..5aeef45200 100644
--- a/tests/expectations/compiler/compiler/integers/u64/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/max.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: ac5dff57de37bbb67bafaa848106ace90f242446d6dbac90a0c15dee454e51e1
+        symbol_table: a7e47aec9a839e089b64e17d3dac5e110bccdf3b97b69d5e8a1a64e4a32138b2
     initial_ast: 01b9771e78ab5bba09192e745dc5ffb2d6efcbe8a7c9cf95f9ff2eefe40e3f29
diff --git a/tests/expectations/compiler/compiler/integers/u64/min.leo.out b/tests/expectations/compiler/compiler/integers/u64/min.leo.out
index 35f1233313..cc89c40532 100644
--- a/tests/expectations/compiler/compiler/integers/u64/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u64/min.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: a29f0a95778e3e879a3e71e61bf69894060e0ff338890149d48fd9af0014c4d3
+        symbol_table: 9579cc0870b2c20e1ce3e47deecb81a0925d4e883403626870b125c10eceb59c
     initial_ast: 7424362afeae0eb87938c932dbf8ed126779d6626fbb310a937f01e5e6a43b7f
diff --git a/tests/expectations/compiler/compiler/integers/u8/add.leo.out b/tests/expectations/compiler/compiler/integers/u8/add.leo.out
index 7d4bb179db..4dcef25aa6 100644
--- a/tests/expectations/compiler/compiler/integers/u8/add.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/add.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: bec6adce6675e69f58bd54bfd2d89ed483f5e6bb722ba9ba3889f200aaf830d1
-        symbol_table: 7c9d2537c4dfee02096129a884b7f7e811c8834ad7d1b11c35027eb8caab39c7
+        symbol_table: b49bebf927e5e92ff081f5c76a421532e86ac349fe85391e838879928e58c9e7
     initial_ast: b7dd798a6c169b0e90da360b86a56644bca050365f6d3f59f20f6b58df88b336
diff --git a/tests/expectations/compiler/compiler/integers/u8/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u8/console_assert.leo.out
index 85914a7783..25841c2f96 100644
--- a/tests/expectations/compiler/compiler/integers/u8/console_assert.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/console_assert.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3e4fef1af04fd43972dc710e4b0e67e1b5f3b03cf0e8d1373cedfb0426b5adb7
-        symbol_table: 8aca3b9422a6097b27e54c6d205754032eb01b325bf5febc689cb0a1dfd9c93c
+        symbol_table: c57bb0b106be07bd5f495f1623ebeb3c455437f59d583d3790cf036253a8e363
     initial_ast: 0e5b41d2d779d29056c60c35f03c863883fb4ff50cf3833b2f40960757b6adda
diff --git a/tests/expectations/compiler/compiler/integers/u8/div.leo.out b/tests/expectations/compiler/compiler/integers/u8/div.leo.out
index 5c58083e00..3a8da08929 100644
--- a/tests/expectations/compiler/compiler/integers/u8/div.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/div.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: e03a50836125b20c3b6f5c0616054b65a694fb183a135db8c600cc84a4e07636
-        symbol_table: 5df47e489214d269e01b424fbccba97be8c1f81d3918c81cdf626ed9ec609d32
+        symbol_table: 8f1027beea373169e2bb06491736fd4099425a4f4d3f8fcb612462982cdb0d05
     initial_ast: 01ffcd880e5569626d16ac43de9db56cd4ee17a01e570d45815277b003fbb01e
diff --git a/tests/expectations/compiler/compiler/integers/u8/eq.leo.out b/tests/expectations/compiler/compiler/integers/u8/eq.leo.out
index 5cdde740d6..f4b105cfe8 100644
--- a/tests/expectations/compiler/compiler/integers/u8/eq.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/eq.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3e4fef1af04fd43972dc710e4b0e67e1b5f3b03cf0e8d1373cedfb0426b5adb7
-        symbol_table: 2c9ef296994a78746d48dfda0b631c806f27e373e6b7f87d118b845167131738
+        symbol_table: 16076a22d3c0df71ab90df94e1ecb26ad330c02fe2536f0b5a5d1fc8a11e05c5
     initial_ast: 8a55d90966d19eae8d35e12c03868d2fb2331b36c799253cd225c3dd92db3fd0
diff --git a/tests/expectations/compiler/compiler/integers/u8/max.leo.out b/tests/expectations/compiler/compiler/integers/u8/max.leo.out
index b684102da8..d80f9f8644 100644
--- a/tests/expectations/compiler/compiler/integers/u8/max.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/max.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: e48e32b105e55526e8c3e2f86506b205fa0b66301397734fb29de2c29122b759
+        symbol_table: 9ff7adccc170c1428f3844c390027a8f9641c9f8a76ce5f0024b2c9140f45d93
     initial_ast: e95ec61a3ab9930a26c2de8e8f184efdc67a2d72f2673db3e1d2c701efc6fbf2
diff --git a/tests/expectations/compiler/compiler/integers/u8/min.leo.out b/tests/expectations/compiler/compiler/integers/u8/min.leo.out
index 1df79d3cb3..197a4d8e75 100644
--- a/tests/expectations/compiler/compiler/integers/u8/min.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/min.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 3674d8249023145121ff35eb4d9e59b0ce79cda7e17f9f98b5dbaa6ba4f80cf2
-        symbol_table: bc79ed97e649afd1c57c04787ef961f3e637c6c6a26a11eb0e1803a688dd4811
+        symbol_table: 2dd055524a0d6eefa18c3248f40c0b7934080c4ea0f8052c2da2191408d2fea1
     initial_ast: 287f0724a7c0aeba2473e7a28d2aab9d76e5810fa9a8ca8f6e1c5e98de496f0f
diff --git a/tests/expectations/compiler/compiler/integers/u8/pow.leo.out b/tests/expectations/compiler/compiler/integers/u8/pow.leo.out
index 014fe94ff2..abdceae059 100644
--- a/tests/expectations/compiler/compiler/integers/u8/pow.leo.out
+++ b/tests/expectations/compiler/compiler/integers/u8/pow.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: ec515007a1c2cbe83aff0029932fe56e397a4ca82f99095abcc7fc25f4e0723f
-        symbol_table: 66ec3fbee8f9a937771f0042e29c84ed1a546bf89135019880eab7b3905f3a8a
+        symbol_table: 73fe24ea2c931a693a817e2b4606430192bc0214fdb762f6db260add7ddb22d4
     initial_ast: 32f692f5afbbadfcd3255f61ce5d63e102d570529ed6bab0c00250f824ff01dd
diff --git a/tests/expectations/compiler/compiler/mutability/cond_mut.leo.out b/tests/expectations/compiler/compiler/mutability/cond_mut.leo.out
index 3ec38ebe70..f9a7b6e5f8 100644
--- a/tests/expectations/compiler/compiler/mutability/cond_mut.leo.out
+++ b/tests/expectations/compiler/compiler/mutability/cond_mut.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 534a7a2cf337da1dc9ea3d25dacec6390f4cdbf6b5961b481564abc44fff1442
-        symbol_table: 7593283e1d83eedb1f92ebb1197d06a54ba86b856b88472e97bd82d5b649fe0c
+        symbol_table: 2945f5477f1985cd91fc0238eda0d96ee5b5e064b5579af5e37cb8d676dbc3cb
     initial_ast: 8f2221b11734ed4889d70e448bb3a6197146403f117d3ba015c611261aadf0df
diff --git a/tests/expectations/compiler/compiler/mutability/function_input_mut.leo.out b/tests/expectations/compiler/compiler/mutability/function_input_mut.leo.out
index d877751bea..095d45c143 100644
--- a/tests/expectations/compiler/compiler/mutability/function_input_mut.leo.out
+++ b/tests/expectations/compiler/compiler/mutability/function_input_mut.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 534a7a2cf337da1dc9ea3d25dacec6390f4cdbf6b5961b481564abc44fff1442
-        symbol_table: 6b646fc79abca7d9ef29d5d12fdfa3d2988d01a2332507ef512d34af7f2d1786
+        symbol_table: 27a1e162691d8e54a3c88d50628e4d865bba598acdc5916aed7edf60d79e68d1
     initial_ast: 0ee6dbfb6d2780de8853573772fac4f757bd7c33feef0e2e7e8d7518107a9e70
diff --git a/tests/expectations/compiler/compiler/mutability/let_mut_nested.leo.out b/tests/expectations/compiler/compiler/mutability/let_mut_nested.leo.out
index 46729bf823..76cf66ff9e 100644
--- a/tests/expectations/compiler/compiler/mutability/let_mut_nested.leo.out
+++ b/tests/expectations/compiler/compiler/mutability/let_mut_nested.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 534a7a2cf337da1dc9ea3d25dacec6390f4cdbf6b5961b481564abc44fff1442
-        symbol_table: e4496279ec6d0ba8103bbca1cc65bf6c92bc40f554085207dbecdda82eb02caf
+        symbol_table: 31926a79e803f137c80e1ee8698b50261c831ee6e83f1b09895e3d2c2b09113f
     initial_ast: 04991c563333ddfd77104bef3d033222a0ea68f0ed97822dd0120adcae1e2eb4
diff --git a/tests/expectations/compiler/compiler/statements/ternary_explicit_and_implicit.leo.out b/tests/expectations/compiler/compiler/statements/ternary_explicit_and_implicit.leo.out
index d9d0623e70..8adda863ae 100644
--- a/tests/expectations/compiler/compiler/statements/ternary_explicit_and_implicit.leo.out
+++ b/tests/expectations/compiler/compiler/statements/ternary_explicit_and_implicit.leo.out
@@ -4,5 +4,5 @@ expectation: Pass
 outputs:
   - output:
       - initial_input_ast: 86fdb64f9c593c85f97a5aae6c5e602840e5b403b1994211f280a1bc99a8ccf4
-        symbol_table: 8abfa842d3611a25fa048e507ef0f53f02a838049f6dd53904da0c384fec2643
+        symbol_table: ea61603fdb0d2d3f9ed43f0b8fd044438c4f662ae0cfb97e95505b741a82ce0b
     initial_ast: a96b034d1255f8b2b0633fb6b6d302b643b32135059bbdb51d4cd7ba91eb35d8