Merge pull request #1362 from AleoHQ/feature/remove-span-snapshot

Feature/remove span snapshot

Cargo.lock

@@ -1296,6 +1296,7 @@ dependencies = [
  "rand_core 0.6.3",
  "rand_xorshift",
  "serde",
+ "serde_json",
  "serde_yaml",
  "sha2",
  "snarkvm-algorithms",
@@ -2472,6 +2473,7 @@ version = "1.0.64"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "799e97dc9fdae36a5c8b8f2cae9ce2ee9fdce2058c57a93e6099d919fd982f79"
 dependencies = [
+ "indexmap",
  "itoa",
  "ryu",
  "serde",

ast/Cargo.toml

@@ -38,6 +38,7 @@ features = [ "derive", "rc" ]
 
 [dependencies.serde_json]
 version = "1.0"
+features = [ "preserve_order" ]
 
 [dependencies.tendril]
 version = "0.4"

ast/src/expression/value.rs

@@ -22,18 +22,30 @@ use crate::{Char, CharValue};
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum ValueExpression {
     // todo: deserialize values here
-    Address(#[serde(with = "leo_errors::common::tendril_json")] StrTendril, Span),
-    Boolean(#[serde(with = "leo_errors::common::tendril_json")] StrTendril, Span),
+    Address(
+        #[serde(with = "leo_errors::common::tendril_json")] StrTendril,
+        #[serde(with = "leo_errors::common::span_json")] Span,
+    ),
+    Boolean(
+        #[serde(with = "leo_errors::common::tendril_json")] StrTendril,
+        #[serde(with = "leo_errors::common::span_json")] Span,
+    ),
     Char(CharValue),
-    Field(#[serde(with = "leo_errors::common::tendril_json")] StrTendril, Span),
+    Field(
+        #[serde(with = "leo_errors::common::tendril_json")] StrTendril,
+        #[serde(with = "leo_errors::common::span_json")] Span,
+    ),
     Group(Box<GroupValue>),
-    Implicit(#[serde(with = "leo_errors::common::tendril_json")] StrTendril, Span),
+    Implicit(
+        #[serde(with = "leo_errors::common::tendril_json")] StrTendril,
+        #[serde(with = "leo_errors::common::span_json")] Span,
+    ),
     Integer(
         IntegerType,
         #[serde(with = "leo_errors::common::tendril_json")] StrTendril,
-        Span,
+        #[serde(with = "leo_errors::common::span_json")] Span,
     ),
-    String(Vec<Char>, Span),
+    String(Vec<Char>, #[serde(with = "leo_errors::common::span_json")] Span),
 }
 
 impl fmt::Display for ValueExpression {

ast/src/groups/group_coordinate.rs

@@ -26,7 +26,10 @@ use tendril::StrTendril;
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum GroupCoordinate {
-    Number(#[serde(with = "leo_errors::common::tendril_json")] StrTendril, Span),
+    Number(
+        #[serde(with = "leo_errors::common::tendril_json")] StrTendril,
+        #[serde(with = "leo_errors::common::span_json")] Span,
+    ),
     SignHigh,
     SignLow,
     Inferred,

ast/src/groups/group_value.rs

@@ -26,7 +26,10 @@ use tendril::StrTendril;
 
 #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)]
 pub enum GroupValue {
-    Single(#[serde(with = "leo_errors::common::tendril_json")] StrTendril, Span),
+    Single(
+        #[serde(with = "leo_errors::common::tendril_json")] StrTendril,
+        #[serde(with = "leo_errors::common::span_json")] Span,
+    ),
     Tuple(GroupTuple),
 }
 

ast/src/lib.rs

@@ -103,6 +103,14 @@ impl Ast {
         Ok(serde_json::to_string_pretty(&self.ast).map_err(|e| AstError::failed_to_convert_ast_to_json_string(&e))?)
     }
 
+    // Converts the ast into a JSON value.
+    // Note that there is no corresponding `from_json_value` function
+    // since we modify JSON values leaving them unable to be converted
+    // back into Programs.
+    pub fn to_json_value(&self) -> Result<serde_json::Value> {
+        Ok(serde_json::to_value(&self.ast).map_err(|e| AstError::failed_to_convert_ast_to_json_value(&e))?)
+    }
+
     /// Serializes the ast into a JSON file.
     pub fn to_json_file(&self, mut path: std::path::PathBuf, file_name: &str) -> Result<()> {
         path.push(file_name);
@@ -112,6 +120,27 @@ impl Ast {
             .map_err(|e| AstError::failed_to_write_ast_to_json_file(&path, &e))?)
     }
 
+    /// Serializes the ast into a JSON value and removes keys from object mappings before writing to a file.
+    pub fn to_json_file_without_keys(
+        &self,
+        mut path: std::path::PathBuf,
+        file_name: &str,
+        excluded_keys: &[&str],
+    ) -> Result<()> {
+        path.push(file_name);
+        let file = std::fs::File::create(&path).map_err(|e| AstError::failed_to_create_ast_json_file(&path, &e))?;
+        let writer = std::io::BufWriter::new(file);
+
+        let mut value = self.to_json_value().unwrap();
+        for key in excluded_keys {
+            value = remove_key_from_json(value, key);
+        }
+        value = normalize_json_value(value);
+
+        Ok(serde_json::to_writer_pretty(writer, &value)
+            .map_err(|e| AstError::failed_to_write_ast_to_json_file(&path, &e))?)
+    }
+
     /// Deserializes the JSON string into a ast.
     pub fn from_json_string(json: &str) -> Result<Self> {
         let ast: Program = serde_json::from_str(json).map_err(|e| AstError::failed_to_read_json_string_to_ast(&e))?;
@@ -130,3 +159,48 @@ impl AsRef<Program> for Ast {
         &self.ast
     }
 }
+
+/// Helper function to recursively filter keys from AST JSON
+fn remove_key_from_json(value: serde_json::Value, key: &str) -> serde_json::Value {
+    match value {
+        serde_json::Value::Object(map) => serde_json::Value::Object(
+            map.into_iter()
+                .filter(|(k, _)| k != key)
+                .map(|(k, v)| (k, remove_key_from_json(v, key)))
+                .collect(),
+        ),
+        serde_json::Value::Array(values) => {
+            serde_json::Value::Array(values.into_iter().map(|v| remove_key_from_json(v, key)).collect())
+        }
+        _ => value,
+    }
+}
+
+/// Helper function to normalize AST JSON into a form compatible with tgc.
+/// This function will traverse the original JSON value and produce a new
+/// one under the following rules:
+/// 1. Remove empty object mappings from JSON arrays
+/// 2. If there are two elements in a JSON array and one is an empty object
+///     mapping and the other is not, then lift up the one that isn't
+fn normalize_json_value(value: serde_json::Value) -> serde_json::Value {
+    match value {
+        serde_json::Value::Array(vec) => {
+            let orig_length = vec.len();
+            let mut new_vec: Vec<serde_json::Value> = vec
+                .into_iter()
+                .filter(|v| !matches!(v, serde_json::Value::Object(map) if map.is_empty()))
+                .map(normalize_json_value)
+                .collect();
+
+            if orig_length == 2 && new_vec.len() == 1 {
+                new_vec.pop().unwrap()
+            } else {
+                serde_json::Value::Array(new_vec)
+            }
+        }
+        serde_json::Value::Object(map) => {
+            serde_json::Value::Object(map.into_iter().map(|(k, v)| (k, normalize_json_value(v))).collect())
+        }
+        _ => value,
+    }
+}

ast/src/statements/assign/assignee.rs

@@ -24,7 +24,7 @@ use std::fmt;
 pub enum AssigneeAccess {
     ArrayRange(Option<Expression>, Option<Expression>),
     ArrayIndex(Expression),
-    Tuple(PositiveNumber, Span),
+    Tuple(PositiveNumber, #[serde(with = "leo_errors::common::span_json")] Span),
     Member(Identifier),
 }
 

compiler/Cargo.toml

@@ -104,6 +104,10 @@ version = "0.8"
 [dependencies.serde]
 version = "1.0"
 
+[dependencies.serde_json]
+version = "1.0"
+features = [ "preserve_order" ]
+
 [dependencies.sha2]
 version = "0.9"
 

compiler/src/compiler.rs

@@ -246,7 +246,11 @@ impl<'a, F: PrimeField, G: GroupType<F>> Compiler<'a, F, G> {
         let mut ast: leo_ast::Ast = parse_ast(self.main_file_path.to_str().unwrap_or_default(), program_string)?;
 
         if self.ast_snapshot_options.initial {
-            ast.to_json_file(self.output_directory.clone(), "initial_ast.json")?;
+            if self.ast_snapshot_options.spans_enabled {
+                ast.to_json_file(self.output_directory.clone(), "initial_ast.json")?;
+            } else {
+                ast.to_json_file_without_keys(self.output_directory.clone(), "initial_ast.json", &["span"])?;
+            }
         }
 
         // Preform import resolution.
@@ -256,14 +260,22 @@ impl<'a, F: PrimeField, G: GroupType<F>> Compiler<'a, F, G> {
         )?;
 
         if self.ast_snapshot_options.imports_resolved {
-            ast.to_json_file(self.output_directory.clone(), "imports_resolved_ast.json")?;
+            if self.ast_snapshot_options.spans_enabled {
+                ast.to_json_file(self.output_directory.clone(), "imports_resolved_ast.json")?;
+            } else {
+                ast.to_json_file_without_keys(self.output_directory.clone(), "imports_resolved_ast.json", &["span"])?;
+            }
         }
 
         // Preform canonicalization of AST always.
         ast = leo_ast_passes::Canonicalizer::do_pass(ast.into_repr())?;
 
         if self.ast_snapshot_options.canonicalized {
-            ast.to_json_file(self.output_directory.clone(), "canonicalization_ast.json")?;
+            if self.ast_snapshot_options.spans_enabled {
+                ast.to_json_file(self.output_directory.clone(), "canonicalization_ast.json")?;
+            } else {
+                ast.to_json_file_without_keys(self.output_directory.clone(), "canonicalization_ast.json", &["span"])?;
+            }
         }
 
         // Store the main program file.
@@ -279,7 +291,16 @@ impl<'a, F: PrimeField, G: GroupType<F>> Compiler<'a, F, G> {
             let new_ast = TypeInferencePhase::default()
                 .phase_ast(&self.program, &asg.clone().into_repr())
                 .expect("Failed to produce type inference ast.");
-            new_ast.to_json_file(self.output_directory.clone(), "type_inferenced_ast.json")?;
+
+            if self.ast_snapshot_options.spans_enabled {
+                new_ast.to_json_file(self.output_directory.clone(), "type_inferenced_ast.json")?;
+            } else {
+                new_ast.to_json_file_without_keys(
+                    self.output_directory.clone(),
+                    "type_inferenced_ast.json",
+                    &["span"],
+                )?;
+            }
         }
 
         tracing::debug!("ASG generation complete");

compiler/src/option.rs

@@ -37,6 +37,7 @@ impl Default for CompilerOptions {
 
 #[derive(Clone, Default)]
 pub struct AstSnapshotOptions {
+    pub spans_enabled: bool,
     pub initial: bool,
     pub imports_resolved: bool,
     pub canonicalized: bool,

compiler/src/test.rs

@@ -118,6 +118,7 @@ impl Namespace for CompileNamespace {
         let parsed = parse_program(
             &test.content,
             Some(AstSnapshotOptions {
+                spans_enabled: false,
                 initial: true,
                 imports_resolved: true,
                 canonicalized: true,

errors/src/ast/ast_errors.rs

@@ -122,4 +122,13 @@ create_errors!(
         msg: format!("failed to resolve import: '{}'", name),
         help: None,
     }
+
+    /// For when the AST fails to be represented as a JSON value.
+    @backtraced
+    failed_to_convert_ast_to_json_value {
+        args: (error: impl ErrorArg),
+        msg: format!("failed to convert ast to a json value {}", error),
+        help: None,
+    }
+
 );

errors/src/common/mod.rs

@@ -31,6 +31,11 @@ pub use self::macros::*;
 pub mod span;
 pub use self::span::Span;
 
+/// This module contains a custome serialize/deserialize
+/// implementation for Span.
+pub mod span_json;
+pub use self::span_json::*;
+
 /// This module contains information on how to serialize and
 /// deserialze StrTendril type.
 pub mod tendril_json;

errors/src/common/span_json.rs

@@ -0,0 +1,55 @@
+// Copyright (C) 2019-2021 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::Span;
+
+use std::fmt;
+
+use serde::de::{MapAccess, Visitor};
+use serde::ser::SerializeMap;
+use serde::{Deserializer, Serializer};
+
+/// The AST contains a few tuple-like enum variants the contain spans
+/// #[derive(Serialize, Deserialize)] outputs these fields as anonmyous
+/// mappings, which makes them difficult to remove from the JSON AST.
+/// This function provides a custom serialization that maps the keyword
+/// `span` to the span information.
+pub fn serialize<S: Serializer>(span: &Span, serializer: S) -> Result<S::Ok, S::Error> {
+    let mut map = serializer.serialize_map(Some(1))?;
+    map.serialize_entry("span", span)?;
+    map.end()
+}
+
+/// Custom deserialization to enable removing spans from enums.
+pub fn deserialize<'de, D: Deserializer<'de>>(deserializer: D) -> Result<Span, D::Error> {
+    deserializer.deserialize_map(SpanMapVisitor)
+}
+
+/// This visitor is used by the deserializer to unwrap mappings
+/// and extract span information.
+struct SpanMapVisitor;
+
+impl<'de> Visitor<'de> for SpanMapVisitor {
+    type Value = Span;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("Mapping from `span` keyword to span information")
+    }
+
+    fn visit_map<M: MapAccess<'de>>(self, mut access: M) -> Result<Self::Value, M::Error> {
+        let (_, value): (String, Span) = access.next_entry()?.unwrap();
+        Ok(value)
+    }
+}

leo/commands/build.rs

@@ -43,6 +43,8 @@ pub struct BuildOptions {
     pub disable_code_elimination: bool,
     #[structopt(long, help = "Disable all compiler optimizations")]
     pub disable_all_optimizations: bool,
+    #[structopt(long, help = "Enable spans in AST snapshots.")]
+    pub enable_spans: bool,
     #[structopt(long, help = "Writes all AST snapshots for the different compiler phases.")]
     pub enable_all_ast_snapshots: bool,
     #[structopt(long, help = "Writes AST snapshot of the initial parse.")]
@@ -75,6 +77,7 @@ impl From<BuildOptions> for AstSnapshotOptions {
     fn from(options: BuildOptions) -> Self {
         if options.enable_all_ast_snapshots {
             AstSnapshotOptions {
+                spans_enabled: options.enable_spans,
                 initial: true,
                 imports_resolved: true,
                 canonicalized: true,
@@ -82,6 +85,7 @@ impl From<BuildOptions> for AstSnapshotOptions {
             }
         } else {
             AstSnapshotOptions {
+                spans_enabled: options.enable_spans,
                 initial: options.enable_initial_ast_snapshot,
                 imports_resolved: options.enable_imports_resolved_ast_snapshot,
                 canonicalized: options.enable_canonicalized_ast_snapshot,

parser/Cargo.toml

@@ -51,6 +51,7 @@ version = "0.3"
 
 [dev-dependencies.serde_json]
 version = "1.0"
+features = [ "preserve_order" ]
 
 [dev-dependencies.serde_yaml]
 version = "0.8"

parser/tests/serialization/expected_leo_ast/one_plus_one.json

@@ -26,12 +26,14 @@
                         "U8",
                         "1",
                         {
-                          "line_start": 2,
-                          "line_stop": 2,
-                          "col_start": 12,
-                          "col_stop": 15,
-                          "path": "",
-                          "content": "    return 1u8 + 1u8;"
+                          "span" : {
+                            "line_start": 2,
+                            "line_stop": 2,
+                            "col_start": 12,
+                            "col_stop": 15,
+                            "path": "",
+                            "content": "    return 1u8 + 1u8;"
+                          }
                         }
                       ]
                     }
@@ -42,12 +44,14 @@
                         "U8",
                         "1",
                         {
-                          "line_start": 2,
-                          "line_stop": 2,
-                          "col_start": 18,
-                          "col_stop": 21,
-                          "path": "",
-                          "content": "    return 1u8 + 1u8;"
+                          "span": {
+                            "line_start": 2,
+                            "line_stop": 2,
+                            "col_start": 18,
+                            "col_stop": 21,
+                            "path": "",
+                            "content": "    return 1u8 + 1u8;"
+                          }
                         }
                       ]
                     }

parser/tests/serialization/expected_leo_ast/pedersen_hash.json

@@ -0,0 +1,299 @@
+{
+  "name": "",
+  "expected_input": [],
+  "import_statements": [],
+  "imports": {},
+  "aliases": {},
+  "circuits": {
+    "{\"name\":\"PedersenHash\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":21,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"circuit PedersenHash {\\\"}\"}": {
+      "circuit_name": "{\"name\":\"PedersenHash\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":21,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"circuit PedersenHash {\\\"}\"}",
+      "core_mapping": null,
+      "members": [
+        {
+          "CircuitVariable": [
+            "{\"name\":\"parameters\",\"span\":\"{\\\"line_start\\\":2,\\\"line_stop\\\":2,\\\"col_start\\\":5,\\\"col_stop\\\":15,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    parameters: [group; 256];\\\"}\"}",
+            {
+              "Array": [
+                "Group",
+                [
+                  {
+                    "value": "256"
+                  }
+                ]
+              ]
+            }
+          ]
+        },
+        {
+          "CircuitFunction": {
+            "annotations": [],
+            "identifier": "{\"name\":\"new\",\"span\":\"{\\\"line_start\\\":5,\\\"line_stop\\\":5,\\\"col_start\\\":14,\\\"col_stop\\\":17,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    function new(parameters: [group; 256]) -> Self {\\\"}\"}",
+            "input": [
+              {
+                "Variable": {
+                  "identifier": "{\"name\":\"parameters\",\"span\":\"{\\\"line_start\\\":5,\\\"line_stop\\\":5,\\\"col_start\\\":18,\\\"col_stop\\\":28,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    function new(parameters: [group; 256]) -> Self {\\\"}\"}",
+                  "const_": false,
+                  "mutable": true,
+                  "type_": {
+                    "Array": [
+                      "Group",
+                      [
+                        {
+                          "value": "256"
+                        }
+                      ]
+                    ]
+                  }
+                }
+              }
+            ],
+            "output": "SelfType",
+            "block": {
+              "statements": [
+                {
+                  "Return": {
+                    "expression": {
+                      "CircuitInit": {
+                        "name": "{\"name\":\"Self\",\"span\":\"{\\\"line_start\\\":6,\\\"line_stop\\\":6,\\\"col_start\\\":16,\\\"col_stop\\\":20,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"        return Self { parameters: parameters };\\\"}\"}",
+                        "members": [
+                          {
+                            "identifier": "{\"name\":\"parameters\",\"span\":\"{\\\"line_start\\\":6,\\\"line_stop\\\":6,\\\"col_start\\\":23,\\\"col_stop\\\":33,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"        return Self { parameters: parameters };\\\"}\"}",
+                            "expression": {
+                              "Identifier": "{\"name\":\"parameters\",\"span\":\"{\\\"line_start\\\":6,\\\"line_stop\\\":6,\\\"col_start\\\":35,\\\"col_stop\\\":45,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"        return Self { parameters: parameters };\\\"}\"}"
+                            }
+                          }
+                        ]
+                      }
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        },
+        {
+          "CircuitFunction": {
+            "annotations": [],
+            "identifier": "{\"name\":\"hash\",\"span\":\"{\\\"line_start\\\":9,\\\"line_stop\\\":9,\\\"col_start\\\":14,\\\"col_stop\\\":18,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    function hash(self, bits: [bool; 256]) -> group {\\\"}\"}",
+            "input": [
+              {
+                "SelfKeyword": "{\"name\":\"self\",\"span\":\"{\\\"line_start\\\":9,\\\"line_stop\\\":9,\\\"col_start\\\":19,\\\"col_stop\\\":23,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    function hash(self, bits: [bool; 256]) -> group {\\\"}\"}"
+              },
+              {
+                "Variable": {
+                  "identifier": "{\"name\":\"bits\",\"span\":\"{\\\"line_start\\\":9,\\\"line_stop\\\":9,\\\"col_start\\\":25,\\\"col_stop\\\":29,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    function hash(self, bits: [bool; 256]) -> group {\\\"}\"}",
+                  "const_": false,
+                  "mutable": true,
+                  "type_": {
+                    "Array": [
+                      "Boolean",
+                      [
+                        {
+                          "value": "256"
+                        }
+                      ]
+                    ]
+                  }
+                }
+              }
+            ],
+            "output": "Group",
+            "block": {
+              "statements": [
+                {
+                  "Definition": {
+                    "declaration_type": "Let",
+                    "variable_names": [
+                      {
+                        "mutable": true,
+                        "identifier": "{\"name\":\"digest\",\"span\":\"{\\\"line_start\\\":10,\\\"line_stop\\\":10,\\\"col_start\\\":13,\\\"col_stop\\\":19,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"        let digest: group = 0group;\\\"}\"}"
+                      }
+                    ],
+                    "type_": "Group",
+                    "value": {
+                      "Value": {
+                        "Group": {
+                          "Single": "0"
+                        }
+                      }
+                    }
+                  }
+                },
+                {
+                  "Iteration": {
+                    "variable": "{\"name\":\"i\",\"span\":\"{\\\"line_start\\\":11,\\\"line_stop\\\":11,\\\"col_start\\\":13,\\\"col_stop\\\":14,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"        for i in 0..256 {\\\"}\"}",
+                    "start": {
+                      "Value": {
+                        "Implicit": "0"
+                      }
+                    },
+                    "stop": {
+                      "Value": {
+                        "Implicit": "256"
+                      }
+                    },
+                    "inclusive": false,
+                    "block": {
+                      "statements": [
+                        {
+                          "Conditional": {
+                            "condition": {
+                              "ArrayAccess": {
+                                "array": {
+                                  "Identifier": "{\"name\":\"bits\",\"span\":\"{\\\"line_start\\\":12,\\\"line_stop\\\":12,\\\"col_start\\\":16,\\\"col_stop\\\":20,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"            if bits[i] {\\\"}\"}"
+                                },
+                                "index": {
+                                  "Identifier": "{\"name\":\"i\",\"span\":\"{\\\"line_start\\\":12,\\\"line_stop\\\":12,\\\"col_start\\\":21,\\\"col_stop\\\":22,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"            if bits[i] {\\\"}\"}"
+                                }
+                              }
+                            },
+                            "block": {
+                              "statements": [
+                                {
+                                  "Assign": {
+                                    "operation": "Add",
+                                    "assignee": {
+                                      "identifier": "{\"name\":\"digest\",\"span\":\"{\\\"line_start\\\":13,\\\"line_stop\\\":13,\\\"col_start\\\":17,\\\"col_stop\\\":23,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"                digest += self.parameters[i];\\\"}\"}",
+                                      "accesses": []
+                                    },
+                                    "value": {
+                                      "ArrayAccess": {
+                                        "array": {
+                                          "CircuitMemberAccess": {
+                                            "circuit": {
+                                              "Identifier": "{\"name\":\"self\",\"span\":\"{\\\"line_start\\\":13,\\\"line_stop\\\":13,\\\"col_start\\\":27,\\\"col_stop\\\":31,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"                digest += self.parameters[i];\\\"}\"}"
+                                            },
+                                            "name": "{\"name\":\"parameters\",\"span\":\"{\\\"line_start\\\":13,\\\"line_stop\\\":13,\\\"col_start\\\":32,\\\"col_stop\\\":42,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"                digest += self.parameters[i];\\\"}\"}",
+                                            "type_": null
+                                          }
+                                        },
+                                        "index": {
+                                          "Identifier": "{\"name\":\"i\",\"span\":\"{\\\"line_start\\\":13,\\\"line_stop\\\":13,\\\"col_start\\\":43,\\\"col_stop\\\":44,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"                digest += self.parameters[i];\\\"}\"}"
+                                        }
+                                      }
+                                    }
+                                  }
+                                }
+                              ]
+                            },
+                            "next": null
+                          }
+                        }
+                      ]
+                    }
+                  }
+                },
+                {
+                  "Return": {
+                    "expression": {
+                      "Identifier": "{\"name\":\"digest\",\"span\":\"{\\\"line_start\\\":16,\\\"line_stop\\\":16,\\\"col_start\\\":16,\\\"col_stop\\\":22,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"        return digest;\\\"}\"}"
+                    }
+                  }
+                }
+              ]
+            }
+          }
+        }
+      ]
+    }
+  },
+  "global_consts": {},
+  "functions": {
+    "{\"name\":\"main\",\"span\":\"{\\\"line_start\\\":21,\\\"line_stop\\\":21,\\\"col_start\\\":10,\\\"col_stop\\\":14,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function main(hash_input: [bool; 256], const parameters: [group; 256]) -> group {\\\"}\"}": {
+      "annotations": [],
+      "identifier": "{\"name\":\"main\",\"span\":\"{\\\"line_start\\\":21,\\\"line_stop\\\":21,\\\"col_start\\\":10,\\\"col_stop\\\":14,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function main(hash_input: [bool; 256], const parameters: [group; 256]) -> group {\\\"}\"}",
+      "input": [
+        {
+          "Variable": {
+            "identifier": "{\"name\":\"hash_input\",\"span\":\"{\\\"line_start\\\":21,\\\"line_stop\\\":21,\\\"col_start\\\":15,\\\"col_stop\\\":25,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function main(hash_input: [bool; 256], const parameters: [group; 256]) -> group {\\\"}\"}",
+            "const_": false,
+            "mutable": true,
+            "type_": {
+              "Array": [
+                "Boolean",
+                [
+                  {
+                    "value": "256"
+                  }
+                ]
+              ]
+            }
+          }
+        },
+        {
+          "Variable": {
+            "identifier": "{\"name\":\"parameters\",\"span\":\"{\\\"line_start\\\":21,\\\"line_stop\\\":21,\\\"col_start\\\":46,\\\"col_stop\\\":56,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function main(hash_input: [bool; 256], const parameters: [group; 256]) -> group {\\\"}\"}",
+            "const_": true,
+            "mutable": false,
+            "type_": {
+              "Array": [
+                "Group",
+                [
+                  {
+                    "value": "256"
+                  }
+                ]
+              ]
+            }
+          }
+        }
+      ],
+      "output": "Group",
+      "block": {
+        "statements": [
+          {
+            "Definition": {
+              "declaration_type": "Const",
+              "variable_names": [
+                {
+                  "mutable": false,
+                  "identifier": "{\"name\":\"pedersen\",\"span\":\"{\\\"line_start\\\":22,\\\"line_stop\\\":22,\\\"col_start\\\":11,\\\"col_stop\\\":19,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    const pedersen = PedersenHash::new(parameters);\\\"}\"}"
+                }
+              ],
+              "type_": null,
+              "value": {
+                "Call": {
+                  "function": {
+                    "CircuitStaticFunctionAccess": {
+                      "circuit": {
+                        "Identifier": "{\"name\":\"PedersenHash\",\"span\":\"{\\\"line_start\\\":22,\\\"line_stop\\\":22,\\\"col_start\\\":22,\\\"col_stop\\\":34,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    const pedersen = PedersenHash::new(parameters);\\\"}\"}"
+                      },
+                      "name": "{\"name\":\"new\",\"span\":\"{\\\"line_start\\\":22,\\\"line_stop\\\":22,\\\"col_start\\\":36,\\\"col_stop\\\":39,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    const pedersen = PedersenHash::new(parameters);\\\"}\"}"
+                    }
+                  },
+                  "arguments": [
+                    {
+                      "Identifier": "{\"name\":\"parameters\",\"span\":\"{\\\"line_start\\\":22,\\\"line_stop\\\":22,\\\"col_start\\\":40,\\\"col_stop\\\":50,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    const pedersen = PedersenHash::new(parameters);\\\"}\"}"
+                    }
+                  ]
+                }
+              }
+            }
+          },
+          {
+            "Return": {
+              "expression": {
+                "Call": {
+                  "function": {
+                    "CircuitMemberAccess": {
+                      "circuit": {
+                        "Identifier": "{\"name\":\"pedersen\",\"span\":\"{\\\"line_start\\\":23,\\\"line_stop\\\":23,\\\"col_start\\\":12,\\\"col_stop\\\":20,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    return pedersen.hash(hash_input);\\\"}\"}"
+                      },
+                      "name": "{\"name\":\"hash\",\"span\":\"{\\\"line_start\\\":23,\\\"line_stop\\\":23,\\\"col_start\\\":21,\\\"col_stop\\\":25,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    return pedersen.hash(hash_input);\\\"}\"}",
+                      "type_": null
+                    }
+                  },
+                  "arguments": [
+                    {
+                      "Identifier": "{\"name\":\"hash_input\",\"span\":\"{\\\"line_start\\\":23,\\\"line_stop\\\":23,\\\"col_start\\\":26,\\\"col_stop\\\":36,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    return pedersen.hash(hash_input);\\\"}\"}"
+                    }
+                  ]
+                }
+              }
+            }
+          }
+        ]
+      }
+    }
+  }
+}

parser/tests/serialization/json.rs

@@ -19,13 +19,16 @@ use leo_ast::Ast;
 use leo_ast::Program;
 use leo_errors::{LeoError, Result};
 
+use std::fs::File;
+use std::io::BufReader;
+use std::iter::Iterator;
 use std::path::{Path, PathBuf};
 
 fn to_ast(program_filepath: &Path) -> Result<Ast> {
     let program_string = std::fs::read_to_string(program_filepath).expect("failed to open test");
 
     // Parses the Leo file and constructs a leo ast.
-    leo_parser::parse_ast("test", &program_string)
+    leo_parser::parse_ast("", &program_string)
 }
 
 fn setup() {
@@ -44,7 +47,7 @@ fn test_serialize() {
     // Construct an ast from the given test file.
     let ast = {
         let mut program_filepath = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        program_filepath.push("tests/serialization/main.leo");
+        program_filepath.push("tests/serialization/leo/one_plus_one.leo");
 
         to_ast(&program_filepath).unwrap()
     };
@@ -53,12 +56,103 @@ fn test_serialize() {
     let serialized_ast: Program = serde_json::from_value(serde_json::to_value(ast.as_repr()).unwrap()).unwrap();
 
     // Load the expected ast.
-    let expected: Program = serde_json::from_str(include_str!("expected_leo_ast.json")).unwrap();
+    let expected: Program = serde_json::from_str(include_str!("./expected_leo_ast/one_plus_one.json")).unwrap();
 
     clean();
     assert_eq!(expected, serialized_ast);
 }
 
+#[test]
+#[cfg(not(feature = "ci_skip"))]
+fn test_serialize_no_span() {
+    setup();
+
+    let program_paths = vec![
+        "tests/serialization/leo/linear_regression.leo",
+        "tests/serialization/leo/palindrome.leo",
+        "tests/serialization/leo/pedersen_hash.leo",
+        "tests/serialization/leo/silly_sudoku.leo",
+    ];
+
+    let json_paths = vec![
+        "tests/serialization/expected_leo_ast/linear_regression.json",
+        "tests/serialization/expected_leo_ast/palindrome.json",
+        "tests/serialization/expected_leo_ast/pedersen_hash.json",
+        "tests/serialization/expected_leo_ast/silly_sudoku.json",
+    ];
+
+    for (program_path, json_path) in program_paths.into_iter().zip(json_paths) {
+        // Construct an ast from the given test file.
+        let ast = {
+            let mut program_filepath = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+            program_filepath.push(program_path);
+            to_ast(&program_filepath).unwrap()
+        };
+
+        let json_reader = {
+            let mut json_filepath = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+            json_filepath.push(json_path);
+            let file = File::open(json_filepath).expect("Failed to read expected ast file");
+            BufReader::new(file)
+        };
+
+        // Serializes the ast into JSON format.
+        let mut serialized_ast: serde_json::Value = serde_json::to_value(ast.as_repr()).unwrap();
+        remove_key_from_json(&mut serialized_ast, "span");
+        serialized_ast = normalize_json_value(serialized_ast);
+
+        // Load the expected ast.
+        let expected: serde_json::Value = serde_json::from_reader(json_reader).unwrap();
+
+        assert_eq!(expected, serialized_ast);
+    }
+    clean();
+}
+
+// Helper functions to recursively filter keys from AST JSON.
+// Redeclaring here since we don't want to make this public.
+fn remove_key_from_json(value: &mut serde_json::Value, key: &str) {
+    match value {
+        serde_json::value::Value::Object(map) => {
+            map.remove(key);
+            for val in map.values_mut() {
+                remove_key_from_json(val, key);
+            }
+        }
+        serde_json::value::Value::Array(values) => {
+            for val in values.iter_mut() {
+                remove_key_from_json(val, key);
+            }
+        }
+        _ => (),
+    }
+}
+
+// Helper function to normalize AST
+// Redeclaring here because we don't want to make this public
+fn normalize_json_value(value: serde_json::Value) -> serde_json::Value {
+    match value {
+        serde_json::Value::Array(vec) => {
+            let orig_length = vec.len();
+            let mut new_vec: Vec<serde_json::Value> = vec
+                .into_iter()
+                .filter(|v| !matches!(v, serde_json::Value::Object(map) if map.is_empty()))
+                .map(normalize_json_value)
+                .collect();
+
+            if orig_length == 2 && new_vec.len() == 1 {
+                new_vec.pop().unwrap()
+            } else {
+                serde_json::Value::Array(new_vec)
+            }
+        }
+        serde_json::Value::Object(map) => {
+            serde_json::Value::Object(map.into_iter().map(|(k, v)| (k, normalize_json_value(v))).collect())
+        }
+        _ => value,
+    }
+}
+
 // TODO Renable when we don't write spans to snapshots.
 /* #[test]
 #[cfg(not(feature = "ci_skip"))]
@@ -112,7 +206,7 @@ fn test_generic_parser_error() {
 
     let error_result = {
         let mut program_filepath = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-        program_filepath.push("tests/serialization/parser_error.leo");
+        program_filepath.push("tests/serialization/leo/parser_error.leo");
 
         to_ast(&program_filepath)
     }

parser/tests/serialization/leo/linear_regression.leo

@@ -0,0 +1,65 @@
+circuit Point {
+    x: i32,
+    y: i32,
+    
+    function new(x: i32, y: i32) -> Self { 
+        return Self { x, y };
+    }
+}
+
+circuit LinearRegression {
+    points: [Point; 5],
+    
+    // Instantiates a linear regression circuit.
+    function new(points: [Point; 5]) -> Self { 
+        return Self { points };
+    }
+    
+    // Return the slope of the linear regression.
+    function slope(self) -> i32 { 
+        
+        let num_points = 5i32;
+        // Calculate the sums.
+        let x_sum = 0i32; 
+        let y_sum = 0i32; 
+        let xy_sum = 0i32; 
+        let x2_sum = 0i32; 
+        for i in 0..5 {
+            x_sum += self.points[i].x;
+            y_sum += self.points[i].y;
+            xy_sum += self.points[i].x * self.points[i].y;
+            x2_sum += self.points[i].x * self.points[i].x;
+        }
+        let numerator = (num_points * xy_sum) - (x_sum * y_sum); 
+        let denominator = (num_points * x2_sum) - (x_sum * x_sum);
+        let slope = numerator / denominator;
+        return slope;
+    }
+    // Return the offset of the linear regression.
+    function offset(self, slope: i32) -> i32 {
+        let num_points = 5i32; 
+        // Calculate the sum. 
+        let x_sum = 0i32;
+        let y_sum = 0i32;
+        for i in 0..5 {
+            x_sum += self.points[i].x;
+            y_sum += self.points[i].y; 
+        }
+        return (y_sum - slope * x_sum) / num_points;
+    }
+}
+
+
+function main (x: i32, y: i32) -> [i32; 2] {
+  let points: [Point; 5] = [
+      Point{x: x + 1, y: y + 1},
+      Point{x: x + 2, y: y + 2},
+      Point{x: x + 3, y: y + 3},
+      Point{x: x + 4, y: y + 4},
+      Point{x: x + 5, y: y + 5}
+  ];
+  let reg = LinearRegression::new(points);
+  let slope = reg.slope();
+  let offset = reg.offset(slope);
+  return [slope, offset];
+}

parser/tests/serialization/leo/palindrome.leo

@@ -0,0 +1,59 @@
+// This Program takes in any 20-byte low register string and tells 
+// whether a string is a palindrome ignoring any spaces.
+
+function main(str: [char; 20]) -> bool {
+    return is_palindrome(str);
+}
+
+function is_palindrome(str: [char; 20]) -> bool {
+    const str_len = 20u32; // saving const for convenience
+
+    // By default we assume that input is a palindrome.
+    let result = true;
+    let processed = 0u8;
+
+    for start in 0..(str_len / 2) {
+        let start_sym = str[start];
+        if start_sym != ' ' {
+            let skipped = 0u8;
+            let end_empty = 0u8;
+            let end_sym = ' ';
+
+            for end in (str_len - 1)..start {
+                if str[end] != ' ' && skipped == processed && end_sym == ' ' {
+                    end_sym = str[end];
+                } else {
+                    end_empty = end_empty + 1;
+                    if str[end] != ' ' {
+                        skipped = skipped + 1;
+                    }
+                }
+            }
+
+            // If there are symbols left to the right from the start.
+            if end_sym != ' ' {
+                console.log("Comparing: {} ? {}", start_sym, end_sym);
+
+                if result {
+                    result = (start_sym == end_sym);
+                }
+
+                processed = processed + 1;
+            }
+        }
+    }
+
+    console.log("Result is: {}", result);
+
+    return result;
+}
+
+@test
+function test_is_palindrome() {
+    console.assert(is_palindrome("a           b   a   "));
+    console.assert(is_palindrome("😀😀😀😀😀          😀😀😀😀😀"));
+    console.assert(is_palindrome("borrow or rob       "));
+    console.assert(is_palindrome("bbbb aaaa  aaaa bbbb"));
+    console.assert(is_palindrome("aaaaaaaaaaaaaaaaaaaa"));
+    console.assert(is_palindrome("taco cat            "));
+}

parser/tests/serialization/leo/pedersen_hash.leo

@@ -0,0 +1,25 @@
+circuit PedersenHash {
+    parameters: [group; 256];
+
+    // Instantiates a Pedersen hash circuit
+    function new(parameters: [group; 256]) -> Self {
+        return Self { parameters: parameters };
+    }
+
+    function hash(self, bits: [bool; 256]) -> group {
+        let digest: group = 0group;
+        for i in 0..256 {
+            if bits[i] {
+                digest += self.parameters[i];
+            }
+        }
+        return digest;
+    }
+}
+
+// The 'pedersen-hash' main function.
+function main(hash_input: [bool; 256], const parameters: [group; 256]) -> group {
+    const pedersen = PedersenHash::new(parameters);
+    return pedersen.hash(hash_input);
+}
+

parser/tests/serialization/leo/silly_sudoku.leo

@@ -0,0 +1,71 @@
+import lib.SillySudoku;
+
+// The `silly-sudoku` main function
+function main(puzzle: [u8; (3, 3)], answer: [u8; (3, 3)]) -> bool {
+    console.log("Starting Sudoku solver...");
+    console.log("{}", puzzle);
+
+    // Instantiate the Sudoku puzzle.
+    let sudoku = SillySudoku { puzzle_grid: puzzle };
+
+    console.log("Checking Sudoku answer...");
+    console.log("{}", answer);
+
+    // Evaluate the Sudoku puzzle with the given answer.
+    let result = sudoku.solve(answer);
+
+    console.log("The answer is {}.", result);
+
+    return result;
+}
+
+// Tests that the `silly-sudoku` circuit outputs true on a correct answer.
+@test
+function test_solve_pass() {
+    let puzzle: [u8; (3, 3)] = [[0, 2, 0],
+                                [0, 0, 6],
+                                [0, 8, 9]];
+
+    let answer: [u8; (3, 3)] = [[1, 2, 3],
+                                [4, 5, 6],
+                                [7, 8, 9]];
+
+    // Runs the Sudoku checker.
+    let result = main(puzzle, answer);
+
+    // Expects the result to be true.
+    console.assert(true == result);
+}
+
+// Tests that the `silly-sudoku` circuit outputs false on an incorrect answer.
+@test
+function test_solve_fail() {
+    let puzzle: [u8; (3, 3)] = [[0, 2, 0],
+                                [0, 0, 6],
+                                [0, 8, 0]];
+
+    let answer: [u8; (3, 3)] = [[1, 2, 3],
+                                [4, 5, 6],
+                                [7, 8, 8]]; // We have an extra `8` in this column!
+
+    // Runs the Sudoku checker.
+    let result = main(puzzle, answer);
+
+    // Expects the result to be false.
+    console.assert(false == result);
+}
+
+// Test that the `silly-sudoku` circuit outputs the expected value on a custom test input.
+@test(test_input)
+function test_solve_with_input(
+    puzzle: [u8; (3, 3)],
+    answer: [u8; (3, 3)],
+    expected: bool
+) {
+    // Runs the Sudoku checker.
+    let result = main(puzzle, answer);
+
+    console.log("expected {}, got {}", expected, result);
+
+    console.assert(expected == result);
+}

test-framework/Cargo.toml

@@ -23,6 +23,7 @@ features = [ "derive" ]
 
 [dependencies.serde_json]
 version = "1.0"
+features = [ "preserve_order" ]
 
 [dependencies.serde_yaml]
 version = "0.8"

test-framework/src/bin/tgc.rs

@@ -114,40 +114,29 @@ fn run_with_args(opt: Opt) -> Result<(), Box<dyn Error>> {
             // Do this to match test-framework ast bc of spans
             let text = &text[end_of_header + 2..];
             // Write all files into the directory.
-            let (initial, imports_resolved, canonicalized, type_inferenced) = generate_asts(cwd, text)?;
-
-            target.push("initial_ast.json");
-            fs::write(target.clone(), initial)?;
-            target.pop();
-
-            target.push("imports_resolved_ast.json");
-            fs::write(target.clone(), imports_resolved)?;
-            target.pop();
-
-            target.push("canonicalization_ast.json");
-            fs::write(target.clone(), canonicalized)?;
-            target.pop();
-
-            target.push("type_inferenced_ast.json");
-            fs::write(target.clone(), type_inferenced)?;
+            generate_asts(cwd, target, text)?;
         }
     }
 
     Ok(())
 }
 
-/// Do what Compiler does - prepare 3 stages of AST: initial, canonicalized and type_inferenced
-fn generate_asts(path: PathBuf, text: &str) -> Result<(String, String, String, String), Box<dyn Error>> {
+/// Do what Compiler does - prepare 3 stages of AST: initial, imports_resolved, canonicalized and type_inferenced
+/// Write these ASTs without Spans to JSON
+fn generate_asts(src_path: PathBuf, target_path: PathBuf, text: &str) -> Result<(), Box<dyn Error>> {
     std::env::set_var("LEO_TESTFRAMEWORK", "true");
 
-    let mut ast = leo_parser::parse_ast(path.clone().into_os_string().into_string().unwrap(), text)?;
-    let initial = ast.to_json_string()?;
+    let mut ast = leo_parser::parse_ast(src_path.clone().into_os_string().into_string().unwrap(), text)?;
 
-    ast = leo_ast_passes::Importer::do_pass(ast.into_repr(), &mut ImportParser::new(path, Default::default()))?;
-    let imports_resolved = ast.to_json_string()?;
+    ast.to_json_file_without_keys(target_path.clone(), "initial_ast.json", &["span"])?;
+
+    ast = leo_ast_passes::Importer::do_pass(ast.into_repr(), &mut ImportParser::new(src_path, Default::default()))?;
+
+    ast.to_json_file_without_keys(target_path.clone(), "imports_resolved_ast.json", &["span"])?;
 
     ast = leo_ast_passes::Canonicalizer::do_pass(ast.into_repr())?;
-    let canonicalized = ast.to_json_string()?;
+
+    ast.to_json_file_without_keys(target_path.clone(), "canonicalization_ast.json", &["span"])?;
 
     let mut ti_ast = ast.into_repr();
     ti_ast.name = "test".to_string(); // Do this to match test-framework ast
@@ -156,12 +145,13 @@ fn generate_asts(path: PathBuf, text: &str) -> Result<(String, String, String, S
 
     let type_inferenced = TypeInferencePhase::default()
         .phase_ast(&ti_ast, &asg.clone().into_repr())
-        .expect("Failed to produce type inference ast.")
-        .to_json_string()?;
+        .expect("Failed to produce type inference ast.");
+
+    type_inferenced.to_json_file_without_keys(target_path, "type_inferenced_ast.json", &["span"])?;
 
     std::env::remove_var("LEO_TESTFRAMEWORK");
 
-    Ok((initial, imports_resolved, canonicalized, type_inferenced))
+    Ok(())
 }
 
 fn handle_error(res: Result<(), Box<dyn Error>>) {

tests/expectations/compiler/compiler/address/branch.leo.out

@@ -16,7 +16,7 @@ outputs:
             a:
               type: bool
               value: "true"
-    initial_ast: 32dcc6719d7d1214782cd1ffe02f067eec8adbf1f3820546e539887d4f1334c8
-    imports_resolved_ast: 4e707995ef2cb41edba1339c811ae476bf30a2f65bb09137372a2a0931285260
-    canonicalized_ast: 4e707995ef2cb41edba1339c811ae476bf30a2f65bb09137372a2a0931285260
-    type_inferenced_ast: e3d743b0cc61c5e785559f469d394ae364f0a338cff37974bfc926497013bdd1
+    initial_ast: 7ad5e2d2d6b833861f055b51029ed74cb9aba444d689578b0a1d1e2ff90d848d
+    imports_resolved_ast: 045b43d9a82ffc1c7d36d8c299aa42e682e43e11b7af043d5d9bde522ef43f24
+    canonicalized_ast: 045b43d9a82ffc1c7d36d8c299aa42e682e43e11b7af043d5d9bde522ef43f24
+    type_inferenced_ast: 45e22455ff329af7695237d84c319e6160fd5a181d18e6b4edfa6bfb33845011

tests/expectations/compiler/compiler/address/equal.leo.out

@@ -22,7 +22,7 @@ outputs:
             a:
               type: bool
               value: "false"
-    initial_ast: d9d5346dff8f825d58daabb3a4fe2fcd1471a3fb3c80e46e5583c4f6cdb12b2b
-    imports_resolved_ast: e5e91879622f5e63f1b465a8d1d99b9ad10e128d3b04493def195d81e5c728f3
-    canonicalized_ast: e5e91879622f5e63f1b465a8d1d99b9ad10e128d3b04493def195d81e5c728f3
-    type_inferenced_ast: 436fd5fbf72020d63c2f462dd271dbeeca6161c68f625e53ab5f827cda3d3d3e
+    initial_ast: 86c87f7c1bda6448d831106aab9bd29a5cb80082503fc7851aac9289d4c355f2
+    imports_resolved_ast: 93751be8c7c9e9d42efdb046b34260713dd0c12667577e631a1d320674cc0ed9
+    canonicalized_ast: 93751be8c7c9e9d42efdb046b34260713dd0c12667577e631a1d320674cc0ed9
+    type_inferenced_ast: 7f22803c150b89187566309e1581f120d8ba838ce1c3a403a98cd6ad71ba08b4

tests/expectations/compiler/compiler/address/index.leo.out

@@ -16,7 +16,7 @@ outputs:
             a:
               type: bool
               value: "true"
-    initial_ast: 9961e21337ff8eed0a27fff91fc442c2530a1bfaf80da6d497a93a371896b1f8
-    imports_resolved_ast: 763fdfbdda86ca59a4e8c18f0e9e7f87516725d886468a7bf5b5d37bfde140f8
-    canonicalized_ast: 763fdfbdda86ca59a4e8c18f0e9e7f87516725d886468a7bf5b5d37bfde140f8
-    type_inferenced_ast: 6acc95039938704a57b102cb2b3e61cde8375cc1e7595394b759dfc23a4fbedb
+    initial_ast: 992bb7370a4fe8caed3018c650b19a6d352b18c94d5e7cd95cdf3200430b249b
+    imports_resolved_ast: a0314b6e06744031cc13b0a3b07c3ab752ba6dc98d33a18c3ced11c64b7d241e
+    canonicalized_ast: a0314b6e06744031cc13b0a3b07c3ab752ba6dc98d33a18c3ced11c64b7d241e
+    type_inferenced_ast: eefeea46faab929c0741ba9fb1dd5b0ac680824e3aaa5b6703f0c6ff86b8f810

tests/expectations/compiler/compiler/address/ternary.leo.out

@@ -22,7 +22,7 @@ outputs:
             a:
               type: bool
               value: "false"
-    initial_ast: 6f8e7a94ccb702790204360959a2673abf6b53027fccaaa9feed8a4e41ee05c1
-    imports_resolved_ast: e3570e385d638499b9ce95f0266f87e1c5bd72f7ddcd2718fee3f8f7080cf218
-    canonicalized_ast: e3570e385d638499b9ce95f0266f87e1c5bd72f7ddcd2718fee3f8f7080cf218
-    type_inferenced_ast: c29bc0a2616f928552e44d4e46c363c5707b986737e825855fd0a6165bfa55f3
+    initial_ast: dd955e706905ed892a0ae72d551f0bdf79711f1cc05c5becf5506e34ad104ead
+    imports_resolved_ast: 7125a2a8ab864e2d9019bfeed49d6450ba21123387ff5bff5b22bd0d679b7c4f
+    canonicalized_ast: 7125a2a8ab864e2d9019bfeed49d6450ba21123387ff5bff5b22bd0d679b7c4f
+    type_inferenced_ast: 35acf899be15516155477b449ea9443c1def435bdd2cb67e27ffa3c6a661465c

tests/expectations/compiler/compiler/aliases/arith.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 6349e2684562bad873bcf643e01eeb02039295bd41e2df77f1fefc7bb3f2d3bb
-    imports_resolved_ast: 2b00607e4a777539b2abb677ac95108208d03409adb6b672e00d26cada45b1e6
-    canonicalized_ast: 2b00607e4a777539b2abb677ac95108208d03409adb6b672e00d26cada45b1e6
-    type_inferenced_ast: f0a02b6b326925afb8b1f8fbdafb5686687e695eb4420010d2c8d1564ac0a7b2
+    initial_ast: a892b24387ed5c315281441638e8b1f16a21b3312390c236205d6ed2e74c61d8
+    imports_resolved_ast: c074f6ad3e328bdf8942d28d370af96a93151388ea67a01f4ac8830f5a4a9471
+    canonicalized_ast: c074f6ad3e328bdf8942d28d370af96a93151388ea67a01f4ac8830f5a4a9471
+    type_inferenced_ast: 50334281e95863d9de35c0c63f0b01b552064790709150ad58b8a9db02a1b43a

tests/expectations/compiler/compiler/aliases/basic.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 9f78c996da10363fb594947ca29fef29e35a7032761ce87f69f3ae454650d47e
-    imports_resolved_ast: 32e35e00fe92c3cd71959cacb44d76f19782e5fcdeb57b839f1ff6a37dee3964
-    canonicalized_ast: 32e35e00fe92c3cd71959cacb44d76f19782e5fcdeb57b839f1ff6a37dee3964
-    type_inferenced_ast: d6afa34bd1c84c58bb1920be76e893f16a0a7ba1a952493679d2e219b70ac13d
+    initial_ast: 47b126e0d1d848b78d9c628e026cb7d3c2691321c450aa1813cbb5e220708a24
+    imports_resolved_ast: 1f5470b9d9eef03ec6c42ab2ced99def2122ff2e6649af0cd275b2808f435182
+    canonicalized_ast: 1f5470b9d9eef03ec6c42ab2ced99def2122ff2e6649af0cd275b2808f435182
+    type_inferenced_ast: a5cf1d5bffdd9c388e99be84d1d06d6d6842d7a0fdcb2ea4d546c62eb778a0f1

tests/expectations/compiler/compiler/aliases/circuit.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: ee817c17e6bef3b458e14d3a81c087ed6a75c4554bc70b62466e8d8e43ff1b5e
-    imports_resolved_ast: 4c477f127d0f5044d37279a8892ad04dafccb200665044e341f74e2e10152de6
-    canonicalized_ast: 4c477f127d0f5044d37279a8892ad04dafccb200665044e341f74e2e10152de6
-    type_inferenced_ast: 9c27915c9e63f5a0a05ead01b6a1564c53956ecbc6e90cb7b33f074d423add24
+    initial_ast: 7e75f01ceabbf7288c7b6a81bc699aa60003a5fb9af26d71af393b6bd87830bd
+    imports_resolved_ast: 92537456e5f6369f2b5d057a875127dec5a9740403fcef775891776cf9f4d624
+    canonicalized_ast: 92537456e5f6369f2b5d057a875127dec5a9740403fcef775891776cf9f4d624
+    type_inferenced_ast: 285dbba74211f78a25e7df78204e5da56ea3e827e078817f180b2f6f4dd34b9b

tests/expectations/compiler/compiler/aliases/fn_return.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 8d5ed3110bc3a61ddee37408133fcc1f77209b65bb83d230729203009e093f40
-    imports_resolved_ast: 3bf9b1a7fe682434578831c20f0ab67ef37aa3a069bc302a99bd8976678158c3
-    canonicalized_ast: 3bf9b1a7fe682434578831c20f0ab67ef37aa3a069bc302a99bd8976678158c3
-    type_inferenced_ast: 397cf0ec0e99c094c9d2aa4f1a67df6564a2f6ff5c9a2bd82b47fac583598dca
+    initial_ast: 87176b25bbfbc6c05992ff1ec6d9b6c25f76d2c99aac5b108f7e35869b295ec3
+    imports_resolved_ast: 3816cc3cde3c85acec9b4bee7aebb1f9af1a5ec7b2d7b31995ee5cc7576f6300
+    canonicalized_ast: 3816cc3cde3c85acec9b4bee7aebb1f9af1a5ec7b2d7b31995ee5cc7576f6300
+    type_inferenced_ast: 4ab1f4ec512d5be971b5a8f72708f424346765db5546b4a2049e365dd583a607

tests/expectations/compiler/compiler/aliases/shadowing_arg.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: f7b2eb89c51644dc8596988bcc66fbfe471489887c6f46b78ca417746c7ef442
-    imports_resolved_ast: 01a3839714be9b09a1ab61b19adde2a8f45ba6eeb0181f3f746dcf2646f73c7c
-    canonicalized_ast: 01a3839714be9b09a1ab61b19adde2a8f45ba6eeb0181f3f746dcf2646f73c7c
-    type_inferenced_ast: 4f5b9e0532f6476cb6a3f11c4c08d4c59b3e67db76f4358b77e77c6d8fdd8a22
+    initial_ast: 841701f4bc6f5dbca4a056983cabbefbe55d0784a74f1bdc15f113ee706e3e12
+    imports_resolved_ast: a813502683d90d84618a2dd32065c3d1ce72bf5e804a29b6bbfea4bc064721e9
+    canonicalized_ast: a813502683d90d84618a2dd32065c3d1ce72bf5e804a29b6bbfea4bc064721e9
+    type_inferenced_ast: 835152b7c631884ae29519f744e9713cd3edaebaef1e3e5fce39ad9d87f3d272

tests/expectations/compiler/compiler/aliases/shadowing_var_allowed.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 66ead06ceac4fea6a24fe071a955986722a53975fa98d2ad2909a83fa8ba8525
-    imports_resolved_ast: 2f34d52f534da1c7ec6ebe99be8cec87483f1a73d4cfa9d1d70d40db6304922f
-    canonicalized_ast: 2f34d52f534da1c7ec6ebe99be8cec87483f1a73d4cfa9d1d70d40db6304922f
-    type_inferenced_ast: 26402d98870ae4395a8b7cacf9d25e9cc0920c42dbc7bf48c944ec220138289e
+    initial_ast: 2d49a9d954383a6daf4aac4e31c5f91dc84a1f75818cdc2146a2b4e4729737f0
+    imports_resolved_ast: 005253b5a5688e8e5faa3ad9f234a3bac85061620b57d3735ef6b80babac6053
+    canonicalized_ast: 005253b5a5688e8e5faa3ad9f234a3bac85061620b57d3735ef6b80babac6053
+    type_inferenced_ast: c633bc1b9da44443337010bc35f9cb42b6f4cb41177992999457974ba9a88744

tests/expectations/compiler/compiler/array/complex_access.leo.out

@@ -16,7 +16,7 @@ outputs:
             out:
               type: bool
               value: "true"
-    initial_ast: 843884ddf198fe566cea0f8e84a2902f720d6211c9d8bad98299eea4da846870
-    imports_resolved_ast: 984f2f99c58550a478b8abd5d9f84e88052dbf1ed92b79d1de2d6d251148ddd7
-    canonicalized_ast: 1dee4c73f9faa33e13c2b98aecba1ce88ab110fde39b7a573e06969f8dbf84d5
-    type_inferenced_ast: 3bb764584aaa81586edbf85ae1e7ae0774d2e03599c04279f8451205b71e16a4
+    initial_ast: 666f40aa5c8cbd89c4fd5734540571cd39c8f09eddcfcbbe9c051a40755368e6
+    imports_resolved_ast: 96a2247b70929ee703ba861a6d0b6b35dec34ce19594bcca6117304ea6ebc5ce
+    canonicalized_ast: 1d62c1faa9463adc8bff7fef47372d4b966db5e2decc03c1af94524a9f7a5cfe
+    type_inferenced_ast: f402f69b8de9fd40669eac875dec9c390454c0eeb6e5931cf0320a308bbdb1f8

tests/expectations/compiler/compiler/array/equal_initializer.leo.out

@@ -22,7 +22,7 @@ outputs:
             x:
               type: bool
               value: "false"
-    initial_ast: aa24022f240400d709b97a44c143ce481109bb0a66926aa5c97cf2e2d06dea2a
-    imports_resolved_ast: eeccd5c884082a153d06ec18d0eefe48c7c10c7f8b2ca4eb8bf07c6135756892
-    canonicalized_ast: 2871e0b38129c9fe8ffb798df90cac534f0c43d2c4bd7b78575ed3e7756027dc
-    type_inferenced_ast: fdee9f43afe71741d8b1783392ce434f30f252d2602902dc964112949c772109
+    initial_ast: 678da5c264bb99ca0d44ce95ab9915927eb1c31df8826cb39bce5af99a32da70
+    imports_resolved_ast: 1a61e4353bebd3aede41ce3afbccd540e385b2f011920bf904617d5baf2b3e55
+    canonicalized_ast: a170ed215e5fe91179941fd4ee89ca7cfdad7f4c197b422bfd439f1a68eb3660
+    type_inferenced_ast: cc8f71fd3df38c4adc5e5a1f14e72ad5a9319ed25a4ae0288b6f9f24b9446789

tests/expectations/compiler/compiler/array/equal_initializer_2.leo.out

@@ -22,7 +22,7 @@ outputs:
             x:
               type: bool
               value: "true"
-    initial_ast: 307b6817fa2a5005462686901129e97bf75c00bf14568fafbe1de2c8afc1804d
-    imports_resolved_ast: 82b0b35a7fdddad336498a8ed852d07f0baa33083ce2777b41ffc40a4e969e12
-    canonicalized_ast: 5cf7e51b880f36efee857debac30612d0f1dc8457529dec4693e1071d56858fe
-    type_inferenced_ast: 113469cf66301a79575823164b365ea8f8cf627df758c1454ff31f42b36ac35e
+    initial_ast: ebf68f4606a7dcb5d02692554d34c386a0266811f890900b5aa99256e46f0a7a
+    imports_resolved_ast: 667d5144a1951ca45221cada73be1ec2983d0ab5d420df3817fc0b050fb83480
+    canonicalized_ast: a01d392be5bada3ed7720009f088fafbaf4d9d76350c56c5aad778b5423bb8eb
+    type_inferenced_ast: fd39c758f304149dde4bdc14685379a0276ed0f988fdac5c5f4ece1b835b45af

tests/expectations/compiler/compiler/array/input_nested_3x2.leo.out

@@ -16,7 +16,7 @@ outputs:
             x:
               type: bool
               value: "true"
-    initial_ast: 6d5be1a3d383ecafa89b5327d3a4b9bce9a459f6c0241cb01f408566ec4a1cc4
-    imports_resolved_ast: 1b2fa78c990dfcaaa8deffd18ce45ca76561da60d0dba1b3f7825f43ee0ac3ef
-    canonicalized_ast: 0a756dbc1859bfbdb6b98b587054bf548402da737df3b7e9c2318cb9bbcb4a67
-    type_inferenced_ast: 97199b96614f9e92928c536b34760c204383495ff1ea198a7593007de61619cc
+    initial_ast: e7619f7fd601b07a7fdbd40328a0f1ceb1c7e31e6799cc788bfed98480c4b642
+    imports_resolved_ast: 7c401a66d810966a517b12d6c393cc1d65acf699a47e523182ef78d6d5ec4957
+    canonicalized_ast: 0c0dbec2435d9685a9cbc3e2976fb63c1df22adeb791baf85059689c8dbb0acf
+    type_inferenced_ast: 1d4c28435a4a0193710d8349710e0e73fdcec30764a5b8813fc72035dcf6227b

tests/expectations/compiler/compiler/array/input_tuple_3x2.leo.out

@@ -16,7 +16,7 @@ outputs:
             x:
               type: bool
               value: "true"
-    initial_ast: aa24022f240400d709b97a44c143ce481109bb0a66926aa5c97cf2e2d06dea2a
-    imports_resolved_ast: eeccd5c884082a153d06ec18d0eefe48c7c10c7f8b2ca4eb8bf07c6135756892
-    canonicalized_ast: 2871e0b38129c9fe8ffb798df90cac534f0c43d2c4bd7b78575ed3e7756027dc
-    type_inferenced_ast: fdee9f43afe71741d8b1783392ce434f30f252d2602902dc964112949c772109
+    initial_ast: 678da5c264bb99ca0d44ce95ab9915927eb1c31df8826cb39bce5af99a32da70
+    imports_resolved_ast: 1a61e4353bebd3aede41ce3afbccd540e385b2f011920bf904617d5baf2b3e55
+    canonicalized_ast: a170ed215e5fe91179941fd4ee89ca7cfdad7f4c197b422bfd439f1a68eb3660
+    type_inferenced_ast: cc8f71fd3df38c4adc5e5a1f14e72ad5a9319ed25a4ae0288b6f9f24b9446789

tests/expectations/compiler/compiler/array/multi_initializer.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 0724c81ae70c56ff047b5d28ef949b72c4b581ce0bb443957064efa1636a3cab
-    imports_resolved_ast: c90904ba0845fa4b092f69fe81782438ecad5bb883c3fd30d3e5c3670e6a98c9
-    canonicalized_ast: 9cd79d308a80e2feafffc66139d517026b15e35b75c7d3eae49ade65bb405338
-    type_inferenced_ast: e4fe63ac330b3a7087740c70e01fd18002a310c7f637de76db62f7d43d2d3c5b
+    initial_ast: 98dec58128652c296b5006c1d9148a3133d5e211c96cd7aa60c71736cbab1276
+    imports_resolved_ast: 3b9b48a555e5b97683884cf99da691779c7a61115e5dfbe3b34316047b91cb3a
+    canonicalized_ast: b2cf4a64fb0c5c1c5c86b7e8c071e2cb6200191a495774a5a10da6bad72f390a
+    type_inferenced_ast: 3dadcd5cf1997d6b7504f1bba4d091028b240e4211030c863f0ba728a80bc3d9

tests/expectations/compiler/compiler/array/nested.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 60d0b81c9f3631aca3c9607df74cfb8e4dbc0d387836398dea86f016fa4210fd
-    imports_resolved_ast: 6e9dfcccc07d698f3b825fe6920bc25f8b97a8fa37b248948fb6d8308d197ff0
-    canonicalized_ast: c2aaa302a5e85a3c369c4246cdfcf97c5644d0b2feb6ba164b63e2bba43959f7
-    type_inferenced_ast: 7beb03c5d82bd7fa0bbe81a92d730e2f2e8689ed183848f0225638b9a39fe6ca
+    initial_ast: 09c819b600d915a4c615b6d911c2dc99bc7c533c58b414653fbad1a6941c1d13
+    imports_resolved_ast: 1efa036e5c996c489f0770577e0e94665ca79cd07abbab101aa79a5e452ab3a5
+    canonicalized_ast: 22ab72eb04b77006d8f1a00596ea3f53870e3611404b0c4a644cc4c938c402ea
+    type_inferenced_ast: 58cba64b60e9237550320c2cc0efa23e0e6d1df4f70447bdba9e2755b844c8a7

tests/expectations/compiler/compiler/array/nested_3x2_value.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 754eca05d485d80c4b710db30efc66f91c0eafdc02c2707f854238863b6c6c02
-    imports_resolved_ast: 74c98b37113df6f99b4ec2dbddb0e7b44c2db43553a1c5dcd168ccff36c067ca
-    canonicalized_ast: a9bf64a55240d8dffde6ae374972edb8229c9284a50c49f7a8430aaf995e57dc
-    type_inferenced_ast: 5153c986fce08dc7e5d9d53769de974e358cc7c6b1883e70f4cd4b7c436e76e3
+    initial_ast: 986b3ccb9ef990b5615670ac6756ff99021f192588dd524f382291c181b15501
+    imports_resolved_ast: aa3c0933cd64b073c3c3749cf6493a7e316d045470ad2f4de0e7d20c61ad0fa6
+    canonicalized_ast: d248faa6caf43c350d5f5432617a9f981b35150702142f1266d4067c178e039d
+    type_inferenced_ast: 37d8a4270c072b6ad5e7b07f63eef006a334b2d59a6826dfc9ae08ec824d254a

tests/expectations/compiler/compiler/array/registers.leo.out

@@ -22,7 +22,7 @@ outputs:
             r:
               type: "[u8; 3]"
               value: "\"123\""
-    initial_ast: 4e74124bc410534941ef9b79ffb64656d14e145b5a79fbd14419c1aef2f0ef69
-    imports_resolved_ast: db3d3efd3292a3bd16296822fbe5d0b51ccae3379d0307e8bb98b6ca062ea3cd
-    canonicalized_ast: db3d3efd3292a3bd16296822fbe5d0b51ccae3379d0307e8bb98b6ca062ea3cd
-    type_inferenced_ast: 81e91909dd86190f8bc2b3b0bcd949c78518b4540a7e8ed6d20ab541b8708345
+    initial_ast: 79cde17d95ee531315d6f4ae8dd0d7ebc5a5d0e22146de6db7e4c846b0833339
+    imports_resolved_ast: bc1282be5ee2d81dd16a0a9958ccd19220f8e3478316e7f60fca1cc3880552c2
+    canonicalized_ast: bc1282be5ee2d81dd16a0a9958ccd19220f8e3478316e7f60fca1cc3880552c2
+    type_inferenced_ast: b61f4082e8b20a016050ff04ced18f5eda53cea053c88bb8af73d5c1b6813407

tests/expectations/compiler/compiler/array/slice.leo.out

@@ -16,7 +16,7 @@ outputs:
             x:
               type: bool
               value: "true"
-    initial_ast: 0e4761ba1228f0a490b51ff2c31df33f623a08d32f62833d64859ca103689f4a
-    imports_resolved_ast: 1b2ba53d65d93c8ba810f1b2c241773e9d901aa987885ccd7db7b7ca606c5dc1
-    canonicalized_ast: 1b2ba53d65d93c8ba810f1b2c241773e9d901aa987885ccd7db7b7ca606c5dc1
-    type_inferenced_ast: 886c9c3d37af3f6d951268eaeddc5c68e1674237dbaf11eb7c76dfdb23e5ece3
+    initial_ast: 1766e095f14495e14d09cc1c17fc4c3dd59a461d9680d18b4b878f12ef10e805
+    imports_resolved_ast: 7495c9e308ab1e82b5c2e85c493afbf959ecaf76f1e6b7a37a59d736b86af430
+    canonicalized_ast: 7495c9e308ab1e82b5c2e85c493afbf959ecaf76f1e6b7a37a59d736b86af430
+    type_inferenced_ast: 1d0373b7f45158e0ccab3ed1c9b9c7291c0a98491a8d2ee6fbe0fc16a3a2034f

tests/expectations/compiler/compiler/array/slice_lower.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 1bf9b30e052d9ecc042a0b20bbc195a98d463ab206963469b9199de462b8be15
-    imports_resolved_ast: 5deb917842e525eb21498976389bc21b716fc2c8d01ee15a868ec347da41eefc
-    canonicalized_ast: 5deb917842e525eb21498976389bc21b716fc2c8d01ee15a868ec347da41eefc
-    type_inferenced_ast: 1cce48ed4862ddb282cb08be969db4d9be64373e83a9458174f2fd63a5a2e878
+    initial_ast: 2cd9e1e07329beaec841339bcf34ef2a4e5a15e56f8a91696a2a68a3de990b00
+    imports_resolved_ast: 65b643ea39133313eef8a32ed276844a486509c8916e0eec3a8fcb147d00edd3
+    canonicalized_ast: 65b643ea39133313eef8a32ed276844a486509c8916e0eec3a8fcb147d00edd3
+    type_inferenced_ast: 671a30cf9d65ff8296bc1b6f592431df5532c058a2adc59b3ccde26b590f0e6e

tests/expectations/compiler/compiler/array/spread.leo.out

@@ -16,7 +16,7 @@ outputs:
             x:
               type: bool
               value: "true"
-    initial_ast: 140097342b7a16fae8542da5d13eb9c2cb4e1b743fa226e345d815f62d0781bb
-    imports_resolved_ast: 691c76eae0533ac08a723ea21c999e9c8fafb71d81dd5a1ff5cf856d98b79cd9
-    canonicalized_ast: 691c76eae0533ac08a723ea21c999e9c8fafb71d81dd5a1ff5cf856d98b79cd9
-    type_inferenced_ast: 6bce331b2bcabd251d039695ea7821e39864bf37f9ba255ab743dddba26c6643
+    initial_ast: d27b7fed60446db7dffac06ca2366c4472ef46025292252a8fd951e0812dbcda
+    imports_resolved_ast: 9cbaf168de5cd80375dfb21010c2ff1562b01e3edc165e159f676b5e1645408e
+    canonicalized_ast: 9cbaf168de5cd80375dfb21010c2ff1562b01e3edc165e159f676b5e1645408e
+    type_inferenced_ast: 67e69ed764ce87f4d640504b5383201fe8138132a444f393eb64d57b5e258bcf

tests/expectations/compiler/compiler/array/ternary_in_array.leo.out

@@ -16,7 +16,7 @@ outputs:
             x:
               type: bool
               value: "true"
-    initial_ast: 002cb467a5c1357617b45f955944bb4a79ab465dc13f3eb5eb8db4c158b8c745
-    imports_resolved_ast: f6f225fdc57fa21359f0188361043bc7dc653cadec3936d4a94cf0c19058cb89
-    canonicalized_ast: f6f225fdc57fa21359f0188361043bc7dc653cadec3936d4a94cf0c19058cb89
-    type_inferenced_ast: 9203e04d2522f45db24dfd1582d6d5708256483a9eb52474b1ab006bfa1e8121
+    initial_ast: d7eec61e078e57cab6c85735e776c5d088768e16a55b198f145e4592f8eb9b5a
+    imports_resolved_ast: aaf0a6266afbddd498e6220d44f84cc255852f40466758e5bef289d5b5027773
+    canonicalized_ast: aaf0a6266afbddd498e6220d44f84cc255852f40466758e5bef289d5b5027773
+    type_inferenced_ast: 2ab582d9455ebee7668a53523e8d7b9f6f9ebd8e3a3e52c84277468e0530f71e

tests/expectations/compiler/compiler/array/tuple_3x2_value.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 97fd9b78f7912a7627e2b2f5615ae35e39304af6122fab85f9b49fcf6a85d8f2
-    imports_resolved_ast: 4132a31ee94a7c187c50f27d1992e25f346bd3c6efabf02106a62a814d9b336a
-    canonicalized_ast: b130bb4ab886d1d855d1f7afbd6af787f7681fbedbd05fcd1cd2561224695bac
-    type_inferenced_ast: a6a9b6069b3f805da8a6ea4fe2fb0530a24b19eb9687ef047f8f3b49d5497590
+    initial_ast: ceeb0995cd4130bf99862b28e5d875f21c5c543b02f13f03f379803bd17edce9
+    imports_resolved_ast: ccaed5ec9aa338901944b351b77337b154b6e2754bbeb6db6bf8e5555727dd94
+    canonicalized_ast: db31b59061604a1d5f335d59a2d14a7069707a277d1664df663caf8fffeb548f
+    type_inferenced_ast: 7a7ae79f8eb44c6a736ddc14e6e7b6e461576ab0750df0d277c2995c75d6e15e

tests/expectations/compiler/compiler/array/type_input_3x2.leo.out

@@ -16,7 +16,7 @@ outputs:
             x:
               type: bool
               value: "true"
-    initial_ast: 9f2080fab6a85294afa2423cd79482fb3d944c4afab7363e66a4086a120ad34d
-    imports_resolved_ast: 266d7ddeb032f20a481e8477ee3ef1c15a33cb2e0fc6f1edd88505a92b6f98c5
-    canonicalized_ast: 266d7ddeb032f20a481e8477ee3ef1c15a33cb2e0fc6f1edd88505a92b6f98c5
-    type_inferenced_ast: 76a31fb9c0d35124f8af084baf96d54d1578a3234e3672c7003043412b915549
+    initial_ast: 1090664406051c30a8f94969f342997aba5ab58623f05dc1576f250b10868bb9
+    imports_resolved_ast: 1b8daa2fcc62d28988deb440e6c5377148ba3a821410acae5e608688dd9acd6d
+    canonicalized_ast: 1b8daa2fcc62d28988deb440e6c5377148ba3a821410acae5e608688dd9acd6d
+    type_inferenced_ast: 488fdcadda8614ee21cae456129a2f988618ab365f64145593ad592de3e9e5a0

tests/expectations/compiler/compiler/array/type_input_4x3x2.leo.out

@@ -16,7 +16,7 @@ outputs:
             x:
               type: bool
               value: "true"
-    initial_ast: f61370b311806223d351c6dd611a178362cf8ad6de976d7b0ed709b51fadbecb
-    imports_resolved_ast: 807d9de7b230026104c0b79e1211028db73f43914e40e5f0d11f86b0cf43b35e
-    canonicalized_ast: 807d9de7b230026104c0b79e1211028db73f43914e40e5f0d11f86b0cf43b35e
-    type_inferenced_ast: 4a8c4abf672625e2e998c83c7b7247b01d338dc496481b9847973946d45d8f18
+    initial_ast: 4eb85f8d228917b40f14e9ca342cde41c15e47fc2968cd12ad2ad535a0d11cdc
+    imports_resolved_ast: a22bb8a25a8e136a05d31bed38659e1b2bceb368037f528751a37520a9085aaf
+    canonicalized_ast: a22bb8a25a8e136a05d31bed38659e1b2bceb368037f528751a37520a9085aaf
+    type_inferenced_ast: 31607be4e3112cb22e74729ff03aa1c2b745c7059666675ca7f3994d4b66514f

tests/expectations/compiler/compiler/array/type_nested_value_nested_3x2.leo.out

@@ -16,7 +16,7 @@ outputs:
             x:
               type: bool
               value: "true"
-    initial_ast: 6bacdd1d42bfa807910c0455c68213007d5ca8f15ee1f3c743d946bfbbff79b7
-    imports_resolved_ast: 2abfe6c0c9d3d0d643ddb315c21c3a79ae7f4ffdb8fb3b2d662d9b2487951374
-    canonicalized_ast: 2abfe6c0c9d3d0d643ddb315c21c3a79ae7f4ffdb8fb3b2d662d9b2487951374
-    type_inferenced_ast: 18da5bbd315adf557e0041af34f6853acf311095e56a249fa1aa734de8d4ab60
+    initial_ast: d96408f3a72f1005a2b2b2c733e359ad689e83ca9e430fb1e8288d3f5efc16ed
+    imports_resolved_ast: cfc96ab62b32eefeb55827bb3a5a946f1126de04efa9af02d1c6eccc4f25cc7b
+    canonicalized_ast: cfc96ab62b32eefeb55827bb3a5a946f1126de04efa9af02d1c6eccc4f25cc7b
+    type_inferenced_ast: e3f44fac1d36705c8f0238489f25d2cc7c22fb46efcf7d873c4ca355f0fce241

tests/expectations/compiler/compiler/array/type_nested_value_nested_4x3x2.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: c3c30cd2e66f21abef8c49e0ac3d49ed3b607097815c354b14ea9e44d41c0a69
-    imports_resolved_ast: 415d47125939d2d4466c2a940e34039bc6654036793e3828ce266f26e99b68e9
-    canonicalized_ast: 415d47125939d2d4466c2a940e34039bc6654036793e3828ce266f26e99b68e9
-    type_inferenced_ast: 2c78c46fc265667040e64ad396a702947197f4e1b2fc19af9cafddd8d233bdc9
+    initial_ast: 387e2c856efca30f1ea52a6481d28d2f978925011c1a58103934ef8758c15b29
+    imports_resolved_ast: b3d4fda2c9ead6fc787d5d04407ecdd021a8d9a61814d22d3596b729b1f6780d
+    canonicalized_ast: b3d4fda2c9ead6fc787d5d04407ecdd021a8d9a61814d22d3596b729b1f6780d
+    type_inferenced_ast: 8960bd55f1fbbddde0c09f2650a1b41d222d4f6c768a376d38313c11bcaca8a0

tests/expectations/compiler/compiler/array/type_nested_value_tuple_3x2.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 6c062f01a78d515f780a4c13de65d466edda274a2cb519af47a319ed165db0fa
-    imports_resolved_ast: d89c5ba774b429aed589ec52560063cc1576ccdd92014108eb3996bdc8846748
-    canonicalized_ast: 724f20553f461602709c1cd1c0f9c86cd65b7f8281f47ebce221decdaf1d4403
-    type_inferenced_ast: bbda06e9afda5ad60c8e4fe0e8e7c7d513c16027bcd5b6efbc2ce981706aa853
+    initial_ast: 2ec515b2e1af4684f04867c3776d3a2ede82088f235dd167c73a4a7d25049a7a
+    imports_resolved_ast: 473ce693dd459ca9236bbca0be402136853a30983ba911de98a80656c9e62f86
+    canonicalized_ast: 053de86de0c265c040c3b963907136de8f13f6ab7fc7b70e6c2e73a8416e33f5
+    type_inferenced_ast: 1f16ccdd08f3778ea7c59e9f0c45a3ebbd6ff730c90d9cefd4524aead1608014

tests/expectations/compiler/compiler/array/type_nested_value_tuple_4x3x2.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 228ba794b578de8828d761676c15059c51455aff96b02ef3cfafbef53c35454b
-    imports_resolved_ast: 7ab2c61eaf51aac67c90f364162e209adc4fc89da67e3be674941456289cadfe
-    canonicalized_ast: d58af0791643776db1c266ea3f78582922d47a5e31cd39b73910139bff6c4aaa
-    type_inferenced_ast: 38ea7a4cbb6fc2ae4c9671acb4747e5ee3c8b61d17328b18c23b9f4c5dde6466
+    initial_ast: d45442435efc1789905a4b6a6c3f240cb9a16a6fcb24f7974288c1f83599a743
+    imports_resolved_ast: 7afcbb7483b4c3c352c6699ee4f8d0e8ba28478ee06cbb9c05c13a01722f0aae
+    canonicalized_ast: 77fa63a870d7fe7651ce0ba021a5548f2c1ef1ea1ac05d0b744d7743e8ff5e19
+    type_inferenced_ast: a43c2502ca47e608b21da828ec263af3744760839eca43b892f1061875e1ca53

tests/expectations/compiler/compiler/array/type_tuple_value_nested_3x2.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 0ea5856bbe7ad96107544e2b12c7ca54c279c4cd1c8b9610083430600ffa86f9
-    imports_resolved_ast: c409a94fbb07fd687e830270c28acbbab31d39c646f551834968ff34c974236f
-    canonicalized_ast: 55407a1c8968dfc96aa4f5f1b3183b6361a6a95b829855cc955d09ac5f428733
-    type_inferenced_ast: 83f98c57d8cb35f70a4eed0814e72ee490999e858c3b798c86cd9668894b46d9
+    initial_ast: 56b516095e2de8dbb63f27337051e43cd6308efc1b7e1c143d67f5adcb9e80fc
+    imports_resolved_ast: 3352f180e96d9f1b2f0834027fd81a85987b734a388b62890e73f2ea1a3aae55
+    canonicalized_ast: 15a30ee3a3901ab85df72e99258697121e31a8bd34f130ceaba1f54e2041a203
+    type_inferenced_ast: 9de76996172b02087fa0930023082e6e083be0050f09dd075f72bf0be53f2f4f

tests/expectations/compiler/compiler/array/type_tuple_value_nested_4x3x2.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: db7e9050580f794aa657700225126e8033c0241240874f6e35df0507469be247
-    imports_resolved_ast: 5df26baf4758af1c8c4556520ad08f2940269996b74142d1d1d3d35dd8747e40
-    canonicalized_ast: 3767f6efa3939259c0736d50e9924901dafdd2625254c38ad4d300c0a300c886
-    type_inferenced_ast: 93ac6b8b3d53c3c0ea5469c3a13ffe5a72fefe403dee16728453c4f182e04a2d
+    initial_ast: a735ab3be60261a32882277e90f44098db84522a196f81c4d6d1830a8357bed1
+    imports_resolved_ast: 5ab736844e244d67441f6e40287ce4cb1fc8210bc9e07867bbb0535853ae323f
+    canonicalized_ast: 3078f5b7c1af187d845fe8b444ff3b20d64115f7b8009d163ba4b0f6be324ee0
+    type_inferenced_ast: 60fa28ea8be6b18050575f3d3b9df64a083b7b7cbd3fc622af186db89f46dec6

tests/expectations/compiler/compiler/array/type_tuple_value_tuple_3x2.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 2730f954bc76f81d29b02a15f8025d75ca963234716112745b806789bb8eb297
-    imports_resolved_ast: b516a9bd2db8c0d95549a81b4437eccb8f911585c380eaf3e1f4778ffc7d6136
-    canonicalized_ast: 7d507bbe756202e754f5775dbacbc5ea17403ea6b320b341e0d3670edd980c55
-    type_inferenced_ast: 219ac85c47e69d451307b5dbd9735df3880ca3610b656f1ce56b96f77a769292
+    initial_ast: 6fbff5ca6317b5e4c2c28eb424f2c002a276a5fb62596d6fb708493f6ce3fa2e
+    imports_resolved_ast: c446dd0d3d61044d069ba3651086f0435c0a8281fb1880d2e8d55ac69916312e
+    canonicalized_ast: 0a0e955e171a3eb76ee32288a0dee7857483d39a9883dc05c22163de1f8b8c7f
+    type_inferenced_ast: 364cc1a3c026fac256192ec1ab694627beb8f6f20942368e3291c75933ce1286

tests/expectations/compiler/compiler/array/type_tuple_value_tuple_4x3x2.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 445b35e7d287dc14a77b2c1c4c77d9b7b4fbd6e7c31f6f35c91a446eeca29775
-    imports_resolved_ast: 594999cfccea90f0116cf0e231a7019bfd25ea7ff667d2f79ad1c1b510c823e0
-    canonicalized_ast: 76a85bbddcb8c9b32fedbfdd1fe4d69721f4e627fb119aa358c3f18137921f51
-    type_inferenced_ast: 3f188b49692f395400046c319dc1c73a235891a8e8a4bcb93b827a433b7de71c
+    initial_ast: a228caa23c8b0332fd611ce3838376e0e31edabf8ba7c35987eded2745bfa4a3
+    imports_resolved_ast: 7e974859d32ff9004f79dce3c02131c0843ff617fd84ff0ff3ba5f8c8e3e405e
+    canonicalized_ast: 33c55f056fd88e12f8fb57ef9751cbcea99bb1fd02dcce5e564731aeb1156752
+    type_inferenced_ast: c9a3f7cce4c052c73e280b817089b883d1121125e678a8def30a2d8238a81eb2

tests/expectations/compiler/compiler/array_without_size/definition.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: edf8a3b7372af353b99830752d41d8c04d1863a4d03c754f41aac3545649c644
-    imports_resolved_ast: f0dbd5c30713c383c8e0a0cc1661540dcc7d2c8ac6411a6a93bed59b6d6ce546
-    canonicalized_ast: f0dbd5c30713c383c8e0a0cc1661540dcc7d2c8ac6411a6a93bed59b6d6ce546
-    type_inferenced_ast: dd228d9d9fa611408636d6a307fd69cd18e7293a08a611ac2f88883d1b978032
+    initial_ast: 71e25416f4a31045a847f29df48d5e9cce19d0df31c479761f2387eca4bb759f
+    imports_resolved_ast: a408ca2965d8d63856b1f95385746d5be9825b646e7f97a5fd3203638681292c
+    canonicalized_ast: a408ca2965d8d63856b1f95385746d5be9825b646e7f97a5fd3203638681292c
+    type_inferenced_ast: 88e5b982b094f07cc0337812b4965b655c020bdebfa1ad7ac8fd2ddd3c730b8b

tests/expectations/compiler/compiler/array_without_size/function_input.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 5ae730ffb3671acde08944aaa8450a54bb9ce436c92d5c21e7a2a7b9c8d404a7
-    imports_resolved_ast: b0a3019e9e93ae0990bce7ffe2b1e075c0ba4f517aacc42c2bd56ebcb15ee1e3
-    canonicalized_ast: b0a3019e9e93ae0990bce7ffe2b1e075c0ba4f517aacc42c2bd56ebcb15ee1e3
-    type_inferenced_ast: 945eef156080f8d2c99f4f34464861a2376ff7261fb6b393ea7dc2b84f30f328
+    initial_ast: d6d3ebe6a0b7f19e51d245d715706122577777a8325459df7db2c08ee5f841bd
+    imports_resolved_ast: 675c0542777db276ce7a39decb9dc5aacfde6b00ebfeb3982c480ed531a79be5
+    canonicalized_ast: 675c0542777db276ce7a39decb9dc5aacfde6b00ebfeb3982c480ed531a79be5
+    type_inferenced_ast: ae8cbfc3938971fc0e42fa400b1277d288ea4b7d4d8149b452fce81ae4813315

tests/expectations/compiler/compiler/array_without_size/length.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: d8e3de13a7f12866871e4117b7c4cf9872350154b19e82087fe8100adeba1354
-    imports_resolved_ast: 37de52ab186133dccfc290bed3f417685ce9ee5de37c820e0e8e3d2a17804bcc
-    canonicalized_ast: 37de52ab186133dccfc290bed3f417685ce9ee5de37c820e0e8e3d2a17804bcc
-    type_inferenced_ast: 2f1b4e2127a33a02bea52ad28c0e9414268b401e11787bbde761820e8ac804e4
+    initial_ast: be4b4279f79a35306e1edf5086275a2b216e9d46d66b9bb5fbf650062b7cd263
+    imports_resolved_ast: c4aae9410df8034a7744ec5f1998454bacde915ddaadfab42181528f1923f742
+    canonicalized_ast: c4aae9410df8034a7744ec5f1998454bacde915ddaadfab42181528f1923f742
+    type_inferenced_ast: 0f8434f9e0430dc238602c0479a928be87101566dc0e9ae60ab9f4f1339ef313

tests/expectations/compiler/compiler/array_without_size/length_function.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 9886d4d97c894fade697bd99ac9cbe2a56973037837f34884e3dbad4dd4d5d65
-    imports_resolved_ast: afd08cb992e4004c551f936d4a5867bbc0a0c05fbb8997bffd2a082badbf03fc
-    canonicalized_ast: 462f0feb8e304b2644d1bbcf90663a03a9e8c53d9e9ae42836ad57d1f0de3165
-    type_inferenced_ast: 20f7f22df0d2826996233e2e513403f84be65d8db9e9a947df128c377299355c
+    initial_ast: cb9419739db39f806ff96983f53aa085a96238833ed754293042724dd3b29704
+    imports_resolved_ast: 675a67a8dae0a33a273d74ec021df0e23c5ed7cb32faf8efd2d2f087979de039
+    canonicalized_ast: b75d02c7cadbcd2906ad0d7b6376bbdc32ff1f26348913e2b0a84ced7496a2f6
+    type_inferenced_ast: 87ee95068efb0a58e18f2e3b8668db8d2ad9826b21e8b8ce6bc26f60c9fe88ca

tests/expectations/compiler/compiler/array_without_size/type_alias.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 0e8ea2eb2de2ad93883ced129ab7c42674fd476d94ede483f5ea042f8386b730
-    imports_resolved_ast: a86e55392b72b3b309d6223d7304035611b1e397580c16839545579d9a95c9ea
-    canonicalized_ast: f202f6e13729555eed8c48727e7df16f72ba3addd62dff7269814acf297f98a1
-    type_inferenced_ast: bd9592a3af130293e2a71a7dbad84805958d857d41be1b39326b5e12c1f7af81
+    initial_ast: 712ed2b7c1ddf180a39cd1bf83c7a4ca3de909a14f87250ec445ba6ae6aa6597
+    imports_resolved_ast: 36d9e14cf42065047dc21a5c68f45d3264dc0d38eb53355d3f9fef7bd7d512b1
+    canonicalized_ast: f1edababa6847e2ca24a0786bc1a0b2e66f0d60f5b11c59a24c8b1503f893092
+    type_inferenced_ast: c979556f787eb3190b0c4cec3d5a6baabbf64d32f7e3281c784f83262da33205

tests/expectations/compiler/compiler/boolean/and.leo.out

@@ -34,7 +34,7 @@ outputs:
             x:
               type: bool
               value: "true"
-    initial_ast: 2f7c3b9c806a873b6445200eb78a8e0e546ffe64c90fe2133355dd37a342b11b
-    imports_resolved_ast: 8c8039a942ada73357ce62cbf478d1252b4c1b022bdf156a8beb8b1f41898efb
-    canonicalized_ast: 8c8039a942ada73357ce62cbf478d1252b4c1b022bdf156a8beb8b1f41898efb
-    type_inferenced_ast: 460e99eaaaf5de2d28b19a692c455bb12d3540503624aeffe281057fbeddb352
+    initial_ast: 7a4ea96dd5092207c18b972784f4dee261b8fcfcbd6591a8f1376afabe2b09f5
+    imports_resolved_ast: 3529a67adc02429d5a17758c0f895348e44469a434a3af443c382135b89c5169
+    canonicalized_ast: 3529a67adc02429d5a17758c0f895348e44469a434a3af443c382135b89c5169
+    type_inferenced_ast: e5daa67ef6314295794fd13dd5b513abfd692ddf36fe2b4509edf99dc34645f5

tests/expectations/compiler/compiler/boolean/conditional.leo.out

@@ -34,7 +34,7 @@ outputs:
             x:
               type: bool
               value: "true"
-    initial_ast: 5316ba00882aa3f9b538d349ed7141c4ee7c77ec01f6af9911b2652b6cd3e659
-    imports_resolved_ast: 96c21aa198ea648d52822abba76f43248dc5701232c0331bdc88b4e7596f894e
-    canonicalized_ast: 96c21aa198ea648d52822abba76f43248dc5701232c0331bdc88b4e7596f894e
-    type_inferenced_ast: 9869ac26b6eaa9d2f97d910b061dce142d7ca6a51f3defd813987f0138fb5fc1
+    initial_ast: 45a04deb6029e54df7233eadfef5d67f56ca3e757e232f0b27febe8b92a7a037
+    imports_resolved_ast: 6aa3054db501b621e4ee499a42a47431f8da29a2b6dd44a6b0ae16f3303aea48
+    canonicalized_ast: 6aa3054db501b621e4ee499a42a47431f8da29a2b6dd44a6b0ae16f3303aea48
+    type_inferenced_ast: 13c07566232bd3efaf33c3b685cf05ab7d14960347bee22c8ddcbe424e7ed7a3

tests/expectations/compiler/compiler/boolean/equal.leo.out

@@ -34,7 +34,7 @@ outputs:
             x:
               type: bool
               value: "true"
-    initial_ast: 08f026e24cab51634a7a2a6f1f3b082eace1d4be649cd9ff7c244194891d7d78
-    imports_resolved_ast: dac2c874c2a6780c36245c75dc2be130aed8bb563911aaa7d1e30a3a4abd5e01
-    canonicalized_ast: dac2c874c2a6780c36245c75dc2be130aed8bb563911aaa7d1e30a3a4abd5e01
-    type_inferenced_ast: 647de266dbd67a1f2cbf40904422e699066aa033470501c7b0dac0010e943ce5
+    initial_ast: 48ea8376628464c6968c55a725f095f6f5060bf7f66961b8f3ea118758207656
+    imports_resolved_ast: 24e8288d6a7ba36e0f73cb6469d499bd058049047086844c800dfd2cafa68c31
+    canonicalized_ast: 24e8288d6a7ba36e0f73cb6469d499bd058049047086844c800dfd2cafa68c31
+    type_inferenced_ast: 9d2e51bd9b2ea5391e45d5355c11cab2df0d693a99748aad10c62f57063cf19a

tests/expectations/compiler/compiler/boolean/not_equal.leo.out

@@ -34,7 +34,7 @@ outputs:
             x:
               type: bool
               value: "false"
-    initial_ast: 094effa7fe12695679a571f560e1d3e8c299cde8de280f9309010c85f48bab95
-    imports_resolved_ast: 1d9d8399fe44bade2bd762e88a1db5805b26cb47710aea505ca5d33a60daa574
-    canonicalized_ast: 1d9d8399fe44bade2bd762e88a1db5805b26cb47710aea505ca5d33a60daa574
-    type_inferenced_ast: 8438f2a6c2db2f16ec11a4f12d0085039e6cd22e9106d14c25d1bbfe55c1df9e
+    initial_ast: 3d0dc21618d13dfb8087f0927018e473ae7d8e62d834003c14e3d180e07a56df
+    imports_resolved_ast: 3a02fa251d1c4386286e0c46b469e907d30140d80b29405e25fc103e073d6ce7
+    canonicalized_ast: 3a02fa251d1c4386286e0c46b469e907d30140d80b29405e25fc103e073d6ce7
+    type_inferenced_ast: 97132ba7a71063118cf6353b9178b21416ec429e43770f1db5b6a92dc6609236

tests/expectations/compiler/compiler/boolean/or.leo.out

@@ -34,7 +34,7 @@ outputs:
             x:
               type: bool
               value: "true"
-    initial_ast: e2facdce5f7cdbed4a3215cc258e54418aac4f4b846349b35e1da67b577b76c9
-    imports_resolved_ast: c82afe6fc023e46a02cfe669c6d90c6da47e71673b3e60dd40e5e976799865db
-    canonicalized_ast: c82afe6fc023e46a02cfe669c6d90c6da47e71673b3e60dd40e5e976799865db
-    type_inferenced_ast: 1af91788f2e6709d95c35e6719238710b4ae2ed6794f59d565c4bfda31aa23d9
+    initial_ast: e1d9891781a91d415be3fefdc4362bc69317f4bbddd5c51ec1fa817004c07bcd
+    imports_resolved_ast: e64ef7e89a12cdbb7a8d6d5cf4c2fd52157820391f6d1ed0b43f597dc83183e0
+    canonicalized_ast: e64ef7e89a12cdbb7a8d6d5cf4c2fd52157820391f6d1ed0b43f597dc83183e0
+    type_inferenced_ast: 15a9981ccb9dac48ac8a755d1219d21bbfab9ef80b27dfd302209aad151485e1

tests/expectations/compiler/compiler/char/circuit.leo.out

@@ -100,7 +100,7 @@ outputs:
             r:
               type: char
               value: "'\\u{1f62d}'"
-    initial_ast: 0c2aeb5b47fc21f5aded4e3aebcdf55eb98c10c6b51a2a6dcb98490a96da0c97
-    imports_resolved_ast: dc29924de4b1752b8e29691b4e6938d20048c684a8e01e77b760f75b76507747
-    canonicalized_ast: dc29924de4b1752b8e29691b4e6938d20048c684a8e01e77b760f75b76507747
-    type_inferenced_ast: 0db49560694863b30bba8e3243ae034956c397249031215042b1615d99d397b7
+    initial_ast: 6d54475996614c882dede07150d709933ddeb083c5402c8769ff0aff7c7b54d9
+    imports_resolved_ast: 38b9d509420bc3aa9821846a941d8a1cdb590fde66bfc772064eaf4ed4466871
+    canonicalized_ast: 38b9d509420bc3aa9821846a941d8a1cdb590fde66bfc772064eaf4ed4466871
+    type_inferenced_ast: de40aa8bab9a6ba15b524012a08066695da1838dc50b5e9e870b1ad526225d93

tests/expectations/compiler/compiler/char/neq.leo.out

@@ -100,7 +100,7 @@ outputs:
             r:
               type: char
               value: "'a'"
-    initial_ast: ac56e34b2a2cb282d36133df39d80947dfdfc56b5655b3ba9f408ba529c8f505
-    imports_resolved_ast: 11a4df3cb6ce54c7ee28b94b4e0a728b7a4895c8907b1a168e4ec726b316f093
-    canonicalized_ast: 11a4df3cb6ce54c7ee28b94b4e0a728b7a4895c8907b1a168e4ec726b316f093
-    type_inferenced_ast: 5b4c5ecb456864365fb66a730386b7dd6fc25427a1aaea5fb8c7017ede56bc32
+    initial_ast: deb875863472b0fa65f002c75732e5e6d87de3641bf799c13eeaa32bbba70705
+    imports_resolved_ast: 19812cd50a6682613586cb11447a29295ef315639b6b536dc61e3bbce277c9f4
+    canonicalized_ast: 19812cd50a6682613586cb11447a29295ef315639b6b536dc61e3bbce277c9f4
+    type_inferenced_ast: 7c35aca042bba8f50725a7a7295bdd99a6e630d0e8c366a33f9a425f235b488f

tests/expectations/compiler/compiler/char/nonprinting.leo.out

@@ -19,7 +19,7 @@ outputs:
             r1:
               type: bool
               value: "true"
-    initial_ast: da8550065db88bba8f0a982612194f6122ec97025c4af5d3007d3a4d42519cb9
-    imports_resolved_ast: fde01d86d58dfcbddd1ab58393dfd3ce4af3df4160b7d2971e983141dee607c5
-    canonicalized_ast: fde01d86d58dfcbddd1ab58393dfd3ce4af3df4160b7d2971e983141dee607c5
-    type_inferenced_ast: f63a99ba7e7a5d37f93aeadfd01d62be4f4eaffad986054093922499b0c9f062
+    initial_ast: a5cb2155289ad9dfbdd51386f09c8522fa50c05e06752b71bc4b486e28d08143
+    imports_resolved_ast: 2784bed86c0b933878e44e9bcba16da2e26a7eebda81f32efb134f824a8d25af
+    canonicalized_ast: 2784bed86c0b933878e44e9bcba16da2e26a7eebda81f32efb134f824a8d25af
+    type_inferenced_ast: 1fd6e1317a070ec77e9d9f43ee0b0264935b016aa015d0cff36ed49f88cab83d

tests/expectations/compiler/compiler/char/out.leo.out

@@ -100,7 +100,7 @@ outputs:
             r:
               type: char
               value: "'\\u{1f62d}'"
-    initial_ast: 6e1cf86d47e056682c6e51dcf0390eb34505b60d50de60970a688f237525bedf
-    imports_resolved_ast: e9012d76c33c37f3940fbc8f9d8fe83cb13d8b7bdaa5b8476180128f91132c71
-    canonicalized_ast: e9012d76c33c37f3940fbc8f9d8fe83cb13d8b7bdaa5b8476180128f91132c71
-    type_inferenced_ast: b19acb9ba2e6e5949839b5fe3d15f52f7187cadbb0602e44b03215f4181a6997
+    initial_ast: b52f25912734ca1e8a869c6a70c526b5253b499e006b753ae7805c50d9b7239d
+    imports_resolved_ast: ccacbba2e0f2cc150247369ab83931ba8bbd1c86404747aa582f95172b73e39d
+    canonicalized_ast: ccacbba2e0f2cc150247369ab83931ba8bbd1c86404747aa582f95172b73e39d
+    type_inferenced_ast: 941b0229280fb4db43b93db05c87955027e8e977cbd24f0b3e5e45dfe8f4d1cd

tests/expectations/compiler/compiler/circuits/big_self_in_circuit_replacement.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: ec52d3b3e69bef6d104f2dcfa9e713a728d7b0e15439c9da3b521b6cbfe719d4
-    imports_resolved_ast: add95914a89cb2686db8c906b94acca8e7dfcad9db26ad83a75c327e0eb19ca0
-    canonicalized_ast: 21d2efd19f936682f161dcdf804c30d745f47201a5702de7ceecf81544291561
-    type_inferenced_ast: 0814bcdc1e7422f32192c44a7b4a12b0d4b9f2e5ef612521c73800fc3e27dfcb
+    initial_ast: d54a742afad532434f6f8ea32792c30a1c0332a667ec014b4dcd484121373e00
+    imports_resolved_ast: bdf55aee686c0162951a0778a0a621abe4adb03da7dbc099ad3a191bbab50d16
+    canonicalized_ast: 137f5314bda5eacc917a0b60794ca9aa21bb0ae920914276517273aa2b6b35fb
+    type_inferenced_ast: f796547040b1bb7fb7acb900b46779b9fc79edf25488094daafeca217019feea

tests/expectations/compiler/compiler/circuits/const_self_variable.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 50c0f7261d879373f4e01ec3d140a2067ca4e78622c8340e8312d717f6effb05
-    imports_resolved_ast: d2bdb4665f5a49124335ba3f3fb39d8dc5a6f4d08d53e84fec635cd27d5eb582
-    canonicalized_ast: d2bdb4665f5a49124335ba3f3fb39d8dc5a6f4d08d53e84fec635cd27d5eb582
-    type_inferenced_ast: edbc4ba37f4a02c487f70b4a0d245154848e54336213420d5ddd2c1f8b966029
+    initial_ast: 0f64e374ac4358d10c551de252c251eaea5b53d798d8de01d910ac04acd40439
+    imports_resolved_ast: caec78b5a182514fd4201dc675667e9b5fbbdc16976af798456581d45d87e19d
+    canonicalized_ast: caec78b5a182514fd4201dc675667e9b5fbbdc16976af798456581d45d87e19d
+    type_inferenced_ast: c4baa319b4d5aaba394c60c030231ddfc96e8f26f2c04de70fa733ded309b614

tests/expectations/compiler/compiler/circuits/define_circuit_inside_circuit_function.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: bfd7751e8ea64c6d41af36d968f194a18a5411ac71932a67766f40448ce755f5
-    imports_resolved_ast: 58a6b067cffc10de35b10a84f7e200fe836890c758174c8126cc4a20417a4c24
-    canonicalized_ast: 58a6b067cffc10de35b10a84f7e200fe836890c758174c8126cc4a20417a4c24
-    type_inferenced_ast: 7b55011299b213dd63dae23315ad0029c6057c46a2ad53f30b28fbdfb5b72934
+    initial_ast: 45a844a9b26d8b2782358c67c3663556c795b43c7ecf8584d0a943421a171c19
+    imports_resolved_ast: b605c15b7bf75061f65216499ca66aa8f5325f42884dfa565985c52e6bbc7096
+    canonicalized_ast: b605c15b7bf75061f65216499ca66aa8f5325f42884dfa565985c52e6bbc7096
+    type_inferenced_ast: 345bf62660bf975e3dc6fc8a4b7e407f0cfcb0bcd7bed74b9da88841396c077a

tests/expectations/compiler/compiler/circuits/duplicate_name_context.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: d8a66347f480161a2215c92d2cf6ded2d0b49fd76b7eb0036d4fa33de371925a
-    imports_resolved_ast: 23ab7ce1f8ade033ad2c0e0a488e3da059795059ffd85bff240436502baff064
-    canonicalized_ast: 23ab7ce1f8ade033ad2c0e0a488e3da059795059ffd85bff240436502baff064
-    type_inferenced_ast: f33e938ad318bd26d2249c7aff5880fd78bb95b3cb8b335a8483830a1be47d4e
+    initial_ast: d69fc19f1ec9b2c3557679875b1cfcf6d73d1f9cb71f58bc3a8db2f4c8ab9d6f
+    imports_resolved_ast: 04f66e06d213c6e3625428b0bad06a8ce1ce8d8359595531f57852e355a18bdc
+    canonicalized_ast: 04f66e06d213c6e3625428b0bad06a8ce1ce8d8359595531f57852e355a18bdc
+    type_inferenced_ast: 8e6c46b9133f7e167f4d3a7961c059c5a5b5423360b23e588723becd617e642d

tests/expectations/compiler/compiler/circuits/inline.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: u32
               value: "100"
-    initial_ast: c40a1d60f872fdb03ab7379a3abf43439a100b8f1546b76ffeac60c8739e0d68
-    imports_resolved_ast: f8c489b07e7dc45c8d42f959cdae47a61101e5fc6110f378af0a34fe41b1777e
-    canonicalized_ast: f8c489b07e7dc45c8d42f959cdae47a61101e5fc6110f378af0a34fe41b1777e
-    type_inferenced_ast: 87619e2e5d2e6a22ed58c5d7938062a074faef5e6bc1ee60036a8050e3271c2f
+    initial_ast: 21a7b1783ce57fa10ef12d6e2bc6afda0b42fcb66cf302ddd413d1540710726d
+    imports_resolved_ast: c91612733b1587c65cbd50a8bc00e0ec260c0235cd22be47d3ee2f8b82683aff
+    canonicalized_ast: c91612733b1587c65cbd50a8bc00e0ec260c0235cd22be47d3ee2f8b82683aff
+    type_inferenced_ast: 196c69c1be9f51170c54831dfdbd49294fbad2f79f0f66ad416ee59e0a2255c9

tests/expectations/compiler/compiler/circuits/inline_member_pass.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: cf642f2f983cd8bcd6cbca2d2920f5234d79375601c1da3c06f97b6185a5629d
-    imports_resolved_ast: ec5c0b1e01e74181406efc8a2b698933726e13e92c87e0fac7dcb28901ed9565
-    canonicalized_ast: b9cf563cea162726122f7d2f7f264dace0c2d6a75e58c13e745fd849404da067
-    type_inferenced_ast: 2e83ce8e0fc851ff003c9e2756c0e0d83364b506e87e2189df473c306814eea8
+    initial_ast: 034a8e1e760970d56d4d57c6dcc0d4435bba69c6887313ed6c46deb3f6843fcd
+    imports_resolved_ast: 37331fa983d6c23166dcba06c01edc69ebc6f88709c8ecad872d5f86b089aece
+    canonicalized_ast: b5842b717f3cb5ad178d95e49b392a37bc4d564ad5aced3c05c0f28e6894c936
+    type_inferenced_ast: 5e3dfcad34d671c541e41fcece2ed1b9ae0cc63398f6738dbbbb8affd5e4a40e

tests/expectations/compiler/compiler/circuits/member_function.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 5273a592b167cfe040b2bca7337521084d7a6640651bca584545e9eeb2e4fa88
-    imports_resolved_ast: 2b5126eef050bdfdb68da8587756219441517fcd1c704c8f9d1ea102392b1580
-    canonicalized_ast: 2b5126eef050bdfdb68da8587756219441517fcd1c704c8f9d1ea102392b1580
-    type_inferenced_ast: 4a42f661d6de987682e28824a97d3989ddd5444d51620d77bc6637abd876c425
+    initial_ast: 480367c3aa94f00e96d4752b28c22e56f8e45557d46dd8f691bbda3ea8108e17
+    imports_resolved_ast: c41fd7e7a3db044f50bf52e816af20676ece9b38ca261a5cb2530d83981a528b
+    canonicalized_ast: c41fd7e7a3db044f50bf52e816af20676ece9b38ca261a5cb2530d83981a528b
+    type_inferenced_ast: 9093fe8030024f2784dfd0bdb7e70109a7bf5b3a69084448027743bd4cf951da

tests/expectations/compiler/compiler/circuits/member_function_nested.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 241f1a42877b012b2e2062cefbd83523a5c719557cb422cf1fbd7efb0f7b1796
-    imports_resolved_ast: 43cca11f696228d0707095273602f51aab997eb3f85309f731d0af3a69bdeb47
-    canonicalized_ast: 43cca11f696228d0707095273602f51aab997eb3f85309f731d0af3a69bdeb47
-    type_inferenced_ast: a81ca1868d802d53a7a541bca7a021ad233d58a2d2ec9ad197ff2f2bcdde8495
+    initial_ast: 5ca688999f1e49e8adcad30a5d4817bba092487e92a162a9fb3c442b2cdd8dcf
+    imports_resolved_ast: 7f24fff92ab1c2428144a5288b35acfb0c9c972fd1b67109739cf3d0596b6920
+    canonicalized_ast: 7f24fff92ab1c2428144a5288b35acfb0c9c972fd1b67109739cf3d0596b6920
+    type_inferenced_ast: f966b81f83b535238074569214924631d7d4da7e81e5c8ce891969c483a0a9fe

tests/expectations/compiler/compiler/circuits/member_static_function.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 11dfbfa2561534a1c965d8f8862b23ed56be50986903c139b763f88a1ba3ad8d
-    imports_resolved_ast: e0a8c32b321be274b67e4ec4897857d614924a6cc4a52c30b7d8d7ff848871d3
-    canonicalized_ast: e0a8c32b321be274b67e4ec4897857d614924a6cc4a52c30b7d8d7ff848871d3
-    type_inferenced_ast: 72b7a987240d2efac67d0d0972f685ddfda6d123035455873cc5d9f1818557b6
+    initial_ast: daf4686b1ac7b315b705c79987a0ab3eda577e6cdb172ac784131718a2a43dd2
+    imports_resolved_ast: 8e393398211b4b71a6039f02b39a21e5fc58d5723e531e62547a97de9384b5f6
+    canonicalized_ast: 8e393398211b4b71a6039f02b39a21e5fc58d5723e531e62547a97de9384b5f6
+    type_inferenced_ast: 22c9cc308bf034f36cd6ecec36584e38ad355806d9d370daeee3624910322af8

tests/expectations/compiler/compiler/circuits/member_static_function_nested.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 42f603efbf7ee8ca53394266f33fbf09110420c822385179d656861e8ceb4a32
-    imports_resolved_ast: 5d6286f1296a269e2b39ec7e6a73257317eb6ce37bb11bce26f34b7f7fba3501
-    canonicalized_ast: ddea7b51d7e218ff02e44be3737128309dabc76d54838db4967a89e901241899
-    type_inferenced_ast: 5c828c5b2324057bd9543a6fafa47f8752cbd33bebf6b5fc186ed121580d791b
+    initial_ast: aafcb8142f94022186f1f6be5a6cc493193e01ee3da1c5c3254fb590e2eda392
+    imports_resolved_ast: 9a627a8c59945f401da0bb4becf5fe8ec8859c473c0bca84fb74a26b2f4cca4b
+    canonicalized_ast: 8610225b3223b6882f717b9cc51252d6648451c43923fe87c0e507f8cf564188
+    type_inferenced_ast: cd510ec07430eb22b1fc5d34c20f6ad780f700561468b503a2aabdf357390a21

tests/expectations/compiler/compiler/circuits/member_variable.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: cf41b78f9435c6555014db8aeebe662556f4f8547ee0f3a204d6f522fcf72644
-    imports_resolved_ast: 82740cfa7a3416a2d5fc9696afe5e9dd2f3e3732d6db958bc47c4be7cb394155
-    canonicalized_ast: 82740cfa7a3416a2d5fc9696afe5e9dd2f3e3732d6db958bc47c4be7cb394155
-    type_inferenced_ast: 35d4a95f99eb210c60830a0d5127d1824d9478ff97efb0d9d60c5fce6706d83f
+    initial_ast: f0fc8349ff7e9b9b130deaaff5510a71f906ad1a53e59b765a098f583f625b2f
+    imports_resolved_ast: 641b6c849d163f6e5d3d5b6657957dcf7652069a2a8f2c1a022d3b4b1f20ca6f
+    canonicalized_ast: 641b6c849d163f6e5d3d5b6657957dcf7652069a2a8f2c1a022d3b4b1f20ca6f
+    type_inferenced_ast: d4bc6a09938328cea2a0f4d92c6f2e1d07364cd024a112da0401a2538f50992d

tests/expectations/compiler/compiler/circuits/member_variable_and_function.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 622baae85ab7776fc38cff17465e8e0dbcdb98f4ba74e734ca494b696cea8ccd
-    imports_resolved_ast: b2b508a4e43faece4959c9f56458ec764fbf80a383f7340745b08c15db9454a8
-    canonicalized_ast: b2b508a4e43faece4959c9f56458ec764fbf80a383f7340745b08c15db9454a8
-    type_inferenced_ast: 0bb06a7a79b64426e12f01c7a5c018fa3e91379e710e2a1e54a466d8a73c4084
+    initial_ast: 30001beeffc01eaff9482bb2a6017b7867d9f64ce83e75af0877ab476e46ac60
+    imports_resolved_ast: 369f63e6ac79b01d97f7f63bffe7b8d78f4cde5add985bb1948a83c5d407ac46
+    canonicalized_ast: 369f63e6ac79b01d97f7f63bffe7b8d78f4cde5add985bb1948a83c5d407ac46
+    type_inferenced_ast: 12c2a16b14c320d11edaaa0779342ed6fdc69618e12116eb9d8a76485689bdd3

tests/expectations/compiler/compiler/circuits/mut_self_variable.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: ba91ea172a2f753bf4a338f29fff05c358d4dc0cb1c2ef461d492ee4fe2a1114
-    imports_resolved_ast: ba3070ce50c6368eccce09d73e5b620fb5965ab6cf2eacce7e782fde736eeb7d
-    canonicalized_ast: 811051cb22f10bf812ac89da97818c36d24519344212ca3f747e49b2b25b4954
-    type_inferenced_ast: e161e0325e6db8ff251d1e22a3b184edf5597583db55582f533c4e5eb4560cb9
+    initial_ast: 2ee3b10e7f7596cb3ef245847e715e8bc4c3ae50206ec7c74e0cb75d6fd4cb72
+    imports_resolved_ast: ba47b7af77dd466754580b447672acf835128752474ac7931dd763d18bd7ad64
+    canonicalized_ast: 9df1e70a47824cb654a22c2f3a855b268d78e6a27f2e97aec9766e77aed369e7
+    type_inferenced_ast: 92b0ca262c4e8fc85e2bf28685c57d1f8fe3e8025c79bc99bc1eb6ffa58afc5b

tests/expectations/compiler/compiler/circuits/mut_self_variable_branch.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: fe7ca41c29d33107a4316b9c6788898217129937cbf1de0f2ea7566a360245f0
-    imports_resolved_ast: d7c50f1b961521f50900e6d406c2184eaf8ef31f0c3bd782318755eb5f7e1f94
-    canonicalized_ast: c40ea46fab334f0b0185fcb14e19e34ea1bbe2d32e1a85724141c69da9e6186f
-    type_inferenced_ast: 9197e7a7747071ecb5e484ef5fa4b0fb8f3fe0be3883a8386d4cfb50ef965f6b
+    initial_ast: 5b089797e2e74cf5d05b8f0b8f09d0f125dc554136b3ac350e2bd259effb68f2
+    imports_resolved_ast: 32de1f6f894e0a17019b4a49393251cf33d42928e9fcfa845d02877535d96349
+    canonicalized_ast: 6dd6756500618d45000ef5e1758629ad0ed63b812dab4e0d026139f8f6235dfc
+    type_inferenced_ast: de35c0782fa4a81650001f7a09fbb1fc711d9f52a7bc2e96d98977e102e4c58b

tests/expectations/compiler/compiler/circuits/mut_self_variable_conditional.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 659e5fcdd16752c6e3504f821a5afd6f0756bd6b8641f127ba049c2a4c83a088
-    imports_resolved_ast: b4abfbb0da91692077c71aea0c432315e28dfc304640cabb2ca1b57054801a1b
-    canonicalized_ast: 466ce72aa3d2268ea98766b74302379015127a406e72526fb7bb7602406ab98f
-    type_inferenced_ast: 9a2a017cd8014367a8f6bdd786bf1b7cdfa937d2565da17c81fb24183676396b
+    initial_ast: 61ed31f158bb011ee836212f80b9acfdae08b794a246a73eed193fd424b50aba
+    imports_resolved_ast: c35a89e0acd5640e5639e036658261a73a1d7d1daf4fe08f76970d2ccb76ebe2
+    canonicalized_ast: a4c457e7c3763fa4aa681655438bc8414ccb90f58329f93a0730cbd507816f06
+    type_inferenced_ast: f512cb55428741c5652dea3cfc28ea87b09eac8dd5eda6755e37d6bd59d537ca

tests/expectations/compiler/compiler/circuits/mut_variable.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 8c4a98dec3d2e9e826e3419c91a251e821861a146325b025c52ff15b5edefe1c
-    imports_resolved_ast: 371665605b41146e53ee801468ab487152e021c574689b256da4ffe19967855e
-    canonicalized_ast: 371665605b41146e53ee801468ab487152e021c574689b256da4ffe19967855e
-    type_inferenced_ast: f959704a73dfbf9b2c868bd91e0ee6f842b9308fa56fdeb3054ed0a3c26d4aee
+    initial_ast: 423ebfc8aa099dd0ac218464c2ab16be3ef249bfe50c81c49e9e0d4c14eee4e5
+    imports_resolved_ast: f72b3680bf9a5ddb26f82d13c4bae220370ff9843af7fdac38fe8f24932f17ed
+    canonicalized_ast: f72b3680bf9a5ddb26f82d13c4bae220370ff9843af7fdac38fe8f24932f17ed
+    type_inferenced_ast: a36a2a66a92dfc53b80460e9d869c990bfad7809bf3707731dbdb739c86fbc6c

tests/expectations/compiler/compiler/circuits/mutable_call_immutable_context.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 842ec0aa120289fc341e19deefa59c7f78af032b1221b749323e0e4b6ce9023d
-    imports_resolved_ast: 86958433b9d8629c9d5ab9ad5e5ef4eaaa9f0e35f0b779ccc60a62d9c4058960
-    canonicalized_ast: 566d34adc815e5adfb60459e7d69f04710d001c62106400e1d17e432532be449
-    type_inferenced_ast: 42fb7a9584623b7ac24a109b023bc6e507bcedcf18e272691e8219d23ec44a00
+    initial_ast: 0c47d2db8962674e0f14a04e113cd36c626c83b8d6f74f8700f41279ec75eaa0
+    imports_resolved_ast: f24d0ff92ed24d8af38da56bed1c825cfdfa5db22f24bd36d03fca6f13553807
+    canonicalized_ast: 23f1d206faa7ab510a470d72abef629efecb64f69821f9e70347f7099466116d
+    type_inferenced_ast: 37cc19ffbdea2f8945eaa380ef54dcfff80a10e424cf9e16159880fa40f77fcd

tests/expectations/compiler/compiler/circuits/pedersen_mock.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: c341e62f8a3940ddc9527bcd01c814f8d496a1f02ca903b080b6228d155af02b
-    imports_resolved_ast: a1782c121612ce35b13c9993d0dbe676e48af5ab4da48d9ec044fd24348e18ce
-    canonicalized_ast: 72b1da9e76745a53e5a91bddce8df1e014fd0b88d295eb9ab7f5b749a44db358
-    type_inferenced_ast: 82d4375347e241b94f38215a193d37fc5f1d6dc9e231281516b05e60d076561f
+    initial_ast: feb613e87fc57af20d1f190142c0e8a69172763b8cf59bde0182e0c336391ad2
+    imports_resolved_ast: 23897a4ad8dfc47e1ca465dcfe26b66a450d2c885463136c4ef38476c7e43cd2
+    canonicalized_ast: d42cf96da20debb01835b8b0866c65ebb069b3a5488d5e84854476523c54dad3
+    type_inferenced_ast: c8e85ac19397ef9193cba09df3b0146e9ac34b6fce5b2de6a91d7902bdeffda4

tests/expectations/compiler/compiler/circuits/return_self_type_array.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 5da09287f1d3a5e4ab57f8da2c8094df25c3b35614791e2f6e84a77b609f29b0
-    imports_resolved_ast: df18a0cb9640cbb173338d9bb1a626a167218dfdfc16aa92a8d2a2a294f8d4a8
-    canonicalized_ast: 2826257744d2a43f5b002ef71e966afca147e383e521a85099c0555568a66ea4
-    type_inferenced_ast: d211e29cc13bfdb4bb748c761c4325fc3900cbcae44c63f779e80cc1d0d4ec4e
+    initial_ast: 1fd36707f7a3f2ec29a27de366205082aa2d20db02986194a2a17be782e58bef
+    imports_resolved_ast: 02a8e75bd719ef63b2319db90ad57f7c730b6acb4af477c7f347a6b2c6f49c70
+    canonicalized_ast: b88d8a81a9d9a431312e4ea3fb40a0995ae398444fd591060c121b3ad25e8d8b
+    type_inferenced_ast: c2633c2a51969d7c4c6aff061c5c0cc3fa136a73b1243f24bd633243be523c9d

tests/expectations/compiler/compiler/circuits/return_self_type_tuple.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: 1dce719e850f6ca6a091fea163d5d6bb069bcdafeeed0a10fb332ba8837e6e5c
-    imports_resolved_ast: 4e65ed61dec957f1b1bd1dd837b066f81462f9ef10eba7070666486041f1ba60
-    canonicalized_ast: 9be723e8689baa1dd1d80cb61fc493ff914b770d063a3adbaef0989ea4696b19
-    type_inferenced_ast: e658ac6c991950a742586fb5d7f5d0bc1e56449282cbe58ce4f9e3627b11d69c
+    initial_ast: e6ca0071804abebda9d404fd9a37e405fa907dd65cb6fe4e048b247987bac1cb
+    imports_resolved_ast: 98853f9a5c136d2222b759f80d15dd8cfa0917fc633be08fe5f9be41a19575c7
+    canonicalized_ast: f05455b2183fc50be83eb6dbff17350f01a2fa87643e6ea3ea31b14fa768593d
+    type_inferenced_ast: df0baf94bb84b776c03ea4f12d4c506094b17a306df234b0713b5b66f2ce69e6

tests/expectations/compiler/compiler/circuits/self_member.leo.out

@@ -16,7 +16,7 @@ outputs:
             r0:
               type: bool
               value: "true"
-    initial_ast: c2f6d0da67de691b14cffbdbe20eba613f2ea274c45aba4347045da2446b6af6
-    imports_resolved_ast: 66b9ad8e1ad5ef5fd0911f2a560d6c9280fa3dc639063046897350d73796823f
-    canonicalized_ast: 66b9ad8e1ad5ef5fd0911f2a560d6c9280fa3dc639063046897350d73796823f
-    type_inferenced_ast: a3054f521ff5efaf53f4b3633ab9926cd286095c1a3e06600d4a4a1326a0bb82
+    initial_ast: c786e0ed2689bc5d950921cb43b2a4689fa93d7ce0f55230be5367cc07ab53f6
+    imports_resolved_ast: 97c5d4d4257324c4b1afc631c40249b97c197dc21c569ef51100d45bc8682475
+    canonicalized_ast: 97c5d4d4257324c4b1afc631c40249b97c197dc21c569ef51100d45bc8682475
+    type_inferenced_ast: 883bd404f9511dfb4c32f26a8cb3f19b5a29f9032e5f3f683c9f74ee8c9ea478