Merge branch 'master' into feature-cli-coverage

.circleci/config.yml

@@ -158,6 +158,19 @@ jobs:
             export LEO=/home/circleci/project/project/bin/leo
             ./project/.circleci/leo-add-remove.sh
 
+  leo-check-constraints:
+    docker:
+      - image: cimg/rust:1.50.0
+    resource_class: xlarge
+    steps:
+      - attach_workspace:
+          at: /home/circleci/project/
+      - run:
+          name: leo check constraints for Pedersen Hash
+          command: |
+            export LEO=/home/circleci/project/project/bin/leo
+            ./project/.circleci/leo-check-constraints.sh
+
   leo-login-logout:
     docker:
       - image: cimg/rust:1.51.0
@@ -171,18 +184,18 @@ jobs:
             export LEO=/home/circleci/project/project/bin/leo
             ./project/.circleci/leo-login-logout.sh
 
-#  leo-clone:
-#    docker:
-#      - image: cimg/rust:1.51.0
-#    resource_class: xlarge
-#    steps:
-#      - attach_workspace:
-#          at: /home/circleci/project/
-#      - run:
-#          name: leo clone
-#          command: |
-#            export LEO=/home/circleci/project/project/bin/leo
-#            ./project/.circleci/leo-clone.sh
+  leo-clone:
+    docker:
+      - image: cimg/rust:1.51.0
+    resource_class: xlarge
+    steps:
+      - attach_workspace:
+          at: /home/circleci/project/
+      - run:
+          name: leo clone
+          command: |
+            export LEO=/home/circleci/project/project/bin/leo
+            ./project/.circleci/leo-clone.sh
 
   leo-publish:
     docker:
@@ -219,12 +232,15 @@ workflows:
       - leo-add-remove:
           requires:
             - leo-executable
+      - leo-check-constraints:
+          requires:
+            - leo-executable
       - leo-login-logout:
           requires:
             - leo-executable
-#      - leo-clone:
-#          requires:
-#            - leo-executable
+      - leo-clone:
+          requires:
+            - leo-executable
       - leo-publish:
           requires:
             - leo-executable

.circleci/leo-check-constraints.sh

@@ -0,0 +1,16 @@
+# leo new hello-world
+
+cd ./project/examples/pedersen-hash
+
+export PEDERSEN_HASH_CONSTRAINTS=1539;
+
+# line that we're searching for is:
+# `Build Number of constraints - 1539`
+export ACTUAL_CONSTRAINTS=$($LEO build | grep constraints | awk '{print $NF}')
+
+# if else expression with only else block
+[[ PEDERSEN_HASH_CONSTRAINTS -eq ACTUAL_CONSTRAINTS ]] || { 
+    echo >&2 "Number of constraints for Pedersen Hash is not $PEDERSEN_HASH_CONSTRAINTS"; 
+    echo >&2 "Real number of constraints is $ACTUAL_CONSTRAINTS";
+    exit 1; 
+}

Cargo.lock

@@ -1716,6 +1716,7 @@ dependencies = [
  "snarkvm-r1cs",
  "snarkvm-utilities",
  "tempfile",
+ "tendril",
  "thiserror",
  "tracing",
 ]
@@ -1811,6 +1812,7 @@ dependencies = [
  "indexmap",
  "lazy_static",
  "leo-ast",
+ "leo-test-framework",
  "serde",
  "serde_json",
  "serde_yaml",
@@ -1850,6 +1852,15 @@ dependencies = [
  "snarkvm-r1cs",
 ]
 
+[[package]]
+name = "leo-test-framework"
+version = "1.4.0"
+dependencies = [
+ "serde",
+ "serde_json",
+ "serde_yaml",
+]
+
 [[package]]
 name = "lexical-core"
 version = "0.7.5"
@@ -4165,9 +4176,9 @@ dependencies = [
 
 [[package]]
 name = "zip"
-version = "0.5.10"
+version = "0.5.12"
 source = "registry+https://github.com/rust-lang/crates.io-index"
-checksum = "5a8977234acab718eb2820494b2f96cbb16004c19dddf88b7445b27381450997"
+checksum = "9c83dc9b784d252127720168abd71ea82bf8c3d96b17dc565b5e2a02854f2b27"
 dependencies = [
  "byteorder",
  "bzip2",

Cargo.toml

@@ -37,7 +37,8 @@ members = [
   "package",
   "parser",
   "state",
-  "synthesizer"
+  "synthesizer",
+  "test-framework"
 ]
 
 [dependencies.leo-ast]

ast/src/errors/canonicalization.rs

@@ -14,7 +14,7 @@
 // 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::{FormattedError, Span};
+use crate::{FormattedError, LeoError, Span};
 
 #[derive(Debug, Error)]
 pub enum CanonicalizeError {
@@ -22,6 +22,8 @@ pub enum CanonicalizeError {
     Error(#[from] FormattedError),
 }
 
+impl LeoError for CanonicalizeError {}
+
 impl CanonicalizeError {
     fn new_from_span(message: String, span: &Span) -> Self {
         CanonicalizeError::Error(FormattedError::new_from_span(message, span))

ast/src/errors/combiner.rs

@@ -0,0 +1,43 @@
+// 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::{FormattedError, LeoError, Span};
+
+#[derive(Debug, Error)]
+pub enum CombinerError {
+    #[error("{}", _0)]
+    Error(#[from] FormattedError),
+}
+
+impl LeoError for CombinerError {}
+
+impl CombinerError {
+    fn new_from_span(message: String, span: &Span) -> Self {
+        CombinerError::Error(FormattedError::new_from_span(message, span))
+    }
+
+    pub fn asg_statement_not_block(span: &Span) -> Self {
+        let message = "AstStatement should be be a block".to_string();
+
+        Self::new_from_span(message, span)
+    }
+
+    pub fn illegal_compound_array_range(span: &Span) -> Self {
+        let message = "Illegal compound assignement with array range".to_string();
+
+        Self::new_from_span(message, span)
+    }
+}

ast/src/errors/mod.rs

@@ -14,7 +14,16 @@
 // 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/>.
 
+pub mod canonicalization;
+pub use canonicalization::*;
+
+pub mod combiner;
+pub use combiner::*;
+
 pub mod error;
 pub use error::*;
 
+pub mod reducer;
+pub use reducer::*;
+
 pub trait LeoError {}

ast/src/errors/reducer.rs

@@ -0,0 +1,43 @@
+// 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::{CanonicalizeError, CombinerError, FormattedError, LeoError, Span};
+
+#[derive(Debug, Error)]
+pub enum ReducerError {
+    #[error("{}", _0)]
+    Error(#[from] FormattedError),
+
+    #[error("{}", _0)]
+    CanonicalizeError(#[from] CanonicalizeError),
+
+    #[error("{}", _0)]
+    CombinerError(#[from] CombinerError),
+}
+
+impl LeoError for ReducerError {}
+
+impl ReducerError {
+    fn new_from_span(message: String, span: &Span) -> Self {
+        ReducerError::Error(FormattedError::new_from_span(message, span))
+    }
+
+    pub fn impossible_console_assert_call(span: &Span) -> Self {
+        let message = "Console::Assert cannot be matched here, its handled in another case.".to_string();
+
+        Self::new_from_span(message, span)
+    }
+}

ast/src/lib.rs

@@ -71,7 +71,7 @@ pub use node::*;
 /// These data types form a tree that begins from a [`Program`] type root.
 ///
 /// A new [`Ast`] can be created from a [`Grammar`] generated by the pest parser in the `grammar` module.
-#[derive(Debug, Eq, PartialEq)]
+#[derive(Clone, Debug, Eq, PartialEq)]
 pub struct Ast {
     ast: Program,
 }
@@ -83,7 +83,7 @@ impl Ast {
     }
 
     /// Mutates the program ast by preforming canonicalization on it.
-    pub fn canonicalize(&mut self) -> Result<(), CanonicalizeError> {
+    pub fn canonicalize(&mut self) -> Result<(), ReducerError> {
         self.ast = ReconstructingDirector::new(Canonicalizer::default()).reduce_program(self.as_repr())?;
         Ok(())
     }

ast/src/reducer/canonicalization.rs

@@ -25,11 +25,78 @@ use crate::*;
 pub struct Canonicalizer {
     // If we are in a circuit keep track of the circuit name.
     circuit_name: Option<Identifier>,
+    in_circuit: bool,
+}
+
+impl Default for Canonicalizer {
+    fn default() -> Self {
+        Self {
+            circuit_name: None,
+            in_circuit: false,
+        }
+    }
 }
 
 impl Canonicalizer {
-    pub fn default() -> Self {
-        Self { circuit_name: None }
+    pub fn canonicalize_accesses(
+        &mut self,
+        start: Expression,
+        accesses: &[AssigneeAccess],
+        span: &Span,
+    ) -> Result<Box<Expression>, ReducerError> {
+        let mut left = Box::new(start);
+
+        for access in accesses.iter() {
+            match self.canonicalize_assignee_access(&access) {
+                AssigneeAccess::ArrayIndex(index) => {
+                    left = Box::new(Expression::ArrayAccess(ArrayAccessExpression {
+                        array: left,
+                        index: Box::new(index),
+                        span: span.clone(),
+                    }));
+                }
+                AssigneeAccess::Tuple(positive_number, _) => {
+                    left = Box::new(Expression::TupleAccess(TupleAccessExpression {
+                        tuple: left,
+                        index: positive_number,
+                        span: span.clone(),
+                    }));
+                }
+                AssigneeAccess::Member(identifier) => {
+                    left = Box::new(Expression::CircuitMemberAccess(CircuitMemberAccessExpression {
+                        circuit: left,
+                        name: identifier,
+                        span: span.clone(),
+                    }));
+                }
+                _ => return Err(ReducerError::from(CombinerError::illegal_compound_array_range(&span))),
+            }
+        }
+
+        Ok(left)
+    }
+
+    pub fn compound_operation_converstion(
+        &mut self,
+        operation: &AssignOperation,
+    ) -> Result<BinaryOperation, ReducerError> {
+        match operation {
+            AssignOperation::Assign => unreachable!(),
+            AssignOperation::Add => Ok(BinaryOperation::Add),
+            AssignOperation::Sub => Ok(BinaryOperation::Sub),
+            AssignOperation::Mul => Ok(BinaryOperation::Mul),
+            AssignOperation::Div => Ok(BinaryOperation::Div),
+            AssignOperation::Pow => Ok(BinaryOperation::Pow),
+            AssignOperation::Or => Ok(BinaryOperation::Or),
+            AssignOperation::And => Ok(BinaryOperation::And),
+            AssignOperation::BitOr => Ok(BinaryOperation::BitOr),
+            AssignOperation::BitAnd => Ok(BinaryOperation::BitAnd),
+            AssignOperation::BitXor => Ok(BinaryOperation::BitXor),
+            AssignOperation::Shr => Ok(BinaryOperation::Shr),
+            AssignOperation::ShrSigned => Ok(BinaryOperation::ShrSigned),
+            AssignOperation::Shl => Ok(BinaryOperation::Shl),
+            AssignOperation::Mod => Ok(BinaryOperation::Mod),
+        }
     }
 
     fn is_self_type(&mut self, type_option: Option<&Type>) -> bool {
@@ -380,17 +447,21 @@ impl Canonicalizer {
 }
 
 impl ReconstructingReducer for Canonicalizer {
-    fn reduce_type(
-        &mut self,
-        _type_: &Type,
-        new: Type,
-        in_circuit: bool,
-        span: &Span,
-    ) -> Result<Type, CanonicalizeError> {
+    fn in_circuit(&self) -> bool {
+        self.in_circuit
+    }
+
+    fn swap_in_circuit(&mut self) {
+        self.in_circuit = !self.in_circuit;
+    }
+
+    fn reduce_type(&mut self, _type_: &Type, new: Type, span: &Span) -> Result<Type, ReducerError> {
         match new {
             Type::Array(type_, mut dimensions) => {
                 if dimensions.is_zero() {
-                    return Err(CanonicalizeError::invalid_array_dimension_size(span));
+                    return Err(ReducerError::from(CanonicalizeError::invalid_array_dimension_size(
+                        span,
+                    )));
                 }
 
                 let mut next = Type::Array(type_, ArrayDimensions(vec![dimensions.remove_last().unwrap()]));
@@ -407,7 +478,9 @@ impl ReconstructingReducer for Canonicalizer {
 
                 Ok(array)
             }
-            Type::SelfType if !in_circuit => Err(CanonicalizeError::big_self_outside_of_circuit(span)),
+            Type::SelfType if !self.in_circuit => {
+                Err(ReducerError::from(CanonicalizeError::big_self_outside_of_circuit(span)))
+            }
             _ => Ok(new.clone()),
         }
     }
@@ -416,10 +489,11 @@ impl ReconstructingReducer for Canonicalizer {
         &mut self,
         array_init: &ArrayInitExpression,
         element: Expression,
-        _in_circuit: bool,
-    ) -> Result<ArrayInitExpression, CanonicalizeError> {
+    ) -> Result<ArrayInitExpression, ReducerError> {
         if array_init.dimensions.is_zero() {
-            return Err(CanonicalizeError::invalid_array_dimension_size(&array_init.span));
+            return Err(ReducerError::from(CanonicalizeError::invalid_array_dimension_size(
+                &array_init.span,
+            )));
         }
 
         let element = Box::new(element);
@@ -466,58 +540,39 @@ impl ReconstructingReducer for Canonicalizer {
         assign: &AssignStatement,
         assignee: Assignee,
         value: Expression,
-        _in_circuit: bool,
-    ) -> Result<AssignStatement, CanonicalizeError> {
+    ) -> Result<AssignStatement, ReducerError> {
         match value {
+            Expression::Binary(binary_expr) if assign.operation != AssignOperation::Assign => {
+                let left = self.canonicalize_accesses(
+                    Expression::Identifier(assignee.identifier.clone()),
+                    &assignee.accesses,
+                    &assign.span,
+                )?;
+                let right = Box::new(Expression::Binary(binary_expr));
+                let op = self.compound_operation_converstion(&assign.operation)?;
+
+                let new_value = Expression::Binary(BinaryExpression {
+                    left,
+                    right,
+                    op,
+                    span: assign.span.clone(),
+                });
+
+                Ok(AssignStatement {
+                    operation: AssignOperation::Assign,
+                    assignee,
+                    value: new_value,
+                    span: assign.span.clone(),
+                })
+            }
             Expression::Value(value_expr) if assign.operation != AssignOperation::Assign => {
-                let mut left = Box::new(Expression::Identifier(assignee.identifier.clone()));
-
-                for access in assignee.accesses.iter() {
-                    match self.canonicalize_assignee_access(&access) {
-                        AssigneeAccess::ArrayIndex(index) => {
-                            left = Box::new(Expression::ArrayAccess(ArrayAccessExpression {
-                                array: left,
-                                index: Box::new(index),
-                                span: assign.span.clone(),
-                            }));
-                        }
-                        AssigneeAccess::Tuple(positive_number, _) => {
-                            left = Box::new(Expression::TupleAccess(TupleAccessExpression {
-                                tuple: left,
-                                index: positive_number,
-                                span: assign.span.clone(),
-                            }));
-                        }
-                        AssigneeAccess::Member(identifier) => {
-                            left = Box::new(Expression::CircuitMemberAccess(CircuitMemberAccessExpression {
-                                circuit: left,
-                                name: identifier,
-                                span: assign.span.clone(),
-                            }));
-                        }
-                        _ => unimplemented!(), // No reason for someone to compute ArrayRanges.
-                    }
-                }
-
+                let left = self.canonicalize_accesses(
+                    Expression::Identifier(assignee.identifier.clone()),
+                    &assignee.accesses,
+                    &assign.span,
+                )?;
                 let right = Box::new(Expression::Value(value_expr));
-
-                let op = match assign.operation {
-                    AssignOperation::Assign => unimplemented!(), // Imposible
-                    AssignOperation::Add => BinaryOperation::Add,
-                    AssignOperation::Sub => BinaryOperation::Sub,
-                    AssignOperation::Mul => BinaryOperation::Mul,
-                    AssignOperation::Div => BinaryOperation::Div,
-                    AssignOperation::Pow => BinaryOperation::Pow,
-                    AssignOperation::Or => BinaryOperation::Or,
-                    AssignOperation::And => BinaryOperation::And,
-                    AssignOperation::BitOr => BinaryOperation::BitOr,
-                    AssignOperation::BitAnd => BinaryOperation::BitAnd,
-                    AssignOperation::BitXor => BinaryOperation::BitXor,
-                    AssignOperation::Shr => BinaryOperation::Shr,
-                    AssignOperation::ShrSigned => BinaryOperation::ShrSigned,
-                    AssignOperation::Shl => BinaryOperation::Shl,
-                    AssignOperation::Mod => BinaryOperation::Mod,
-                };
+                let op = self.compound_operation_converstion(&assign.operation)?;
 
                 let new_value = Expression::Binary(BinaryExpression {
                     left,
@@ -545,8 +600,7 @@ impl ReconstructingReducer for Canonicalizer {
         input: Vec<FunctionInput>,
         output: Option<Type>,
         block: Block,
-        _in_circuit: bool,
-    ) -> Result<Function, CanonicalizeError> {
+    ) -> Result<Function, ReducerError> {
         let new_output = match output {
             None => Some(Type::Tuple(vec![])),
             _ => output,
@@ -567,7 +621,7 @@ impl ReconstructingReducer for Canonicalizer {
         _circuit: &Circuit,
         circuit_name: Identifier,
         members: Vec<CircuitMember>,
-    ) -> Result<Circuit, CanonicalizeError> {
+    ) -> Result<Circuit, ReducerError> {
         self.circuit_name = Some(circuit_name.clone());
         let circ = Circuit {
             circuit_name,

ast/src/reducer/mod.rs

@@ -17,9 +17,6 @@
 mod canonicalization;
 pub use canonicalization::*;
 
-mod errors;
-pub use errors::*;
-
 mod reconstructing_reducer;
 pub use reconstructing_reducer::*;
 

ast/src/reducer/reconstructing_director.rs

@@ -22,18 +22,14 @@ use indexmap::IndexMap;
 
 pub struct ReconstructingDirector<R: ReconstructingReducer> {
     reducer: R,
-    in_circuit: bool,
 }
 
 impl<R: ReconstructingReducer> ReconstructingDirector<R> {
     pub fn new(reducer: R) -> Self {
-        Self {
-            reducer,
-            in_circuit: false,
-        }
+        Self { reducer }
     }
 
-    pub fn reduce_type(&mut self, type_: &Type, span: &Span) -> Result<Type, CanonicalizeError> {
+    pub fn reduce_type(&mut self, type_: &Type, span: &Span) -> Result<Type, ReducerError> {
         let new = match type_ {
             Type::Array(type_, dimensions) => Type::Array(Box::new(self.reduce_type(type_, span)?), dimensions.clone()),
             Type::Tuple(types) => {
@@ -48,11 +44,11 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
             _ => type_.clone(),
         };
 
-        self.reducer.reduce_type(type_, new, self.in_circuit, span)
+        self.reducer.reduce_type(type_, new, span)
     }
 
     // Expressions
-    pub fn reduce_expression(&mut self, expression: &Expression) -> Result<Expression, CanonicalizeError> {
+    pub fn reduce_expression(&mut self, expression: &Expression) -> Result<Expression, ReducerError> {
         let new = match expression {
             Expression::Identifier(identifier) => Expression::Identifier(self.reduce_identifier(&identifier)?),
             Expression::Value(value) => Expression::Value(self.reduce_value(&value)?),
@@ -84,18 +80,18 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
             Expression::Call(call) => Expression::Call(self.reduce_call(&call)?),
         };
 
-        self.reducer.reduce_expression(expression, new, self.in_circuit)
+        self.reducer.reduce_expression(expression, new)
     }
 
-    pub fn reduce_identifier(&mut self, identifier: &Identifier) -> Result<Identifier, CanonicalizeError> {
+    pub fn reduce_identifier(&mut self, identifier: &Identifier) -> Result<Identifier, ReducerError> {
         self.reducer.reduce_identifier(identifier)
     }
 
-    pub fn reduce_group_tuple(&mut self, group_tuple: &GroupTuple) -> Result<GroupTuple, CanonicalizeError> {
+    pub fn reduce_group_tuple(&mut self, group_tuple: &GroupTuple) -> Result<GroupTuple, ReducerError> {
         self.reducer.reduce_group_tuple(group_tuple)
     }
 
-    pub fn reduce_group_value(&mut self, group_value: &GroupValue) -> Result<GroupValue, CanonicalizeError> {
+    pub fn reduce_group_value(&mut self, group_value: &GroupValue) -> Result<GroupValue, ReducerError> {
         let new = match group_value {
             GroupValue::Tuple(group_tuple) => GroupValue::Tuple(self.reduce_group_tuple(&group_tuple)?),
             _ => group_value.clone(),
@@ -104,7 +100,7 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
         self.reducer.reduce_group_value(group_value, new)
     }
 
-    pub fn reduce_value(&mut self, value: &ValueExpression) -> Result<ValueExpression, CanonicalizeError> {
+    pub fn reduce_value(&mut self, value: &ValueExpression) -> Result<ValueExpression, ReducerError> {
         let new = match value {
             ValueExpression::Group(group_value) => {
                 ValueExpression::Group(Box::new(self.reduce_group_value(&group_value)?))
@@ -115,41 +111,38 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
         self.reducer.reduce_value(value, new)
     }
 
-    pub fn reduce_binary(&mut self, binary: &BinaryExpression) -> Result<BinaryExpression, CanonicalizeError> {
+    pub fn reduce_binary(&mut self, binary: &BinaryExpression) -> Result<BinaryExpression, ReducerError> {
         let left = self.reduce_expression(&binary.left)?;
         let right = self.reduce_expression(&binary.right)?;
 
-        self.reducer
-            .reduce_binary(binary, left, right, binary.op.clone(), self.in_circuit)
+        self.reducer.reduce_binary(binary, left, right, binary.op.clone())
     }
 
-    pub fn reduce_unary(&mut self, unary: &UnaryExpression) -> Result<UnaryExpression, CanonicalizeError> {
+    pub fn reduce_unary(&mut self, unary: &UnaryExpression) -> Result<UnaryExpression, ReducerError> {
         let inner = self.reduce_expression(&unary.inner)?;
 
-        self.reducer
-            .reduce_unary(unary, inner, unary.op.clone(), self.in_circuit)
+        self.reducer.reduce_unary(unary, inner, unary.op.clone())
     }
 
-    pub fn reduce_ternary(&mut self, ternary: &TernaryExpression) -> Result<TernaryExpression, CanonicalizeError> {
+    pub fn reduce_ternary(&mut self, ternary: &TernaryExpression) -> Result<TernaryExpression, ReducerError> {
         let condition = self.reduce_expression(&ternary.condition)?;
         let if_true = self.reduce_expression(&ternary.if_true)?;
         let if_false = self.reduce_expression(&ternary.if_false)?;
 
-        self.reducer
-            .reduce_ternary(ternary, condition, if_true, if_false, self.in_circuit)
+        self.reducer.reduce_ternary(ternary, condition, if_true, if_false)
     }
 
-    pub fn reduce_cast(&mut self, cast: &CastExpression) -> Result<CastExpression, CanonicalizeError> {
+    pub fn reduce_cast(&mut self, cast: &CastExpression) -> Result<CastExpression, ReducerError> {
         let inner = self.reduce_expression(&cast.inner)?;
         let target_type = self.reduce_type(&cast.target_type, &cast.span)?;
 
-        self.reducer.reduce_cast(cast, inner, target_type, self.in_circuit)
+        self.reducer.reduce_cast(cast, inner, target_type)
     }
 
     pub fn reduce_array_inline(
         &mut self,
         array_inline: &ArrayInlineExpression,
-    ) -> Result<ArrayInlineExpression, CanonicalizeError> {
+    ) -> Result<ArrayInlineExpression, ReducerError> {
         let mut elements = vec![];
         for element in array_inline.elements.iter() {
             let reduced_element = match element {
@@ -164,34 +157,29 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
             elements.push(reduced_element);
         }
 
-        self.reducer
-            .reduce_array_inline(array_inline, elements, self.in_circuit)
+        self.reducer.reduce_array_inline(array_inline, elements)
     }
 
-    pub fn reduce_array_init(
-        &mut self,
-        array_init: &ArrayInitExpression,
-    ) -> Result<ArrayInitExpression, CanonicalizeError> {
+    pub fn reduce_array_init(&mut self, array_init: &ArrayInitExpression) -> Result<ArrayInitExpression, ReducerError> {
         let element = self.reduce_expression(&array_init.element)?;
 
-        self.reducer.reduce_array_init(array_init, element, self.in_circuit)
+        self.reducer.reduce_array_init(array_init, element)
     }
 
     pub fn reduce_array_access(
         &mut self,
         array_access: &ArrayAccessExpression,
-    ) -> Result<ArrayAccessExpression, CanonicalizeError> {
+    ) -> Result<ArrayAccessExpression, ReducerError> {
         let array = self.reduce_expression(&array_access.array)?;
         let index = self.reduce_expression(&array_access.index)?;
 
-        self.reducer
-            .reduce_array_access(array_access, array, index, self.in_circuit)
+        self.reducer.reduce_array_access(array_access, array, index)
     }
 
     pub fn reduce_array_range_access(
         &mut self,
         array_range_access: &ArrayRangeAccessExpression,
-    ) -> Result<ArrayRangeAccessExpression, CanonicalizeError> {
+    ) -> Result<ArrayRangeAccessExpression, ReducerError> {
         let array = self.reduce_expression(&array_range_access.array)?;
         let left = array_range_access
             .left
@@ -205,34 +193,31 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
             .transpose()?;
 
         self.reducer
-            .reduce_array_range_access(array_range_access, array, left, right, self.in_circuit)
+            .reduce_array_range_access(array_range_access, array, left, right)
     }
 
-    pub fn reduce_tuple_init(
-        &mut self,
-        tuple_init: &TupleInitExpression,
-    ) -> Result<TupleInitExpression, CanonicalizeError> {
+    pub fn reduce_tuple_init(&mut self, tuple_init: &TupleInitExpression) -> Result<TupleInitExpression, ReducerError> {
         let mut elements = vec![];
         for element in tuple_init.elements.iter() {
             elements.push(self.reduce_expression(element)?);
         }
 
-        self.reducer.reduce_tuple_init(tuple_init, elements, self.in_circuit)
+        self.reducer.reduce_tuple_init(tuple_init, elements)
     }
 
     pub fn reduce_tuple_access(
         &mut self,
         tuple_access: &TupleAccessExpression,
-    ) -> Result<TupleAccessExpression, CanonicalizeError> {
+    ) -> Result<TupleAccessExpression, ReducerError> {
         let tuple = self.reduce_expression(&tuple_access.tuple)?;
 
-        self.reducer.reduce_tuple_access(tuple_access, tuple, self.in_circuit)
+        self.reducer.reduce_tuple_access(tuple_access, tuple)
     }
 
     pub fn reduce_circuit_implied_variable_definition(
         &mut self,
         variable: &CircuitImpliedVariableDefinition,
-    ) -> Result<CircuitImpliedVariableDefinition, CanonicalizeError> {
+    ) -> Result<CircuitImpliedVariableDefinition, ReducerError> {
         let identifier = self.reduce_identifier(&variable.identifier)?;
         let expression = variable
             .expression
@@ -241,13 +226,13 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
             .transpose()?;
 
         self.reducer
-            .reduce_circuit_implied_variable_definition(variable, identifier, expression, self.in_circuit)
+            .reduce_circuit_implied_variable_definition(variable, identifier, expression)
     }
 
     pub fn reduce_circuit_init(
         &mut self,
         circuit_init: &CircuitInitExpression,
-    ) -> Result<CircuitInitExpression, CanonicalizeError> {
+    ) -> Result<CircuitInitExpression, ReducerError> {
         let name = self.reduce_identifier(&circuit_init.name)?;
 
         let mut members = vec![];
@@ -255,33 +240,32 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
             members.push(self.reduce_circuit_implied_variable_definition(member)?);
         }
 
-        self.reducer
-            .reduce_circuit_init(circuit_init, name, members, self.in_circuit)
+        self.reducer.reduce_circuit_init(circuit_init, name, members)
     }
 
     pub fn reduce_circuit_member_access(
         &mut self,
         circuit_member_access: &CircuitMemberAccessExpression,
-    ) -> Result<CircuitMemberAccessExpression, CanonicalizeError> {
+    ) -> Result<CircuitMemberAccessExpression, ReducerError> {
         let circuit = self.reduce_expression(&circuit_member_access.circuit)?;
         let name = self.reduce_identifier(&circuit_member_access.name)?;
 
         self.reducer
-            .reduce_circuit_member_access(circuit_member_access, circuit, name, self.in_circuit)
+            .reduce_circuit_member_access(circuit_member_access, circuit, name)
     }
 
     pub fn reduce_circuit_static_fn_access(
         &mut self,
         circuit_static_fn_access: &CircuitStaticFunctionAccessExpression,
-    ) -> Result<CircuitStaticFunctionAccessExpression, CanonicalizeError> {
+    ) -> Result<CircuitStaticFunctionAccessExpression, ReducerError> {
         let circuit = self.reduce_expression(&circuit_static_fn_access.circuit)?;
         let name = self.reduce_identifier(&circuit_static_fn_access.name)?;
 
         self.reducer
-            .reduce_circuit_static_fn_access(circuit_static_fn_access, circuit, name, self.in_circuit)
+            .reduce_circuit_static_fn_access(circuit_static_fn_access, circuit, name)
     }
 
-    pub fn reduce_call(&mut self, call: &CallExpression) -> Result<CallExpression, CanonicalizeError> {
+    pub fn reduce_call(&mut self, call: &CallExpression) -> Result<CallExpression, ReducerError> {
         let function = self.reduce_expression(&call.function)?;
 
         let mut arguments = vec![];
@@ -289,11 +273,11 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
             arguments.push(self.reduce_expression(argument)?);
         }
 
-        self.reducer.reduce_call(call, function, arguments, self.in_circuit)
+        self.reducer.reduce_call(call, function, arguments)
     }
 
     // Statements
-    pub fn reduce_statement(&mut self, statement: &Statement) -> Result<Statement, CanonicalizeError> {
+    pub fn reduce_statement(&mut self, statement: &Statement) -> Result<Statement, ReducerError> {
         let new = match statement {
             Statement::Return(return_statement) => Statement::Return(self.reduce_return(&return_statement)?),
             Statement::Definition(definition) => Statement::Definition(self.reduce_definition(&definition)?),
@@ -305,26 +289,22 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
             Statement::Block(block) => Statement::Block(self.reduce_block(&block)?),
         };
 
-        self.reducer.reduce_statement(statement, new, self.in_circuit)
+        self.reducer.reduce_statement(statement, new)
     }
 
-    pub fn reduce_return(&mut self, return_statement: &ReturnStatement) -> Result<ReturnStatement, CanonicalizeError> {
+    pub fn reduce_return(&mut self, return_statement: &ReturnStatement) -> Result<ReturnStatement, ReducerError> {
         let expression = self.reduce_expression(&return_statement.expression)?;
 
-        self.reducer
-            .reduce_return(return_statement, expression, self.in_circuit)
+        self.reducer.reduce_return(return_statement, expression)
     }
 
-    pub fn reduce_variable_name(&mut self, variable_name: &VariableName) -> Result<VariableName, CanonicalizeError> {
+    pub fn reduce_variable_name(&mut self, variable_name: &VariableName) -> Result<VariableName, ReducerError> {
         let identifier = self.reduce_identifier(&variable_name.identifier)?;
 
         self.reducer.reduce_variable_name(variable_name, identifier)
     }
 
-    pub fn reduce_definition(
-        &mut self,
-        definition: &DefinitionStatement,
-    ) -> Result<DefinitionStatement, CanonicalizeError> {
+    pub fn reduce_definition(&mut self, definition: &DefinitionStatement) -> Result<DefinitionStatement, ReducerError> {
         let mut variable_names = vec![];
         for variable_name in definition.variable_names.iter() {
             variable_names.push(self.reduce_variable_name(variable_name)?);
@@ -338,11 +318,10 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
 
         let value = self.reduce_expression(&definition.value)?;
 
-        self.reducer
-            .reduce_definition(definition, variable_names, type_, value, self.in_circuit)
+        self.reducer.reduce_definition(definition, variable_names, type_, value)
     }
 
-    pub fn reduce_assignee_access(&mut self, access: &AssigneeAccess) -> Result<AssigneeAccess, CanonicalizeError> {
+    pub fn reduce_assignee_access(&mut self, access: &AssigneeAccess) -> Result<AssigneeAccess, ReducerError> {
         let new = match access {
             AssigneeAccess::ArrayRange(left, right) => {
                 let left = left.as_ref().map(|left| self.reduce_expression(left)).transpose()?;
@@ -355,10 +334,10 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
             _ => access.clone(),
         };
 
-        self.reducer.reduce_assignee_access(access, new, self.in_circuit)
+        self.reducer.reduce_assignee_access(access, new)
     }
 
-    pub fn reduce_assignee(&mut self, assignee: &Assignee) -> Result<Assignee, CanonicalizeError> {
+    pub fn reduce_assignee(&mut self, assignee: &Assignee) -> Result<Assignee, ReducerError> {
         let identifier = self.reduce_identifier(&assignee.identifier)?;
 
         let mut accesses = vec![];
@@ -366,21 +345,20 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
             accesses.push(self.reduce_assignee_access(access)?);
         }
 
-        self.reducer
-            .reduce_assignee(assignee, identifier, accesses, self.in_circuit)
+        self.reducer.reduce_assignee(assignee, identifier, accesses)
     }
 
-    pub fn reduce_assign(&mut self, assign: &AssignStatement) -> Result<AssignStatement, CanonicalizeError> {
+    pub fn reduce_assign(&mut self, assign: &AssignStatement) -> Result<AssignStatement, ReducerError> {
         let assignee = self.reduce_assignee(&assign.assignee)?;
         let value = self.reduce_expression(&assign.value)?;
 
-        self.reducer.reduce_assign(assign, assignee, value, self.in_circuit)
+        self.reducer.reduce_assign(assign, assignee, value)
     }
 
     pub fn reduce_conditional(
         &mut self,
         conditional: &ConditionalStatement,
-    ) -> Result<ConditionalStatement, CanonicalizeError> {
+    ) -> Result<ConditionalStatement, ReducerError> {
         let condition = self.reduce_expression(&conditional.condition)?;
         let block = self.reduce_block(&conditional.block)?;
         let next = conditional
@@ -389,27 +367,22 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
             .map(|condition| self.reduce_statement(condition))
             .transpose()?;
 
-        self.reducer
-            .reduce_conditional(conditional, condition, block, next, self.in_circuit)
+        self.reducer.reduce_conditional(conditional, condition, block, next)
     }
 
-    pub fn reduce_iteration(
-        &mut self,
-        iteration: &IterationStatement,
-    ) -> Result<IterationStatement, CanonicalizeError> {
+    pub fn reduce_iteration(&mut self, iteration: &IterationStatement) -> Result<IterationStatement, ReducerError> {
         let variable = self.reduce_identifier(&iteration.variable)?;
         let start = self.reduce_expression(&iteration.start)?;
         let stop = self.reduce_expression(&iteration.stop)?;
         let block = self.reduce_block(&iteration.block)?;
 
-        self.reducer
-            .reduce_iteration(iteration, variable, start, stop, block, self.in_circuit)
+        self.reducer.reduce_iteration(iteration, variable, start, stop, block)
     }
 
     pub fn reduce_console(
         &mut self,
         console_function_call: &ConsoleStatement,
-    ) -> Result<ConsoleStatement, CanonicalizeError> {
+    ) -> Result<ConsoleStatement, ReducerError> {
         let function = match &console_function_call.function {
             ConsoleFunction::Assert(expression) => ConsoleFunction::Assert(self.reduce_expression(expression)?),
             ConsoleFunction::Debug(format) | ConsoleFunction::Error(format) | ConsoleFunction::Log(format) => {
@@ -428,35 +401,33 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
                     ConsoleFunction::Debug(_) => ConsoleFunction::Debug(formatted),
                     ConsoleFunction::Error(_) => ConsoleFunction::Error(formatted),
                     ConsoleFunction::Log(_) => ConsoleFunction::Log(formatted),
-                    _ => unimplemented!(), // impossible
+                    _ => return Err(ReducerError::impossible_console_assert_call(&format.span)),
                 }
             }
         };
 
-        self.reducer
-            .reduce_console(console_function_call, function, self.in_circuit)
+        self.reducer.reduce_console(console_function_call, function)
     }
 
     pub fn reduce_expression_statement(
         &mut self,
         expression: &ExpressionStatement,
-    ) -> Result<ExpressionStatement, CanonicalizeError> {
+    ) -> Result<ExpressionStatement, ReducerError> {
         let inner_expression = self.reduce_expression(&expression.expression)?;
-        self.reducer
-            .reduce_expression_statement(expression, inner_expression, self.in_circuit)
+        self.reducer.reduce_expression_statement(expression, inner_expression)
     }
 
-    pub fn reduce_block(&mut self, block: &Block) -> Result<Block, CanonicalizeError> {
+    pub fn reduce_block(&mut self, block: &Block) -> Result<Block, ReducerError> {
         let mut statements = vec![];
         for statement in block.statements.iter() {
             statements.push(self.reduce_statement(statement)?);
         }
 
-        self.reducer.reduce_block(block, statements, self.in_circuit)
+        self.reducer.reduce_block(block, statements)
     }
 
     // Program
-    pub fn reduce_program(&mut self, program: &Program) -> Result<Program, CanonicalizeError> {
+    pub fn reduce_program(&mut self, program: &Program) -> Result<Program, ReducerError> {
         let mut inputs = vec![];
         for input in program.expected_input.iter() {
             inputs.push(self.reduce_function_input(input)?);
@@ -468,9 +439,11 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
         }
 
         let mut circuits = IndexMap::new();
+        self.reducer.swap_in_circuit();
         for (identifier, circuit) in program.circuits.iter() {
             circuits.insert(self.reduce_identifier(identifier)?, self.reduce_circuit(circuit)?);
         }
+        self.reducer.swap_in_circuit();
 
         let mut functions = IndexMap::new();
         for (identifier, function) in program.functions.iter() {
@@ -484,15 +457,14 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
     pub fn reduce_function_input_variable(
         &mut self,
         variable: &FunctionInputVariable,
-    ) -> Result<FunctionInputVariable, CanonicalizeError> {
+    ) -> Result<FunctionInputVariable, ReducerError> {
         let identifier = self.reduce_identifier(&variable.identifier)?;
         let type_ = self.reduce_type(&variable.type_, &variable.span)?;
 
-        self.reducer
-            .reduce_function_input_variable(variable, identifier, type_, self.in_circuit)
+        self.reducer.reduce_function_input_variable(variable, identifier, type_)
     }
 
-    pub fn reduce_function_input(&mut self, input: &FunctionInput) -> Result<FunctionInput, CanonicalizeError> {
+    pub fn reduce_function_input(&mut self, input: &FunctionInput) -> Result<FunctionInput, ReducerError> {
         let new = match input {
             FunctionInput::Variable(function_input_variable) => {
                 FunctionInput::Variable(self.reduce_function_input_variable(function_input_variable)?)
@@ -500,13 +472,13 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
             _ => input.clone(),
         };
 
-        self.reducer.reduce_function_input(input, new, self.in_circuit)
+        self.reducer.reduce_function_input(input, new)
     }
 
     pub fn reduce_package_or_packages(
         &mut self,
         package_or_packages: &PackageOrPackages,
-    ) -> Result<PackageOrPackages, CanonicalizeError> {
+    ) -> Result<PackageOrPackages, ReducerError> {
         let new = match package_or_packages {
             PackageOrPackages::Package(package) => PackageOrPackages::Package(Package {
                 name: self.reduce_identifier(&package.name)?,
@@ -523,17 +495,13 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
         self.reducer.reduce_package_or_packages(package_or_packages, new)
     }
 
-    pub fn reduce_import(&mut self, import: &ImportStatement) -> Result<ImportStatement, CanonicalizeError> {
+    pub fn reduce_import(&mut self, import: &ImportStatement) -> Result<ImportStatement, ReducerError> {
         let package_or_packages = self.reduce_package_or_packages(&import.package_or_packages)?;
 
         self.reducer.reduce_import(import, package_or_packages)
     }
 
-    pub fn reduce_circuit_member(
-        &mut self,
-        circuit_member: &CircuitMember,
-    ) -> Result<CircuitMember, CanonicalizeError> {
-        self.in_circuit = !self.in_circuit;
+    pub fn reduce_circuit_member(&mut self, circuit_member: &CircuitMember) -> Result<CircuitMember, ReducerError> {
         let new = match circuit_member {
             CircuitMember::CircuitVariable(identifier, type_) => CircuitMember::CircuitVariable(
                 self.reduce_identifier(&identifier)?,
@@ -543,12 +511,11 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
                 CircuitMember::CircuitFunction(self.reduce_function(&function)?)
             }
         };
-        self.in_circuit = !self.in_circuit;
 
         self.reducer.reduce_circuit_member(circuit_member, new)
     }
 
-    pub fn reduce_circuit(&mut self, circuit: &Circuit) -> Result<Circuit, CanonicalizeError> {
+    pub fn reduce_circuit(&mut self, circuit: &Circuit) -> Result<Circuit, ReducerError> {
         let circuit_name = self.reduce_identifier(&circuit.circuit_name)?;
 
         let mut members = vec![];
@@ -559,13 +526,13 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
         self.reducer.reduce_circuit(circuit, circuit_name, members)
     }
 
-    fn reduce_annotation(&mut self, annotation: &Annotation) -> Result<Annotation, CanonicalizeError> {
+    fn reduce_annotation(&mut self, annotation: &Annotation) -> Result<Annotation, ReducerError> {
         let name = self.reduce_identifier(&annotation.name)?;
 
         self.reducer.reduce_annotation(annotation, name)
     }
 
-    pub fn reduce_function(&mut self, function: &Function) -> Result<Function, CanonicalizeError> {
+    pub fn reduce_function(&mut self, function: &Function) -> Result<Function, ReducerError> {
         let identifier = self.reduce_identifier(&function.identifier)?;
 
         let mut annotations = vec![];
@@ -586,14 +553,7 @@ impl<R: ReconstructingReducer> ReconstructingDirector<R> {
 
         let block = self.reduce_block(&function.block)?;
 
-        self.reducer.reduce_function(
-            function,
-            identifier,
-            annotations,
-            inputs,
-            output,
-            block,
-            self.in_circuit,
-        )
+        self.reducer
+            .reduce_function(function, identifier, annotations, inputs, output, block)
     }
 }

ast/src/reducer/reconstructing_reducer.rs

@@ -20,34 +20,26 @@ use indexmap::IndexMap;
 // Needed to fix clippy bug.
 #[allow(clippy::redundant_closure)]
 pub trait ReconstructingReducer {
-    fn reduce_type(
-        &mut self,
-        _type_: &Type,
-        new: Type,
-        _in_circuit: bool,
-        _span: &Span,
-    ) -> Result<Type, CanonicalizeError> {
+    fn in_circuit(&self) -> bool;
+    fn swap_in_circuit(&mut self);
+
+    fn reduce_type(&mut self, _type_: &Type, new: Type, _span: &Span) -> Result<Type, ReducerError> {
         Ok(new)
     }
 
     // Expressions
-    fn reduce_expression(
-        &mut self,
-        _expression: &Expression,
-        new: Expression,
-        _in_circuit: bool,
-    ) -> Result<Expression, CanonicalizeError> {
+    fn reduce_expression(&mut self, _expression: &Expression, new: Expression) -> Result<Expression, ReducerError> {
         Ok(new)
     }
 
-    fn reduce_identifier(&mut self, identifier: &Identifier) -> Result<Identifier, CanonicalizeError> {
+    fn reduce_identifier(&mut self, identifier: &Identifier) -> Result<Identifier, ReducerError> {
         Ok(Identifier {
             name: identifier.name.clone(),
             span: identifier.span.clone(),
         })
     }
 
-    fn reduce_group_tuple(&mut self, group_tuple: &GroupTuple) -> Result<GroupTuple, CanonicalizeError> {
+    fn reduce_group_tuple(&mut self, group_tuple: &GroupTuple) -> Result<GroupTuple, ReducerError> {
         Ok(GroupTuple {
             x: group_tuple.x.clone(),
             y: group_tuple.y.clone(),
@@ -55,11 +47,7 @@ pub trait ReconstructingReducer {
         })
     }
 
-    fn reduce_group_value(
-        &mut self,
-        _group_value: &GroupValue,
-        new: GroupValue,
-    ) -> Result<GroupValue, CanonicalizeError> {
+    fn reduce_group_value(&mut self, _group_value: &GroupValue, new: GroupValue) -> Result<GroupValue, ReducerError> {
         Ok(new)
     }
 
@@ -67,7 +55,7 @@ pub trait ReconstructingReducer {
         &mut self,
         _value: &ValueExpression,
         new: ValueExpression,
-    ) -> Result<ValueExpression, CanonicalizeError> {
+    ) -> Result<ValueExpression, ReducerError> {
         Ok(new)
     }
 
@@ -77,8 +65,7 @@ pub trait ReconstructingReducer {
         left: Expression,
         right: Expression,
         op: BinaryOperation,
-        _in_circuit: bool,
-    ) -> Result<BinaryExpression, CanonicalizeError> {
+    ) -> Result<BinaryExpression, ReducerError> {
         Ok(BinaryExpression {
             left: Box::new(left),
             right: Box::new(right),
@@ -92,8 +79,7 @@ pub trait ReconstructingReducer {
         unary: &UnaryExpression,
         inner: Expression,
         op: UnaryOperation,
-        _in_circuit: bool,
-    ) -> Result<UnaryExpression, CanonicalizeError> {
+    ) -> Result<UnaryExpression, ReducerError> {
         Ok(UnaryExpression {
             inner: Box::new(inner),
             op,
@@ -107,8 +93,7 @@ pub trait ReconstructingReducer {
         condition: Expression,
         if_true: Expression,
         if_false: Expression,
-        _in_circuit: bool,
-    ) -> Result<TernaryExpression, CanonicalizeError> {
+    ) -> Result<TernaryExpression, ReducerError> {
         Ok(TernaryExpression {
             condition: Box::new(condition),
             if_true: Box::new(if_true),
@@ -122,8 +107,7 @@ pub trait ReconstructingReducer {
         cast: &CastExpression,
         inner: Expression,
         target_type: Type,
-        _in_circuit: bool,
-    ) -> Result<CastExpression, CanonicalizeError> {
+    ) -> Result<CastExpression, ReducerError> {
         Ok(CastExpression {
             inner: Box::new(inner),
             target_type,
@@ -135,8 +119,7 @@ pub trait ReconstructingReducer {
         &mut self,
         array_inline: &ArrayInlineExpression,
         elements: Vec<SpreadOrExpression>,
-        _in_circuit: bool,
-    ) -> Result<ArrayInlineExpression, CanonicalizeError> {
+    ) -> Result<ArrayInlineExpression, ReducerError> {
         Ok(ArrayInlineExpression {
             elements,
             span: array_inline.span.clone(),
@@ -147,8 +130,7 @@ pub trait ReconstructingReducer {
         &mut self,
         array_init: &ArrayInitExpression,
         element: Expression,
-        _in_circuit: bool,
-    ) -> Result<ArrayInitExpression, CanonicalizeError> {
+    ) -> Result<ArrayInitExpression, ReducerError> {
         Ok(ArrayInitExpression {
             element: Box::new(element),
             dimensions: array_init.dimensions.clone(),
@@ -161,8 +143,7 @@ pub trait ReconstructingReducer {
         array_access: &ArrayAccessExpression,
         array: Expression,
         index: Expression,
-        _in_circuit: bool,
-    ) -> Result<ArrayAccessExpression, CanonicalizeError> {
+    ) -> Result<ArrayAccessExpression, ReducerError> {
         Ok(ArrayAccessExpression {
             array: Box::new(array),
             index: Box::new(index),
@@ -176,8 +157,7 @@ pub trait ReconstructingReducer {
         array: Expression,
         left: Option<Expression>,
         right: Option<Expression>,
-        _in_circuit: bool,
-    ) -> Result<ArrayRangeAccessExpression, CanonicalizeError> {
+    ) -> Result<ArrayRangeAccessExpression, ReducerError> {
         Ok(ArrayRangeAccessExpression {
             array: Box::new(array),
             left: left.map(|expr| Box::new(expr)),
@@ -190,8 +170,7 @@ pub trait ReconstructingReducer {
         &mut self,
         tuple_init: &TupleInitExpression,
         elements: Vec<Expression>,
-        _in_circuit: bool,
-    ) -> Result<TupleInitExpression, CanonicalizeError> {
+    ) -> Result<TupleInitExpression, ReducerError> {
         Ok(TupleInitExpression {
             elements,
             span: tuple_init.span.clone(),
@@ -202,8 +181,7 @@ pub trait ReconstructingReducer {
         &mut self,
         tuple_access: &TupleAccessExpression,
         tuple: Expression,
-        _in_circuit: bool,
-    ) -> Result<TupleAccessExpression, CanonicalizeError> {
+    ) -> Result<TupleAccessExpression, ReducerError> {
         Ok(TupleAccessExpression {
             tuple: Box::new(tuple),
             index: tuple_access.index.clone(),
@@ -216,8 +194,7 @@ pub trait ReconstructingReducer {
         _variable: &CircuitImpliedVariableDefinition,
         identifier: Identifier,
         expression: Option<Expression>,
-        _in_circuit: bool,
-    ) -> Result<CircuitImpliedVariableDefinition, CanonicalizeError> {
+    ) -> Result<CircuitImpliedVariableDefinition, ReducerError> {
         Ok(CircuitImpliedVariableDefinition { identifier, expression })
     }
 
@@ -226,8 +203,7 @@ pub trait ReconstructingReducer {
         circuit_init: &CircuitInitExpression,
         name: Identifier,
         members: Vec<CircuitImpliedVariableDefinition>,
-        _in_circuit: bool,
-    ) -> Result<CircuitInitExpression, CanonicalizeError> {
+    ) -> Result<CircuitInitExpression, ReducerError> {
         Ok(CircuitInitExpression {
             name,
             members,
@@ -240,8 +216,7 @@ pub trait ReconstructingReducer {
         circuit_member_access: &CircuitMemberAccessExpression,
         circuit: Expression,
         name: Identifier,
-        _in_circuit: bool,
-    ) -> Result<CircuitMemberAccessExpression, CanonicalizeError> {
+    ) -> Result<CircuitMemberAccessExpression, ReducerError> {
         Ok(CircuitMemberAccessExpression {
             circuit: Box::new(circuit),
             name,
@@ -254,8 +229,7 @@ pub trait ReconstructingReducer {
         circuit_static_fn_access: &CircuitStaticFunctionAccessExpression,
         circuit: Expression,
         name: Identifier,
-        _in_circuit: bool,
-    ) -> Result<CircuitStaticFunctionAccessExpression, CanonicalizeError> {
+    ) -> Result<CircuitStaticFunctionAccessExpression, ReducerError> {
         Ok(CircuitStaticFunctionAccessExpression {
             circuit: Box::new(circuit),
             name,
@@ -268,8 +242,7 @@ pub trait ReconstructingReducer {
         call: &CallExpression,
         function: Expression,
         arguments: Vec<Expression>,
-        _in_circuit: bool,
-    ) -> Result<CallExpression, CanonicalizeError> {
+    ) -> Result<CallExpression, ReducerError> {
         Ok(CallExpression {
             function: Box::new(function),
             arguments,
@@ -278,12 +251,7 @@ pub trait ReconstructingReducer {
     }
 
     // Statements
-    fn reduce_statement(
-        &mut self,
-        _statement: &Statement,
-        new: Statement,
-        _in_circuit: bool,
-    ) -> Result<Statement, CanonicalizeError> {
+    fn reduce_statement(&mut self, _statement: &Statement, new: Statement) -> Result<Statement, ReducerError> {
         Ok(new)
     }
 
@@ -291,8 +259,7 @@ pub trait ReconstructingReducer {
         &mut self,
         return_statement: &ReturnStatement,
         expression: Expression,
-        _in_circuit: bool,
-    ) -> Result<ReturnStatement, CanonicalizeError> {
+    ) -> Result<ReturnStatement, ReducerError> {
         Ok(ReturnStatement {
             expression,
             span: return_statement.span.clone(),
@@ -303,7 +270,7 @@ pub trait ReconstructingReducer {
         &mut self,
         variable_name: &VariableName,
         identifier: Identifier,
-    ) -> Result<VariableName, CanonicalizeError> {
+    ) -> Result<VariableName, ReducerError> {
         Ok(VariableName {
             mutable: variable_name.mutable,
             identifier,
@@ -317,8 +284,7 @@ pub trait ReconstructingReducer {
         variable_names: Vec<VariableName>,
         type_: Option<Type>,
         value: Expression,
-        _in_circuit: bool,
-    ) -> Result<DefinitionStatement, CanonicalizeError> {
+    ) -> Result<DefinitionStatement, ReducerError> {
         Ok(DefinitionStatement {
             declaration_type: definition.declaration_type.clone(),
             variable_names,
@@ -332,8 +298,7 @@ pub trait ReconstructingReducer {
         &mut self,
         _access: &AssigneeAccess,
         new: AssigneeAccess,
-        _in_circuit: bool,
-    ) -> Result<AssigneeAccess, CanonicalizeError> {
+    ) -> Result<AssigneeAccess, ReducerError> {
         Ok(new)
     }
 
@@ -342,8 +307,7 @@ pub trait ReconstructingReducer {
         assignee: &Assignee,
         identifier: Identifier,
         accesses: Vec<AssigneeAccess>,
-        _in_circuit: bool,
-    ) -> Result<Assignee, CanonicalizeError> {
+    ) -> Result<Assignee, ReducerError> {
         Ok(Assignee {
             identifier,
             accesses,
@@ -356,8 +320,7 @@ pub trait ReconstructingReducer {
         assign: &AssignStatement,
         assignee: Assignee,
         value: Expression,
-        _in_circuit: bool,
-    ) -> Result<AssignStatement, CanonicalizeError> {
+    ) -> Result<AssignStatement, ReducerError> {
         Ok(AssignStatement {
             operation: assign.operation.clone(),
             assignee,
@@ -372,8 +335,7 @@ pub trait ReconstructingReducer {
         condition: Expression,
         block: Block,
         statement: Option<Statement>,
-        _in_circuit: bool,
-    ) -> Result<ConditionalStatement, CanonicalizeError> {
+    ) -> Result<ConditionalStatement, ReducerError> {
         Ok(ConditionalStatement {
             condition,
             block,
@@ -389,8 +351,7 @@ pub trait ReconstructingReducer {
         start: Expression,
         stop: Expression,
         block: Block,
-        _in_circuit: bool,
-    ) -> Result<IterationStatement, CanonicalizeError> {
+    ) -> Result<IterationStatement, ReducerError> {
         Ok(IterationStatement {
             variable,
             start,
@@ -404,8 +365,7 @@ pub trait ReconstructingReducer {
         &mut self,
         console: &ConsoleStatement,
         function: ConsoleFunction,
-        _in_circuit: bool,
-    ) -> Result<ConsoleStatement, CanonicalizeError> {
+    ) -> Result<ConsoleStatement, ReducerError> {
         Ok(ConsoleStatement {
             function,
             span: console.span.clone(),
@@ -416,20 +376,14 @@ pub trait ReconstructingReducer {
         &mut self,
         expression_statement: &ExpressionStatement,
         expression: Expression,
-        _in_circuit: bool,
-    ) -> Result<ExpressionStatement, CanonicalizeError> {
+    ) -> Result<ExpressionStatement, ReducerError> {
         Ok(ExpressionStatement {
             expression,
             span: expression_statement.span.clone(),
         })
     }
 
-    fn reduce_block(
-        &mut self,
-        block: &Block,
-        statements: Vec<Statement>,
-        _in_circuit: bool,
-    ) -> Result<Block, CanonicalizeError> {
+    fn reduce_block(&mut self, block: &Block, statements: Vec<Statement>) -> Result<Block, ReducerError> {
         Ok(Block {
             statements,
             span: block.span.clone(),
@@ -444,7 +398,7 @@ pub trait ReconstructingReducer {
         imports: Vec<ImportStatement>,
         circuits: IndexMap<Identifier, Circuit>,
         functions: IndexMap<Identifier, Function>,
-    ) -> Result<Program, CanonicalizeError> {
+    ) -> Result<Program, ReducerError> {
         Ok(Program {
             name: program.name.clone(),
             expected_input,
@@ -459,8 +413,7 @@ pub trait ReconstructingReducer {
         variable: &FunctionInputVariable,
         identifier: Identifier,
         type_: Type,
-        _in_circuit: bool,
-    ) -> Result<FunctionInputVariable, CanonicalizeError> {
+    ) -> Result<FunctionInputVariable, ReducerError> {
         Ok(FunctionInputVariable {
             identifier,
             const_: variable.const_,
@@ -474,8 +427,7 @@ pub trait ReconstructingReducer {
         &mut self,
         _input: &FunctionInput,
         new: FunctionInput,
-        _in_circuit: bool,
-    ) -> Result<FunctionInput, CanonicalizeError> {
+    ) -> Result<FunctionInput, ReducerError> {
         Ok(new)
     }
 
@@ -483,7 +435,7 @@ pub trait ReconstructingReducer {
         &mut self,
         _package_or_packages: &PackageOrPackages,
         new: PackageOrPackages,
-    ) -> Result<PackageOrPackages, CanonicalizeError> {
+    ) -> Result<PackageOrPackages, ReducerError> {
         Ok(new)
     }
 
@@ -491,7 +443,7 @@ pub trait ReconstructingReducer {
         &mut self,
         import: &ImportStatement,
         package_or_packages: PackageOrPackages,
-    ) -> Result<ImportStatement, CanonicalizeError> {
+    ) -> Result<ImportStatement, ReducerError> {
         Ok(ImportStatement {
             package_or_packages,
             span: import.span.clone(),
@@ -502,7 +454,7 @@ pub trait ReconstructingReducer {
         &mut self,
         _circuit_member: &CircuitMember,
         new: CircuitMember,
-    ) -> Result<CircuitMember, CanonicalizeError> {
+    ) -> Result<CircuitMember, ReducerError> {
         Ok(new)
     }
 
@@ -511,15 +463,11 @@ pub trait ReconstructingReducer {
         _circuit: &Circuit,
         circuit_name: Identifier,
         members: Vec<CircuitMember>,
-    ) -> Result<Circuit, CanonicalizeError> {
+    ) -> Result<Circuit, ReducerError> {
         Ok(Circuit { circuit_name, members })
     }
 
-    fn reduce_annotation(
-        &mut self,
-        annotation: &Annotation,
-        name: Identifier,
-    ) -> Result<Annotation, CanonicalizeError> {
+    fn reduce_annotation(&mut self, annotation: &Annotation, name: Identifier) -> Result<Annotation, ReducerError> {
         Ok(Annotation {
             span: annotation.span.clone(),
             name,
@@ -536,8 +484,7 @@ pub trait ReconstructingReducer {
         input: Vec<FunctionInput>,
         output: Option<Type>,
         block: Block,
-        _in_circuit: bool,
-    ) -> Result<Function, CanonicalizeError> {
+    ) -> Result<Function, ReducerError> {
         Ok(Function {
             identifier,
             annotations,

compiler/Cargo.toml

@@ -49,6 +49,9 @@ version = "1.4.0"
 path = "../asg-passes"
 version = "1.4.0"
 
+[dependencies.tendril]
+version = "0.4"
+
 [dependencies.snarkvm-curves]
 version = "0.2.2"
 default-features = false

compiler/src/compiler.rs

@@ -216,6 +216,7 @@ impl<'a, F: PrimeField, G: GroupType<F>> Compiler<'a, F, G> {
         // Use the parser to construct the abstract syntax tree (ast).
 
         let mut ast = parse_ast(self.main_file_path.to_str().unwrap_or_default(), program_string)?;
+
         // Preform compiler optimization via canonicalizing AST if its enabled.
         if self.options.canonicalization_enabled {
             ast.canonicalize()?;

compiler/src/errors/compiler.rs

@@ -16,7 +16,7 @@
 
 use crate::errors::FunctionError;
 use leo_asg::{AsgConvertError, FormattedError};
-use leo_ast::{CanonicalizeError, LeoError};
+use leo_ast::{LeoError, ReducerError};
 use leo_input::InputParserError;
 use leo_parser::SyntaxError;
 use leo_state::LocalDataVerificationError;
@@ -56,7 +56,7 @@ pub enum CompilerError {
     AsgConvertError(#[from] AsgConvertError),
 
     #[error("{}", _0)]
-    CanonicalizeError(#[from] CanonicalizeError),
+    ReducerError(#[from] ReducerError),
 }
 
 impl LeoError for CompilerError {}

compiler/src/lib.rs

@@ -57,8 +57,11 @@ pub use prelude::*;
 pub mod value;
 pub use value::*;
 
-pub mod stage;
-pub use stage::*;
+pub mod phase;
+pub use phase::*;
+
+pub mod phases;
+pub use phases::*;
 
 pub mod option;
 pub use option::*;

compiler/src/phase.rs

@@ -16,6 +16,6 @@
 
 use leo_asg::Program;
 
-pub trait ASGStage {
+pub trait ASGPhase {
     fn apply(asg: &mut Program);
 }

compiler/src/phases/mod.rs

@@ -0,0 +1,23 @@
+// 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/>.
+
+//! Compiles a Leo program from a file path.
+
+pub mod reducing_director;
+pub use reducing_director::*;
+
+pub mod phase;
+pub use phase::*;

compiler/src/phases/phase.rs

@@ -0,0 +1,65 @@
+// 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/>.
+
+//! Compiles a Leo program from a file path.
+
+use crate::{CombineAstAsgDirector, CombinerOptions};
+use leo_asg::Program as AsgProgram;
+use leo_ast::{Ast, Program as AstProgram, ReconstructingReducer, ReducerError};
+
+macro_rules! phase {
+    ($phase_name:ident, $function:item) => {
+        pub struct $phase_name {
+            in_circuit: bool,
+        }
+
+        pub struct Options;
+
+        impl CombinerOptions for Options {
+            $function
+        }
+
+        impl ReconstructingReducer for $phase_name {
+            fn in_circuit(&self) -> bool {
+                self.in_circuit
+            }
+
+            fn swap_in_circuit(&mut self) {
+                self.in_circuit = !self.in_circuit;
+            }
+        }
+
+        impl Default for $phase_name {
+            fn default() -> Self {
+                Self { in_circuit: false }
+            }
+        }
+
+        impl $phase_name {
+            pub fn phase_ast(&self, ast: &AstProgram, asg: &AsgProgram) -> Result<Ast, ReducerError> {
+                Ok(Ast::new(CombineAstAsgDirector::new(Self::default(), Options{})
+                    .reduce_program(ast, asg)?))
+            }
+        }
+    };
+}
+
+phase!(
+    TypeInferencePhase,
+    fn type_inference_enabled(&self) -> bool {
+        true
+    }
+);

compiler/src/phases/reducing_director.rs

@@ -0,0 +1,775 @@
+// 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/>.
+
+//! Compiles a Leo program from a file path.
+
+use indexmap::IndexMap;
+use leo_asg::{
+    ArrayAccessExpression as AsgArrayAccessExpression,
+    ArrayInitExpression as AsgArrayInitExpression,
+    ArrayInlineExpression as AsgArrayInlineExpression,
+    ArrayRangeAccessExpression as AsgArrayRangeAccessExpression,
+    AssignAccess as AsgAssignAccess,
+    AssignStatement as AsgAssignStatement,
+    BinaryExpression as AsgBinaryExpression,
+    BlockStatement as AsgBlockStatement,
+    CallExpression as AsgCallExpression,
+    CastExpression as AsgCastExpression,
+    Circuit as AsgCircuit,
+    CircuitAccessExpression as AsgCircuitAccessExpression,
+    CircuitInitExpression as AsgCircuitInitExpression,
+    CircuitMember as AsgCircuitMember,
+    ConditionalStatement as AsgConditionalStatement,
+    ConsoleFunction as AsgConsoleFunction,
+    ConsoleStatement as AsgConsoleStatement,
+    ConstValue,
+    Constant as AsgConstant,
+    DefinitionStatement as AsgDefinitionStatement,
+    Expression as AsgExpression,
+    ExpressionStatement as AsgExpressionStatement,
+    Function as AsgFunction,
+    GroupValue as AsgGroupValue,
+    IterationStatement as AsgIterationStatement,
+    ReturnStatement as AsgReturnStatement,
+    Statement as AsgStatement,
+    TernaryExpression as AsgTernaryExpression,
+    TupleAccessExpression as AsgTupleAccessExpression,
+    TupleInitExpression as AsgTupleInitExpression,
+    Type as AsgType,
+    UnaryExpression as AsgUnaryExpression,
+    VariableRef as AsgVariableRef,
+};
+use leo_ast::{
+    ArrayAccessExpression as AstArrayAccessExpression,
+    ArrayDimensions,
+    ArrayInitExpression as AstArrayInitExpression,
+    ArrayInlineExpression as AstArrayInlineExpression,
+    ArrayRangeAccessExpression as AstArrayRangeAccessExpression,
+    AssignStatement as AstAssignStatement,
+    Assignee,
+    AssigneeAccess as AstAssignAccess,
+    BinaryExpression as AstBinaryExpression,
+    Block as AstBlockStatement,
+    CallExpression as AstCallExpression,
+    CastExpression as AstCastExpression,
+    Circuit as AstCircuit,
+    CircuitImpliedVariableDefinition,
+    CircuitInitExpression as AstCircuitInitExpression,
+    CircuitMember as AstCircuitMember,
+    CircuitMemberAccessExpression,
+    CircuitStaticFunctionAccessExpression,
+    CombinerError,
+    ConditionalStatement as AstConditionalStatement,
+    ConsoleFunction as AstConsoleFunction,
+    ConsoleStatement as AstConsoleStatement,
+    DefinitionStatement as AstDefinitionStatement,
+    Expression as AstExpression,
+    ExpressionStatement as AstExpressionStatement,
+    FormatString,
+    Function as AstFunction,
+    GroupTuple,
+    GroupValue as AstGroupValue,
+    IterationStatement as AstIterationStatement,
+    PositiveNumber,
+    ReconstructingReducer,
+    ReducerError,
+    ReturnStatement as AstReturnStatement,
+    Span,
+    SpreadOrExpression,
+    Statement as AstStatement,
+    TernaryExpression as AstTernaryExpression,
+    TupleAccessExpression as AstTupleAccessExpression,
+    TupleInitExpression as AstTupleInitExpression,
+    Type as AstType,
+    UnaryExpression as AstUnaryExpression,
+    ValueExpression,
+};
+use tendril::StrTendril;
+
+pub trait CombinerOptions {
+    fn type_inference_enabled(&self) -> bool {
+        false
+    }
+}
+
+pub struct CombineAstAsgDirector<R: ReconstructingReducer, O: CombinerOptions> {
+    ast_reducer: R,
+    options: O,
+}
+
+impl<R: ReconstructingReducer, O: CombinerOptions> CombineAstAsgDirector<R, O> {
+    pub fn new(ast_reducer: R, options: O) -> Self {
+        Self { ast_reducer, options }
+    }
+
+    pub fn reduce_type(&mut self, ast: &AstType, asg: &AsgType, span: &Span) -> Result<AstType, ReducerError> {
+        let new = match (ast, asg) {
+            (AstType::Array(ast_type, ast_dimensions), AsgType::Array(asg_type, asg_dimensions)) => {
+                if self.options.type_inference_enabled() {
+                    AstType::Array(
+                        Box::new(self.reduce_type(ast_type, asg_type, span)?),
+                        ArrayDimensions(vec![PositiveNumber {
+                            value: StrTendril::from(format!("{}", asg_dimensions)),
+                        }]),
+                    )
+                } else {
+                    AstType::Array(
+                        Box::new(self.reduce_type(ast_type, asg_type, span)?),
+                        ast_dimensions.clone(),
+                    )
+                }
+            }
+            (AstType::Tuple(ast_types), AsgType::Tuple(asg_types)) => {
+                let mut reduced_types = vec![];
+                for (ast_type, asg_type) in ast_types.iter().zip(asg_types) {
+                    reduced_types.push(self.reduce_type(ast_type, asg_type, span)?);
+                }
+
+                AstType::Tuple(reduced_types)
+            }
+            _ => ast.clone(),
+        };
+
+        self.ast_reducer.reduce_type(ast, new, span)
+    }
+
+    pub fn reduce_expression(
+        &mut self,
+        ast: &AstExpression,
+        asg: &AsgExpression,
+    ) -> Result<AstExpression, ReducerError> {
+        let new = match (ast, asg) {
+            (AstExpression::Value(value), AsgExpression::Constant(const_)) => {
+                AstExpression::Value(self.reduce_value(&value, &const_)?)
+            }
+            (AstExpression::Binary(ast), AsgExpression::Binary(asg)) => {
+                AstExpression::Binary(self.reduce_binary(&ast, &asg)?)
+            }
+            (AstExpression::Unary(ast), AsgExpression::Unary(asg)) => {
+                AstExpression::Unary(self.reduce_unary(&ast, &asg)?)
+            }
+            (AstExpression::Ternary(ast), AsgExpression::Ternary(asg)) => {
+                AstExpression::Ternary(self.reduce_ternary(&ast, &asg)?)
+            }
+            (AstExpression::Cast(ast), AsgExpression::Cast(asg)) => AstExpression::Cast(self.reduce_cast(&ast, &asg)?),
+
+            (AstExpression::ArrayInline(ast), AsgExpression::ArrayInline(asg)) => {
+                AstExpression::ArrayInline(self.reduce_array_inline(&ast, &asg)?)
+            }
+            (AstExpression::ArrayInit(ast), AsgExpression::ArrayInit(asg)) => {
+                AstExpression::ArrayInit(self.reduce_array_init(&ast, &asg)?)
+            }
+            (AstExpression::ArrayAccess(ast), AsgExpression::ArrayAccess(asg)) => {
+                AstExpression::ArrayAccess(self.reduce_array_access(&ast, &asg)?)
+            }
+            (AstExpression::ArrayRangeAccess(ast), AsgExpression::ArrayRangeAccess(asg)) => {
+                AstExpression::ArrayRangeAccess(self.reduce_array_range_access(&ast, &asg)?)
+            }
+
+            (AstExpression::TupleInit(ast), AsgExpression::TupleInit(asg)) => {
+                AstExpression::TupleInit(self.reduce_tuple_init(&ast, &asg)?)
+            }
+            (AstExpression::TupleAccess(ast), AsgExpression::TupleAccess(asg)) => {
+                AstExpression::TupleAccess(self.reduce_tuple_access(&ast, &asg)?)
+            }
+
+            (AstExpression::CircuitInit(ast), AsgExpression::CircuitInit(asg)) => {
+                AstExpression::CircuitInit(self.reduce_circuit_init(&ast, &asg)?)
+            }
+            (AstExpression::CircuitMemberAccess(ast), AsgExpression::CircuitAccess(asg)) => {
+                AstExpression::CircuitMemberAccess(self.reduce_circuit_member_access(&ast, &asg)?)
+            }
+            (AstExpression::CircuitStaticFunctionAccess(ast), AsgExpression::CircuitAccess(asg)) => {
+                AstExpression::CircuitStaticFunctionAccess(self.reduce_circuit_static_fn_access(&ast, &asg)?)
+            }
+
+            (AstExpression::Call(ast), AsgExpression::Call(asg)) => AstExpression::Call(self.reduce_call(&ast, &asg)?),
+            _ => ast.clone(),
+        };
+
+        self.ast_reducer.reduce_expression(ast, new)
+    }
+
+    pub fn reduce_array_access(
+        &mut self,
+        ast: &AstArrayAccessExpression,
+        asg: &AsgArrayAccessExpression,
+    ) -> Result<AstArrayAccessExpression, ReducerError> {
+        let array = self.reduce_expression(&ast.array, asg.array.get())?;
+        let index = self.reduce_expression(&ast.index, asg.index.get())?;
+
+        self.ast_reducer.reduce_array_access(ast, array, index)
+    }
+
+    pub fn reduce_array_init(
+        &mut self,
+        ast: &AstArrayInitExpression,
+        asg: &AsgArrayInitExpression,
+    ) -> Result<AstArrayInitExpression, ReducerError> {
+        let element = self.reduce_expression(&ast.element, asg.element.get())?;
+
+        self.ast_reducer.reduce_array_init(ast, element)
+    }
+
+    pub fn reduce_array_inline(
+        &mut self,
+        ast: &AstArrayInlineExpression,
+        asg: &AsgArrayInlineExpression,
+    ) -> Result<AstArrayInlineExpression, ReducerError> {
+        let mut elements = vec![];
+        for (ast_element, asg_element) in ast.elements.iter().zip(asg.elements.iter()) {
+            let reduced_element = match ast_element {
+                SpreadOrExpression::Expression(ast_expression) => {
+                    SpreadOrExpression::Expression(self.reduce_expression(ast_expression, asg_element.0.get())?)
+                }
+                SpreadOrExpression::Spread(ast_expression) => {
+                    SpreadOrExpression::Spread(self.reduce_expression(ast_expression, asg_element.0.get())?)
+                }
+            };
+
+            elements.push(reduced_element);
+        }
+
+        self.ast_reducer.reduce_array_inline(ast, elements)
+    }
+
+    pub fn reduce_array_range_access(
+        &mut self,
+        ast: &AstArrayRangeAccessExpression,
+        asg: &AsgArrayRangeAccessExpression,
+    ) -> Result<AstArrayRangeAccessExpression, ReducerError> {
+        let array = self.reduce_expression(&ast.array, asg.array.get())?;
+        let left = match (ast.left.as_ref(), asg.left.get()) {
+            (Some(ast_left), Some(asg_left)) => Some(self.reduce_expression(ast_left, asg_left)?),
+            _ => None,
+        };
+        let right = match (ast.right.as_ref(), asg.right.get()) {
+            (Some(ast_right), Some(asg_right)) => Some(self.reduce_expression(ast_right, asg_right)?),
+            _ => None,
+        };
+
+        self.ast_reducer.reduce_array_range_access(ast, array, left, right)
+    }
+
+    pub fn reduce_binary(
+        &mut self,
+        ast: &AstBinaryExpression,
+        asg: &AsgBinaryExpression,
+    ) -> Result<AstBinaryExpression, ReducerError> {
+        let left = self.reduce_expression(&ast.left, asg.left.get())?;
+        let right = self.reduce_expression(&ast.right, asg.right.get())?;
+
+        self.ast_reducer.reduce_binary(ast, left, right, ast.op.clone())
+    }
+
+    pub fn reduce_call(
+        &mut self,
+        ast: &AstCallExpression,
+        asg: &AsgCallExpression,
+    ) -> Result<AstCallExpression, ReducerError> {
+        // TODO FIGURE IT OUT
+        // let function = self.reduce_expression(&ast.function, asg.function.get())?;
+        // let target = asg.target.get().map(|exp| self.reduce_expression())
+        // Is this needed?
+
+        let mut arguments = vec![];
+        for (ast_arg, asg_arg) in ast.arguments.iter().zip(asg.arguments.iter()) {
+            arguments.push(self.reduce_expression(ast_arg, asg_arg.get())?);
+        }
+
+        self.ast_reducer.reduce_call(ast, *ast.function.clone(), arguments)
+    }
+
+    pub fn reduce_cast(
+        &mut self,
+        ast: &AstCastExpression,
+        asg: &AsgCastExpression,
+    ) -> Result<AstCastExpression, ReducerError> {
+        let inner = self.reduce_expression(&ast.inner, &asg.inner.get())?;
+        let target_type = self.reduce_type(&ast.target_type, &asg.target_type, &ast.span)?;
+
+        self.ast_reducer.reduce_cast(ast, inner, target_type)
+    }
+
+    pub fn reduce_circuit_member_access(
+        &mut self,
+        ast: &CircuitMemberAccessExpression,
+        _asg: &AsgCircuitAccessExpression,
+    ) -> Result<CircuitMemberAccessExpression, ReducerError> {
+        // let circuit = self.reduce_expression(&circuit_member_access.circuit)?;
+        // let name = self.reduce_identifier(&circuit_member_access.name)?;
+        // let target = input.target.get().map(|e| self.reduce_expression(e));
+
+        self.ast_reducer
+            .reduce_circuit_member_access(ast, *ast.circuit.clone(), ast.name.clone())
+    }
+
+    pub fn reduce_circuit_static_fn_access(
+        &mut self,
+        ast: &CircuitStaticFunctionAccessExpression,
+        _asg: &AsgCircuitAccessExpression,
+    ) -> Result<CircuitStaticFunctionAccessExpression, ReducerError> {
+        // let circuit = self.reduce_expression(&circuit_member_access.circuit)?;
+        // let name = self.reduce_identifier(&circuit_member_access.name)?;
+        // let target = input.target.get().map(|e| self.reduce_expression(e));
+
+        self.ast_reducer
+            .reduce_circuit_static_fn_access(ast, *ast.circuit.clone(), ast.name.clone())
+    }
+
+    pub fn reduce_circuit_implied_variable_definition(
+        &mut self,
+        ast: &CircuitImpliedVariableDefinition,
+        asg: &AsgExpression,
+    ) -> Result<CircuitImpliedVariableDefinition, ReducerError> {
+        let expression = ast
+            .expression
+            .as_ref()
+            .map(|ast_expr| self.reduce_expression(ast_expr, asg))
+            .transpose()?;
+
+        self.ast_reducer
+            .reduce_circuit_implied_variable_definition(ast, ast.identifier.clone(), expression)
+    }
+
+    pub fn reduce_circuit_init(
+        &mut self,
+        ast: &AstCircuitInitExpression,
+        asg: &AsgCircuitInitExpression,
+    ) -> Result<AstCircuitInitExpression, ReducerError> {
+        let mut members = vec![];
+        for (ast_member, asg_member) in ast.members.iter().zip(asg.values.iter()) {
+            members.push(self.reduce_circuit_implied_variable_definition(ast_member, asg_member.1.get())?);
+        }
+
+        self.ast_reducer.reduce_circuit_init(ast, ast.name.clone(), members)
+    }
+
+    pub fn reduce_ternary(
+        &mut self,
+        ast: &AstTernaryExpression,
+        asg: &AsgTernaryExpression,
+    ) -> Result<AstTernaryExpression, ReducerError> {
+        let condition = self.reduce_expression(&ast.condition, asg.condition.get())?;
+        let if_true = self.reduce_expression(&ast.if_true, asg.if_true.get())?;
+        let if_false = self.reduce_expression(&ast.if_false, asg.if_false.get())?;
+
+        self.ast_reducer.reduce_ternary(ast, condition, if_true, if_false)
+    }
+
+    pub fn reduce_tuple_access(
+        &mut self,
+        ast: &AstTupleAccessExpression,
+        asg: &AsgTupleAccessExpression,
+    ) -> Result<AstTupleAccessExpression, ReducerError> {
+        let tuple = self.reduce_expression(&ast.tuple, asg.tuple_ref.get())?;
+
+        self.ast_reducer.reduce_tuple_access(ast, tuple)
+    }
+
+    pub fn reduce_tuple_init(
+        &mut self,
+        ast: &AstTupleInitExpression,
+        asg: &AsgTupleInitExpression,
+    ) -> Result<AstTupleInitExpression, ReducerError> {
+        let mut elements = vec![];
+        for (ast_element, asg_element) in ast.elements.iter().zip(asg.elements.iter()) {
+            let element = self.reduce_expression(ast_element, asg_element.get())?;
+            elements.push(element);
+        }
+
+        self.ast_reducer.reduce_tuple_init(ast, elements)
+    }
+
+    pub fn reduce_unary(
+        &mut self,
+        ast: &AstUnaryExpression,
+        asg: &AsgUnaryExpression,
+    ) -> Result<AstUnaryExpression, ReducerError> {
+        let inner = self.reduce_expression(&ast.inner, asg.inner.get())?;
+
+        self.ast_reducer.reduce_unary(ast, inner, ast.op.clone())
+    }
+
+    pub fn reduce_value(&mut self, ast: &ValueExpression, asg: &AsgConstant) -> Result<ValueExpression, ReducerError> {
+        let mut new = ast.clone();
+
+        if self.options.type_inference_enabled() {
+            if let ValueExpression::Implicit(tendril, span) = ast {
+                match &asg.value {
+                    ConstValue::Int(int) => {
+                        new = ValueExpression::Integer(int.get_int_type(), tendril.clone(), span.clone());
+                    }
+                    ConstValue::Group(group) => {
+                        let group_value = match group {
+                            AsgGroupValue::Single(_) => AstGroupValue::Single(tendril.clone(), span.clone()),
+                            AsgGroupValue::Tuple(x, y) => AstGroupValue::Tuple(GroupTuple {
+                                x: x.into(),
+                                y: y.into(),
+                                span: span.clone(),
+                            }),
+                        };
+                        new = ValueExpression::Group(Box::new(group_value));
+                    }
+                    ConstValue::Field(_) => {
+                        new = ValueExpression::Field(tendril.clone(), span.clone());
+                    }
+                    ConstValue::Address(_) => {
+                        new = ValueExpression::Address(tendril.clone(), span.clone());
+                    }
+                    ConstValue::Boolean(_) => {
+                        new = ValueExpression::Boolean(tendril.clone(), span.clone());
+                    }
+                    _ => unimplemented!(), // impossible?
+                }
+            }
+        }
+
+        self.ast_reducer.reduce_value(ast, new)
+    }
+
+    pub fn reduce_variable_ref(
+        &mut self,
+        ast: &ValueExpression,
+        _asg: &AsgVariableRef,
+    ) -> Result<ValueExpression, ReducerError> {
+        // TODO FIGURE IT OUT
+        let new = match ast {
+            // ValueExpression::Group(group_value) => {
+            //     ValueExpression::Group(Box::new(self.reduce_group_value(&group_value)?))
+            // }
+            _ => ast.clone(),
+        };
+
+        Ok(new)
+        // self.ast_reducer.reduce_value(value, new)
+    }
+
+    pub fn reduce_statement(
+        &mut self,
+        ast_statement: &AstStatement,
+        asg_statement: &AsgStatement,
+    ) -> Result<AstStatement, ReducerError> {
+        let new = match (ast_statement, asg_statement) {
+            (AstStatement::Assign(ast), AsgStatement::Assign(asg)) => {
+                AstStatement::Assign(self.reduce_assign(ast, asg)?)
+            }
+            (AstStatement::Block(ast), AsgStatement::Block(asg)) => AstStatement::Block(self.reduce_block(ast, asg)?),
+            (AstStatement::Conditional(ast), AsgStatement::Conditional(asg)) => {
+                AstStatement::Conditional(self.reduce_conditional(ast, asg)?)
+            }
+            (AstStatement::Console(ast), AsgStatement::Console(asg)) => {
+                AstStatement::Console(self.reduce_console(ast, asg)?)
+            }
+            (AstStatement::Definition(ast), AsgStatement::Definition(asg)) => {
+                AstStatement::Definition(self.reduce_definition(ast, asg)?)
+            }
+            (AstStatement::Expression(ast), AsgStatement::Expression(asg)) => {
+                AstStatement::Expression(self.reduce_expression_statement(ast, asg)?)
+            }
+            (AstStatement::Iteration(ast), AsgStatement::Iteration(asg)) => {
+                AstStatement::Iteration(self.reduce_iteration(ast, asg)?)
+            }
+            (AstStatement::Return(ast), AsgStatement::Return(asg)) => {
+                AstStatement::Return(self.reduce_return(ast, asg)?)
+            }
+            _ => ast_statement.clone(),
+        };
+
+        self.ast_reducer.reduce_statement(ast_statement, new)
+    }
+
+    pub fn reduce_assign_access(
+        &mut self,
+        ast: &AstAssignAccess,
+        asg: &AsgAssignAccess,
+    ) -> Result<AstAssignAccess, ReducerError> {
+        let new = match (ast, asg) {
+            (AstAssignAccess::ArrayRange(ast_left, ast_right), AsgAssignAccess::ArrayRange(asg_left, asg_right)) => {
+                let left = match (ast_left.as_ref(), asg_left.get()) {
+                    (Some(ast_left), Some(asg_left)) => Some(self.reduce_expression(ast_left, asg_left)?),
+                    _ => None,
+                };
+                let right = match (ast_right.as_ref(), asg_right.get()) {
+                    (Some(ast_right), Some(asg_right)) => Some(self.reduce_expression(ast_right, asg_right)?),
+                    _ => None,
+                };
+
+                AstAssignAccess::ArrayRange(left, right)
+            }
+            (AstAssignAccess::ArrayIndex(ast_index), AsgAssignAccess::ArrayIndex(asg_index)) => {
+                let index = self.reduce_expression(&ast_index, asg_index.get())?;
+                AstAssignAccess::ArrayIndex(index)
+            }
+            _ => ast.clone(),
+        };
+
+        self.ast_reducer.reduce_assignee_access(ast, new)
+    }
+
+    pub fn reduce_assignee(&mut self, ast: &Assignee, asg: &[AsgAssignAccess]) -> Result<Assignee, ReducerError> {
+        let mut accesses = vec![];
+        for (ast_access, asg_access) in ast.accesses.iter().zip(asg) {
+            accesses.push(self.reduce_assign_access(ast_access, asg_access)?);
+        }
+
+        self.ast_reducer.reduce_assignee(ast, ast.identifier.clone(), accesses)
+    }
+
+    pub fn reduce_assign(
+        &mut self,
+        ast: &AstAssignStatement,
+        asg: &AsgAssignStatement,
+    ) -> Result<AstAssignStatement, ReducerError> {
+        let assignee = self.reduce_assignee(&ast.assignee, &asg.target_accesses)?;
+        let value = self.reduce_expression(&ast.value, asg.value.get())?;
+
+        self.ast_reducer.reduce_assign(ast, assignee, value)
+    }
+
+    pub fn reduce_block(
+        &mut self,
+        ast: &AstBlockStatement,
+        asg: &AsgBlockStatement,
+    ) -> Result<AstBlockStatement, ReducerError> {
+        let mut statements = vec![];
+        for (ast_statement, asg_statement) in ast.statements.iter().zip(asg.statements.iter()) {
+            statements.push(self.reduce_statement(ast_statement, asg_statement.get())?);
+        }
+
+        self.ast_reducer.reduce_block(ast, statements)
+    }
+
+    pub fn reduce_conditional(
+        &mut self,
+        ast: &AstConditionalStatement,
+        asg: &AsgConditionalStatement,
+    ) -> Result<AstConditionalStatement, ReducerError> {
+        let condition = self.reduce_expression(&ast.condition, asg.condition.get())?;
+        let block;
+        if let AsgStatement::Block(asg_block) = asg.result.get() {
+            block = self.reduce_block(&ast.block, asg_block)?;
+        } else {
+            return Err(ReducerError::from(CombinerError::asg_statement_not_block(
+                &asg.span.as_ref().unwrap(),
+            )));
+        }
+        let next = match (ast.next.as_ref(), asg.next.get()) {
+            (Some(ast_next), Some(asg_next)) => Some(self.reduce_statement(ast_next, asg_next)?),
+            _ => None,
+        };
+
+        self.ast_reducer.reduce_conditional(ast, condition, block, next)
+    }
+
+    pub fn reduce_console(
+        &mut self,
+        ast: &AstConsoleStatement,
+        asg: &AsgConsoleStatement,
+    ) -> Result<AstConsoleStatement, ReducerError> {
+        let function = match (&ast.function, &asg.function) {
+            (AstConsoleFunction::Assert(ast_expression), AsgConsoleFunction::Assert(asg_expression)) => {
+                AstConsoleFunction::Assert(self.reduce_expression(&ast_expression, asg_expression.get())?)
+            }
+            (AstConsoleFunction::Debug(ast_format), AsgConsoleFunction::Debug(asg_format))
+            | (AstConsoleFunction::Error(ast_format), AsgConsoleFunction::Error(asg_format))
+            | (AstConsoleFunction::Log(ast_format), AsgConsoleFunction::Log(asg_format)) => {
+                let mut parameters = vec![];
+                for (ast_parameter, asg_parameter) in ast_format.parameters.iter().zip(asg_format.parameters.iter()) {
+                    parameters.push(self.reduce_expression(&ast_parameter, asg_parameter.get())?);
+                }
+
+                let formatted = FormatString {
+                    parts: ast_format.parts.clone(),
+                    parameters,
+                    span: ast_format.span.clone(),
+                };
+
+                match &ast.function {
+                    AstConsoleFunction::Debug(_) => AstConsoleFunction::Debug(formatted),
+                    AstConsoleFunction::Error(_) => AstConsoleFunction::Error(formatted),
+                    AstConsoleFunction::Log(_) => AstConsoleFunction::Log(formatted),
+                    _ => return Err(ReducerError::impossible_console_assert_call(&ast_format.span)),
+                }
+            }
+            _ => ast.function.clone(),
+        };
+
+        self.ast_reducer.reduce_console(ast, function)
+    }
+
+    pub fn reduce_definition(
+        &mut self,
+        ast: &AstDefinitionStatement,
+        asg: &AsgDefinitionStatement,
+    ) -> Result<AstDefinitionStatement, ReducerError> {
+        let type_;
+
+        if asg.variables.len() > 1 {
+            let mut types = vec![];
+            for variable in asg.variables.iter() {
+                types.push(variable.borrow().type_.clone());
+            }
+
+            let asg_type = AsgType::Tuple(types);
+
+            type_ = match &ast.type_ {
+                Some(ast_type) => Some(self.reduce_type(&ast_type, &asg_type, &ast.span)?),
+                None if self.options.type_inference_enabled() => Some((&asg_type).into()),
+                _ => None,
+            };
+        } else {
+            type_ = match &ast.type_ {
+                Some(ast_type) => {
+                    Some(self.reduce_type(&ast_type, &asg.variables.first().unwrap().borrow().type_, &ast.span)?)
+                }
+                None if self.options.type_inference_enabled() => {
+                    Some((&asg.variables.first().unwrap().borrow().type_).into())
+                }
+                _ => None,
+            };
+        }
+
+        let value = self.reduce_expression(&ast.value, asg.value.get())?;
+
+        self.ast_reducer
+            .reduce_definition(ast, ast.variable_names.clone(), type_, value)
+    }
+
+    pub fn reduce_expression_statement(
+        &mut self,
+        ast: &AstExpressionStatement,
+        asg: &AsgExpressionStatement,
+    ) -> Result<AstExpressionStatement, ReducerError> {
+        let inner_expression = self.reduce_expression(&ast.expression, asg.expression.get())?;
+        self.ast_reducer.reduce_expression_statement(ast, inner_expression)
+    }
+
+    pub fn reduce_iteration(
+        &mut self,
+        ast: &AstIterationStatement,
+        asg: &AsgIterationStatement,
+    ) -> Result<AstIterationStatement, ReducerError> {
+        let start = self.reduce_expression(&ast.start, asg.start.get())?;
+        let stop = self.reduce_expression(&ast.stop, asg.stop.get())?;
+        let block;
+        if let AsgStatement::Block(asg_block) = asg.body.get() {
+            block = self.reduce_block(&ast.block, asg_block)?;
+        } else {
+            return Err(ReducerError::from(CombinerError::asg_statement_not_block(
+                &asg.span.as_ref().unwrap(),
+            )));
+        }
+
+        self.ast_reducer
+            .reduce_iteration(ast, ast.variable.clone(), start, stop, block)
+    }
+
+    pub fn reduce_return(
+        &mut self,
+        ast: &AstReturnStatement,
+        asg: &AsgReturnStatement,
+    ) -> Result<AstReturnStatement, ReducerError> {
+        let expression = self.reduce_expression(&ast.expression, asg.expression.get())?;
+
+        self.ast_reducer.reduce_return(ast, expression)
+    }
+
+    pub fn reduce_program(
+        &mut self,
+        ast: &leo_ast::Program,
+        asg: &leo_asg::Program,
+    ) -> Result<leo_ast::Program, leo_ast::ReducerError> {
+        self.ast_reducer.swap_in_circuit();
+        let mut circuits = IndexMap::new();
+        for ((ast_ident, ast_circuit), (_asg_ident, asg_circuit)) in ast.circuits.iter().zip(&asg.circuits) {
+            circuits.insert(ast_ident.clone(), self.reduce_circuit(ast_circuit, asg_circuit)?);
+        }
+        self.ast_reducer.swap_in_circuit();
+
+        let mut functions = IndexMap::new();
+        for ((ast_ident, ast_function), (_asg_ident, asg_function)) in ast.functions.iter().zip(&asg.functions) {
+            functions.insert(ast_ident.clone(), self.reduce_function(ast_function, asg_function)?);
+        }
+
+        self.ast_reducer.reduce_program(
+            ast,
+            ast.expected_input.clone(),
+            ast.imports.clone(),
+            circuits,
+            functions,
+        )
+    }
+
+    pub fn reduce_function(&mut self, ast: &AstFunction, asg: &AsgFunction) -> Result<AstFunction, ReducerError> {
+        let output = ast
+            .output
+            .as_ref()
+            .map(|type_| self.reduce_type(type_, &asg.output, &ast.span))
+            .transpose()?;
+
+        let mut statements = vec![];
+        if let Some(AsgStatement::Block(asg_block)) = asg.body.get() {
+            for (ast_statement, asg_statement) in ast.block.statements.iter().zip(asg_block.statements.iter()) {
+                statements.push(self.reduce_statement(ast_statement, asg_statement.get())?);
+            }
+        }
+
+        let block = AstBlockStatement {
+            statements,
+            span: ast.block.span.clone(),
+        };
+
+        self.ast_reducer.reduce_function(
+            ast,
+            ast.identifier.clone(),
+            ast.annotations.clone(),
+            ast.input.clone(),
+            output,
+            block,
+        )
+    }
+
+    pub fn reduce_circuit_member(
+        &mut self,
+        ast: &AstCircuitMember,
+        asg: &AsgCircuitMember,
+    ) -> Result<AstCircuitMember, ReducerError> {
+        let new = match (ast, asg) {
+            (AstCircuitMember::CircuitVariable(identifier, ast_type), AsgCircuitMember::Variable(asg_type)) => {
+                AstCircuitMember::CircuitVariable(
+                    identifier.clone(),
+                    self.reduce_type(ast_type, asg_type, &identifier.span)?,
+                )
+            }
+            (AstCircuitMember::CircuitFunction(ast_function), AsgCircuitMember::Function(asg_function)) => {
+                AstCircuitMember::CircuitFunction(self.reduce_function(ast_function, asg_function)?)
+            }
+            _ => ast.clone(),
+        };
+
+        self.ast_reducer.reduce_circuit_member(ast, new)
+    }
+
+    pub fn reduce_circuit(&mut self, ast: &AstCircuit, asg: &AsgCircuit) -> Result<AstCircuit, ReducerError> {
+        let mut members = vec![];
+        for (ast_member, asg_member) in ast.members.iter().zip(asg.members.borrow().iter()) {
+            members.push(self.reduce_circuit_member(ast_member, asg_member.1)?);
+        }
+
+        self.ast_reducer.reduce_circuit(ast, ast.circuit_name.clone(), members)
+    }
+}

compiler/tests/canonicalization/compound_assignment.json

@@ -225,7 +225,9 @@
                   }
                 }
               ],
-              "type_": null,
+              "type_": {
+                "IntegerType": "U32"
+              },
               "value": {
                 "Value": {
                   "Integer": [
@@ -274,7 +276,8 @@
                   },
                   "right": {
                     "Value": {
-                      "Implicit": [
+                      "Integer": [
+                        "U32",
                         "20",
                         {
                           "line_start": 12,
@@ -371,7 +374,18 @@
                   }
                 }
               ],
-              "type_": null,
+              "type_": {
+                "Array": [
+                  {
+                    "IntegerType": "U8"
+                  },
+                  [
+                    {
+                      "value": "2"
+                    }
+                  ]
+                ]
+              },
               "value": {
                 "ArrayInline": {
                   "elements": [
@@ -441,7 +455,8 @@
                   {
                     "ArrayIndex": {
                       "Value": {
-                        "Implicit": [
+                        "Integer": [
+                          "U32",
                           "0",
                           {
                             "line_start": 16,
@@ -474,7 +489,8 @@
                       },
                       "index": {
                         "Value": {
-                          "Implicit": [
+                          "Integer": [
+                            "U32",
                             "0",
                             {
                               "line_start": 16,
@@ -546,7 +562,8 @@
                         },
                         "index": {
                           "Value": {
-                            "Implicit": [
+                            "Integer": [
+                              "U32",
                               "0",
                               {
                                 "line_start": 17,
@@ -624,7 +641,16 @@
                   }
                 }
               ],
-              "type_": null,
+              "type_": {
+                "Tuple": [
+                  {
+                    "IntegerType": "U8"
+                  },
+                  {
+                    "IntegerType": "U8"
+                  }
+                ]
+              },
               "value": {
                 "TupleInit": {
                   "elements": [
@@ -847,7 +873,9 @@
                   }
                 }
               ],
-              "type_": null,
+              "type_": {
+                "Circuit": "{\"name\":\"Foo\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":12,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"circuit Foo {\\\"}\"}"
+              },
               "value": {
                 "CircuitInit": {
                   "name": "{\"name\":\"Foo\",\"span\":\"{\\\"line_start\\\":23,\\\"line_stop\\\":23,\\\"col_start\\\":13,\\\"col_stop\\\":16,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  let foo = Foo { f: 6u8, y: (1u8, 1u8) };\\\"}\"}",
@@ -1080,18 +1108,245 @@
               "variable_names": [
                 {
                   "mutable": true,
-                  "identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":27,\\\"line_stop\\\":27,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  let a = [[0u8; 1]; 4];\\\"}\"}",
+                  "identifier": "{\"name\":\"complex\",\"span\":\"{\\\"line_start\\\":27,\\\"line_stop\\\":27,\\\"col_start\\\":7,\\\"col_stop\\\":14,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  let complex = 2u8;\\\"}\"}",
                   "span": {
                     "line_start": 27,
                     "line_stop": 27,
                     "col_start": 7,
+                    "col_stop": 14,
+                    "path": "",
+                    "content": "  let complex = 2u8;"
+                  }
+                }
+              ],
+              "type_": {
+                "IntegerType": "U8"
+              },
+              "value": {
+                "Value": {
+                  "Integer": [
+                    "U8",
+                    "2",
+                    {
+                      "line_start": 27,
+                      "line_stop": 27,
+                      "col_start": 17,
+                      "col_stop": 20,
+                      "path": "",
+                      "content": "  let complex = 2u8;"
+                    }
+                  ]
+                }
+              },
+              "span": {
+                "line_start": 27,
+                "line_stop": 27,
+                "col_start": 3,
+                "col_stop": 20,
+                "path": "",
+                "content": "  let complex = 2u8;"
+              }
+            }
+          },
+          {
+            "Assign": {
+              "operation": "Assign",
+              "assignee": {
+                "identifier": "{\"name\":\"complex\",\"span\":\"{\\\"line_start\\\":28,\\\"line_stop\\\":28,\\\"col_start\\\":3,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  complex += 22u8 - 2u8+ 1u8;\\\"}\"}",
+                "accesses": [],
+                "span": {
+                  "line_start": 28,
+                  "line_stop": 28,
+                  "col_start": 3,
+                  "col_stop": 10,
+                  "path": "",
+                  "content": "  complex += 22u8 - 2u8+ 1u8;"
+                }
+              },
+              "value": {
+                "Binary": {
+                  "left": {
+                    "Identifier": "{\"name\":\"complex\",\"span\":\"{\\\"line_start\\\":28,\\\"line_stop\\\":28,\\\"col_start\\\":3,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  complex += 22u8 - 2u8+ 1u8;\\\"}\"}"
+                  },
+                  "right": {
+                    "Binary": {
+                      "left": {
+                        "Binary": {
+                          "left": {
+                            "Value": {
+                              "Integer": [
+                                "U8",
+                                "22",
+                                {
+                                  "line_start": 28,
+                                  "line_stop": 28,
+                                  "col_start": 14,
+                                  "col_stop": 18,
+                                  "path": "",
+                                  "content": "  complex += 22u8 - 2u8+ 1u8;"
+                                }
+                              ]
+                            }
+                          },
+                          "right": {
+                            "Value": {
+                              "Integer": [
+                                "U8",
+                                "2",
+                                {
+                                  "line_start": 28,
+                                  "line_stop": 28,
+                                  "col_start": 21,
+                                  "col_stop": 24,
+                                  "path": "",
+                                  "content": "  complex += 22u8 - 2u8+ 1u8;"
+                                }
+                              ]
+                            }
+                          },
+                          "op": "Sub",
+                          "span": {
+                            "line_start": 28,
+                            "line_stop": 28,
+                            "col_start": 14,
+                            "col_stop": 24,
+                            "path": "",
+                            "content": "  complex += 22u8 - 2u8+ 1u8;"
+                          }
+                        }
+                      },
+                      "right": {
+                        "Value": {
+                          "Integer": [
+                            "U8",
+                            "1",
+                            {
+                              "line_start": 28,
+                              "line_stop": 28,
+                              "col_start": 26,
+                              "col_stop": 29,
+                              "path": "",
+                              "content": "  complex += 22u8 - 2u8+ 1u8;"
+                            }
+                          ]
+                        }
+                      },
+                      "op": "Add",
+                      "span": {
+                        "line_start": 28,
+                        "line_stop": 28,
+                        "col_start": 14,
+                        "col_stop": 29,
+                        "path": "",
+                        "content": "  complex += 22u8 - 2u8+ 1u8;"
+                      }
+                    }
+                  },
+                  "op": "Add",
+                  "span": {
+                    "line_start": 28,
+                    "line_stop": 28,
+                    "col_start": 3,
+                    "col_stop": 29,
+                    "path": "",
+                    "content": "  complex += 22u8 - 2u8+ 1u8;"
+                  }
+                }
+              },
+              "span": {
+                "line_start": 28,
+                "line_stop": 28,
+                "col_start": 3,
+                "col_stop": 29,
+                "path": "",
+                "content": "  complex += 22u8 - 2u8+ 1u8;"
+              }
+            }
+          },
+          {
+            "Console": {
+              "function": {
+                "Assert": {
+                  "Binary": {
+                    "left": {
+                      "Identifier": "{\"name\":\"complex\",\"span\":\"{\\\"line_start\\\":29,\\\"line_stop\\\":29,\\\"col_start\\\":18,\\\"col_stop\\\":25,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  console.assert(complex == 23u8);\\\"}\"}"
+                    },
+                    "right": {
+                      "Value": {
+                        "Integer": [
+                          "U8",
+                          "23",
+                          {
+                            "line_start": 29,
+                            "line_stop": 29,
+                            "col_start": 29,
+                            "col_stop": 33,
+                            "path": "",
+                            "content": "  console.assert(complex == 23u8);"
+                          }
+                        ]
+                      }
+                    },
+                    "op": "Eq",
+                    "span": {
+                      "line_start": 29,
+                      "line_stop": 29,
+                      "col_start": 18,
+                      "col_stop": 33,
+                      "path": "",
+                      "content": "  console.assert(complex == 23u8);"
+                    }
+                  }
+                }
+              },
+              "span": {
+                "line_start": 29,
+                "line_stop": 29,
+                "col_start": 3,
+                "col_stop": 33,
+                "path": "",
+                "content": "  console.assert(complex == 23u8);"
+              }
+            }
+          },
+          {
+            "Definition": {
+              "declaration_type": "Let",
+              "variable_names": [
+                {
+                  "mutable": true,
+                  "identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":30,\\\"line_stop\\\":30,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  let a = [[0u8; 1]; 4];\\\"}\"}",
+                  "span": {
+                    "line_start": 30,
+                    "line_stop": 30,
+                    "col_start": 7,
                     "col_stop": 8,
                     "path": "",
                     "content": "  let a = [[0u8; 1]; 4];"
                   }
                 }
               ],
-              "type_": null,
+              "type_": {
+                "Array": [
+                  {
+                    "Array": [
+                      {
+                        "IntegerType": "U8"
+                      },
+                      [
+                        {
+                          "value": "1"
+                        }
+                      ]
+                    ]
+                  },
+                  [
+                    {
+                      "value": "4"
+                    }
+                  ]
+                ]
+              },
               "value": {
                 "ArrayInit": {
                   "element": {
@@ -1102,8 +1357,8 @@
                             "U8",
                             "0",
                             {
-                              "line_start": 27,
-                              "line_stop": 27,
+                              "line_start": 30,
+                              "line_stop": 30,
                               "col_start": 13,
                               "col_stop": 16,
                               "path": "",
@@ -1118,8 +1373,8 @@
                         }
                       ],
                       "span": {
-                        "line_start": 27,
-                        "line_stop": 27,
+                        "line_start": 30,
+                        "line_stop": 30,
                         "col_start": 12,
                         "col_stop": 20,
                         "path": "",
@@ -1133,8 +1388,8 @@
                     }
                   ],
                   "span": {
-                    "line_start": 27,
-                    "line_stop": 27,
+                    "line_start": 30,
+                    "line_stop": 30,
                     "col_start": 11,
                     "col_stop": 24,
                     "path": "",
@@ -1143,8 +1398,8 @@
                 }
               },
               "span": {
-                "line_start": 27,
-                "line_stop": 27,
+                "line_start": 30,
+                "line_stop": 30,
                 "col_start": 3,
                 "col_stop": 24,
                 "path": "",
@@ -1156,16 +1411,17 @@
             "Assign": {
               "operation": "Assign",
               "assignee": {
-                "identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":28,\\\"line_stop\\\":28,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  a[2][0] += 1u8;\\\"}\"}",
+                "identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":31,\\\"line_stop\\\":31,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  a[2][0] += 1u8;\\\"}\"}",
                 "accesses": [
                   {
                     "ArrayIndex": {
                       "Value": {
-                        "Implicit": [
+                        "Integer": [
+                          "U32",
                           "2",
                           {
-                            "line_start": 28,
-                            "line_stop": 28,
+                            "line_start": 31,
+                            "line_stop": 31,
                             "col_start": 5,
                             "col_stop": 6,
                             "path": "",
@@ -1178,11 +1434,12 @@
                   {
                     "ArrayIndex": {
                       "Value": {
-                        "Implicit": [
+                        "Integer": [
+                          "U32",
                           "0",
                           {
-                            "line_start": 28,
-                            "line_stop": 28,
+                            "line_start": 31,
+                            "line_stop": 31,
                             "col_start": 8,
                             "col_stop": 9,
                             "path": "",
@@ -1194,8 +1451,8 @@
                   }
                 ],
                 "span": {
-                  "line_start": 28,
-                  "line_stop": 28,
+                  "line_start": 31,
+                  "line_stop": 31,
                   "col_start": 3,
                   "col_stop": 10,
                   "path": "",
@@ -1209,15 +1466,16 @@
                       "array": {
                         "ArrayAccess": {
                           "array": {
-                            "Identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":28,\\\"line_stop\\\":28,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  a[2][0] += 1u8;\\\"}\"}"
+                            "Identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":31,\\\"line_stop\\\":31,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  a[2][0] += 1u8;\\\"}\"}"
                           },
                           "index": {
                             "Value": {
-                              "Implicit": [
+                              "Integer": [
+                                "U32",
                                 "2",
                                 {
-                                  "line_start": 28,
-                                  "line_stop": 28,
+                                  "line_start": 31,
+                                  "line_stop": 31,
                                   "col_start": 5,
                                   "col_stop": 6,
                                   "path": "",
@@ -1227,8 +1485,8 @@
                             }
                           },
                           "span": {
-                            "line_start": 28,
-                            "line_stop": 28,
+                            "line_start": 31,
+                            "line_stop": 31,
                             "col_start": 3,
                             "col_stop": 17,
                             "path": "",
@@ -1238,11 +1496,12 @@
                       },
                       "index": {
                         "Value": {
-                          "Implicit": [
+                          "Integer": [
+                            "U32",
                             "0",
                             {
-                              "line_start": 28,
-                              "line_stop": 28,
+                              "line_start": 31,
+                              "line_stop": 31,
                               "col_start": 8,
                               "col_stop": 9,
                               "path": "",
@@ -1252,8 +1511,8 @@
                         }
                       },
                       "span": {
-                        "line_start": 28,
-                        "line_stop": 28,
+                        "line_start": 31,
+                        "line_stop": 31,
                         "col_start": 3,
                         "col_stop": 17,
                         "path": "",
@@ -1267,8 +1526,8 @@
                         "U8",
                         "1",
                         {
-                          "line_start": 28,
-                          "line_stop": 28,
+                          "line_start": 31,
+                          "line_stop": 31,
                           "col_start": 14,
                           "col_stop": 17,
                           "path": "",
@@ -1279,8 +1538,8 @@
                   },
                   "op": "Add",
                   "span": {
-                    "line_start": 28,
-                    "line_stop": 28,
+                    "line_start": 31,
+                    "line_stop": 31,
                     "col_start": 3,
                     "col_stop": 17,
                     "path": "",
@@ -1289,8 +1548,8 @@
                 }
               },
               "span": {
-                "line_start": 28,
-                "line_stop": 28,
+                "line_start": 31,
+                "line_stop": 31,
                 "col_start": 3,
                 "col_stop": 17,
                 "path": "",
@@ -1308,15 +1567,16 @@
                         "array": {
                           "ArrayAccess": {
                             "array": {
-                              "Identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":29,\\\"line_stop\\\":29,\\\"col_start\\\":18,\\\"col_stop\\\":19,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  console.assert(a[2][0] == 1u8);\\\"}\"}"
+                              "Identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":32,\\\"line_stop\\\":32,\\\"col_start\\\":18,\\\"col_stop\\\":19,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  console.assert(a[2][0] == 1u8);\\\"}\"}"
                             },
                             "index": {
                               "Value": {
-                                "Implicit": [
+                                "Integer": [
+                                  "U32",
                                   "2",
                                   {
-                                    "line_start": 29,
-                                    "line_stop": 29,
+                                    "line_start": 32,
+                                    "line_stop": 32,
                                     "col_start": 20,
                                     "col_stop": 21,
                                     "path": "",
@@ -1326,8 +1586,8 @@
                               }
                             },
                             "span": {
-                              "line_start": 29,
-                              "line_stop": 29,
+                              "line_start": 32,
+                              "line_stop": 32,
                               "col_start": 18,
                               "col_stop": 22,
                               "path": "",
@@ -1337,11 +1597,12 @@
                         },
                         "index": {
                           "Value": {
-                            "Implicit": [
+                            "Integer": [
+                              "U32",
                               "0",
                               {
-                                "line_start": 29,
-                                "line_stop": 29,
+                                "line_start": 32,
+                                "line_stop": 32,
                                 "col_start": 23,
                                 "col_stop": 24,
                                 "path": "",
@@ -1351,8 +1612,8 @@
                           }
                         },
                         "span": {
-                          "line_start": 29,
-                          "line_stop": 29,
+                          "line_start": 32,
+                          "line_stop": 32,
                           "col_start": 18,
                           "col_stop": 25,
                           "path": "",
@@ -1366,8 +1627,8 @@
                           "U8",
                           "1",
                           {
-                            "line_start": 29,
-                            "line_stop": 29,
+                            "line_start": 32,
+                            "line_stop": 32,
                             "col_start": 29,
                             "col_stop": 32,
                             "path": "",
@@ -1378,8 +1639,8 @@
                     },
                     "op": "Eq",
                     "span": {
-                      "line_start": 29,
-                      "line_stop": 29,
+                      "line_start": 32,
+                      "line_stop": 32,
                       "col_start": 18,
                       "col_stop": 32,
                       "path": "",
@@ -1389,8 +1650,8 @@
                 }
               },
               "span": {
-                "line_start": 29,
-                "line_stop": 29,
+                "line_start": 32,
+                "line_stop": 32,
                 "col_start": 3,
                 "col_stop": 32,
                 "path": "",
@@ -1404,10 +1665,10 @@
               "variable_names": [
                 {
                   "mutable": true,
-                  "identifier": "{\"name\":\"b\",\"span\":\"{\\\"line_start\\\":31,\\\"line_stop\\\":31,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  let b = [0u8; (4, 1)];\\\"}\"}",
+                  "identifier": "{\"name\":\"b\",\"span\":\"{\\\"line_start\\\":34,\\\"line_stop\\\":34,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  let b = [0u8; (4, 1)];\\\"}\"}",
                   "span": {
-                    "line_start": 31,
-                    "line_stop": 31,
+                    "line_start": 34,
+                    "line_stop": 34,
                     "col_start": 7,
                     "col_stop": 8,
                     "path": "",
@@ -1415,7 +1676,27 @@
                   }
                 }
               ],
-              "type_": null,
+              "type_": {
+                "Array": [
+                  {
+                    "Array": [
+                      {
+                        "IntegerType": "U8"
+                      },
+                      [
+                        {
+                          "value": "1"
+                        }
+                      ]
+                    ]
+                  },
+                  [
+                    {
+                      "value": "4"
+                    }
+                  ]
+                ]
+              },
               "value": {
                 "ArrayInit": {
                   "element": {
@@ -1426,8 +1707,8 @@
                             "U8",
                             "0",
                             {
-                              "line_start": 31,
-                              "line_stop": 31,
+                              "line_start": 34,
+                              "line_stop": 34,
                               "col_start": 12,
                               "col_stop": 15,
                               "path": "",
@@ -1442,8 +1723,8 @@
                         }
                       ],
                       "span": {
-                        "line_start": 31,
-                        "line_stop": 31,
+                        "line_start": 34,
+                        "line_stop": 34,
                         "col_start": 11,
                         "col_stop": 24,
                         "path": "",
@@ -1457,8 +1738,8 @@
                     }
                   ],
                   "span": {
-                    "line_start": 31,
-                    "line_stop": 31,
+                    "line_start": 34,
+                    "line_stop": 34,
                     "col_start": 11,
                     "col_stop": 24,
                     "path": "",
@@ -1467,8 +1748,8 @@
                 }
               },
               "span": {
-                "line_start": 31,
-                "line_stop": 31,
+                "line_start": 34,
+                "line_stop": 34,
                 "col_start": 3,
                 "col_stop": 24,
                 "path": "",
@@ -1480,16 +1761,17 @@
             "Assign": {
               "operation": "Assign",
               "assignee": {
-                "identifier": "{\"name\":\"b\",\"span\":\"{\\\"line_start\\\":32,\\\"line_stop\\\":32,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  b[2][0] += 1u8;\\\"}\"}",
+                "identifier": "{\"name\":\"b\",\"span\":\"{\\\"line_start\\\":35,\\\"line_stop\\\":35,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  b[2][0] += 1u8;\\\"}\"}",
                 "accesses": [
                   {
                     "ArrayIndex": {
                       "Value": {
-                        "Implicit": [
+                        "Integer": [
+                          "U32",
                           "2",
                           {
-                            "line_start": 32,
-                            "line_stop": 32,
+                            "line_start": 35,
+                            "line_stop": 35,
                             "col_start": 5,
                             "col_stop": 6,
                             "path": "",
@@ -1502,11 +1784,12 @@
                   {
                     "ArrayIndex": {
                       "Value": {
-                        "Implicit": [
+                        "Integer": [
+                          "U32",
                           "0",
                           {
-                            "line_start": 32,
-                            "line_stop": 32,
+                            "line_start": 35,
+                            "line_stop": 35,
                             "col_start": 8,
                             "col_stop": 9,
                             "path": "",
@@ -1518,8 +1801,8 @@
                   }
                 ],
                 "span": {
-                  "line_start": 32,
-                  "line_stop": 32,
+                  "line_start": 35,
+                  "line_stop": 35,
                   "col_start": 3,
                   "col_stop": 10,
                   "path": "",
@@ -1533,15 +1816,16 @@
                       "array": {
                         "ArrayAccess": {
                           "array": {
-                            "Identifier": "{\"name\":\"b\",\"span\":\"{\\\"line_start\\\":32,\\\"line_stop\\\":32,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  b[2][0] += 1u8;\\\"}\"}"
+                            "Identifier": "{\"name\":\"b\",\"span\":\"{\\\"line_start\\\":35,\\\"line_stop\\\":35,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  b[2][0] += 1u8;\\\"}\"}"
                           },
                           "index": {
                             "Value": {
-                              "Implicit": [
+                              "Integer": [
+                                "U32",
                                 "2",
                                 {
-                                  "line_start": 32,
-                                  "line_stop": 32,
+                                  "line_start": 35,
+                                  "line_stop": 35,
                                   "col_start": 5,
                                   "col_stop": 6,
                                   "path": "",
@@ -1551,8 +1835,8 @@
                             }
                           },
                           "span": {
-                            "line_start": 32,
-                            "line_stop": 32,
+                            "line_start": 35,
+                            "line_stop": 35,
                             "col_start": 3,
                             "col_stop": 17,
                             "path": "",
@@ -1562,11 +1846,12 @@
                       },
                       "index": {
                         "Value": {
-                          "Implicit": [
+                          "Integer": [
+                            "U32",
                             "0",
                             {
-                              "line_start": 32,
-                              "line_stop": 32,
+                              "line_start": 35,
+                              "line_stop": 35,
                               "col_start": 8,
                               "col_stop": 9,
                               "path": "",
@@ -1576,8 +1861,8 @@
                         }
                       },
                       "span": {
-                        "line_start": 32,
-                        "line_stop": 32,
+                        "line_start": 35,
+                        "line_stop": 35,
                         "col_start": 3,
                         "col_stop": 17,
                         "path": "",
@@ -1591,8 +1876,8 @@
                         "U8",
                         "1",
                         {
-                          "line_start": 32,
-                          "line_stop": 32,
+                          "line_start": 35,
+                          "line_stop": 35,
                           "col_start": 14,
                           "col_stop": 17,
                           "path": "",
@@ -1603,8 +1888,8 @@
                   },
                   "op": "Add",
                   "span": {
-                    "line_start": 32,
-                    "line_stop": 32,
+                    "line_start": 35,
+                    "line_stop": 35,
                     "col_start": 3,
                     "col_stop": 17,
                     "path": "",
@@ -1613,8 +1898,8 @@
                 }
               },
               "span": {
-                "line_start": 32,
-                "line_stop": 32,
+                "line_start": 35,
+                "line_stop": 35,
                 "col_start": 3,
                 "col_stop": 17,
                 "path": "",
@@ -1632,15 +1917,16 @@
                         "array": {
                           "ArrayAccess": {
                             "array": {
-                              "Identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":33,\\\"line_stop\\\":33,\\\"col_start\\\":18,\\\"col_stop\\\":19,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  console.assert(a[2][0] == 1u8);\\\"}\"}"
+                              "Identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":36,\\\"line_stop\\\":36,\\\"col_start\\\":18,\\\"col_stop\\\":19,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  console.assert(a[2][0] == 1u8);\\\"}\"}"
                             },
                             "index": {
                               "Value": {
-                                "Implicit": [
+                                "Integer": [
+                                  "U32",
                                   "2",
                                   {
-                                    "line_start": 33,
-                                    "line_stop": 33,
+                                    "line_start": 36,
+                                    "line_stop": 36,
                                     "col_start": 20,
                                     "col_stop": 21,
                                     "path": "",
@@ -1650,8 +1936,8 @@
                               }
                             },
                             "span": {
-                              "line_start": 33,
-                              "line_stop": 33,
+                              "line_start": 36,
+                              "line_stop": 36,
                               "col_start": 18,
                               "col_stop": 22,
                               "path": "",
@@ -1661,11 +1947,12 @@
                         },
                         "index": {
                           "Value": {
-                            "Implicit": [
+                            "Integer": [
+                              "U32",
                               "0",
                               {
-                                "line_start": 33,
-                                "line_stop": 33,
+                                "line_start": 36,
+                                "line_stop": 36,
                                 "col_start": 23,
                                 "col_stop": 24,
                                 "path": "",
@@ -1675,8 +1962,8 @@
                           }
                         },
                         "span": {
-                          "line_start": 33,
-                          "line_stop": 33,
+                          "line_start": 36,
+                          "line_stop": 36,
                           "col_start": 18,
                           "col_stop": 25,
                           "path": "",
@@ -1690,8 +1977,8 @@
                           "U8",
                           "1",
                           {
-                            "line_start": 33,
-                            "line_stop": 33,
+                            "line_start": 36,
+                            "line_stop": 36,
                             "col_start": 29,
                             "col_stop": 32,
                             "path": "",
@@ -1702,8 +1989,8 @@
                     },
                     "op": "Eq",
                     "span": {
-                      "line_start": 33,
-                      "line_stop": 33,
+                      "line_start": 36,
+                      "line_stop": 36,
                       "col_start": 18,
                       "col_stop": 32,
                       "path": "",
@@ -1713,8 +2000,8 @@
                 }
               },
               "span": {
-                "line_start": 33,
-                "line_stop": 33,
+                "line_start": 36,
+                "line_stop": 36,
                 "col_start": 3,
                 "col_stop": 32,
                 "path": "",
@@ -1725,7 +2012,7 @@
         ],
         "span": {
           "line_start": 10,
-          "line_stop": 34,
+          "line_stop": 37,
           "col_start": 17,
           "col_stop": 2,
           "path": "",
@@ -1734,12 +2021,12 @@
       },
       "span": {
         "line_start": 10,
-        "line_stop": 34,
+        "line_stop": 37,
         "col_start": 1,
         "col_stop": 2,
         "path": "",
-        "content": "function main() {\n...\n}\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
+        "content": "function main() {\n...\n}\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n"
       }
     }
   }
-}
+}

compiler/tests/canonicalization/compound_assignment.leo

@@ -24,6 +24,9 @@ function main() {
   foo.f += 2u8;
   console.assert(foo.f == 8u8);
 
+  let complex = 2u8;
+  complex += 22u8 - 2u8+ 1u8;
+  console.assert(complex == 23u8);
   let a = [[0u8; 1]; 4];
   a[2][0] += 1u8;
   console.assert(a[2][0] == 1u8);

compiler/tests/canonicalization/illegal_array_range_fail.leo

@@ -0,0 +1,4 @@
+function main () {
+  let x = [1u32; 5];
+  x[..2] += 1;
+}

compiler/tests/canonicalization/mod.rs

@@ -87,3 +87,11 @@ fn test_compound_assignment() {
 
     assert_eq!(expected_ast, ast);
 }
+
+#[test]
+fn test_illegal_array_range_fail() {
+    // Check program is invalid.
+    let program_string = include_str!("illegal_array_range_fail.leo");
+    let program = parse_program(program_string);
+    assert!(program.is_err());
+}

compiler/tests/mod.rs

@@ -37,6 +37,7 @@ pub mod mutability;
 pub mod statements;
 pub mod syntax;
 pub mod tuples;
+pub mod type_inference;
 
 use leo_asg::{new_alloc_context, new_context, AsgContext};
 use leo_ast::{InputValue, MainInput};

compiler/tests/type_inference/basic.json

@@ -0,0 +1,962 @@
+{
+    "name": "",
+    "expected_input": [],
+    "imports": [],
+    "circuits": {
+      "{\"name\":\"Foo\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":12,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"circuit Foo {}\\\"}\"}": {
+        "circuit_name": "{\"name\":\"Foo\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":12,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"circuit Foo {}\\\"}\"}",
+        "members": []
+      }
+    },
+    "functions": {
+      "{\"name\":\"two\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":10,\\\"col_stop\\\":13,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function two() -> u8 {\\\"}\"}": {
+        "annotations": [],
+        "identifier": "{\"name\":\"two\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":10,\\\"col_stop\\\":13,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function two() -> u8 {\\\"}\"}",
+        "input": [],
+        "output": {
+          "IntegerType": "U8"
+        },
+        "block": {
+          "statements": [
+            {
+              "Return": {
+                "expression": {
+                  "Value": {
+                    "Integer": [
+                      "U8",
+                      "2",
+                      {
+                        "line_start": 4,
+                        "line_stop": 4,
+                        "col_start": 10,
+                        "col_stop": 13,
+                        "path": "",
+                        "content": "  return 2u8"
+                      }
+                    ]
+                  }
+                },
+                "span": {
+                  "line_start": 4,
+                  "line_stop": 4,
+                  "col_start": 3,
+                  "col_stop": 13,
+                  "path": "",
+                  "content": "  return 2u8"
+                }
+              }
+            }
+          ],
+          "span": {
+            "line_start": 3,
+            "line_stop": 5,
+            "col_start": 22,
+            "col_stop": 2,
+            "path": "",
+            "content": "function two() -> u8 {\n...\n}"
+          }
+        },
+        "span": {
+          "line_start": 3,
+          "line_stop": 5,
+          "col_start": 1,
+          "col_stop": 2,
+          "path": "",
+          "content": "function two() -> u8 {\n...\n}"
+        }
+      },
+      "{\"name\":\"main\",\"span\":\"{\\\"line_start\\\":7,\\\"line_stop\\\":7,\\\"col_start\\\":10,\\\"col_stop\\\":14,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function main() {\\\"}\"}": {
+        "annotations": [],
+        "identifier": "{\"name\":\"main\",\"span\":\"{\\\"line_start\\\":7,\\\"line_stop\\\":7,\\\"col_start\\\":10,\\\"col_stop\\\":14,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function main() {\\\"}\"}",
+        "input": [],
+        "output": {
+          "Tuple": []
+        },
+        "block": {
+          "statements": [
+            {
+              "Definition": {
+                "declaration_type": "Const",
+                "variable_names": [
+                  {
+                    "mutable": false,
+                    "identifier": "{\"name\":\"a\",\"span\":\"{\\\"line_start\\\":8,\\\"line_stop\\\":8,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const a = 1u8;\\\"}\"}",
+                    "span": {
+                      "line_start": 8,
+                      "line_stop": 8,
+                      "col_start": 9,
+                      "col_stop": 10,
+                      "path": "",
+                      "content": "  const a = 1u8;"
+                    }
+                  }
+                ],
+                "type_": {
+                  "IntegerType": "U8"
+                },
+                "value": {
+                  "Value": {
+                    "Integer": [
+                      "U8",
+                      "1",
+                      {
+                        "line_start": 8,
+                        "line_stop": 8,
+                        "col_start": 13,
+                        "col_stop": 16,
+                        "path": "",
+                        "content": "  const a = 1u8;"
+                      }
+                    ]
+                  }
+                },
+                "span": {
+                  "line_start": 8,
+                  "line_stop": 8,
+                  "col_start": 3,
+                  "col_stop": 16,
+                  "path": "",
+                  "content": "  const a = 1u8;"
+                }
+              }
+            },
+            {
+              "Definition": {
+                "declaration_type": "Const",
+                "variable_names": [
+                  {
+                    "mutable": false,
+                    "identifier": "{\"name\":\"b\",\"span\":\"{\\\"line_start\\\":9,\\\"line_stop\\\":9,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const b = 1field;\\\"}\"}",
+                    "span": {
+                      "line_start": 9,
+                      "line_stop": 9,
+                      "col_start": 9,
+                      "col_stop": 10,
+                      "path": "",
+                      "content": "  const b = 1field;"
+                    }
+                  }
+                ],
+                "type_": "Field",
+                "value": {
+                  "Value": {
+                    "Field": [
+                      "1",
+                      {
+                        "line_start": 9,
+                        "line_stop": 9,
+                        "col_start": 13,
+                        "col_stop": 19,
+                        "path": "",
+                        "content": "  const b = 1field;"
+                      }
+                    ]
+                  }
+                },
+                "span": {
+                  "line_start": 9,
+                  "line_stop": 9,
+                  "col_start": 3,
+                  "col_stop": 19,
+                  "path": "",
+                  "content": "  const b = 1field;"
+                }
+              }
+            },
+            {
+              "Definition": {
+                "declaration_type": "Const",
+                "variable_names": [
+                  {
+                    "mutable": false,
+                    "identifier": "{\"name\":\"c\",\"span\":\"{\\\"line_start\\\":10,\\\"line_stop\\\":10,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const c = 1group;\\\"}\"}",
+                    "span": {
+                      "line_start": 10,
+                      "line_stop": 10,
+                      "col_start": 9,
+                      "col_stop": 10,
+                      "path": "",
+                      "content": "  const c = 1group;"
+                    }
+                  }
+                ],
+                "type_": "Group",
+                "value": {
+                  "Value": {
+                    "Group": {
+                      "Single": [
+                        "1",
+                        {
+                          "line_start": 10,
+                          "line_stop": 10,
+                          "col_start": 13,
+                          "col_stop": 19,
+                          "path": "",
+                          "content": "  const c = 1group;"
+                        }
+                      ]
+                    }
+                  }
+                },
+                "span": {
+                  "line_start": 10,
+                  "line_stop": 10,
+                  "col_start": 3,
+                  "col_stop": 19,
+                  "path": "",
+                  "content": "  const c = 1group;"
+                }
+              }
+            },
+            {
+              "Definition": {
+                "declaration_type": "Const",
+                "variable_names": [
+                  {
+                    "mutable": false,
+                    "identifier": "{\"name\":\"d\",\"span\":\"{\\\"line_start\\\":11,\\\"line_stop\\\":11,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const d = (0, 1)group;\\\"}\"}",
+                    "span": {
+                      "line_start": 11,
+                      "line_stop": 11,
+                      "col_start": 9,
+                      "col_stop": 10,
+                      "path": "",
+                      "content": "  const d = (0, 1)group;"
+                    }
+                  }
+                ],
+                "type_": "Group",
+                "value": {
+                  "Value": {
+                    "Group": {
+                      "Tuple": {
+                        "x": {
+                          "Number": [
+                            "0",
+                            {
+                              "line_start": 11,
+                              "line_stop": 11,
+                              "col_start": 14,
+                              "col_stop": 15,
+                              "path": "",
+                              "content": "  const d = (0, 1)group;"
+                            }
+                          ]
+                        },
+                        "y": {
+                          "Number": [
+                            "1",
+                            {
+                              "line_start": 11,
+                              "line_stop": 11,
+                              "col_start": 17,
+                              "col_stop": 18,
+                              "path": "",
+                              "content": "  const d = (0, 1)group;"
+                            }
+                          ]
+                        },
+                        "span": {
+                          "line_start": 11,
+                          "line_stop": 11,
+                          "col_start": 14,
+                          "col_stop": 24,
+                          "path": "",
+                          "content": "  const d = (0, 1)group;"
+                        }
+                      }
+                    }
+                  }
+                },
+                "span": {
+                  "line_start": 11,
+                  "line_stop": 11,
+                  "col_start": 3,
+                  "col_stop": 24,
+                  "path": "",
+                  "content": "  const d = (0, 1)group;"
+                }
+              }
+            },
+            {
+              "Definition": {
+                "declaration_type": "Const",
+                "variable_names": [
+                  {
+                    "mutable": false,
+                    "identifier": "{\"name\":\"e\",\"span\":\"{\\\"line_start\\\":12,\\\"line_stop\\\":12,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const e = address(aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8);\\\"}\"}",
+                    "span": {
+                      "line_start": 12,
+                      "line_stop": 12,
+                      "col_start": 9,
+                      "col_stop": 10,
+                      "path": "",
+                      "content": "  const e = address(aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8);"
+                    }
+                  }
+                ],
+                "type_": "Address",
+                "value": {
+                  "Value": {
+                    "Address": [
+                      "aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8",
+                      {
+                        "line_start": 12,
+                        "line_stop": 12,
+                        "col_start": 13,
+                        "col_stop": 85,
+                        "path": "",
+                        "content": "  const e = address(aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8);"
+                      }
+                    ]
+                  }
+                },
+                "span": {
+                  "line_start": 12,
+                  "line_stop": 12,
+                  "col_start": 3,
+                  "col_stop": 85,
+                  "path": "",
+                  "content": "  const e = address(aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8);"
+                }
+              }
+            },
+            {
+              "Definition": {
+                "declaration_type": "Const",
+                "variable_names": [
+                  {
+                    "mutable": false,
+                    "identifier": "{\"name\":\"f\",\"span\":\"{\\\"line_start\\\":13,\\\"line_stop\\\":13,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const f = two();\\\"}\"}",
+                    "span": {
+                      "line_start": 13,
+                      "line_stop": 13,
+                      "col_start": 9,
+                      "col_stop": 10,
+                      "path": "",
+                      "content": "  const f = two();"
+                    }
+                  }
+                ],
+                "type_": {
+                  "IntegerType": "U8"
+                },
+                "value": {
+                  "Call": {
+                    "function": {
+                      "Identifier": "{\"name\":\"two\",\"span\":\"{\\\"line_start\\\":13,\\\"line_stop\\\":13,\\\"col_start\\\":13,\\\"col_stop\\\":16,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const f = two();\\\"}\"}"
+                    },
+                    "arguments": [],
+                    "span": {
+                      "line_start": 13,
+                      "line_stop": 13,
+                      "col_start": 13,
+                      "col_stop": 18,
+                      "path": "",
+                      "content": "  const f = two();"
+                    }
+                  }
+                },
+                "span": {
+                  "line_start": 13,
+                  "line_stop": 13,
+                  "col_start": 3,
+                  "col_stop": 18,
+                  "path": "",
+                  "content": "  const f = two();"
+                }
+              }
+            },
+            {
+              "Definition": {
+                "declaration_type": "Const",
+                "variable_names": [
+                  {
+                    "mutable": false,
+                    "identifier": "{\"name\":\"g\",\"span\":\"{\\\"line_start\\\":14,\\\"line_stop\\\":14,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const g = [0u8; (3, 2)];\\\"}\"}",
+                    "span": {
+                      "line_start": 14,
+                      "line_stop": 14,
+                      "col_start": 9,
+                      "col_stop": 10,
+                      "path": "",
+                      "content": "  const g = [0u8; (3, 2)];"
+                    }
+                  }
+                ],
+                "type_": {
+                  "Array": [
+                    {
+                      "Array": [
+                        {
+                          "IntegerType": "U8"
+                        },
+                        [
+                          {
+                            "value": "2"
+                          }
+                        ]
+                      ]
+                    },
+                    [
+                      {
+                        "value": "3"
+                      }
+                    ]
+                  ]
+                },
+                "value": {
+                  "ArrayInit": {
+                    "element": {
+                      "ArrayInit": {
+                        "element": {
+                          "Value": {
+                            "Integer": [
+                              "U8",
+                              "0",
+                              {
+                                "line_start": 14,
+                                "line_stop": 14,
+                                "col_start": 14,
+                                "col_stop": 17,
+                                "path": "",
+                                "content": "  const g = [0u8; (3, 2)];"
+                              }
+                            ]
+                          }
+                        },
+                        "dimensions": [
+                          {
+                            "value": "2"
+                          }
+                        ],
+                        "span": {
+                          "line_start": 14,
+                          "line_stop": 14,
+                          "col_start": 13,
+                          "col_stop": 26,
+                          "path": "",
+                          "content": "  const g = [0u8; (3, 2)];"
+                        }
+                      }
+                    },
+                    "dimensions": [
+                      {
+                        "value": "3"
+                      }
+                    ],
+                    "span": {
+                      "line_start": 14,
+                      "line_stop": 14,
+                      "col_start": 13,
+                      "col_stop": 26,
+                      "path": "",
+                      "content": "  const g = [0u8; (3, 2)];"
+                    }
+                  }
+                },
+                "span": {
+                  "line_start": 14,
+                  "line_stop": 14,
+                  "col_start": 3,
+                  "col_stop": 26,
+                  "path": "",
+                  "content": "  const g = [0u8; (3, 2)];"
+                }
+              }
+            },
+            {
+              "Definition": {
+                "declaration_type": "Const",
+                "variable_names": [
+                  {
+                    "mutable": false,
+                    "identifier": "{\"name\":\"h\",\"span\":\"{\\\"line_start\\\":15,\\\"line_stop\\\":15,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const h = [[0u8; 3]; 2];\\\"}\"}",
+                    "span": {
+                      "line_start": 15,
+                      "line_stop": 15,
+                      "col_start": 9,
+                      "col_stop": 10,
+                      "path": "",
+                      "content": "  const h = [[0u8; 3]; 2];"
+                    }
+                  }
+                ],
+                "type_": {
+                  "Array": [
+                    {
+                      "Array": [
+                        {
+                          "IntegerType": "U8"
+                        },
+                        [
+                          {
+                            "value": "3"
+                          }
+                        ]
+                      ]
+                    },
+                    [
+                      {
+                        "value": "2"
+                      }
+                    ]
+                  ]
+                },
+                "value": {
+                  "ArrayInit": {
+                    "element": {
+                      "ArrayInit": {
+                        "element": {
+                          "Value": {
+                            "Integer": [
+                              "U8",
+                              "0",
+                              {
+                                "line_start": 15,
+                                "line_stop": 15,
+                                "col_start": 15,
+                                "col_stop": 18,
+                                "path": "",
+                                "content": "  const h = [[0u8; 3]; 2];"
+                              }
+                            ]
+                          }
+                        },
+                        "dimensions": [
+                          {
+                            "value": "3"
+                          }
+                        ],
+                        "span": {
+                          "line_start": 15,
+                          "line_stop": 15,
+                          "col_start": 14,
+                          "col_stop": 22,
+                          "path": "",
+                          "content": "  const h = [[0u8; 3]; 2];"
+                        }
+                      }
+                    },
+                    "dimensions": [
+                      {
+                        "value": "2"
+                      }
+                    ],
+                    "span": {
+                      "line_start": 15,
+                      "line_stop": 15,
+                      "col_start": 13,
+                      "col_stop": 26,
+                      "path": "",
+                      "content": "  const h = [[0u8; 3]; 2];"
+                    }
+                  }
+                },
+                "span": {
+                  "line_start": 15,
+                  "line_stop": 15,
+                  "col_start": 3,
+                  "col_stop": 26,
+                  "path": "",
+                  "content": "  const h = [[0u8; 3]; 2];"
+                }
+              }
+            },
+            {
+              "Definition": {
+                "declaration_type": "Const",
+                "variable_names": [
+                  {
+                    "mutable": false,
+                    "identifier": "{\"name\":\"i\",\"span\":\"{\\\"line_start\\\":16,\\\"line_stop\\\":16,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const i = [1u8, 1u8, 1u8];\\\"}\"}",
+                    "span": {
+                      "line_start": 16,
+                      "line_stop": 16,
+                      "col_start": 9,
+                      "col_stop": 10,
+                      "path": "",
+                      "content": "  const i = [1u8, 1u8, 1u8];"
+                    }
+                  }
+                ],
+                "type_": {
+                  "Array": [
+                    {
+                      "IntegerType": "U8"
+                    },
+                    [
+                      {
+                        "value": "3"
+                      }
+                    ]
+                  ]
+                },
+                "value": {
+                  "ArrayInline": {
+                    "elements": [
+                      {
+                        "Expression": {
+                          "Value": {
+                            "Integer": [
+                              "U8",
+                              "1",
+                              {
+                                "line_start": 16,
+                                "line_stop": 16,
+                                "col_start": 14,
+                                "col_stop": 17,
+                                "path": "",
+                                "content": "  const i = [1u8, 1u8, 1u8];"
+                              }
+                            ]
+                          }
+                        }
+                      },
+                      {
+                        "Expression": {
+                          "Value": {
+                            "Integer": [
+                              "U8",
+                              "1",
+                              {
+                                "line_start": 16,
+                                "line_stop": 16,
+                                "col_start": 19,
+                                "col_stop": 22,
+                                "path": "",
+                                "content": "  const i = [1u8, 1u8, 1u8];"
+                              }
+                            ]
+                          }
+                        }
+                      },
+                      {
+                        "Expression": {
+                          "Value": {
+                            "Integer": [
+                              "U8",
+                              "1",
+                              {
+                                "line_start": 16,
+                                "line_stop": 16,
+                                "col_start": 24,
+                                "col_stop": 27,
+                                "path": "",
+                                "content": "  const i = [1u8, 1u8, 1u8];"
+                              }
+                            ]
+                          }
+                        }
+                      }
+                    ],
+                    "span": {
+                      "line_start": 16,
+                      "line_stop": 16,
+                      "col_start": 13,
+                      "col_stop": 28,
+                      "path": "",
+                      "content": "  const i = [1u8, 1u8, 1u8];"
+                    }
+                  }
+                },
+                "span": {
+                  "line_start": 16,
+                  "line_stop": 16,
+                  "col_start": 3,
+                  "col_stop": 28,
+                  "path": "",
+                  "content": "  const i = [1u8, 1u8, 1u8];"
+                }
+              }
+            },
+            {
+              "Definition": {
+                "declaration_type": "Const",
+                "variable_names": [
+                  {
+                    "mutable": false,
+                    "identifier": "{\"name\":\"j\",\"span\":\"{\\\"line_start\\\":17,\\\"line_stop\\\":17,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const j = true;\\\"}\"}",
+                    "span": {
+                      "line_start": 17,
+                      "line_stop": 17,
+                      "col_start": 9,
+                      "col_stop": 10,
+                      "path": "",
+                      "content": "  const j = true;"
+                    }
+                  }
+                ],
+                "type_": "Boolean",
+                "value": {
+                  "Value": {
+                    "Boolean": [
+                      "true",
+                      {
+                        "line_start": 17,
+                        "line_stop": 17,
+                        "col_start": 13,
+                        "col_stop": 17,
+                        "path": "",
+                        "content": "  const j = true;"
+                      }
+                    ]
+                  }
+                },
+                "span": {
+                  "line_start": 17,
+                  "line_stop": 17,
+                  "col_start": 3,
+                  "col_stop": 17,
+                  "path": "",
+                  "content": "  const j = true;"
+                }
+              }
+            },
+            {
+              "Definition": {
+                "declaration_type": "Const",
+                "variable_names": [
+                  {
+                    "mutable": false,
+                    "identifier": "{\"name\":\"k\",\"span\":\"{\\\"line_start\\\":18,\\\"line_stop\\\":18,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const k = (1u8, 1u8);\\\"}\"}",
+                    "span": {
+                      "line_start": 18,
+                      "line_stop": 18,
+                      "col_start": 9,
+                      "col_stop": 10,
+                      "path": "",
+                      "content": "  const k = (1u8, 1u8);"
+                    }
+                  }
+                ],
+                "type_": {
+                  "Tuple": [
+                    {
+                      "IntegerType": "U8"
+                    },
+                    {
+                      "IntegerType": "U8"
+                    }
+                  ]
+                },
+                "value": {
+                  "TupleInit": {
+                    "elements": [
+                      {
+                        "Value": {
+                          "Integer": [
+                            "U8",
+                            "1",
+                            {
+                              "line_start": 18,
+                              "line_stop": 18,
+                              "col_start": 14,
+                              "col_stop": 17,
+                              "path": "",
+                              "content": "  const k = (1u8, 1u8);"
+                            }
+                          ]
+                        }
+                      },
+                      {
+                        "Value": {
+                          "Integer": [
+                            "U8",
+                            "1",
+                            {
+                              "line_start": 18,
+                              "line_stop": 18,
+                              "col_start": 19,
+                              "col_stop": 22,
+                              "path": "",
+                              "content": "  const k = (1u8, 1u8);"
+                            }
+                          ]
+                        }
+                      }
+                    ],
+                    "span": {
+                      "line_start": 18,
+                      "line_stop": 18,
+                      "col_start": 13,
+                      "col_stop": 23,
+                      "path": "",
+                      "content": "  const k = (1u8, 1u8);"
+                    }
+                  }
+                },
+                "span": {
+                  "line_start": 18,
+                  "line_stop": 18,
+                  "col_start": 3,
+                  "col_stop": 23,
+                  "path": "",
+                  "content": "  const k = (1u8, 1u8);"
+                }
+              }
+            },
+            {
+              "Definition": {
+                "declaration_type": "Const",
+                "variable_names": [
+                  {
+                    "mutable": false,
+                    "identifier": "{\"name\":\"l\",\"span\":\"{\\\"line_start\\\":19,\\\"line_stop\\\":19,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const l = (1u8, 1u8, true);\\\"}\"}",
+                    "span": {
+                      "line_start": 19,
+                      "line_stop": 19,
+                      "col_start": 9,
+                      "col_stop": 10,
+                      "path": "",
+                      "content": "  const l = (1u8, 1u8, true);"
+                    }
+                  }
+                ],
+                "type_": {
+                  "Tuple": [
+                    {
+                      "IntegerType": "U8"
+                    },
+                    {
+                      "IntegerType": "U8"
+                    },
+                    "Boolean"
+                  ]
+                },
+                "value": {
+                  "TupleInit": {
+                    "elements": [
+                      {
+                        "Value": {
+                          "Integer": [
+                            "U8",
+                            "1",
+                            {
+                              "line_start": 19,
+                              "line_stop": 19,
+                              "col_start": 14,
+                              "col_stop": 17,
+                              "path": "",
+                              "content": "  const l = (1u8, 1u8, true);"
+                            }
+                          ]
+                        }
+                      },
+                      {
+                        "Value": {
+                          "Integer": [
+                            "U8",
+                            "1",
+                            {
+                              "line_start": 19,
+                              "line_stop": 19,
+                              "col_start": 19,
+                              "col_stop": 22,
+                              "path": "",
+                              "content": "  const l = (1u8, 1u8, true);"
+                            }
+                          ]
+                        }
+                      },
+                      {
+                        "Value": {
+                          "Boolean": [
+                            "true",
+                            {
+                              "line_start": 19,
+                              "line_stop": 19,
+                              "col_start": 24,
+                              "col_stop": 28,
+                              "path": "",
+                              "content": "  const l = (1u8, 1u8, true);"
+                            }
+                          ]
+                        }
+                      }
+                    ],
+                    "span": {
+                      "line_start": 19,
+                      "line_stop": 19,
+                      "col_start": 13,
+                      "col_stop": 29,
+                      "path": "",
+                      "content": "  const l = (1u8, 1u8, true);"
+                    }
+                  }
+                },
+                "span": {
+                  "line_start": 19,
+                  "line_stop": 19,
+                  "col_start": 3,
+                  "col_stop": 29,
+                  "path": "",
+                  "content": "  const l = (1u8, 1u8, true);"
+                }
+              }
+            },
+            {
+              "Definition": {
+                "declaration_type": "Const",
+                "variable_names": [
+                  {
+                    "mutable": false,
+                    "identifier": "{\"name\":\"m\",\"span\":\"{\\\"line_start\\\":20,\\\"line_stop\\\":20,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const m = Foo {};\\\"}\"}",
+                    "span": {
+                      "line_start": 20,
+                      "line_stop": 20,
+                      "col_start": 9,
+                      "col_stop": 10,
+                      "path": "",
+                      "content": "  const m = Foo {};"
+                    }
+                  }
+                ],
+                "type_": {
+                  "Circuit": "{\"name\":\"Foo\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":12,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"circuit Foo {}\\\"}\"}"
+                },
+                "value": {
+                  "CircuitInit": {
+                    "name": "{\"name\":\"Foo\",\"span\":\"{\\\"line_start\\\":20,\\\"line_stop\\\":20,\\\"col_start\\\":13,\\\"col_stop\\\":16,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"  const m = Foo {};\\\"}\"}",
+                    "members": [],
+                    "span": {
+                      "line_start": 20,
+                      "line_stop": 20,
+                      "col_start": 13,
+                      "col_stop": 19,
+                      "path": "",
+                      "content": "  const m = Foo {};"
+                    }
+                  }
+                },
+                "span": {
+                  "line_start": 20,
+                  "line_stop": 20,
+                  "col_start": 3,
+                  "col_stop": 19,
+                  "path": "",
+                  "content": "  const m = Foo {};"
+                }
+              }
+            }
+          ],
+          "span": {
+            "line_start": 7,
+            "line_stop": 21,
+            "col_start": 17,
+            "col_stop": 2,
+            "path": "",
+            "content": "function main() {\n...\n}"
+          }
+        },
+        "span": {
+          "line_start": 7,
+          "line_stop": 21,
+          "col_start": 1,
+          "col_stop": 2,
+          "path": "",
+          "content": "function main() {\n...\n}\n\n\n\n\n\n\n\n\n\n\n\n"
+        }
+      }
+    }
+  }

compiler/tests/type_inference/basic.leo

@@ -0,0 +1,21 @@
+circuit Foo {}
+
+function two() -> u8 {
+  return 2u8;
+}
+
+function main() {
+  const a = 1u8;
+  const b = 1field;
+  const c = 1group;
+  const d = (0, 1)group;
+  const e = aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8;
+  const f = two();
+  const g = [0u8; (3, 2)];
+  const h = [[0u8; 3]; 2];
+  const i = [1u8, 1u8, 1u8];
+  const j = true;
+  const k = (1u8, 1u8);
+  const l = (1u8, 1u8, true);
+  const m = Foo {};
+}

compiler/tests/type_inference/for_loop_and_compound.json

@@ -0,0 +1,242 @@
+{
+    "name": "",
+    "expected_input": [],
+    "imports": [],
+    "circuits": {},
+    "functions": {
+      "{\"name\":\"main\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":14,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function main() {\\\"}\"}": {
+        "annotations": [],
+        "identifier": "{\"name\":\"main\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":14,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function main() {\\\"}\"}",
+        "input": [],
+        "output": {
+          "Tuple": []
+        },
+        "block": {
+          "statements": [
+            {
+              "Definition": {
+                "declaration_type": "Let",
+                "variable_names": [
+                  {
+                    "mutable": true,
+                    "identifier": "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":2,\\\"line_stop\\\":2,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    let x = 10u16;\\\"}\"}",
+                    "span": {
+                      "line_start": 2,
+                      "line_stop": 2,
+                      "col_start": 9,
+                      "col_stop": 10,
+                      "path": "",
+                      "content": "    let x = 10u16;"
+                    }
+                  }
+                ],
+                "type_": {
+                  "IntegerType": "U16"
+                },
+                "value": {
+                  "Value": {
+                    "Integer": [
+                      "U16",
+                      "10",
+                      {
+                        "line_start": 2,
+                        "line_stop": 2,
+                        "col_start": 13,
+                        "col_stop": 18,
+                        "path": "",
+                        "content": "    let x = 10u16;"
+                      }
+                    ]
+                  }
+                },
+                "span": {
+                  "line_start": 2,
+                  "line_stop": 2,
+                  "col_start": 5,
+                  "col_stop": 18,
+                  "path": "",
+                  "content": "    let x = 10u16;"
+                }
+              }
+            },
+            {
+              "Iteration": {
+                "variable": "{\"name\":\"i\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    for i in 0..3 {\\\"}\"}",
+                "start": {
+                  "Value": {
+                    "Integer": [
+                      "U32",
+                      "0",
+                      {
+                        "line_start": 3,
+                        "line_stop": 3,
+                        "col_start": 14,
+                        "col_stop": 15,
+                        "path": "",
+                        "content": "    for i in 0..3 {"
+                      }
+                    ]
+                  }
+                },
+                "stop": {
+                  "Value": {
+                    "Integer": [
+                      "U32",
+                      "3",
+                      {
+                        "line_start": 3,
+                        "line_stop": 3,
+                        "col_start": 17,
+                        "col_stop": 18,
+                        "path": "",
+                        "content": "    for i in 0..3 {"
+                      }
+                    ]
+                  }
+                },
+                "block": {
+                  "statements": [
+                    {
+                      "Assign": {
+                        "operation": "Assign",
+                        "assignee": {
+                          "identifier": "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"        x -= 1;\\\"}\"}",
+                          "accesses": [],
+                          "span": {
+                            "line_start": 4,
+                            "line_stop": 4,
+                            "col_start": 9,
+                            "col_stop": 10,
+                            "path": "",
+                            "content": "        x -= 1;"
+                          }
+                        },
+                        "value": {
+                          "Binary": {
+                            "left": {
+                              "Identifier": "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"        x -= 1;\\\"}\"}"
+                            },
+                            "right": {
+                              "Value": {
+                                "Integer": [
+                                  "U16",
+                                  "1",
+                                  {
+                                    "line_start": 4,
+                                    "line_stop": 4,
+                                    "col_start": 14,
+                                    "col_stop": 15,
+                                    "path": "",
+                                    "content": "        x -= 1;"
+                                  }
+                                ]
+                              }
+                            },
+                            "op": "Sub",
+                            "span": {
+                              "line_start": 4,
+                              "line_stop": 4,
+                              "col_start": 9,
+                              "col_stop": 15,
+                              "path": "",
+                              "content": "        x -= 1;"
+                            }
+                          }
+                        },
+                        "span": {
+                          "line_start": 4,
+                          "line_stop": 4,
+                          "col_start": 9,
+                          "col_stop": 15,
+                          "path": "",
+                          "content": "        x -= 1;"
+                        }
+                      }
+                    }
+                  ],
+                  "span": {
+                    "line_start": 3,
+                    "line_stop": 5,
+                    "col_start": 19,
+                    "col_stop": 6,
+                    "path": "",
+                    "content": "    for i in 0..3 {\n...\n    }"
+                  }
+                },
+                "span": {
+                  "line_start": 3,
+                  "line_stop": 5,
+                  "col_start": 5,
+                  "col_stop": 6,
+                  "path": "",
+                  "content": "    for i in 0..3 {\n...\n    }"
+                }
+              }
+            },
+            {
+              "Console": {
+                "function": {
+                  "Assert": {
+                    "Binary": {
+                      "left": {
+                        "Identifier": "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":6,\\\"line_stop\\\":6,\\\"col_start\\\":20,\\\"col_stop\\\":21,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"    console.assert(x == 7u16);\\\"}\"}"
+                      },
+                      "right": {
+                        "Value": {
+                          "Integer": [
+                            "U16",
+                            "7",
+                            {
+                              "line_start": 6,
+                              "line_stop": 6,
+                              "col_start": 25,
+                              "col_stop": 29,
+                              "path": "",
+                              "content": "    console.assert(x == 7u16);"
+                            }
+                          ]
+                        }
+                      },
+                      "op": "Eq",
+                      "span": {
+                        "line_start": 6,
+                        "line_stop": 6,
+                        "col_start": 20,
+                        "col_stop": 29,
+                        "path": "",
+                        "content": "    console.assert(x == 7u16);"
+                      }
+                    }
+                  }
+                },
+                "span": {
+                  "line_start": 6,
+                  "line_stop": 6,
+                  "col_start": 5,
+                  "col_stop": 29,
+                  "path": "",
+                  "content": "    console.assert(x == 7u16);"
+                }
+              }
+            }
+          ],
+          "span": {
+            "line_start": 1,
+            "line_stop": 7,
+            "col_start": 17,
+            "col_stop": 2,
+            "path": "",
+            "content": "function main() {\n...\n}"
+          }
+        },
+        "span": {
+          "line_start": 1,
+          "line_stop": 7,
+          "col_start": 1,
+          "col_stop": 2,
+          "path": "",
+          "content": "function main() {\n...\n}\n\n\n\n"
+        }
+      }
+    }
+  }

compiler/tests/type_inference/for_loop_and_compound.leo

@@ -1,8 +1,7 @@
 function main() {
-    let x = 4u32;
+    let x = 10u16;
     for i in 0..3 {
         x -= 1;
     }
-
-    console.assert(x == 1u32);
+    console.assert(x == 7u16);
 }

compiler/tests/type_inference/mod.rs

@@ -0,0 +1,85 @@
+// 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::{assert_satisfied, parse_program};
+#[allow(unused)]
+use leo_asg::{new_context, Asg, AsgContext};
+use leo_ast::Ast;
+use leo_compiler::TypeInferencePhase;
+use leo_imports::ImportParser;
+use leo_parser::parser;
+
+thread_local! {
+    static THREAD_GLOBAL_CONTEXT: AsgContext<'static> = {
+        let leaked = Box::leak(Box::new(leo_asg::new_alloc_context()));
+        leo_asg::new_context(leaked)
+    }
+}
+
+pub fn thread_leaked_context() -> AsgContext<'static> {
+    THREAD_GLOBAL_CONTEXT.with(|f| *f)
+}
+
+pub fn parse_program_ast(file_string: &str) -> Ast {
+    const TEST_PROGRAM_PATH: &str = "";
+    let test_program_file_path = std::path::PathBuf::from(TEST_PROGRAM_PATH);
+
+    let mut ast = Ast::new(
+        parser::parse(test_program_file_path.to_str().expect("unwrap fail"), &file_string)
+            .expect("Failed to parse file."),
+    );
+    ast.canonicalize().expect("Failed to canonicalize program.");
+
+    let program = ast.clone().into_repr();
+    let asg = Asg::new(thread_leaked_context(), &program, &mut ImportParser::default())
+        .expect("Failed to create ASG from AST");
+
+    let new_ast = TypeInferencePhase::default()
+        .phase_ast(&program, &asg.into_repr())
+        .expect("Failed to produce type inference ast.");
+
+    new_ast
+}
+
+#[test]
+fn test_basic() {
+    // Check program is valid.
+    let program_string = include_str!("basic.leo");
+    let program = parse_program(program_string).unwrap();
+    assert_satisfied(program);
+
+    // Check we get expected ast.
+    let ast = parse_program_ast(program_string);
+    let expected_json = include_str!("basic.json");
+    let expected_ast: Ast = Ast::from_json_string(expected_json).expect("Unable to parse json.");
+
+    assert_eq!(expected_ast, ast);
+}
+
+#[test]
+fn test_for_loop_and_compound() {
+    // Check program is valid.
+    let program_string = include_str!("for_loop_and_compound.leo");
+    let program = parse_program(program_string).unwrap();
+    assert_satisfied(program);
+
+    // Check we get expected ast.
+    let ast = parse_program_ast(program_string);
+    let expected_json = include_str!("for_loop_and_compound.json");
+    let expected_ast: Ast = Ast::from_json_string(expected_json).expect("Unable to parse json.");
+
+    assert_eq!(expected_ast, ast);
+}

grammar/README.md

@@ -57,59 +57,59 @@ without going beyond context-free grammars.
 
 Instead of BNF's angle-bracket notation for nonterminals,
 ABNF uses case-insensitive names consisting of letters, digits, and dashes,
-e.g. HTTP-message and IPv6address.
+e.g. `HTTP-message` and `IPv6address`.
 ABNF includes an angle-bracket notation for prose descriptions,
-e.g. <host, see [RFC3986], Section 3.2.2>,
+e.g. `<host, see [RFC3986], Section 3.2.2>`,
 usable as last resort in the definiens of a nonterminal.
 
 While BNF allows arbitrary terminals,
 ABNF uses only natural numbers as terminals,
 and denotes them via:
 (i) binary, decimal, or hexadecimal sequences,
-e.g. %b1.11.1010, %d1.3.10, and %x.1.3.A
-all denote the sequence of terminals '1 3 10';
+e.g. `%b1.11.1010`, `%d1.3.10`, and `%x.1.3.A`
+all denote the sequence of terminals [1, 3, 10];
 (ii) binary, decimal, or hexadecimal ranges,
-e.g. %x30-39 denotes any singleton sequence of terminals
-'n' with 48 <= n <= 57 (an ASCII digit);
+e.g. `%x30-39` denotes any singleton sequence of terminals
+[_n_] with 48 <= _n_ <= 57 (an ASCII digit);
 (iii) case-sensitive ASCII strings,
-e.g. %s"Ab" denotes the sequence of terminals '65 98';
+e.g. `%s"Ab"` denotes the sequence of terminals [65, 98];
 and (iv) case-insensitive ASCII strings,
-e.g. %i"ab", or just "ab", denotes
+e.g. `%i"ab"`, or just `"ab"`, denotes
 any sequence of terminals among
-'65 66',
-'65 98',
-'97 66', and
-'97 98'.
+[65, 66],
+[65, 98],
+[97, 66], and
+[97, 98].
 ABNF terminals in suitable sets represent ASCII or Unicode characters.
 
-ABNF allows repetition prefixes n*m,
-where n and m are natural numbers in decimal notation;
+ABNF allows repetition prefixes `n*m`,
+where `n` and `m` are natural numbers in decimal notation;
 if absent,
-n defaults to 0, and
-m defaults to infinity.
+`n` defaults to 0, and
+`m` defaults to infinity.
 For example,
-1*4HEXDIG denotes one to four HEXDIGs,
-*3DIGIT denotes up to three DIGITs, and
-1*OCTET denotes one or more OCTETs.
-A single n prefix
-abbreviates n*n,
-e.g. 3DIGIT denotes three DIGITs.
+`1*4HEXDIG` denotes one to four `HEXDIG`s,
+`*3DIGIT` denotes up to three `DIGIT`s, and
+`1*OCTET` denotes one or more `OCTET`s.
+A single `n` prefix
+abbreviates `n*n`,
+e.g. `3DIGIT` denotes three `DIGIT`s.
 
-Instead of BNF's |, ABNF uses / to separate alternatives.
+Instead of BNF's `|`, ABNF uses `/` to separate alternatives.
 Repetition prefixes have precedence over juxtapositions,
-which have precedence over /.
+which have precedence over `/`.
 Round brackets group things and override the aforementioned precedence rules,
-e.g. *(WSP / CRLF WSP) denotes sequences of terminals
+e.g. `*(WSP / CRLF WSP)` denotes sequences of terminals
 obtained by repeating, zero or more times,
-either (i) a WSP or (ii) a CRLF followed by a WSP.
+either (i) a `WSP` or (ii) a `CRLF` followed by a `WSP`.
 Square brackets also group things but make them optional,
-e.g. [":" port] is equivalent to 0*1(":" port).
+e.g. `[":" port]` is equivalent to `0*1(":" port)`.
 
-Instead of BNF's ::=, ABNF uses = to define nonterminals,
-and =/ to incrementally add alternatives
+Instead of BNF's `::=`, ABNF uses `=` to define nonterminals,
+and `=/` to incrementally add alternatives
 to previously defined nonterminals.
-For example, the rule BIT = "0" / "1"
-is equivalent to BIT = "0" followed by BIT =/ "1".
+For example, the rule `BIT = "0" / "1"`
+is equivalent to `BIT = "0"` followed by `BIT =/ "1"`.
 
 The syntax of ABNF itself is formally specified in ABNF
 (in Section 4 of the aforementioned RFC 5234,
@@ -131,7 +131,7 @@ Structure
 This ABNF grammar consists of two (sub-)grammars:
 (i) a lexical grammar that describes how
 sequence of characters are parsed into tokens, and
-(ii) a syntactic grammar that described how
+(ii) a syntactic grammar that describes how
 tokens are parsed into expressions, statements, etc.
 The adjectives 'lexical' and 'syntactic' are
 the same ones used in the Java language reference,
@@ -198,8 +198,8 @@ additive-expression =
 
 
 These rules tell us
-that the additive operators '+' and '-' have lower precedence
-than the multiplicative operators '*' and '/',
+that the additive operators `+` and `-` have lower precedence
+than the multiplicative operators `*` and `/`,
 and that both the additive and multiplicative operators associate to the left.
 This may be best understood via the examples given below.
 
@@ -295,7 +295,7 @@ Naming Convention
 This ABNF grammar uses nonterminal names
 that consist of complete English words, separated by dashes,
 and that describe the construct the way it is in English.
-For instance, we use the name 'conditional-statement'
+For instance, we use the name `conditional-statement`
 to describe conditional statements.
 
 At the same time, this grammar establishes
@@ -354,8 +354,8 @@ Lexical Grammar
 
 A Leo file is a finite sequence of Unicode characters,
 represented as Unicode code points,
-which are numbers in the range form 0 to 10FFFFh.
-These are captured by the ABNF rule 'character' below.
+which are numbers in the range from 0 to 10FFFFh.
+These are captured by the ABNF rule `character` below.
 
 The lexical grammar defines how, at least conceptually,
 the sequence of characters is turned into
@@ -363,20 +363,20 @@ a sequence of tokens, comments, and whitespaces:
 these entities are all defined by the grammar rules below.
 
 As stated, the lexical grammar alone is ambiguous.
-For example, the sequence of characters '**' (i.e. two stars)
-could be equally parsed as two '*' symbol tokens or one '**' symbol token
-(see rule for 'symbol' below).
-As another example, the sequence or characters '<CR><LF>'
+For example, the sequence of characters `**` (i.e. two stars)
+could be equally parsed as two `*` symbol tokens or one `**` symbol token
+(see rule for `symbol` below).
+As another example, the sequence or characters `<CR><LF>`
 (i.e. carriage return followed by line feed)
 could be equally parsed as two line terminators or one
-(see rule for 'newline').
+(see rule for `newline`).
 
 Thus, as often done in language syntax definitions,
 the lexical grammar is disambiguated by
 the extra-grammatical requirement that
 the longest possible sequence of characters is always parsed.
-This way, '**' must be parsed as one '**' symbol token,
-and '<CR><LF>' must be parsed as one line terminator.
+This way, `**` must be parsed as one `**` symbol token,
+and `<CR><LF>` must be parsed as one line terminator.
 
 As mentioned above, a character is any Unicode code point.
 This grammar does not say how those are encoded in files (e.g. UTF-8):
@@ -393,27 +393,27 @@ We give names to certain ASCII characters.
 
 <a name="horizontal-tab"></a>
 ```abnf
-horizontal-tab = %x9
+horizontal-tab = %x9   ; <HT>
 ```
 
 <a name="line-feed"></a>
 ```abnf
-line-feed = %xA
+line-feed = %xA   ; <LF>
 ```
 
 <a name="carriage-return"></a>
 ```abnf
-carriage-return = %xD
+carriage-return = %xD   ; <CR>
 ```
 
 <a name="space"></a>
 ```abnf
-space = %x20
+space = %x20   ; <SP>
 ```
 
 <a name="double-quote"></a>
 ```abnf
-double-quote = %x22
+double-quote = %x22   ; "
 ```
 
 We give names to complements of certain ASCII characters.
@@ -432,12 +432,25 @@ not-star = %x0-29 / %x2B-10FFFF   ; anything but *
 <a name="not-line-feed-or-carriage-return"></a>
 ```abnf
 not-line-feed-or-carriage-return = %x0-9 / %xB-C / %xE-10FFFF
-                                   ; anything but LF or CR
+                                   ; anything but <LF> or <CR>
+```
+
+<a name="not-double-quote-or-open-brace"></a>
+```abnf
+not-double-quote-or-open-brace = %x0-22 / %x24-7A / %x7C-10FFFF
+                                 ; anything but " or {
+```
+
+<a name="not-double-quote-or-close-brace"></a>
+```abnf
+not-double-quote-or-close-brace = %x0-22 / %x24-7C / %x7E-10FFFF
+                                  ; anything but " or }
 ```
 
 <a name="not-star-or-slash"></a>
 ```abnf
-not-star-or-slash = %x0-29 / %x2B-2E / %x30-10FFFF   ; anything but * or /
+not-star-or-slash = %x0-29 / %x2B-2E / %x30-10FFFF
+                    ; anything but * or /
 ```
 
 Lines in Leo may be terminated via
@@ -453,7 +466,7 @@ described above.
 newline = line-feed / carriage-return / carriage-return line-feed
 ```
 
-Go to: _[carriage-return](#user-content-carriage-return), [line-feed](#user-content-line-feed)_;
+Go to: _[line-feed](#user-content-line-feed), [carriage-return](#user-content-carriage-return)_;
 
 
 Line terminators form whitespace, along with spaces and horizontal tabs.
@@ -463,16 +476,16 @@ Line terminators form whitespace, along with spaces and horizontal tabs.
 whitespace = space / horizontal-tab / newline
 ```
 
-Go to: _[space](#user-content-space), [horizontal-tab](#user-content-horizontal-tab), [newline](#user-content-newline)_;
+Go to: _[horizontal-tab](#user-content-horizontal-tab), [space](#user-content-space), [newline](#user-content-newline)_;
 
 
 There are two kinds of comments in Leo, as in other languages.
-One is block comments of the form '/* ... */',
-and the other is end-of-line comments of the form '// ...'.
-The first kind start at '/*' and end at the first '*/',
+One is block comments of the form `/* ... */`,
+and the other is end-of-line comments of the form `// ...`.
+The first kind start at `/*` and end at the first `*/`,
 possibly spanning multiple (partial) lines;
 these do no nest.
-The second kind start at '//' and extend till the end of the line.
+The second kind start at `//` and extend till the end of the line.
 The rules about comments given below are similar to
 the ones used in the Java language reference.
 
@@ -481,7 +494,7 @@ the ones used in the Java language reference.
 comment = block-comment / end-of-line-comment
 ```
 
-Go to: _[block-comment](#user-content-block-comment), [end-of-line-comment](#user-content-end-of-line-comment)_;
+Go to: _[end-of-line-comment](#user-content-end-of-line-comment), [block-comment](#user-content-block-comment)_;
 
 
 <a name="block-comment"></a>
@@ -498,7 +511,7 @@ rest-of-block-comment = "*" rest-of-block-comment-after-star
                       / not-star rest-of-block-comment
 ```
 
-Go to: _[rest-of-block-comment-after-star](#user-content-rest-of-block-comment-after-star), [not-star](#user-content-not-star), [rest-of-block-comment](#user-content-rest-of-block-comment)_;
+Go to: _[not-star](#user-content-not-star), [rest-of-block-comment-after-star](#user-content-rest-of-block-comment-after-star), [rest-of-block-comment](#user-content-rest-of-block-comment)_;
 
 
 <a name="rest-of-block-comment-after-star"></a>
@@ -609,31 +622,16 @@ package-name = 1*( lowercase-letter / digit )
 
 A format string is a sequence of characters, other than double quote,
 surrounded by double quotes.
-Within a format string, sub-strings '{}' are distinguished as containers
+Within a format string, sub-strings `{}` are distinguished as containers
 (these are the ones that may be matched with values
 whose textual representation replaces the containers
 in the printed string).
-There is an implicit extra-grammatical requirements that
-the explicit 'format-string-container' instances include
-all the occurrences of '{}' in the parsed character sequence:
-that is, there may not be two contiguous 'not-double-quote' instances
-that are '{' and '}'.
 
 <a name="format-string-container"></a>
 ```abnf
 format-string-container = "{}"
 ```
 
-<a name="not-double-quote-or-open-brace"></a>
-```abnf
-not-double-quote-or-open-brace = %x0-22 / %x24-7A / %x7C-10FFFF
-```
-
-<a name="not-double-quote-or-close-brace"></a>
-```abnf
-not-double-quote-or-close-brace = %x0-22 / %x24-7C / %x7E-10FFFF
-```
-
 <a name="format-string-element"></a>
 ```abnf
 format-string-element = not-double-quote-or-open-brace
@@ -641,7 +639,7 @@ format-string-element = not-double-quote-or-open-brace
                       / format-string-container
 ```
 
-Go to: _[not-double-quote-or-open-brace](#user-content-not-double-quote-or-open-brace), [not-double-quote-or-close-brace](#user-content-not-double-quote-or-close-brace), [format-string-container](#user-content-format-string-container)_;
+Go to: _[not-double-quote-or-close-brace](#user-content-not-double-quote-or-close-brace), [format-string-container](#user-content-format-string-container), [not-double-quote-or-open-brace](#user-content-not-double-quote-or-open-brace)_;
 
 
 <a name="format-string"></a>
@@ -652,43 +650,7 @@ format-string = double-quote *format-string-element double-quote
 Go to: _[double-quote](#user-content-double-quote)_;
 
 
-Here is (part of this ABNF comment),
-an alternative way to specify format strings,
-which captures the extra-grammatical requirement above in the grammar,
-but is more complicated:
-
-
-
-```
-not-double-quote-or-open-brace = %x0-22 / %x24-7A / %x7C-10FFFF
-```
-
-
-
-```
-not-double-quote-or-close-brace = %x0-22 / %x24-7C / %x7E-10FFFF
-```
-
-
-
-```
-format-string-element = not-double-quote-or-open-brace
-                         / "{" not-double-quote-or-close-brace
-                         / format-string-container
-```
-
-
-
-```
-format-string = double-quote *format-string-element double-quote
-```
-
-
-
-It is not immediately clear which approach is better; there are tradeoffs.
-We may choose to adopt this one in future revisions of the grammar.
-
-Annotations have names, which are identifiers immediately preceded by '@'.
+Annotations have names, which are identifiers immediately preceded by `@`.
 
 <a name="annotation-name"></a>
 ```abnf
@@ -699,7 +661,7 @@ Go to: _[identifier](#user-content-identifier)_;
 
 
 A natural (number) is a sequence of one or more digits.
-We allow leading zeros, e.g. '007'.
+We allow leading zeros, e.g. `007`.
 
 <a name="natural"></a>
 ```abnf
@@ -707,7 +669,7 @@ natural = 1*digit
 ```
 
 An integer (number) is either a natural or its negation.
-We allow leading zeros also in negative numbers, e.g. '-007'.
+We allow leading zeros also in negative numbers, e.g. `-007`.
 
 <a name="integer"></a>
 ```abnf
@@ -778,7 +740,7 @@ Boolean literals are the usual two.
 boolean-literal = %s"true" / %s"false"
 ```
 
-An address literal starts with 'aleo1'
+An address literal starts with `aleo1`
 and continues with exactly 58 lowercase letters and digits.
 Thus an address always consists of 63 characters.
 
@@ -802,16 +764,16 @@ atomic-literal = untyped-literal
                / address-literal
 ```
 
-Go to: _[unsigned-literal](#user-content-unsigned-literal), [field-literal](#user-content-field-literal), [product-group-literal](#user-content-product-group-literal), [address-literal](#user-content-address-literal), [signed-literal](#user-content-signed-literal), [untyped-literal](#user-content-untyped-literal), [boolean-literal](#user-content-boolean-literal)_;
+Go to: _[signed-literal](#user-content-signed-literal), [field-literal](#user-content-field-literal), [product-group-literal](#user-content-product-group-literal), [unsigned-literal](#user-content-unsigned-literal), [untyped-literal](#user-content-untyped-literal), [boolean-literal](#user-content-boolean-literal), [address-literal](#user-content-address-literal)_;
 
 
 After defining the (mostly) alphanumeric tokens above,
-it remains to define tokens for non-alphanumeric symbols such as "+" and "(".
+it remains to define tokens for non-alphanumeric symbols such as `+` and `(`.
 Different programming languages used different terminologies for these,
 e.g. operators, separators, punctuators, etc.
-Here we use 'symbol', for all of them.
+Here we use `symbol`, for all of them.
 We also include a token consisting of
-a closing parenthesis immediately followed by 'group':
+a closing parenthesis `)` immediately followed by `group`:
 as defined in the syntactic grammar,
 this is the final part of an affine group literal;
 even though it includes letters,
@@ -829,7 +791,7 @@ equality-operator = "=="
 
 
 
-and defining 'symbol' in terms of those
+and defining `symbol` in terms of those
 
 
 
@@ -844,7 +806,7 @@ but it would help establish a terminology in the grammar,
 namely the exact names of some of these token.
 On the other hand, at least some of them are perhaps simple enough
 that they could be just described in terms of their symbols,
-e.g. 'double dot', 'question mark', etc.
+e.g. double dot, question mark, etc.
 
 <a name="symbol"></a>
 ```abnf
@@ -875,7 +837,7 @@ token = keyword
       / symbol
 ```
 
-Go to: _[format-string](#user-content-format-string), [annotation-name](#user-content-annotation-name), [symbol](#user-content-symbol), [keyword](#user-content-keyword), [atomic-literal](#user-content-atomic-literal), [identifier](#user-content-identifier), [package-name](#user-content-package-name)_;
+Go to: _[package-name](#user-content-package-name), [format-string](#user-content-format-string), [symbol](#user-content-symbol), [identifier](#user-content-identifier), [atomic-literal](#user-content-atomic-literal), [annotation-name](#user-content-annotation-name), [keyword](#user-content-keyword)_;
 
 
 
@@ -953,10 +915,10 @@ address-type = %s"address"
 scalar-type =  boolean-type / arithmetic-type / address-type
 ```
 
-Go to: _[arithmetic-type](#user-content-arithmetic-type), [address-type](#user-content-address-type), [boolean-type](#user-content-boolean-type)_;
+Go to: _[address-type](#user-content-address-type), [arithmetic-type](#user-content-arithmetic-type), [boolean-type](#user-content-boolean-type)_;
 
 
-Circuit types are denoted by identifiers and the keyword 'Self'.
+Circuit types are denoted by identifiers and the keyword `Self`.
 The latter is only allowed inside a circuit definition,
 to denote the circuit being defined.
 
@@ -970,7 +932,7 @@ self-type = %s"Self"
 circuit-type = identifier / self-type
 ```
 
-Go to: _[identifier](#user-content-identifier), [self-type](#user-content-self-type)_;
+Go to: _[self-type](#user-content-self-type), [identifier](#user-content-identifier)_;
 
 
 A tuple type consists of zero, two, or more component types.
@@ -993,7 +955,7 @@ or a tuple of one or more dimensions.
 array-type = "[" type ";" array-dimensions "]"
 ```
 
-Go to: _[type](#user-content-type), [array-dimensions](#user-content-array-dimensions)_;
+Go to: _[array-dimensions](#user-content-array-dimensions), [type](#user-content-type)_;
 
 
 <a name="array-dimensions"></a>
@@ -1024,7 +986,7 @@ Scalar and aggregate types form all the types.
 type = scalar-type / aggregate-type
 ```
 
-Go to: _[scalar-type](#user-content-scalar-type), [aggregate-type](#user-content-aggregate-type)_;
+Go to: _[aggregate-type](#user-content-aggregate-type), [scalar-type](#user-content-scalar-type)_;
 
 
 The lexical grammar given earlier defines product group literals.
@@ -1060,11 +1022,11 @@ A literal is either an atomic one or an affine group literal.
 literal = atomic-literal / affine-group-literal
 ```
 
-Go to: _[affine-group-literal](#user-content-affine-group-literal), [atomic-literal](#user-content-atomic-literal)_;
+Go to: _[atomic-literal](#user-content-atomic-literal), [affine-group-literal](#user-content-affine-group-literal)_;
 
 
 The following rule is not directly referenced in the rules for expressions
-(which reference 'literal' instead),
+(which reference `literal` instead),
 but it is useful to establish terminology:
 a group literal is either a product group literal or an affine group literal.
 
@@ -1102,7 +1064,7 @@ primary-expression = identifier
                    / circuit-expression
 ```
 
-Go to: _[literal](#user-content-literal), [array-expression](#user-content-array-expression), [tuple-expression](#user-content-tuple-expression), [identifier](#user-content-identifier), [expression](#user-content-expression), [circuit-expression](#user-content-circuit-expression)_;
+Go to: _[array-expression](#user-content-array-expression), [identifier](#user-content-identifier), [expression](#user-content-expression), [literal](#user-content-literal), [tuple-expression](#user-content-tuple-expression), [circuit-expression](#user-content-circuit-expression)_;
 
 
 Tuple expressions construct tuples.
@@ -1127,7 +1089,7 @@ Go to: _[tuple-construction](#user-content-tuple-construction)_;
 Array expressions construct arrays.
 There are two kinds:
 one lists the element expressions (at least one),
-including spreads (via '...') which are arrays being spliced in;
+including spreads (via `...`) which are arrays being spliced in;
 the other repeats (the value of) a single expression
 across one or more dimensions.
 
@@ -1155,7 +1117,7 @@ Go to: _[expression](#user-content-expression)_;
 array-repeat-construction = "[" expression ";" array-dimensions "]"
 ```
 
-Go to: _[array-dimensions](#user-content-array-dimensions), [expression](#user-content-expression)_;
+Go to: _[expression](#user-content-expression), [array-dimensions](#user-content-array-dimensions)_;
 
 
 <a name="array-construction"></a>
@@ -1163,7 +1125,7 @@ Go to: _[array-dimensions](#user-content-array-dimensions), [expression](#user-c
 array-construction = array-inline-construction / array-repeat-construction
 ```
 
-Go to: _[array-inline-construction](#user-content-array-inline-construction), [array-repeat-construction](#user-content-array-repeat-construction)_;
+Go to: _[array-repeat-construction](#user-content-array-repeat-construction), [array-inline-construction](#user-content-array-inline-construction)_;
 
 
 <a name="array-expression"></a>
@@ -1186,7 +1148,8 @@ so they are syntactically identical but semantically different.
 <a name="circuit-construction"></a>
 ```abnf
 circuit-construction = circuit-type "{"
-                       circuit-inline-element *( "," circuit-inline-element ) [ "," ]
+                       circuit-inline-element
+                       *( "," circuit-inline-element ) [ "," ]
                        "}"
 ```
 
@@ -1249,7 +1212,7 @@ postfix-expression = primary-expression
                    / postfix-expression "[" [expression] ".." [expression] "]"
 ```
 
-Go to: _[primary-expression](#user-content-primary-expression), [expression](#user-content-expression), [postfix-expression](#user-content-postfix-expression), [natural](#user-content-natural), [identifier](#user-content-identifier), [function-arguments](#user-content-function-arguments), [circuit-type](#user-content-circuit-type)_;
+Go to: _[identifier](#user-content-identifier), [function-arguments](#user-content-function-arguments), [natural](#user-content-natural), [circuit-type](#user-content-circuit-type), [primary-expression](#user-content-primary-expression), [postfix-expression](#user-content-postfix-expression), [expression](#user-content-expression)_;
 
 
 Unary operators have the highest operator precedence.
@@ -1263,13 +1226,13 @@ unary-expression = postfix-expression
                  / "-" unary-expression
 ```
 
-Go to: _[unary-expression](#user-content-unary-expression), [postfix-expression](#user-content-postfix-expression)_;
+Go to: _[postfix-expression](#user-content-postfix-expression), [unary-expression](#user-content-unary-expression)_;
 
 
 Next in the operator precedence is exponentiation,
 following mathematical practice.
-The current rule below makes exponentiation left-associative,
-i.e. 'a ** b ** c' must be parsed as '(a ** b) ** c'.
+The current rule below makes exponentiation right-associative,
+i.e. `a ** b ** c` must be parsed as `a ** (b ** c)`.
 
 <a name="exponential-expression"></a>
 ```abnf
@@ -1277,7 +1240,7 @@ exponential-expression = unary-expression
                        / unary-expression "**" exponential-expression
 ```
 
-Go to: _[exponential-expression](#user-content-exponential-expression), [unary-expression](#user-content-unary-expression)_;
+Go to: _[unary-expression](#user-content-unary-expression), [exponential-expression](#user-content-exponential-expression)_;
 
 
 Next in precedence come multiplication and division, both left-associative.
@@ -1301,7 +1264,7 @@ additive-expression = multiplicative-expression
                     / additive-expression "-" multiplicative-expression
 ```
 
-Go to: _[multiplicative-expression](#user-content-multiplicative-expression), [additive-expression](#user-content-additive-expression)_;
+Go to: _[additive-expression](#user-content-additive-expression), [multiplicative-expression](#user-content-multiplicative-expression)_;
 
 
 Next in the precedence order are ordering relations.
@@ -1351,7 +1314,7 @@ disjunctive-expression = conjunctive-expression
                        / disjunctive-expression "||" conjunctive-expression
 ```
 
-Go to: _[disjunctive-expression](#user-content-disjunctive-expression), [conjunctive-expression](#user-content-conjunctive-expression)_;
+Go to: _[conjunctive-expression](#user-content-conjunctive-expression), [disjunctive-expression](#user-content-disjunctive-expression)_;
 
 
 Finally we have conditional expressions.
@@ -1396,7 +1359,7 @@ statement = expression-statement
           / block
 ```
 
-Go to: _[assignment-statement](#user-content-assignment-statement), [block](#user-content-block), [variable-definition-statement](#user-content-variable-definition-statement), [return-statement](#user-content-return-statement), [loop-statement](#user-content-loop-statement), [console-statement](#user-content-console-statement), [conditional-statement](#user-content-conditional-statement), [expression-statement](#user-content-expression-statement)_;
+Go to: _[return-statement](#user-content-return-statement), [loop-statement](#user-content-loop-statement), [assignment-statement](#user-content-assignment-statement), [expression-statement](#user-content-expression-statement), [console-statement](#user-content-console-statement), [block](#user-content-block), [conditional-statement](#user-content-conditional-statement), [variable-definition-statement](#user-content-variable-definition-statement)_;
 
 
 <a name="block"></a>
@@ -1415,8 +1378,7 @@ expression-statement = expression ";"
 Go to: _[expression](#user-content-expression)_;
 
 
-A return statement always takes an expression,
-and does not end with a semicolon.
+A return statement always takes an expression, and ends with a semicolon.
 
 <a name="return-statement"></a>
 ```abnf
@@ -1439,7 +1401,7 @@ variable-definition-statement = ( %s"let" / %s"const" )
                                 [ ":" type ] "=" expression ";"
 ```
 
-Go to: _[identifier-or-identifiers](#user-content-identifier-or-identifiers), [expression](#user-content-expression), [type](#user-content-type)_;
+Go to: _[type](#user-content-type), [identifier-or-identifiers](#user-content-identifier-or-identifiers), [expression](#user-content-expression)_;
 
 
 <a name="identifier-or-identifiers"></a>
@@ -1472,7 +1434,7 @@ conditional-statement = branch
                       / branch %s"else" conditional-statement
 ```
 
-Go to: _[branch](#user-content-branch), [conditional-statement](#user-content-conditional-statement), [block](#user-content-block)_;
+Go to: _[block](#user-content-block), [conditional-statement](#user-content-conditional-statement), [branch](#user-content-branch)_;
 
 
 A loop statement implicitly defines a loop variable
@@ -1484,11 +1446,11 @@ The body is a block.
 loop-statement = %s"for" identifier %s"in" expression ".." expression block
 ```
 
-Go to: _[block](#user-content-block), [identifier](#user-content-identifier), [expression](#user-content-expression)_;
+Go to: _[block](#user-content-block), [expression](#user-content-expression), [identifier](#user-content-identifier)_;
 
 
 An assignment statement is straightforward.
-Based on the operator, the assignment may be simple (i.e. '=')
+Based on the operator, the assignment may be simple (i.e. `=`)
 or compound (i.e. combining assignment with an arithmetic operation).
 
 <a name="assignment-operator"></a>
@@ -1504,13 +1466,13 @@ assignment-statement = expression assignment-operator expression ";"
 Go to: _[expression](#user-content-expression), [assignment-operator](#user-content-assignment-operator)_;
 
 
-Console statements start with the 'console' keyword,
+Console statements start with the `console` keyword,
 followed by a console function call.
 The call may be an assertion or a print command.
 The former takes an expression (which must be boolean) as argument.
 The latter takes either no argument,
 or a format string followed by expressions,
-whose number must match the number of containers '{}' in the format string.
+whose number must match the number of containers `{}` in the format string.
 Note that the console function names are identifiers, not keywords.
 There are three kinds of print commands.
 
@@ -1557,10 +1519,10 @@ Go to: _[format-string](#user-content-format-string)_;
 print-call = print-function print-arguments
 ```
 
-Go to: _[print-function](#user-content-print-function), [print-arguments](#user-content-print-arguments)_;
+Go to: _[print-arguments](#user-content-print-arguments), [print-function](#user-content-print-function)_;
 
 
-An annotation consists of an annotation name (which starts with '@')
+An annotation consists of an annotation name (which starts with `@`)
 with optional annotation arguments, which are identifiers.
 Note that no parentheses are used if there are no arguments.
 
@@ -1578,8 +1540,7 @@ The output type is optional, defaulting to the empty tuple type.
 In general, a function input consists of an identifier and a type,
 with an optional 'const' modifier.
 Additionally, functions inside circuits
-may start with a 'mut self' or 'const self' or 'self' parameter.
-Furthermore, any function may end with an 'input' parameter.
+may start with a `mut self` or `const self` or `self` parameter.
 
 <a name="function-declaration"></a>
 ```abnf
@@ -1588,7 +1549,7 @@ function-declaration = *annotation %s"function" identifier
                        block
 ```
 
-Go to: _[block](#user-content-block), [function-parameters](#user-content-function-parameters), [identifier](#user-content-identifier), [type](#user-content-type)_;
+Go to: _[type](#user-content-type), [block](#user-content-block), [identifier](#user-content-identifier), [function-parameters](#user-content-function-parameters)_;
 
 
 <a name="function-parameters"></a>
@@ -1598,7 +1559,7 @@ function-parameters = self-parameter
                     / function-inputs
 ```
 
-Go to: _[self-parameter](#user-content-self-parameter), [function-inputs](#user-content-function-inputs)_;
+Go to: _[function-inputs](#user-content-function-inputs), [self-parameter](#user-content-self-parameter)_;
 
 
 <a name="self-parameter"></a>
@@ -1622,11 +1583,6 @@ function-input = [ %s"const" ] identifier ":" type
 Go to: _[identifier](#user-content-identifier), [type](#user-content-type)_;
 
 
-<a name="input-parameter"></a>
-```abnf
-input-parameter = %s"input"
-```
-
 A circuit member variable declaration consists of an identifier and a type.
 A circuit member function declaration consists of a function declaration.
 
@@ -1636,7 +1592,7 @@ member-declaration = member-variable-declaration
                    / member-function-declaration
 ```
 
-Go to: _[member-function-declaration](#user-content-member-function-declaration), [member-variable-declaration](#user-content-member-variable-declaration)_;
+Go to: _[member-variable-declaration](#user-content-member-variable-declaration), [member-function-declaration](#user-content-member-function-declaration)_;
 
 
 <a name="member-variable-declaration"></a>
@@ -1644,7 +1600,7 @@ Go to: _[member-function-declaration](#user-content-member-function-declaration)
 member-variable-declaration = identifier ":" type
 ```
 
-Go to: _[type](#user-content-type), [identifier](#user-content-identifier)_;
+Go to: _[identifier](#user-content-identifier), [type](#user-content-type)_;
 
 
 <a name="member-function-declaration"></a>
@@ -1667,7 +1623,7 @@ circuit-declaration = *annotation %s"circuit" identifier
 Go to: _[identifier](#user-content-identifier), [member-declaration](#user-content-member-declaration)_;
 
 
-An import declaration consists of the 'import' keyword
+An import declaration consists of the `import` keyword
 followed by a package path, which may be one of the following:
 a single wildcard;
 an identifier, optionally followed by a local renamer;
@@ -1693,7 +1649,7 @@ package-path = "*"
              / "(" package-path *( "," package-path ) [","] ")"
 ```
 
-Go to: _[package-path](#user-content-package-path), [package-name](#user-content-package-name), [identifier](#user-content-identifier)_;
+Go to: _[package-name](#user-content-package-name), [package-path](#user-content-package-path), [identifier](#user-content-identifier)_;
 
 
 Finally, we define a file as a sequence of zero or more declarations.
@@ -1705,7 +1661,7 @@ declaration = import-declaration
             / circuit-declaration
 ```
 
-Go to: _[import-declaration](#user-content-import-declaration), [function-declaration](#user-content-function-declaration), [circuit-declaration](#user-content-circuit-declaration)_;
+Go to: _[function-declaration](#user-content-function-declaration), [circuit-declaration](#user-content-circuit-declaration), [import-declaration](#user-content-import-declaration)_;
 
 
 <a name="file"></a>
@@ -1720,16 +1676,18 @@ file = *declaration
 Format Note
 -----------
 
-The ABNF standard requires grammars to consist of lines terminated by CR LF
+The ABNF standard requires grammars
+to consist of lines terminated by `<CR><LF>`
 (i.e. carriage return followed by line feed, DOS/Windows-style),
 as explained in the background on ABNF earlier in this file.
-This file's lines are therefore terminated by CR LF.
+This file's lines are therefore terminated by `<CR><LF>`.
 To avoid losing this requirement across systems,
-this file is marked as 'text eol=crlf' in .gitattributes:
+this file is marked as `text eol=crlf` in `.gitattributes`:
 this means that the file is textual, enabling visual diffs,
-but its lines will always be terminated by CR LF on any system.
+but its lines will always be terminated by `<CR><LF>` on any system.
 
-Note that this CR LF requirement only applies to the grammar files themselves.
+Note that this `<CR><LF>` requirement only applies
+to the grammar files themselves.
 It does not apply to the lines of the languages described by the grammar.
 ABNF grammars may describe any kind of languages,
 with any kind of line terminators,

grammar/abnf-grammar.txt

@@ -53,59 +53,59 @@
 
 ; Instead of BNF's angle-bracket notation for nonterminals,
 ; ABNF uses case-insensitive names consisting of letters, digits, and dashes,
-; e.g. HTTP-message and IPv6address.
+; e.g. `HTTP-message` and `IPv6address`.
 ; ABNF includes an angle-bracket notation for prose descriptions,
-; e.g. <host, see [RFC3986], Section 3.2.2>,
+; e.g. `<host, see [RFC3986], Section 3.2.2>`,
 ; usable as last resort in the definiens of a nonterminal.
 
 ; While BNF allows arbitrary terminals,
 ; ABNF uses only natural numbers as terminals,
 ; and denotes them via:
 ; (i) binary, decimal, or hexadecimal sequences,
-; e.g. %b1.11.1010, %d1.3.10, and %x.1.3.A
-; all denote the sequence of terminals '1 3 10';
+; e.g. `%b1.11.1010`, `%d1.3.10`, and `%x.1.3.A`
+; all denote the sequence of terminals [1, 3, 10];
 ; (ii) binary, decimal, or hexadecimal ranges,
-; e.g. %x30-39 denotes any singleton sequence of terminals
-; 'n' with 48 <= n <= 57 (an ASCII digit);
+; e.g. `%x30-39` denotes any singleton sequence of terminals
+; [_n_] with 48 <= _n_ <= 57 (an ASCII digit);
 ; (iii) case-sensitive ASCII strings,
-; e.g. %s"Ab" denotes the sequence of terminals '65 98';
+; e.g. `%s"Ab"` denotes the sequence of terminals [65, 98];
 ; and (iv) case-insensitive ASCII strings,
-; e.g. %i"ab", or just "ab", denotes
+; e.g. `%i"ab"`, or just `"ab"`, denotes
 ; any sequence of terminals among
-; '65 66',
-; '65 98',
-; '97 66', and
-; '97 98'.
+; [65, 66],
+; [65, 98],
+; [97, 66], and
+; [97, 98].
 ; ABNF terminals in suitable sets represent ASCII or Unicode characters.
 
-; ABNF allows repetition prefixes n*m,
-; where n and m are natural numbers in decimal notation;
+; ABNF allows repetition prefixes `n*m`,
+; where `n` and `m` are natural numbers in decimal notation;
 ; if absent,
-; n defaults to 0, and
-; m defaults to infinity.
+; `n` defaults to 0, and
+; `m` defaults to infinity.
 ; For example,
-; 1*4HEXDIG denotes one to four HEXDIGs,
-; *3DIGIT denotes up to three DIGITs, and
-; 1*OCTET denotes one or more OCTETs.
-; A single n prefix
-; abbreviates n*n,
-; e.g. 3DIGIT denotes three DIGITs.
+; `1*4HEXDIG` denotes one to four `HEXDIG`s,
+; `*3DIGIT` denotes up to three `DIGIT`s, and
+; `1*OCTET` denotes one or more `OCTET`s.
+; A single `n` prefix
+; abbreviates `n*n`,
+; e.g. `3DIGIT` denotes three `DIGIT`s.
 
-; Instead of BNF's |, ABNF uses / to separate alternatives.
+; Instead of BNF's `|`, ABNF uses `/` to separate alternatives.
 ; Repetition prefixes have precedence over juxtapositions,
-; which have precedence over /.
+; which have precedence over `/`.
 ; Round brackets group things and override the aforementioned precedence rules,
-; e.g. *(WSP / CRLF WSP) denotes sequences of terminals
+; e.g. `*(WSP / CRLF WSP)` denotes sequences of terminals
 ; obtained by repeating, zero or more times,
-; either (i) a WSP or (ii) a CRLF followed by a WSP.
+; either (i) a `WSP` or (ii) a `CRLF` followed by a `WSP`.
 ; Square brackets also group things but make them optional,
-; e.g. [":" port] is equivalent to 0*1(":" port).
+; e.g. `[":" port]` is equivalent to `0*1(":" port)`.
 
-; Instead of BNF's ::=, ABNF uses = to define nonterminals,
-; and =/ to incrementally add alternatives
+; Instead of BNF's `::=`, ABNF uses `=` to define nonterminals,
+; and `=/` to incrementally add alternatives
 ; to previously defined nonterminals.
-; For example, the rule BIT = "0" / "1"
-; is equivalent to BIT = "0" followed by BIT =/ "1".
+; For example, the rule `BIT = "0" / "1"`
+; is equivalent to `BIT = "0"` followed by `BIT =/ "1"`.
 
 ; The syntax of ABNF itself is formally specified in ABNF
 ; (in Section 4 of the aforementioned RFC 5234,
@@ -125,7 +125,7 @@
 ; This ABNF grammar consists of two (sub-)grammars:
 ; (i) a lexical grammar that describes how
 ; sequence of characters are parsed into tokens, and
-; (ii) a syntactic grammar that described how
+; (ii) a syntactic grammar that describes how
 ; tokens are parsed into expressions, statements, etc.
 ; The adjectives 'lexical' and 'syntactic' are
 ; the same ones used in the Java language reference,
@@ -180,8 +180,8 @@
 ;        / additive-expression "-" multiplicative-expression
 ;
 ; These rules tell us
-; that the additive operators '+' and '-' have lower precedence
-; than the multiplicative operators '*' and '/',
+; that the additive operators `+` and `-` have lower precedence
+; than the multiplicative operators `*` and `/`,
 ; and that both the additive and multiplicative operators associate to the left.
 ; This may be best understood via the examples given below.
 
@@ -239,7 +239,7 @@
 ; This ABNF grammar uses nonterminal names
 ; that consist of complete English words, separated by dashes,
 ; and that describe the construct the way it is in English.
-; For instance, we use the name 'conditional-statement'
+; For instance, we use the name `conditional-statement`
 ; to describe conditional statements.
 
 ; At the same time, this grammar establishes
@@ -284,8 +284,8 @@
 
 ; A Leo file is a finite sequence of Unicode characters,
 ; represented as Unicode code points,
-; which are numbers in the range form 0 to 10FFFFh.
-; These are captured by the ABNF rule 'character' below.
+; which are numbers in the range from 0 to 10FFFFh.
+; These are captured by the ABNF rule `character` below.
 
 ; The lexical grammar defines how, at least conceptually,
 ; the sequence of characters is turned into
@@ -293,20 +293,20 @@
 ; these entities are all defined by the grammar rules below.
 
 ; As stated, the lexical grammar alone is ambiguous.
-; For example, the sequence of characters '**' (i.e. two stars)
-; could be equally parsed as two '*' symbol tokens or one '**' symbol token
-; (see rule for 'symbol' below).
-; As another example, the sequence or characters '<CR><LF>'
+; For example, the sequence of characters `**` (i.e. two stars)
+; could be equally parsed as two `*` symbol tokens or one `**` symbol token
+; (see rule for `symbol` below).
+; As another example, the sequence or characters `<CR><LF>`
 ; (i.e. carriage return followed by line feed)
 ; could be equally parsed as two line terminators or one
-; (see rule for 'newline').
+; (see rule for `newline`).
 
 ; Thus, as often done in language syntax definitions,
 ; the lexical grammar is disambiguated by
 ; the extra-grammatical requirement that
 ; the longest possible sequence of characters is always parsed.
-; This way, '**' must be parsed as one '**' symbol token,
-; and '<CR><LF>' must be parsed as one line terminator.
+; This way, `**` must be parsed as one `**` symbol token,
+; and `<CR><LF>` must be parsed as one line terminator.
 
 ; As mentioned above, a character is any Unicode code point.
 ; This grammar does not say how those are encoded in files (e.g. UTF-8):
@@ -318,15 +318,15 @@ character = %x0-10FFFF   ; any Unicode code point
 
 ; We give names to certain ASCII characters.
 
-horizontal-tab = %x9
+horizontal-tab = %x9   ; <HT>
 
-line-feed = %xA
+line-feed = %xA   ; <LF>
 
-carriage-return = %xD
+carriage-return = %xD   ; <CR>
 
-space = %x20
+space = %x20   ; <SP>
 
-double-quote = %x22
+double-quote = %x22   ; "
 
 ; We give names to complements of certain ASCII characters.
 ; These consist of all the Unicode characters except for one or two.
@@ -336,9 +336,16 @@ not-double-quote = %x0-22 / %x24-10FFFF   ; anything but "
 not-star = %x0-29 / %x2B-10FFFF   ; anything but *
 
 not-line-feed-or-carriage-return = %x0-9 / %xB-C / %xE-10FFFF
-                                   ; anything but LF or CR
+                                   ; anything but <LF> or <CR>
 
-not-star-or-slash = %x0-29 / %x2B-2E / %x30-10FFFF   ; anything but * or /
+not-double-quote-or-open-brace = %x0-22 / %x24-7A / %x7C-10FFFF
+                                 ; anything but " or {
+
+not-double-quote-or-close-brace = %x0-22 / %x24-7C / %x7E-10FFFF
+                                  ; anything but " or }
+
+not-star-or-slash = %x0-29 / %x2B-2E / %x30-10FFFF
+                    ; anything but * or /
 
 ; Lines in Leo may be terminated via
 ; a single carriage return,
@@ -355,12 +362,12 @@ newline = line-feed / carriage-return / carriage-return line-feed
 whitespace = space / horizontal-tab / newline
 
 ; There are two kinds of comments in Leo, as in other languages.
-; One is block comments of the form '/* ... */',
-; and the other is end-of-line comments of the form '// ...'.
-; The first kind start at '/*' and end at the first '*/',
+; One is block comments of the form `/* ... */`,
+; and the other is end-of-line comments of the form `// ...`.
+; The first kind start at `/*` and end at the first `*/`,
 ; possibly spanning multiple (partial) lines;
 ; these do no nest.
-; The second kind start at '//' and extend till the end of the line.
+; The second kind start at `//` and extend till the end of the line.
 ; The rules about comments given below are similar to
 ; the ones used in the Java language reference.
 
@@ -440,57 +447,30 @@ package-name = 1*( lowercase-letter / digit )
 
 ; A format string is a sequence of characters, other than double quote,
 ; surrounded by double quotes.
-; Within a format string, sub-strings '{}' are distinguished as containers
+; Within a format string, sub-strings `{}` are distinguished as containers
 ; (these are the ones that may be matched with values
 ; whose textual representation replaces the containers
 ; in the printed string).
-; There is an implicit extra-grammatical requirements that
-; the explicit 'format-string-container' instances include
-; all the occurrences of '{}' in the parsed character sequence:
-; that is, there may not be two contiguous 'not-double-quote' instances
-; that are '{' and '}'.
 
 format-string-container = "{}"
 
-not-double-quote-or-open-brace = %x0-22 / %x24-7A / %x7C-10FFFF
-
-not-double-quote-or-close-brace = %x0-22 / %x24-7C / %x7E-10FFFF
-
 format-string-element = not-double-quote-or-open-brace
                       / "{" not-double-quote-or-close-brace
                       / format-string-container
 
 format-string = double-quote *format-string-element double-quote
 
-; Here is (part of this ABNF comment),
-; an alternative way to specify format strings,
-; which captures the extra-grammatical requirement above in the grammar,
-; but is more complicated:
-;
-;  not-double-quote-or-open-brace = %x0-22 / %x24-7A / %x7C-10FFFF
-;
-;  not-double-quote-or-close-brace = %x0-22 / %x24-7C / %x7E-10FFFF
-;
-;  format-string-element = not-double-quote-or-open-brace
-;                           / "{" not-double-quote-or-close-brace
-;                           / format-string-container
-;
-;  format-string = double-quote *format-string-element double-quote
-;
-; It is not immediately clear which approach is better; there are tradeoffs.
-; We may choose to adopt this one in future revisions of the grammar.
-
-; Annotations have names, which are identifiers immediately preceded by '@'.
+; Annotations have names, which are identifiers immediately preceded by `@`.
 
 annotation-name = "@" identifier
 
 ; A natural (number) is a sequence of one or more digits.
-; We allow leading zeros, e.g. '007'.
+; We allow leading zeros, e.g. `007`.
 
 natural = 1*digit
 
 ; An integer (number) is either a natural or its negation.
-; We allow leading zeros also in negative numbers, e.g. '-007'.
+; We allow leading zeros also in negative numbers, e.g. `-007`.
 
 integer = [ "-" ] natural
 
@@ -522,7 +502,7 @@ product-group-literal = integer %s"group"
 
 boolean-literal = %s"true" / %s"false"
 
-; An address literal starts with 'aleo1'
+; An address literal starts with `aleo1`
 ; and continues with exactly 58 lowercase letters and digits.
 ; Thus an address always consists of 63 characters.
 
@@ -541,12 +521,12 @@ atomic-literal = untyped-literal
                / address-literal
 
 ; After defining the (mostly) alphanumeric tokens above,
-; it remains to define tokens for non-alphanumeric symbols such as "+" and "(".
+; it remains to define tokens for non-alphanumeric symbols such as `+` and `(`.
 ; Different programming languages used different terminologies for these,
 ; e.g. operators, separators, punctuators, etc.
-; Here we use 'symbol', for all of them.
+; Here we use `symbol`, for all of them.
 ; We also include a token consisting of
-; a closing parenthesis immediately followed by 'group':
+; a closing parenthesis `)` immediately followed by `group`:
 ; as defined in the syntactic grammar,
 ; this is the final part of an affine group literal;
 ; even though it includes letters,
@@ -558,7 +538,7 @@ atomic-literal = untyped-literal
 ;
 ;  equality-operator = "=="
 ;
-; and defining 'symbol' in terms of those
+; and defining `symbol` in terms of those
 ;
 ;  symbol = ... / equality-operator / ...
 ;
@@ -567,7 +547,7 @@ atomic-literal = untyped-literal
 ; namely the exact names of some of these token.
 ; On the other hand, at least some of them are perhaps simple enough
 ; that they could be just described in terms of their symbols,
-; e.g. 'double dot', 'question mark', etc.
+; e.g. double dot, question mark, etc.
 
 symbol = "!" / "&&" / "||"
        / "==" / "!="
@@ -632,7 +612,7 @@ address-type = %s"address"
 
 scalar-type =  boolean-type / arithmetic-type / address-type
 
-; Circuit types are denoted by identifiers and the keyword 'Self'.
+; Circuit types are denoted by identifiers and the keyword `Self`.
 ; The latter is only allowed inside a circuit definition,
 ; to denote the circuit being defined.
 
@@ -683,7 +663,7 @@ affine-group-literal = "(" group-coordinate "," group-coordinate %s")group"
 literal = atomic-literal / affine-group-literal
 
 ; The following rule is not directly referenced in the rules for expressions
-; (which reference 'literal' instead),
+; (which reference `literal` instead),
 ; but it is useful to establish terminology:
 ; a group literal is either a product group literal or an affine group literal.
 
@@ -722,7 +702,7 @@ tuple-expression = tuple-construction
 ; Array expressions construct arrays.
 ; There are two kinds:
 ; one lists the element expressions (at least one),
-; including spreads (via '...') which are arrays being spliced in;
+; including spreads (via `...`) which are arrays being spliced in;
 ; the other repeats (the value of) a single expression
 ; across one or more dimensions.
 
@@ -749,7 +729,8 @@ array-expression = array-construction
 ; so they are syntactically identical but semantically different.
 
 circuit-construction = circuit-type "{"
-                       circuit-inline-element *( "," circuit-inline-element ) [ "," ]
+                       circuit-inline-element
+                       *( "," circuit-inline-element ) [ "," ]
                        "}"
 
 circuit-inline-element = identifier ":" expression / identifier
@@ -797,8 +778,8 @@ unary-expression = postfix-expression
 
 ; Next in the operator precedence is exponentiation,
 ; following mathematical practice.
-; The current rule below makes exponentiation left-associative,
-; i.e. 'a ** b ** c' must be parsed as '(a ** b) ** c'.
+; The current rule below makes exponentiation right-associative,
+; i.e. `a ** b ** c` must be parsed as `a ** (b ** c)`.
 
 exponential-expression = unary-expression
                        / unary-expression "**" exponential-expression
@@ -875,8 +856,7 @@ block = "{" *statement "}"
 
 expression-statement = expression ";"
 
-; A return statement always takes an expression,
-; and does not end with a semicolon.
+; A return statement always takes an expression, and ends with a semicolon.
 
 return-statement = %s"return" expression ";"
 
@@ -912,20 +892,20 @@ conditional-statement = branch
 loop-statement = %s"for" identifier %s"in" expression ".." expression block
 
 ; An assignment statement is straightforward.
-; Based on the operator, the assignment may be simple (i.e. '=')
+; Based on the operator, the assignment may be simple (i.e. `=`)
 ; or compound (i.e. combining assignment with an arithmetic operation).
 
 assignment-operator = "=" / "+=" / "-=" / "*=" / "/=" / "**="
 
 assignment-statement = expression assignment-operator expression ";"
 
-; Console statements start with the 'console' keyword,
+; Console statements start with the `console` keyword,
 ; followed by a console function call.
 ; The call may be an assertion or a print command.
 ; The former takes an expression (which must be boolean) as argument.
 ; The latter takes either no argument,
 ; or a format string followed by expressions,
-; whose number must match the number of containers '{}' in the format string.
+; whose number must match the number of containers `{}` in the format string.
 ; Note that the console function names are identifiers, not keywords.
 ; There are three kinds of print commands.
 
@@ -942,7 +922,7 @@ print-arguments = "(" [ format-string *( "," expression ) ] ")"
 
 print-call = print-function print-arguments
 
-; An annotation consists of an annotation name (which starts with '@')
+; An annotation consists of an annotation name (which starts with `@`)
 ; with optional annotation arguments, which are identifiers.
 ; Note that no parentheses are used if there are no arguments.
 
@@ -954,8 +934,7 @@ annotation = annotation-name
 ; In general, a function input consists of an identifier and a type,
 ; with an optional 'const' modifier.
 ; Additionally, functions inside circuits
-; may start with a 'mut self' or 'const self' or 'self' parameter.
-; Furthermore, any function may end with an 'input' parameter.
+; may start with a `mut self` or `const self` or `self` parameter.
 
 function-declaration = *annotation %s"function" identifier
                        "(" [ function-parameters ] ")" [ "->" type ]
@@ -971,8 +950,6 @@ function-inputs = function-input *( "," function-input )
 
 function-input = [ %s"const" ] identifier ":" type
 
-input-parameter = %s"input"
-
 ; A circuit member variable declaration consists of an identifier and a type.
 ; A circuit member function declaration consists of a function declaration.
 
@@ -989,7 +966,7 @@ member-function-declaration = function-declaration
 circuit-declaration = *annotation %s"circuit" identifier
                       "{" member-declaration *( "," member-declaration ) "}"
 
-; An import declaration consists of the 'import' keyword
+; An import declaration consists of the `import` keyword
 ; followed by a package path, which may be one of the following:
 ; a single wildcard;
 ; an identifier, optionally followed by a local renamer;
@@ -1019,16 +996,18 @@ file = *declaration
 ; Format Note
 ; -----------
 
-; The ABNF standard requires grammars to consist of lines terminated by CR LF
+; The ABNF standard requires grammars
+; to consist of lines terminated by `<CR><LF>`
 ; (i.e. carriage return followed by line feed, DOS/Windows-style),
 ; as explained in the background on ABNF earlier in this file.
-; This file's lines are therefore terminated by CR LF.
+; This file's lines are therefore terminated by `<CR><LF>`.
 ; To avoid losing this requirement across systems,
-; this file is marked as 'text eol=crlf' in .gitattributes:
+; this file is marked as `text eol=crlf` in `.gitattributes`:
 ; this means that the file is textual, enabling visual diffs,
-; but its lines will always be terminated by CR LF on any system.
+; but its lines will always be terminated by `<CR><LF>` on any system.
 
-; Note that this CR LF requirement only applies to the grammar files themselves.
+; Note that this `<CR><LF>` requirement only applies
+; to the grammar files themselves.
 ; It does not apply to the lines of the languages described by the grammar.
 ; ABNF grammars may describe any kind of languages,
 ; with any kind of line terminators,

leo/api.rs

@@ -22,25 +22,24 @@ use reqwest::{
 };
 use serde::{Deserialize, Serialize};
 
-/// Trait describes API Routes and Request bodies, struct which implements
-/// Route MUST also support Serialize to be usable in Api::run_route(r: Route)
+/// API Routes and Request bodies.
+/// Structs that implement Route MUST also support Serialize to be usable in Api::run_route(r: Route)
 pub trait Route {
-    /// Whether to use bearer auth or not. Some routes may have additional
-    /// features for logged-in users, so authorization token should be sent
-    /// if it is created of course
+    /// [`true`] if a route supports bearer authentication.
+    /// For example, the login route.
     const AUTH: bool;
 
-    /// HTTP method to use when requesting
+    /// The HTTP method to use when requesting.
     const METHOD: Method;
 
-    /// URL path without first forward slash (e.g. v1/package/fetch)
+    /// The URL path without the first forward slash (e.g. v1/package/fetch)
     const PATH: &'static str;
 
-    /// Output type for this route. For login it is simple - String
+    /// The output type for this route. For example, the login route output is [`String`].
     /// But for other routes may be more complex.
     type Output;
 
-    /// Process reqwest Response and turn it into Output
+    /// Process the reqwest Response and turn it into an Output.
     fn process(&self, res: Response) -> Result<Self::Output>;
 
     /// Transform specific status codes into correct errors for this route.
@@ -50,18 +49,18 @@ pub trait Route {
     }
 }
 
-/// REST API handler with reqwest::blocking inside
+/// REST API handler with reqwest::blocking inside.
 #[derive(Clone, Debug)]
 pub struct Api {
     host: String,
     client: Client,
-    /// Authorization token for API requests
+    /// Authorization token for API requests.
     auth_token: Option<String>,
 }
 
 impl Api {
-    /// Create new instance of API, set host and Client is going to be
-    /// created and set automatically
+    /// Returns a new instance of API.
+    /// The set host and Client are created automatically.
     pub fn new(host: String, auth_token: Option<String>) -> Api {
         Api {
             client: Client::new(),
@@ -70,18 +69,23 @@ impl Api {
         }
     }
 
-    /// Get token for bearer auth, should be passed into Api through Context
+    pub fn host(&self) -> &str {
+        &*self.host
+    }
+
+    /// Returns the token for bearer auth, otherwise None.
+    /// The [`auth_token`] should be passed into the Api through Context.
     pub fn auth_token(&self) -> Option<String> {
         self.auth_token.clone()
     }
 
-    /// Set authorization token for future requests
+    /// Set the authorization token for future requests.
     pub fn set_auth_token(&mut self, token: String) {
         self.auth_token = Some(token);
     }
 
     /// Run specific route struct. Turn struct into request body
-    /// and use type constants and Route implementation to get request params
+    /// and use type constants and Route implementation to get request params.
     pub fn run_route<T>(&self, route: T) -> Result<T::Output>
     where
         T: Route,
@@ -100,7 +104,9 @@ impl Api {
         };
 
         // only one error is possible here
-        let res = res.send().map_err(|_| anyhow!("Unable to connect to Aleo PM"))?;
+        let res = res.send().map_err(|_| {
+            anyhow!("Unable to connect to Aleo PM. If you specified custom API endpoint, then check the URL for errors")
+        })?;
 
         // where magic begins
         route.process(res)
@@ -143,7 +149,7 @@ impl Route for Fetch {
             // TODO: we should return 404 on not found author/package
             // and return BAD_REQUEST if data format is incorrect or some of the arguments
             // were not passed
-            StatusCode::NOT_FOUND => anyhow!("Package is hidden"),
+            StatusCode::NOT_FOUND => anyhow!("Package not found"),
             _ => anyhow!("Unknown API error: {}", status),
         }
     }
@@ -183,7 +189,7 @@ impl Route for Login {
 }
 
 /// Handler for 'my_profile' route. Meant to be used to get profile details but
-/// in current application is used to check if user is logged in. Any non-200 response
+/// in the current application it is used to check if the user is logged in. Any non-200 response
 /// is treated as Unauthorized.
 #[derive(Serialize)]
 pub struct Profile {}

leo/commands/package/publish.rs

@@ -15,10 +15,7 @@
 // along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
 
 use super::build::Build;
-use crate::{
-    commands::Command,
-    context::{Context, PACKAGE_MANAGER_URL},
-};
+use crate::{commands::Command, context::Context};
 use leo_package::{
     outputs::OutputsDirectory,
     root::{ZipFile, AUTHOR_PLACEHOLDER},
@@ -118,7 +115,7 @@ impl Command for Publish {
 
         // Make a request to publish a package
         let response = client
-            .post(format!("{}{}", PACKAGE_MANAGER_URL, PUBLISH_URL).as_str())
+            .post(format!("{}{}", context.api.host(), PUBLISH_URL).as_str())
             .headers(headers)
             .multipart(form_data)
             .send();

leo/context.rs

@@ -48,19 +48,19 @@ impl Context {
 }
 
 /// Create a new context for the current directory.
-pub fn create_context(path: PathBuf) -> Result<Context> {
+pub fn create_context(path: PathBuf, api_url: Option<String>) -> Result<Context> {
     let token = config::read_token().ok();
 
-    let api = Api::new(PACKAGE_MANAGER_URL.to_string(), token);
+    let api = Api::new(api_url.unwrap_or_else(|| PACKAGE_MANAGER_URL.to_string()), token);
 
     Ok(Context { api, path: Some(path) })
 }
 
 /// Returns project context.
-pub fn get_context() -> Result<Context> {
+pub fn get_context(api_url: Option<String>) -> Result<Context> {
     let token = config::read_token().ok();
 
-    let api = Api::new(PACKAGE_MANAGER_URL.to_string(), token);
+    let api = Api::new(api_url.unwrap_or_else(|| PACKAGE_MANAGER_URL.to_string()), token);
 
     Ok(Context { api, path: None })
 }

leo/main.rs

@@ -55,6 +55,9 @@ struct Opt {
     #[structopt(subcommand)]
     command: CommandOpts,
 
+    #[structopt(help = "Custom Aleo PM backend URL", env = "APM_URL")]
+    api: Option<String>,
+
     #[structopt(
         long,
         global = true,
@@ -192,8 +195,8 @@ fn main() {
     // Get custom root folder and create context for it.
     // If not specified, default context will be created in cwd.
     let context = handle_error(match opt.path {
-        Some(path) => context::create_context(path),
-        None => context::get_context(),
+        Some(path) => context::create_context(path, opt.api),
+        None => context::get_context(opt.api),
     });
 
     handle_error(match opt.command {

leo/tests/mod.rs

@@ -153,7 +153,7 @@ pub fn leo_update_and_update_automatic() -> Result<()> {
 /// Create context for Pedersen Hash example
 fn context() -> Result<Context> {
     let path = PathBuf::from(&PEDERSEN_HASH_PATH);
-    let context = create_context(path)?;
+    let context = create_context(path, None)?;
 
     Ok(context)
 }

parser/Cargo.toml

@@ -54,6 +54,10 @@ version = "0.3"
 [dev-dependencies.serde_yaml]
 version = "0.8"
 
+[dev-dependencies.leo-test-framework]
+path = "../test-framework"
+version = "1.4.0"
+
 [features]
 default = [ ]
 ci_skip = [ ]

parser/src/test.rs

@@ -14,158 +14,36 @@
 // 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 std::{
-    fmt,
-    fs,
-    path::{Path, PathBuf},
-    sync::Arc,
-};
-
-use leo_ast::{Expression, ExpressionStatement, Program, Span, Statement, ValueExpression};
+use leo_ast::{Expression, ExpressionStatement, Span, Statement, ValueExpression};
+use leo_test_framework::runner::{Namespace, ParseType, Runner};
 use serde_yaml::Value;
 use tokenizer::Token;
 
-use crate::{tokenizer, DeprecatedError, ParserContext, SyntaxError, TokenError};
+use crate::{tokenizer, ParserContext};
 
-struct TestFailure {
-    path: String,
-    errors: Vec<TestError>,
-}
+struct TokenNamespace;
 
-#[derive(Debug)]
-enum TestError {
-    UnexpectedOutput {
-        index: usize,
-        expected: String,
-        output: String,
-    },
-    PassedAndShouldntHave {
-        index: usize,
-    },
-    FailedAndShouldntHave {
-        index: usize,
-        error: String,
-    },
-    UnexpectedError {
-        index: usize,
-        expected: String,
-        output: String,
-    },
-    MismatchedTestExpectationLength,
-}
-
-impl fmt::Display for TestError {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            TestError::UnexpectedOutput {
-                index,
-                expected,
-                output,
-            } => {
-                write!(f, "test #{} expected\n{}\ngot\n{}", index + 1, expected, output)
-            }
-            TestError::PassedAndShouldntHave { index } => write!(f, "test #{} passed and shouldn't have", index + 1),
-            TestError::FailedAndShouldntHave { index, error } => {
-                write!(f, "test #{} failed and shouldn't have:\n{}", index + 1, error)
-            }
-            TestError::UnexpectedError {
-                expected,
-                output,
-                index,
-            } => {
-                write!(f, "test #{} expected error\n{}\ngot\n{}", index + 1, expected, output)
-            }
-            TestError::MismatchedTestExpectationLength => write!(f, "invalid number of test expectations"),
-        }
+impl Namespace for TokenNamespace {
+    fn parse_type(&self) -> ParseType {
+        ParseType::Line
     }
-}
 
-pub fn find_tests<T: AsRef<Path>>(path: T, out: &mut Vec<(String, String)>) {
-    for entry in fs::read_dir(path).expect("fail to read tests").into_iter() {
-        let entry = entry.expect("fail to read tests").path();
-        if entry.is_dir() {
-            find_tests(entry.as_path(), out);
-            continue;
-        } else if entry.extension().map(|x| x.to_str()).flatten().unwrap_or_default() != "leo" {
-            continue;
-        }
-        let content = fs::read_to_string(entry.as_path()).expect("failed to read test");
-        out.push((entry.as_path().to_str().unwrap_or_default().to_string(), content));
+    fn run_test(&self, test: &str) -> Result<Value, String> {
+        let output = tokenizer::tokenize("test", test.into());
+        output
+            .map(|tokens| {
+                Value::String(
+                    tokens
+                        .into_iter()
+                        .map(|x| x.to_string())
+                        .collect::<Vec<String>>()
+                        .join(","),
+                )
+            })
+            .map_err(|x| x.to_string())
     }
 }
 
-#[derive(serde::Serialize, serde::Deserialize, PartialEq, Debug, Clone)]
-enum TestNamespace {
-    Parse,
-    ParseStatement,
-    ParseExpression,
-    Token,
-}
-
-#[derive(serde::Serialize, serde::Deserialize, PartialEq, Debug, Clone)]
-enum TestExpectationMode {
-    Pass,
-    Fail,
-}
-
-#[derive(serde::Serialize, serde::Deserialize)]
-struct TestConfig {
-    namespace: TestNamespace,
-    expectation: TestExpectationMode,
-}
-
-#[derive(serde::Serialize, serde::Deserialize, Clone)]
-struct TestExpectation {
-    namespace: TestNamespace,
-    expectation: TestExpectationMode,
-    outputs: Vec<Value>,
-}
-
-fn extract_test_config(source: &str) -> Option<TestConfig> {
-    let first_comment_start = source.find("/*")?;
-    let end_first_comment = source[first_comment_start + 2..].find("*/")?;
-    let comment_inner = &source[first_comment_start + 2..first_comment_start + 2 + end_first_comment];
-    Some(serde_yaml::from_str(comment_inner).expect("invalid test configuration"))
-}
-
-fn split_tests_oneline(source: &str) -> Vec<&str> {
-    source.lines().map(|x| x.trim()).filter(|x| !x.is_empty()).collect()
-}
-
-fn split_tests_twoline(source: &str) -> Vec<String> {
-    let mut out = vec![];
-    let mut lines = vec![];
-    for line in source.lines() {
-        let line = line.trim();
-        if line.is_empty() {
-            if !lines.is_empty() {
-                out.push(lines.join("\n"));
-            }
-            lines.clear();
-            continue;
-        }
-        lines.push(line);
-    }
-    let last_test = lines.join("\n");
-    if !last_test.trim().is_empty() {
-        out.push(last_test.trim().to_string());
-    }
-    out
-}
-
-fn run_individual_token_test(path: &str, source: &str) -> Result<String, String> {
-    let output = tokenizer::tokenize(path, source.into());
-    output
-        .map(|tokens| {
-            tokens
-                .into_iter()
-                .map(|x| x.to_string())
-                .collect::<Vec<String>>()
-                .join(",")
-        })
-        .map_err(|x| strip_path_syntax_error(x.into()))
-}
-
 fn not_fully_consumed(tokens: &mut ParserContext) -> Result<(), String> {
     if !tokens.has_next() {
         return Ok(());
@@ -178,389 +56,95 @@ fn not_fully_consumed(tokens: &mut ParserContext) -> Result<(), String> {
     Err(out)
 }
 
-fn run_individual_expression_test(path: &str, source: &str) -> Result<Expression, String> {
-    let tokenizer = tokenizer::tokenize(path, source.into()).map_err(|x| strip_path_syntax_error(x.into()))?;
-    if tokenizer
-        .iter()
-        .all(|x| matches!(x.token, Token::CommentLine(_) | Token::CommentBlock(_)))
-    {
-        return Ok(Expression::Value(ValueExpression::Implicit("".into(), Span::default())));
+struct ParseExpressionNamespace;
+
+impl Namespace for ParseExpressionNamespace {
+    fn parse_type(&self) -> ParseType {
+        ParseType::Line
     }
-    let mut tokens = ParserContext::new(tokenizer);
 
-    let parsed = tokens.parse_expression().map_err(strip_path_syntax_error)?;
-    not_fully_consumed(&mut tokens)?;
-
-    Ok(parsed)
-}
-
-fn run_individual_statement_test(path: &str, source: &str) -> Result<Statement, String> {
-    let tokenizer = tokenizer::tokenize(path, source.into()).map_err(|x| strip_path_syntax_error(x.into()))?;
-    if tokenizer
-        .iter()
-        .all(|x| matches!(x.token, Token::CommentLine(_) | Token::CommentBlock(_)))
-    {
-        return Ok(Statement::Expression(ExpressionStatement {
-            expression: Expression::Value(ValueExpression::Implicit("".into(), Span::default())),
-            span: Span::default(),
-        }));
-    }
-    let mut tokens = ParserContext::new(tokenizer);
-
-    let parsed = tokens.parse_statement().map_err(strip_path_syntax_error)?;
-    not_fully_consumed(&mut tokens)?;
-
-    Ok(parsed)
-}
-
-fn strip_path_syntax_error(mut err: SyntaxError) -> String {
-    let inner = match &mut err {
-        SyntaxError::DeprecatedError(DeprecatedError::Error(x)) => x,
-        SyntaxError::Error(x) => x,
-        SyntaxError::TokenError(TokenError::Error(x)) => x,
-    };
-    inner.path = Arc::new("test".to_string());
-    err.to_string()
-}
-
-fn run_individual_parse_test(path: &str, source: &str) -> Result<Program, String> {
-    let tokenizer = tokenizer::tokenize(path, source.into()).map_err(|x| strip_path_syntax_error(x.into()))?;
-    let mut tokens = ParserContext::new(tokenizer);
-
-    let parsed = tokens.parse_program().map_err(strip_path_syntax_error)?;
-    not_fully_consumed(&mut tokens)?;
-
-    Ok(parsed)
-}
-
-fn emit_errors<T: PartialEq + ToString + serde::de::DeserializeOwned>(
-    output: Result<&T, &str>,
-    mode: &TestExpectationMode,
-    expected_output: Option<Value>,
-    test_index: usize,
-) -> Option<TestError> {
-    match (output, mode) {
-        (Ok(output), TestExpectationMode::Pass) => {
-            let expected_output: Option<T> =
-                expected_output.map(|x| serde_yaml::from_value(x).expect("test expectation deserialize failed"));
-            // passed and should have
-            if let Some(expected_output) = expected_output.as_ref() {
-                if output != expected_output {
-                    // invalid output
-                    return Some(TestError::UnexpectedOutput {
-                        index: test_index,
-                        expected: expected_output.to_string(),
-                        output: output.to_string(),
-                    });
-                }
-            }
-            None
-        }
-        (Ok(_tokens), TestExpectationMode::Fail) => Some(TestError::PassedAndShouldntHave { index: test_index }),
-        (Err(err), TestExpectationMode::Pass) => Some(TestError::FailedAndShouldntHave {
-            error: err.to_string(),
-            index: test_index,
-        }),
-        (Err(err), TestExpectationMode::Fail) => {
-            let expected_output: Option<String> =
-                expected_output.map(|x| serde_yaml::from_value(x).expect("test expectation deserialize failed"));
-            if let Some(expected_output) = expected_output.as_deref() {
-                if err != expected_output {
-                    // invalid output
-                    return Some(TestError::UnexpectedError {
-                        expected: expected_output.to_string(),
-                        output: err.to_string(),
-                        index: test_index,
-                    });
-                }
-            }
-            None
+    fn run_test(&self, test: &str) -> Result<Value, String> {
+        let tokenizer = tokenizer::tokenize("test", test.into()).map_err(|x| x.to_string())?;
+        if tokenizer
+            .iter()
+            .all(|x| matches!(x.token, Token::CommentLine(_) | Token::CommentBlock(_)))
+        {
+            return Ok(serde_yaml::to_value(&Expression::Value(ValueExpression::Implicit(
+                "".into(),
+                Span::default(),
+            )))
+            .expect("serialization failed"));
         }
+        let mut tokens = ParserContext::new(tokenizer);
+
+        let parsed = tokens.parse_expression().map_err(|x| x.to_string())?;
+        not_fully_consumed(&mut tokens)?;
+
+        Ok(serde_yaml::to_value(&parsed).expect("serialization failed"))
     }
 }
 
-fn run_test(
-    config: &TestConfig,
-    path: &str,
-    source: &str,
-    expectations: Option<&TestExpectation>,
-    errors: &mut Vec<TestError>,
-) -> Vec<Value> {
-    let end_of_header = source.find("*/").expect("failed to find header block in test");
-    let source = &source[end_of_header + 2..];
-    let mut outputs = vec![];
-    match &config.namespace {
-        TestNamespace::Token => {
-            let tests = split_tests_oneline(source);
-            if let Some(expectations) = expectations.as_ref() {
-                if tests.len() != expectations.outputs.len() {
-                    errors.push(TestError::MismatchedTestExpectationLength);
-                }
-            }
-            let mut expected_output = expectations.as_ref().map(|x| x.outputs.iter());
-            for (i, test) in tests.into_iter().enumerate() {
-                let expected_output = expected_output
-                    .as_mut()
-                    .map(|x| x.next())
-                    .flatten()
-                    .map(|x| x.as_str())
-                    .flatten();
-                let output = run_individual_token_test(path, test);
-                if let Some(error) = emit_errors(
-                    output.as_ref().map_err(|x| &**x),
-                    &config.expectation,
-                    expected_output.map(|x| Value::String(x.to_string())),
-                    i,
-                ) {
-                    errors.push(error);
-                } else {
-                    outputs.push(serde_yaml::to_value(output.unwrap_or_else(|e| e)).expect("serialization failed"));
-                }
-            }
-        }
-        TestNamespace::Parse => {
-            if let Some(expectations) = expectations.as_ref() {
-                if expectations.outputs.len() != 1 {
-                    errors.push(TestError::MismatchedTestExpectationLength);
-                }
-            }
-            let expected_output = expectations
-                .map(|x| x.outputs.get(0))
-                .flatten()
-                .map(|x| serde_yaml::from_value(x.clone()).expect("invalid test expectation form"));
-            let output = run_individual_parse_test(path, source);
-            if let Some(error) = emit_errors(
-                output.as_ref().map_err(|x| &**x),
-                &config.expectation,
-                expected_output,
-                0,
-            ) {
-                errors.push(error);
-            } else {
-                outputs.push(
-                    output
-                        .map(|x| serde_yaml::to_value(x).expect("serialization failed"))
-                        .unwrap_or_else(|e| serde_yaml::to_value(e).expect("serialization failed")),
-                );
-            }
-        }
-        TestNamespace::ParseStatement => {
-            let tests = split_tests_twoline(source);
-            if let Some(expectations) = expectations.as_ref() {
-                if tests.len() != expectations.outputs.len() {
-                    errors.push(TestError::MismatchedTestExpectationLength);
-                }
-            }
-            let mut expected_output = expectations.as_ref().map(|x| x.outputs.iter());
-            for (i, test) in tests.into_iter().enumerate() {
-                let expected_output = expected_output
-                    .as_mut()
-                    .map(|x| x.next())
-                    .flatten()
-                    .map(|x| serde_yaml::from_value(x.clone()).expect("invalid test expectation form"));
+struct ParseStatementNamespace;
 
-                let output = run_individual_statement_test(path, &test);
-                if let Some(error) = emit_errors(
-                    output.as_ref().map_err(|x| &**x),
-                    &config.expectation,
-                    expected_output,
-                    i,
-                ) {
-                    errors.push(error);
-                } else {
-                    outputs.push(
-                        output
-                            .map(|x| serde_yaml::to_value(x).expect("serialization failed"))
-                            .unwrap_or_else(|e| serde_yaml::to_value(e).expect("serialization failed")),
-                    );
-                }
-            }
-        }
-        TestNamespace::ParseExpression => {
-            let tests = split_tests_oneline(source);
-            if let Some(expectations) = expectations.as_ref() {
-                if tests.len() != expectations.outputs.len() {
-                    errors.push(TestError::MismatchedTestExpectationLength);
-                }
-            }
-            let mut expected_output = expectations.as_ref().map(|x| x.outputs.iter());
-            for (i, test) in tests.into_iter().enumerate() {
-                let expected_output = expected_output
-                    .as_mut()
-                    .map(|x| x.next())
-                    .flatten()
-                    .map(|x| serde_yaml::from_value(x.clone()).expect("invalid test expectation form"));
-
-                let output = run_individual_expression_test(path, test);
-                if let Some(error) = emit_errors(
-                    output.as_ref().map_err(|x| &**x),
-                    &config.expectation,
-                    expected_output,
-                    i,
-                ) {
-                    errors.push(error);
-                } else {
-                    outputs.push(
-                        output
-                            .map(|x| serde_yaml::to_value(x).expect("serialization failed"))
-                            .unwrap_or_else(|e| serde_yaml::to_value(e).expect("serialization failed")),
-                    );
-                }
-            }
-        }
+impl Namespace for ParseStatementNamespace {
+    fn parse_type(&self) -> ParseType {
+        ParseType::ContinuousLines
+    }
+
+    fn run_test(&self, test: &str) -> Result<Value, String> {
+        let tokenizer = tokenizer::tokenize("test", test.into()).map_err(|x| x.to_string())?;
+        if tokenizer
+            .iter()
+            .all(|x| matches!(x.token, Token::CommentLine(_) | Token::CommentBlock(_)))
+        {
+            return Ok(serde_yaml::to_value(&Statement::Expression(ExpressionStatement {
+                expression: Expression::Value(ValueExpression::Implicit("".into(), Span::default())),
+                span: Span::default(),
+            }))
+            .expect("serialization failed"));
+        }
+        let mut tokens = ParserContext::new(tokenizer);
+
+        let parsed = tokens.parse_statement().map_err(|x| x.to_string())?;
+        not_fully_consumed(&mut tokens)?;
+
+        Ok(serde_yaml::to_value(&parsed).expect("serialization failed"))
+    }
+}
+
+struct ParseNamespace;
+
+impl Namespace for ParseNamespace {
+    fn parse_type(&self) -> ParseType {
+        ParseType::Whole
+    }
+
+    fn run_test(&self, test: &str) -> Result<Value, String> {
+        let tokenizer = tokenizer::tokenize("test", test.into()).map_err(|x| x.to_string())?;
+        let mut tokens = ParserContext::new(tokenizer);
+
+        let parsed = tokens.parse_program().map_err(|x| x.to_string())?;
+        not_fully_consumed(&mut tokens)?;
+
+        Ok(serde_yaml::to_value(&parsed).expect("serialization failed"))
+    }
+}
+
+struct TestRunner;
+
+impl Runner for TestRunner {
+    fn resolve_namespace(&self, name: &str) -> Option<Box<dyn Namespace>> {
+        Some(match name {
+            "Parse" => Box::new(ParseNamespace),
+            "ParseStatement" => Box::new(ParseStatementNamespace),
+            "ParseExpression" => Box::new(ParseExpressionNamespace),
+            "Token" => Box::new(TokenNamespace),
+            _ => return None,
+        })
     }
-    outputs
 }
 
 #[test]
 pub fn parser_tests() {
-    let mut pass = 0;
-    let mut fail = Vec::new();
-    let mut tests = Vec::new();
-    let mut test_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-    test_dir.push("../tests/parser/");
-    find_tests(&test_dir, &mut tests);
-    let mut outputs = vec![];
-    for (path, content) in tests.into_iter() {
-        let config = extract_test_config(&content);
-        if config.is_none() {
-            panic!("missing configuration for {}", path);
-        }
-        let config = config.unwrap();
-        let mut expectation_path = path.clone();
-        expectation_path += ".out";
-        let expectations: Option<TestExpectation> = if std::path::Path::new(&expectation_path).exists() {
-            if !std::env::var("CLEAR_LEO_TEST_EXPECTATIONS")
-                .unwrap_or_default()
-                .trim()
-                .is_empty()
-            {
-                None
-            } else {
-                let raw = std::fs::read_to_string(&expectation_path).expect("failed to read expectations file");
-                Some(serde_yaml::from_str(&raw).expect("invalid yaml in expectations file"))
-            }
-        } else {
-            None
-        };
-        let mut errors = vec![];
-        let raw_path = Path::new(&path);
-        let new_outputs = run_test(
-            &config,
-            raw_path.file_name().unwrap_or_default().to_str().unwrap_or_default(),
-            &content,
-            expectations.as_ref(),
-            &mut errors,
-        );
-        if errors.is_empty() {
-            if expectations.is_none() {
-                outputs.push((expectation_path, TestExpectation {
-                    namespace: config.namespace,
-                    expectation: config.expectation,
-                    outputs: new_outputs,
-                }));
-            }
-            pass += 1;
-        } else {
-            fail.push(TestFailure {
-                path: path.clone(),
-                errors,
-            })
-        }
-    }
-    if !fail.is_empty() {
-        for (i, fail) in fail.iter().enumerate() {
-            println!(
-                "\n\n-----------------TEST #{} FAILED (and shouldn't have)-----------------",
-                i + 1
-            );
-            println!("File: {}", fail.path);
-            for error in &fail.errors {
-                println!("{}", error);
-            }
-        }
-        panic!("failed {}/{} tests", fail.len(), fail.len() + pass);
-    } else {
-        for (path, new_expectation) in outputs {
-            std::fs::write(
-                &path,
-                serde_yaml::to_string(&new_expectation).expect("failed to serialize expectation yaml"),
-            )
-            .expect("failed to write expectation file");
-        }
-        println!("passed {}/{} tests", pass, pass);
-    }
-}
-
-#[test]
-pub fn parser_pass_tests() {
-    let mut pass = 0;
-    let mut fail = Vec::new();
-    let mut tests = Vec::new();
-    let mut test_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-    test_dir.push("../tests/old/pass/");
-    find_tests(&test_dir, &mut tests);
-    for (path, content) in tests.into_iter() {
-        match crate::parse(&path, &content) {
-            Ok(_) => {
-                pass += 1;
-            }
-            Err(e) => {
-                fail.push(TestFailure {
-                    path,
-                    errors: vec![TestError::FailedAndShouldntHave {
-                        index: 0,
-                        error: e.to_string(),
-                    }],
-                });
-            }
-        }
-    }
-    if !fail.is_empty() {
-        for (i, fail) in fail.iter().enumerate() {
-            println!(
-                "\n\n-----------------TEST #{} FAILED (and shouldn't have)-----------------",
-                i + 1
-            );
-            println!("File: {}", fail.path);
-            for error in &fail.errors {
-                println!("{}", error);
-            }
-        }
-        panic!("failed {}/{} tests", fail.len(), fail.len() + pass);
-    } else {
-        println!("passed {}/{} tests", pass, pass);
-    }
-}
-
-#[test]
-pub fn parser_fail_tests() {
-    let mut pass = 0;
-    let mut fail = Vec::new();
-    let mut tests = Vec::new();
-    let mut test_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
-    test_dir.push("../tests/old/fail/");
-    find_tests(&test_dir, &mut tests);
-    for (path, content) in tests.into_iter() {
-        match crate::parse(&path, &content) {
-            Ok(_) => {
-                fail.push(path);
-            }
-            Err(_e) => {
-                pass += 1;
-            }
-        }
-    }
-    if !fail.is_empty() {
-        for (i, fail) in fail.iter().enumerate() {
-            println!(
-                "\n\n-----------------TEST #{} PASSED (and shouldn't have)-----------------",
-                i + 1
-            );
-            println!("File: {}", fail);
-        }
-        panic!("failed {}/{} tests", fail.len(), fail.len() + pass);
-    } else {
-        println!("passed {}/{} tests", pass, pass);
-    }
+    leo_test_framework::run_tests(&TestRunner, "parser");
 }

test-framework/Cargo.toml

@@ -0,0 +1,28 @@
+[package]
+name = "leo-test-framework"
+version = "1.4.0"
+authors = [ "The Aleo Team <hello@aleo.org>" ]
+description = "Leo testing framework"
+homepage = "https://aleo.org"
+repository = "https://github.com/AleoHQ/leo"
+keywords = [
+  "aleo",
+  "cryptography",
+  "leo",
+  "programming-language",
+  "zero-knowledge"
+]
+categories = [ "cryptography::cryptocurrencies", "web-programming" ]
+include = [ "Cargo.toml", "src", "README.md", "LICENSE.md" ]
+license = "GPL-3.0"
+edition = "2018"
+
+[dependencies.serde]
+version = "1.0"
+features = [ "derive" ]
+
+[dependencies.serde_json]
+version = "1.0"
+
+[dependencies.serde_yaml]
+version = "0.8"

test-framework/src/error.rs

@@ -0,0 +1,124 @@
+// 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 std::fmt;
+
+use serde_yaml::Value;
+
+use crate::test::TestExpectationMode;
+
+pub struct TestFailure {
+    pub path: String,
+    pub errors: Vec<TestError>,
+}
+
+#[derive(Debug)]
+pub enum TestError {
+    UnexpectedOutput {
+        index: usize,
+        expected: Value,
+        output: Value,
+    },
+    PassedAndShouldntHave {
+        index: usize,
+    },
+    FailedAndShouldntHave {
+        index: usize,
+        error: String,
+    },
+    UnexpectedError {
+        index: usize,
+        expected: String,
+        output: String,
+    },
+    MismatchedTestExpectationLength,
+}
+
+impl fmt::Display for TestError {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        match self {
+            TestError::UnexpectedOutput {
+                index,
+                expected,
+                output,
+            } => {
+                write!(
+                    f,
+                    "test #{} expected\n{}\ngot\n{}",
+                    index + 1,
+                    serde_yaml::to_string(&expected).expect("serialization failed"),
+                    serde_yaml::to_string(&output).expect("serialization failed")
+                )
+            }
+            TestError::PassedAndShouldntHave { index } => write!(f, "test #{} passed and shouldn't have", index + 1),
+            TestError::FailedAndShouldntHave { index, error } => {
+                write!(f, "test #{} failed and shouldn't have:\n{}", index + 1, error)
+            }
+            TestError::UnexpectedError {
+                expected,
+                output,
+                index,
+            } => {
+                write!(f, "test #{} expected error\n{}\ngot\n{}", index + 1, expected, output)
+            }
+            TestError::MismatchedTestExpectationLength => write!(f, "invalid number of test expectations"),
+        }
+    }
+}
+
+pub fn emit_errors(
+    output: Result<&Value, &str>,
+    mode: &TestExpectationMode,
+    expected_output: Option<Value>,
+    test_index: usize,
+) -> Option<TestError> {
+    match (output, mode) {
+        (Ok(output), TestExpectationMode::Pass) => {
+            // passed and should have
+            if let Some(expected_output) = expected_output.as_ref() {
+                if output != expected_output {
+                    // invalid output
+                    return Some(TestError::UnexpectedOutput {
+                        index: test_index,
+                        expected: expected_output.clone(),
+                        output: output.clone(),
+                    });
+                }
+            }
+            None
+        }
+        (Ok(_tokens), TestExpectationMode::Fail) => Some(TestError::PassedAndShouldntHave { index: test_index }),
+        (Err(err), TestExpectationMode::Pass) => Some(TestError::FailedAndShouldntHave {
+            error: err.to_string(),
+            index: test_index,
+        }),
+        (Err(err), TestExpectationMode::Fail) => {
+            let expected_output: Option<String> =
+                expected_output.map(|x| serde_yaml::from_value(x).expect("test expectation deserialize failed"));
+            if let Some(expected_output) = expected_output.as_deref() {
+                if err != expected_output {
+                    // invalid output
+                    return Some(TestError::UnexpectedError {
+                        expected: expected_output.to_string(),
+                        output: err.to_string(),
+                        index: test_index,
+                    });
+                }
+            }
+            None
+        }
+    }
+}

test-framework/src/fetch.rs

@@ -0,0 +1,56 @@
+// 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 std::{fs, path::Path};
+
+pub fn find_tests<T: AsRef<Path>>(path: T, out: &mut Vec<(String, String)>) {
+    for entry in fs::read_dir(path).expect("fail to read tests").into_iter() {
+        let entry = entry.expect("fail to read tests").path();
+        if entry.is_dir() {
+            find_tests(entry.as_path(), out);
+            continue;
+        } else if entry.extension().map(|x| x.to_str()).flatten().unwrap_or_default() != "leo" {
+            continue;
+        }
+        let content = fs::read_to_string(entry.as_path()).expect("failed to read test");
+        out.push((entry.as_path().to_str().unwrap_or_default().to_string(), content));
+    }
+}
+
+pub fn split_tests_oneline(source: &str) -> Vec<&str> {
+    source.lines().map(|x| x.trim()).filter(|x| !x.is_empty()).collect()
+}
+
+pub fn split_tests_twoline(source: &str) -> Vec<String> {
+    let mut out = vec![];
+    let mut lines = vec![];
+    for line in source.lines() {
+        let line = line.trim();
+        if line.is_empty() {
+            if !lines.is_empty() {
+                out.push(lines.join("\n"));
+            }
+            lines.clear();
+            continue;
+        }
+        lines.push(line);
+    }
+    let last_test = lines.join("\n");
+    if !last_test.trim().is_empty() {
+        out.push(last_test.trim().to_string());
+    }
+    out
+}

test-framework/src/lib.rs

@@ -0,0 +1,35 @@
+// 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/>.
+
+//! The test framework to run integration tests with Leo code text.
+//!
+//! This module contains the [`run_tests()`] method which runs all integration tests in the
+//! root [`tests/`] directory.
+//!
+//! To regenerate the tests after a syntax change or failing test, delete the [`tests/expectations/`]
+//! directory and run the [`parser_tests()`] test in [`parser/src/test.rs`].
+
+pub mod error;
+
+pub mod fetch;
+
+pub mod output;
+
+pub mod runner;
+
+pub mod test;
+
+pub use runner::*;

test-framework/src/output.rs

@@ -0,0 +1,25 @@
+// 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::test::TestExpectationMode;
+use serde_yaml::Value;
+
+#[derive(serde::Serialize, serde::Deserialize, Clone)]
+pub struct TestExpectation {
+    pub namespace: String,
+    pub expectation: TestExpectationMode,
+    pub outputs: Vec<Value>,
+}

test-framework/src/runner.rs

@@ -0,0 +1,196 @@
+// 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 serde_yaml::Value;
+use std::path::{Path, PathBuf};
+
+use crate::{error::*, fetch::find_tests, output::TestExpectation, test::*};
+
+#[derive(Debug, PartialEq, Clone, Copy)]
+pub enum ParseType {
+    Line,
+    ContinuousLines,
+    Whole,
+}
+
+pub trait Namespace {
+    fn parse_type(&self) -> ParseType;
+
+    fn run_test(&self, test: &str) -> Result<Value, String>;
+}
+
+pub trait Runner {
+    fn resolve_namespace(&self, name: &str) -> Option<Box<dyn Namespace>>;
+}
+
+pub fn run_tests<T: Runner>(runner: &T, expectation_category: &str) {
+    let mut pass_categories = 0;
+    let mut pass_tests = 0;
+    let mut fail_tests = 0;
+    let mut fail_categories = Vec::new();
+
+    let mut tests = Vec::new();
+    let mut test_dir = PathBuf::from(env!("CARGO_MANIFEST_DIR"));
+    test_dir.push("../tests/");
+
+    let mut expectation_dir = test_dir.clone();
+    expectation_dir.push("expectations");
+
+    find_tests(&test_dir, &mut tests);
+    let mut outputs = vec![];
+
+    for (path, content) in tests.into_iter() {
+        let config = extract_test_config(&content);
+        if config.is_none() {
+            panic!("missing configuration for {}", path);
+        }
+        let config = config.unwrap();
+        let namespace = runner.resolve_namespace(&config.namespace);
+        if namespace.is_none() {
+            continue;
+        }
+        let namespace = namespace.unwrap();
+
+        let path = Path::new(&path);
+        let relative_path = path.strip_prefix(&test_dir).expect("path error for test");
+        let mut expectation_path = expectation_dir.clone();
+        expectation_path.push(expectation_category);
+        expectation_path.push(relative_path.parent().expect("no parent dir for test"));
+        let mut test_name = relative_path
+            .file_name()
+            .expect("no file name for test")
+            .to_str()
+            .unwrap()
+            .to_string();
+        test_name += ".out";
+        expectation_path.push(&test_name);
+
+        let expectations: Option<TestExpectation> = if expectation_path.exists() {
+            if !std::env::var("CLEAR_LEO_TEST_EXPECTATIONS")
+                .unwrap_or_default()
+                .trim()
+                .is_empty()
+            {
+                None
+            } else {
+                let raw = std::fs::read_to_string(&expectation_path).expect("failed to read expectations file");
+                Some(serde_yaml::from_str(&raw).expect("invalid yaml in expectations file"))
+            }
+        } else {
+            None
+        };
+
+        let end_of_header = content.find("*/").expect("failed to find header block in test");
+        let content = &content[end_of_header + 2..];
+
+        let tests = match namespace.parse_type() {
+            ParseType::Line => crate::fetch::split_tests_oneline(content)
+                .into_iter()
+                .map(|x| x.to_string())
+                .collect(),
+            ParseType::ContinuousLines => crate::fetch::split_tests_twoline(content),
+            ParseType::Whole => vec![content.to_string()],
+        };
+
+        let mut errors = vec![];
+        if let Some(expectations) = expectations.as_ref() {
+            if tests.len() != expectations.outputs.len() {
+                errors.push(TestError::MismatchedTestExpectationLength);
+            }
+        }
+
+        let mut new_outputs = vec![];
+
+        let mut expected_output = expectations.as_ref().map(|x| x.outputs.iter());
+        for (i, test) in tests.into_iter().enumerate() {
+            let expected_output = expected_output
+                .as_mut()
+                .map(|x| x.next())
+                .flatten()
+                .map(|x| x.as_str())
+                .flatten();
+            let output = namespace.run_test(&test);
+            if let Some(error) = emit_errors(
+                output.as_ref().map_err(|x| &**x),
+                &config.expectation,
+                expected_output.map(|x| Value::String(x.to_string())),
+                i,
+            ) {
+                fail_tests += 1;
+                errors.push(error);
+            } else {
+                pass_tests += 1;
+                new_outputs.push(
+                    output
+                        .as_ref()
+                        .map(|x| serde_yaml::to_value(x).expect("serialization failed"))
+                        .unwrap_or_else(|e| Value::String(e.clone())),
+                );
+            }
+        }
+
+        if errors.is_empty() {
+            if expectations.is_none() {
+                outputs.push((expectation_path, TestExpectation {
+                    namespace: config.namespace,
+                    expectation: config.expectation,
+                    outputs: new_outputs,
+                }));
+            }
+            pass_categories += 1;
+        } else {
+            fail_categories.push(TestFailure {
+                path: path.to_str().unwrap().to_string(),
+                errors,
+            })
+        }
+    }
+    if !fail_categories.is_empty() {
+        for (i, fail) in fail_categories.iter().enumerate() {
+            println!(
+                "\n\n-----------------TEST #{} FAILED (and shouldn't have)-----------------",
+                i + 1
+            );
+            println!("File: {}", fail.path);
+            for error in &fail.errors {
+                println!("{}", error);
+            }
+        }
+        panic!(
+            "failed {}/{} tests in {}/{} categories",
+            pass_tests,
+            fail_tests + pass_tests,
+            fail_categories.len(),
+            fail_categories.len() + pass_categories
+        );
+    } else {
+        for (path, new_expectation) in outputs {
+            std::fs::create_dir_all(path.parent().unwrap()).expect("failed to make test expectation parent directory");
+            std::fs::write(
+                &path,
+                serde_yaml::to_string(&new_expectation).expect("failed to serialize expectation yaml"),
+            )
+            .expect("failed to write expectation file");
+        }
+        println!(
+            "passed {}/{} tests in {}/{} categories",
+            pass_tests,
+            fail_tests + pass_tests,
+            pass_categories,
+            pass_categories
+        );
+    }
+}

test-framework/src/test.rs

@@ -0,0 +1,34 @@
+// 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/>.
+
+#[derive(serde::Serialize, serde::Deserialize, PartialEq, Debug, Clone)]
+pub enum TestExpectationMode {
+    Pass,
+    Fail,
+}
+
+#[derive(serde::Serialize, serde::Deserialize)]
+pub struct TestConfig {
+    pub namespace: String,
+    pub expectation: TestExpectationMode,
+}
+
+pub fn extract_test_config(source: &str) -> Option<TestConfig> {
+    let first_comment_start = source.find("/*")?;
+    let end_first_comment = source[first_comment_start + 2..].find("*/")?;
+    let comment_inner = &source[first_comment_start + 2..first_comment_start + 2 + end_first_comment];
+    Some(serde_yaml::from_str(comment_inner).expect("invalid test configuration"))
+}

tests/expectations/parser/parser/circuits/big_self.leo.out

@@ -6,12 +6,12 @@ outputs:
     expected_input: []
     imports: []
     circuits:
-      "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"big_self.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
-        circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"big_self.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
+      "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
+        circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
         members:
           - CircuitFunction:
               annotations: []
-              identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"big_self.leo\\\",\\\"content\\\":\\\"    function x() -> Self {\\\"}\"}"
+              identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"    function x() -> Self {\\\"}\"}"
               input: []
               output: SelfType
               block:
@@ -19,34 +19,34 @@ outputs:
                   - Return:
                       expression:
                         CircuitInit:
-                          name: "{\"name\":\"Self\",\"span\":\"{\\\"line_start\\\":5,\\\"line_stop\\\":5,\\\"col_start\\\":16,\\\"col_stop\\\":20,\\\"path\\\":\\\"big_self.leo\\\",\\\"content\\\":\\\"        return Self {};\\\"}\"}"
+                          name: "{\"name\":\"Self\",\"span\":\"{\\\"line_start\\\":5,\\\"line_stop\\\":5,\\\"col_start\\\":16,\\\"col_stop\\\":20,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"        return Self {};\\\"}\"}"
                           members: []
                           span:
                             line_start: 5
                             line_stop: 5
                             col_start: 16
                             col_stop: 23
-                            path: big_self.leo
+                            path: test
                             content: "        return Self {};"
                       span:
                         line_start: 5
                         line_stop: 5
                         col_start: 9
                         col_stop: 23
-                        path: big_self.leo
+                        path: test
                         content: "        return Self {};"
                 span:
                   line_start: 4
                   line_stop: 6
                   col_start: 26
                   col_stop: 6
-                  path: big_self.leo
+                  path: test
                   content: "    function x() -> Self {\n...\n    }"
               span:
                 line_start: 4
                 line_stop: 6
                 col_start: 5
                 col_stop: 6
-                path: big_self.leo
+                path: test
                 content: "    function x() -> Self {\n...\n    }"
     functions: {}

tests/expectations/parser/parser/circuits/empty.leo.out

@@ -6,7 +6,7 @@ outputs:
     expected_input: []
     imports: []
     circuits:
-      "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"empty.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
-        circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"empty.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
+      "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
+        circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
         members: []
     functions: {}

tests/expectations/parser/parser/circuits/field_and_functions.leo.out

@@ -6,18 +6,18 @@ outputs:
     expected_input: []
     imports: []
     circuits:
-      "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"field_and_functions.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
-        circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"field_and_functions.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
+      "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
+        circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
         members:
           - CircuitVariable:
-              - "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"field_and_functions.leo\\\",\\\"content\\\":\\\"    x: u32,\\\"}\"}"
+              - "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"    x: u32,\\\"}\"}"
               - IntegerType: U32
           - CircuitVariable:
-              - "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":5,\\\"line_stop\\\":5,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"field_and_functions.leo\\\",\\\"content\\\":\\\"    y: u32,\\\"}\"}"
+              - "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":5,\\\"line_stop\\\":5,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"    y: u32,\\\"}\"}"
               - IntegerType: U32
           - CircuitFunction:
               annotations: []
-              identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":6,\\\"line_stop\\\":6,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"field_and_functions.leo\\\",\\\"content\\\":\\\"    function x() {\\\"}\"}"
+              identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":6,\\\"line_stop\\\":6,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"    function x() {\\\"}\"}"
               input: []
               output: ~
               block:
@@ -31,32 +31,32 @@ outputs:
                             line_stop: 7
                             col_start: 16
                             col_stop: 18
-                            path: field_and_functions.leo
+                            path: test
                             content: "        return ();"
                       span:
                         line_start: 7
                         line_stop: 7
                         col_start: 9
                         col_stop: 18
-                        path: field_and_functions.leo
+                        path: test
                         content: "        return ();"
                 span:
                   line_start: 6
                   line_stop: 8
                   col_start: 18
                   col_stop: 6
-                  path: field_and_functions.leo
+                  path: test
                   content: "    function x() {\n...\n    }"
               span:
                 line_start: 6
                 line_stop: 8
                 col_start: 5
                 col_stop: 6
-                path: field_and_functions.leo
+                path: test
                 content: "    function x() {\n...\n    }"
           - CircuitFunction:
               annotations: []
-              identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":9,\\\"line_stop\\\":9,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"field_and_functions.leo\\\",\\\"content\\\":\\\"    function y() {\\\"}\"}"
+              identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":9,\\\"line_stop\\\":9,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"    function y() {\\\"}\"}"
               input: []
               output: ~
               block:
@@ -70,27 +70,27 @@ outputs:
                             line_stop: 10
                             col_start: 16
                             col_stop: 18
-                            path: field_and_functions.leo
+                            path: test
                             content: "        return ();"
                       span:
                         line_start: 10
                         line_stop: 10
                         col_start: 9
                         col_stop: 18
-                        path: field_and_functions.leo
+                        path: test
                         content: "        return ();"
                 span:
                   line_start: 9
                   line_stop: 11
                   col_start: 18
                   col_stop: 6
-                  path: field_and_functions.leo
+                  path: test
                   content: "    function y() {\n...\n    }"
               span:
                 line_start: 9
                 line_stop: 11
                 col_start: 5
                 col_stop: 6
-                path: field_and_functions.leo
+                path: test
                 content: "    function y() {\n...\n    }"
     functions: {}

tests/expectations/parser/parser/circuits/fields.leo.out

@@ -6,13 +6,13 @@ outputs:
     expected_input: []
     imports: []
     circuits:
-      "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"fields.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
-        circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"fields.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
+      "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
+        circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
         members:
           - CircuitVariable:
-              - "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"fields.leo\\\",\\\"content\\\":\\\"    x: u32,\\\"}\"}"
+              - "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"    x: u32,\\\"}\"}"
               - IntegerType: U32
           - CircuitVariable:
-              - "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":5,\\\"line_stop\\\":5,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"fields.leo\\\",\\\"content\\\":\\\"    y: u32,\\\"}\"}"
+              - "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":5,\\\"line_stop\\\":5,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"    y: u32,\\\"}\"}"
               - IntegerType: U32
     functions: {}

tests/expectations/parser/parser/circuits/functions.leo.out

@@ -6,12 +6,12 @@ outputs:
     expected_input: []
     imports: []
     circuits:
-      "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"functions.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
-        circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"functions.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
+      "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
+        circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
         members:
           - CircuitFunction:
               annotations: []
-              identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"functions.leo\\\",\\\"content\\\":\\\"    function x() {\\\"}\"}"
+              identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"    function x() {\\\"}\"}"
               input: []
               output: ~
               block:
@@ -25,32 +25,32 @@ outputs:
                             line_stop: 5
                             col_start: 16
                             col_stop: 18
-                            path: functions.leo
+                            path: test
                             content: "        return ();"
                       span:
                         line_start: 5
                         line_stop: 5
                         col_start: 9
                         col_stop: 18
-                        path: functions.leo
+                        path: test
                         content: "        return ();"
                 span:
                   line_start: 4
                   line_stop: 6
                   col_start: 18
                   col_stop: 6
-                  path: functions.leo
+                  path: test
                   content: "    function x() {\n...\n    }"
               span:
                 line_start: 4
                 line_stop: 6
                 col_start: 5
                 col_stop: 6
-                path: functions.leo
+                path: test
                 content: "    function x() {\n...\n    }"
           - CircuitFunction:
               annotations: []
-              identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":7,\\\"line_stop\\\":7,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"functions.leo\\\",\\\"content\\\":\\\"    function y() {\\\"}\"}"
+              identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":7,\\\"line_stop\\\":7,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"    function y() {\\\"}\"}"
               input: []
               output: ~
               block:
@@ -64,27 +64,27 @@ outputs:
                             line_stop: 8
                             col_start: 16
                             col_stop: 18
-                            path: functions.leo
+                            path: test
                             content: "        return ();"
                       span:
                         line_start: 8
                         line_stop: 8
                         col_start: 9
                         col_stop: 18
-                        path: functions.leo
+                        path: test
                         content: "        return ();"
                 span:
                   line_start: 7
                   line_stop: 9
                   col_start: 18
                   col_stop: 6
-                  path: functions.leo
+                  path: test
                   content: "    function y() {\n...\n    }"
               span:
                 line_start: 7
                 line_stop: 9
                 col_start: 5
                 col_stop: 6
-                path: functions.leo
+                path: test
                 content: "    function y() {\n...\n    }"
     functions: {}

tests/expectations/parser/parser/circuits/mut_self.leo.out

@@ -6,14 +6,14 @@ outputs:
     expected_input: []
     imports: []
     circuits:
-      "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"mut_self.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
-        circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"mut_self.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
+      "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
+        circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
         members:
           - CircuitFunction:
               annotations: []
-              identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"mut_self.leo\\\",\\\"content\\\":\\\"    function x(mut self) {\\\"}\"}"
+              identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"    function x(mut self) {\\\"}\"}"
               input:
-                - MutSelfKeyword: "{\"name\":\"mut self\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":16,\\\"col_stop\\\":24,\\\"path\\\":\\\"mut_self.leo\\\",\\\"content\\\":\\\"    function x(mut self) {\\\"}\"}"
+                - MutSelfKeyword: "{\"name\":\"mut self\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":16,\\\"col_stop\\\":24,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"    function x(mut self) {\\\"}\"}"
               output: ~
               block:
                 statements:
@@ -26,27 +26,27 @@ outputs:
                             line_stop: 5
                             col_start: 16
                             col_stop: 18
-                            path: mut_self.leo
+                            path: test
                             content: "        return ();"
                       span:
                         line_start: 5
                         line_stop: 5
                         col_start: 9
                         col_stop: 18
-                        path: mut_self.leo
+                        path: test
                         content: "        return ();"
                 span:
                   line_start: 4
                   line_stop: 6
                   col_start: 26
                   col_stop: 6
-                  path: mut_self.leo
+                  path: test
                   content: "    function x(mut self) {\n...\n    }"
               span:
                 line_start: 4
                 line_stop: 6
                 col_start: 5
                 col_stop: 6
-                path: mut_self.leo
+                path: test
                 content: "    function x(mut self) {\n...\n    }"
     functions: {}

tests/expectations/parser/parser/circuits/self.leo.out

@@ -6,14 +6,14 @@ outputs:
     expected_input: []
     imports: []
     circuits:
-      "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"self.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
-        circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"self.leo\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
+      "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}":
+        circuit_name: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"circuit X {\\\"}\"}"
         members:
           - CircuitFunction:
               annotations: []
-              identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"self.leo\\\",\\\"content\\\":\\\"    function x(self) {\\\"}\"}"
+              identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"    function x(self) {\\\"}\"}"
               input:
-                - SelfKeyword: "{\"name\":\"self\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":16,\\\"col_stop\\\":20,\\\"path\\\":\\\"self.leo\\\",\\\"content\\\":\\\"    function x(self) {\\\"}\"}"
+                - SelfKeyword: "{\"name\":\"self\",\"span\":\"{\\\"line_start\\\":4,\\\"line_stop\\\":4,\\\"col_start\\\":16,\\\"col_stop\\\":20,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"    function x(self) {\\\"}\"}"
               output: ~
               block:
                 statements:
@@ -26,27 +26,27 @@ outputs:
                             line_stop: 5
                             col_start: 16
                             col_stop: 18
-                            path: self.leo
+                            path: test
                             content: "        return ();"
                       span:
                         line_start: 5
                         line_stop: 5
                         col_start: 9
                         col_stop: 18
-                        path: self.leo
+                        path: test
                         content: "        return ();"
                 span:
                   line_start: 4
                   line_stop: 6
                   col_start: 22
                   col_stop: 6
-                  path: self.leo
+                  path: test
                   content: "    function x(self) {\n...\n    }"
               span:
                 line_start: 4
                 line_stop: 6
                 col_start: 5
                 col_stop: 6
-                path: self.leo
+                path: test
                 content: "    function x(self) {\n...\n    }"
     functions: {}

tests/expectations/parser/parser/expression/access/array_access.leo.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - ArrayAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[0]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0]\\\"}\"}"
       index:
         Value:
           Implicit:
@@ -13,18 +13,18 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 4
-              path: array_access.leo
+              path: test
               content: "x[0]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 5
-        path: array_access.leo
+        path: test
         content: "x[0]"
   - ArrayAccess:
       array:
-        Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"X[1]\\\"}\"}"
+        Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"X[1]\\\"}\"}"
       index:
         Value:
           Implicit:
@@ -33,18 +33,18 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 4
-              path: array_access.leo
+              path: test
               content: "X[1]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 5
-        path: array_access.leo
+        path: test
         content: "X[1]"
   - ArrayAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[0u8]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0u8]\\\"}\"}"
       index:
         Value:
           Integer:
@@ -54,20 +54,20 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 6
-              path: array_access.leo
+              path: test
               content: "x[0u8]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: array_access.leo
+        path: test
         content: "x[0u8]"
   - ArrayAccess:
       array:
         ArrayAccess:
           array:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[1u8][2u8]\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[1u8][2u8]\\\"}\"}"
           index:
             Value:
               Integer:
@@ -77,14 +77,14 @@ outputs:
                   line_stop: 1
                   col_start: 3
                   col_stop: 6
-                  path: array_access.leo
+                  path: test
                   content: "x[1u8][2u8]"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 7
-            path: array_access.leo
+            path: test
             content: "x[1u8][2u8]"
       index:
         Value:
@@ -95,14 +95,14 @@ outputs:
               line_stop: 1
               col_start: 8
               col_stop: 11
-              path: array_access.leo
+              path: test
               content: "x[1u8][2u8]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 12
-        path: array_access.leo
+        path: test
         content: "x[1u8][2u8]"
   - ArrayAccess:
       array:
@@ -110,39 +110,39 @@ outputs:
           array:
             ArrayAccess:
               array:
-                Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
+                Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
               index:
-                Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
+                Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
               span:
                 line_start: 1
                 line_stop: 1
                 col_start: 1
                 col_stop: 5
-                path: array_access.leo
+                path: test
                 content: "x[x][y][z]"
           index:
-            Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
+            Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 8
-            path: array_access.leo
+            path: test
             content: "x[x][y][z]"
       index:
-        Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
+        Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x][y][z]\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 11
-        path: array_access.leo
+        path: test
         content: "x[x][y][z]"
   - Call:
       function:
         ArrayAccess:
           array:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[0]()\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0]()\\\"}\"}"
           index:
             Value:
               Implicit:
@@ -151,14 +151,14 @@ outputs:
                   line_stop: 1
                   col_start: 3
                   col_stop: 4
-                  path: array_access.leo
+                  path: test
                   content: "x[0]()"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 5
-            path: array_access.leo
+            path: test
             content: "x[0]()"
       arguments: []
       span:
@@ -166,20 +166,20 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: array_access.leo
+        path: test
         content: "x[0]()"
   - ArrayAccess:
       array:
         Call:
           function:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x()[0]\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x()[0]\\\"}\"}"
           arguments: []
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 4
-            path: array_access.leo
+            path: test
             content: "x()[0]"
       index:
         Value:
@@ -189,14 +189,14 @@ outputs:
               line_stop: 1
               col_start: 5
               col_stop: 6
-              path: array_access.leo
+              path: test
               content: "x()[0]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: array_access.leo
+        path: test
         content: "x()[0]"
   - Call:
       function:
@@ -204,32 +204,32 @@ outputs:
           circuit:
             Call:
               function:
-                Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
+                Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
               arguments:
-                - Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
+                - Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
               span:
                 line_start: 1
                 line_stop: 1
                 col_start: 1
                 col_stop: 5
-                path: array_access.leo
+                path: test
                 content: "x(y)::y(x)"
-          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
+          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 8
-            path: array_access.leo
+            path: test
             content: "x(y)::y(x)"
       arguments:
-        - Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
+        - Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y)::y(x)\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 11
-        path: array_access.leo
+        path: test
         content: "x(y)::y(x)"
   - ArrayAccess:
       array:
@@ -237,15 +237,15 @@ outputs:
           tuple:
             ArrayAccess:
               array:
-                Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[x].0[x]\\\"}\"}"
+                Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x].0[x]\\\"}\"}"
               index:
-                Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[x].0[x]\\\"}\"}"
+                Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x].0[x]\\\"}\"}"
               span:
                 line_start: 1
                 line_stop: 1
                 col_start: 1
                 col_stop: 5
-                path: array_access.leo
+                path: test
                 content: "x[x].0[x]"
           index:
             value: "0"
@@ -254,14 +254,14 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 7
-            path: array_access.leo
+            path: test
             content: "x[x].0[x]"
       index:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":8,\\\"col_stop\\\":9,\\\"path\\\":\\\"array_access.leo\\\",\\\"content\\\":\\\"x[x].0[x]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":8,\\\"col_stop\\\":9,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x].0[x]\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: array_access.leo
+        path: test
         content: "x[x].0[x]"

tests/expectations/parser/parser/expression/access/array_range_access.leo.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - ArrayRangeAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[..]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[..]\\\"}\"}"
       left: ~
       right: ~
       span:
@@ -12,11 +12,11 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: array_range_access.leo
+        path: test
         content: "x[..]"
   - ArrayRangeAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[1..]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[1..]\\\"}\"}"
       left:
         Value:
           Implicit:
@@ -25,7 +25,7 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 4
-              path: array_range_access.leo
+              path: test
               content: "x[1..]"
       right: ~
       span:
@@ -33,11 +33,11 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: array_range_access.leo
+        path: test
         content: "x[1..]"
   - ArrayRangeAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[..1]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[..1]\\\"}\"}"
       left: ~
       right:
         Value:
@@ -47,18 +47,18 @@ outputs:
               line_stop: 1
               col_start: 5
               col_stop: 6
-              path: array_range_access.leo
+              path: test
               content: "x[..1]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: array_range_access.leo
+        path: test
         content: "x[..1]"
   - ArrayRangeAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[1..1]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[1..1]\\\"}\"}"
       left:
         Value:
           Implicit:
@@ -67,7 +67,7 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 4
-              path: array_range_access.leo
+              path: test
               content: "x[1..1]"
       right:
         Value:
@@ -77,18 +77,18 @@ outputs:
               line_stop: 1
               col_start: 6
               col_stop: 7
-              path: array_range_access.leo
+              path: test
               content: "x[1..1]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 8
-        path: array_range_access.leo
+        path: test
         content: "x[1..1]"
   - ArrayRangeAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[0..100]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0..100]\\\"}\"}"
       left:
         Value:
           Implicit:
@@ -97,7 +97,7 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 4
-              path: array_range_access.leo
+              path: test
               content: "x[0..100]"
       right:
         Value:
@@ -107,20 +107,20 @@ outputs:
               line_stop: 1
               col_start: 6
               col_stop: 9
-              path: array_range_access.leo
+              path: test
               content: "x[0..100]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: array_range_access.leo
+        path: test
         content: "x[0..100]"
   - ArrayAccess:
       array:
         ArrayAccess:
           array:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[323452345.2345234523453453][323452345.2345234523453453]\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[323452345.2345234523453453][323452345.2345234523453453]\\\"}\"}"
           index:
             TupleAccess:
               tuple:
@@ -131,7 +131,7 @@ outputs:
                       line_stop: 1
                       col_start: 3
                       col_stop: 12
-                      path: array_range_access.leo
+                      path: test
                       content: "x[323452345.2345234523453453][323452345.2345234523453453]"
               index:
                 value: "2345234523453453"
@@ -140,14 +140,14 @@ outputs:
                 line_stop: 1
                 col_start: 3
                 col_stop: 29
-                path: array_range_access.leo
+                path: test
                 content: "x[323452345.2345234523453453][323452345.2345234523453453]"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 30
-            path: array_range_access.leo
+            path: test
             content: "x[323452345.2345234523453453][323452345.2345234523453453]"
       index:
         TupleAccess:
@@ -159,7 +159,7 @@ outputs:
                   line_stop: 1
                   col_start: 31
                   col_stop: 40
-                  path: array_range_access.leo
+                  path: test
                   content: "x[323452345.2345234523453453][323452345.2345234523453453]"
           index:
             value: "2345234523453453"
@@ -168,18 +168,18 @@ outputs:
             line_stop: 1
             col_start: 31
             col_stop: 57
-            path: array_range_access.leo
+            path: test
             content: "x[323452345.2345234523453453][323452345.2345234523453453]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 58
-        path: array_range_access.leo
+        path: test
         content: "x[323452345.2345234523453453][323452345.2345234523453453]"
   - ArrayRangeAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[0u8..1u8]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0u8..1u8]\\\"}\"}"
       left:
         Value:
           Integer:
@@ -189,7 +189,7 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 6
-              path: array_range_access.leo
+              path: test
               content: "x[0u8..1u8]"
       right:
         Value:
@@ -200,18 +200,18 @@ outputs:
               line_stop: 1
               col_start: 8
               col_stop: 11
-              path: array_range_access.leo
+              path: test
               content: "x[0u8..1u8]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 12
-        path: array_range_access.leo
+        path: test
         content: "x[0u8..1u8]"
   - ArrayRangeAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[0u8..]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0u8..]\\\"}\"}"
       left:
         Value:
           Integer:
@@ -221,7 +221,7 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 6
-              path: array_range_access.leo
+              path: test
               content: "x[0u8..]"
       right: ~
       span:
@@ -229,11 +229,11 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 9
-        path: array_range_access.leo
+        path: test
         content: "x[0u8..]"
   - ArrayRangeAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[..0u8]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[..0u8]\\\"}\"}"
       left: ~
       right:
         Value:
@@ -244,18 +244,18 @@ outputs:
               line_stop: 1
               col_start: 5
               col_stop: 8
-              path: array_range_access.leo
+              path: test
               content: "x[..0u8]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 9
-        path: array_range_access.leo
+        path: test
         content: "x[..0u8]"
   - ArrayRangeAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[..]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[..]\\\"}\"}"
       left: ~
       right: ~
       span:
@@ -263,22 +263,22 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: array_range_access.leo
+        path: test
         content: "x[..]"
   - ArrayRangeAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..]\\\"}\"}"
       left:
         CircuitMemberAccess:
           circuit:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..]\\\"}\"}"
-          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..]\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..]\\\"}\"}"
+          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..]\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 3
             col_stop: 6
-            path: array_range_access.leo
+            path: test
             content: "x[x.y..]"
       right: ~
       span:
@@ -286,116 +286,116 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 9
-        path: array_range_access.leo
+        path: test
         content: "x[x.y..]"
   - ArrayRangeAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[..y.x]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[..y.x]\\\"}\"}"
       left: ~
       right:
         CircuitMemberAccess:
           circuit:
-            Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[..y.x]\\\"}\"}"
-          name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[..y.x]\\\"}\"}"
+            Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[..y.x]\\\"}\"}"
+          name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[..y.x]\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 5
             col_stop: 8
-            path: array_range_access.leo
+            path: test
             content: "x[..y.x]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 9
-        path: array_range_access.leo
+        path: test
         content: "x[..y.x]"
   - ArrayRangeAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
       left:
         CircuitMemberAccess:
           circuit:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
-          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
+          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 3
             col_stop: 6
-            path: array_range_access.leo
+            path: test
             content: "x[x.y..y.x]"
       right:
         CircuitMemberAccess:
           circuit:
-            Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":8,\\\"col_stop\\\":9,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
-          name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
+            Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":8,\\\"col_stop\\\":9,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
+          name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y..y.x]\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 8
             col_stop: 11
-            path: array_range_access.leo
+            path: test
             content: "x[x.y..y.x]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 12
-        path: array_range_access.leo
+        path: test
         content: "x[x.y..y.x]"
   - ArrayRangeAccess:
       array:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
       left:
         CircuitMemberAccess:
           circuit:
             CircuitMemberAccess:
               circuit:
-                Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
-              name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
+                Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
+              name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
               span:
                 line_start: 1
                 line_stop: 1
                 col_start: 3
                 col_stop: 6
-                path: array_range_access.leo
+                path: test
                 content: "x[x.y.x..y.x.y]"
-          name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
+          name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 3
             col_stop: 8
-            path: array_range_access.leo
+            path: test
             content: "x[x.y.x..y.x.y]"
       right:
         CircuitMemberAccess:
           circuit:
             CircuitMemberAccess:
               circuit:
-                Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
-              name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":12,\\\"col_stop\\\":13,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
+                Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
+              name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":12,\\\"col_stop\\\":13,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
               span:
                 line_start: 1
                 line_stop: 1
                 col_start: 10
                 col_stop: 13
-                path: array_range_access.leo
+                path: test
                 content: "x[x.y.x..y.x.y]"
-          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"array_range_access.leo\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
+          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":14,\\\"col_stop\\\":15,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[x.y.x..y.x.y]\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 10
             col_stop: 15
-            path: array_range_access.leo
+            path: test
             content: "x[x.y.x..y.x.y]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 16
-        path: array_range_access.leo
+        path: test
         content: "x[x.y.x..y.x.y]"

tests/expectations/parser/parser/expression/access/call.leo.out

@@ -4,77 +4,77 @@ expectation: Pass
 outputs:
   - Call:
       function:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x()\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x()\\\"}\"}"
       arguments: []
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: call.leo
+        path: test
         content: x()
   - Call:
       function:
-        Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"X()\\\"}\"}"
+        Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"X()\\\"}\"}"
       arguments: []
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: call.leo
+        path: test
         content: X()
   - Call:
       function:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(y)\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y)\\\"}\"}"
       arguments:
-        - Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(y)\\\"}\"}"
+        - Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y)\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 5
-        path: call.leo
+        path: test
         content: x(y)
   - Call:
       function:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(y, z)\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y, z)\\\"}\"}"
       arguments:
-        - Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(y, z)\\\"}\"}"
-        - Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(y, z)\\\"}\"}"
+        - Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y, z)\\\"}\"}"
+        - Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(y, z)\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 8
-        path: call.leo
+        path: test
         content: "x(y, z)"
   - Call:
       function:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
       arguments:
-        - Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
-        - Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
-        - Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
+        - Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
+        - Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
+        - Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":9,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x(x, y, z)\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 11
-        path: call.leo
+        path: test
         content: "x(x, y, z)"
   - Call:
       function:
         CircuitStaticFunctionAccess:
           circuit:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
-          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
+          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 5
-            path: call.leo
+            path: test
             content: "x::y()"
       arguments: []
       span:
@@ -82,35 +82,35 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: call.leo
+        path: test
         content: "x::y()"
   - Call:
       function:
         CircuitStaticFunctionAccess:
           circuit:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x::y(x)\\\"}\"}"
-          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x::y(x)\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y(x)\\\"}\"}"
+          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y(x)\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 5
-            path: call.leo
+            path: test
             content: "x::y(x)"
       arguments:
-        - Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x::y(x)\\\"}\"}"
+        - Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y(x)\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 8
-        path: call.leo
+        path: test
         content: "x::y(x)"
   - Call:
       function:
         TupleAccess:
           tuple:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x.0(x)\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.0(x)\\\"}\"}"
           index:
             value: "0"
           span:
@@ -118,22 +118,22 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 4
-            path: call.leo
+            path: test
             content: x.0(x)
       arguments:
-        - Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x.0(x)\\\"}\"}"
+        - Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.0(x)\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: call.leo
+        path: test
         content: x.0(x)
   - Call:
       function:
         ArrayAccess:
           array:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x[0](x)\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0](x)\\\"}\"}"
           index:
             Value:
               Implicit:
@@ -142,21 +142,21 @@ outputs:
                   line_stop: 1
                   col_start: 3
                   col_stop: 4
-                  path: call.leo
+                  path: test
                   content: "x[0](x)"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 5
-            path: call.leo
+            path: test
             content: "x[0](x)"
       arguments:
-        - Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"call.leo\\\",\\\"content\\\":\\\"x[0](x)\\\"}\"}"
+        - Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x[0](x)\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 8
-        path: call.leo
+        path: test
         content: "x[0](x)"

tests/expectations/parser/parser/expression/access/circuit.leo.out

@@ -4,59 +4,59 @@ expectation: Pass
 outputs:
   - CircuitMemberAccess:
       circuit:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y\\\"}\"}"
-      name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y\\\"}\"}"
+      name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: circuit.leo
+        path: test
         content: x.y
   - CircuitMemberAccess:
       circuit:
-        Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"X.Y\\\"}\"}"
-      name: "{\"name\":\"Y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"X.Y\\\"}\"}"
+        Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"X.Y\\\"}\"}"
+      name: "{\"name\":\"Y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"X.Y\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: circuit.leo
+        path: test
         content: X.Y
   - CircuitMemberAccess:
       circuit:
         CircuitMemberAccess:
           circuit:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y.z\\\"}\"}"
-          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y.z\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y.z\\\"}\"}"
+          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y.z\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 4
-            path: circuit.leo
+            path: test
             content: x.y.z
-      name: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y.z\\\"}\"}"
+      name: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y.z\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: circuit.leo
+        path: test
         content: x.y.z
   - Call:
       function:
         CircuitMemberAccess:
           circuit:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y()\\\"}\"}"
-          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y()\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y()\\\"}\"}"
+          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y()\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 4
-            path: circuit.leo
+            path: test
             content: x.y()
       arguments: []
       span:
@@ -64,20 +64,20 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: circuit.leo
+        path: test
         content: x.y()
   - TupleAccess:
       tuple:
         CircuitMemberAccess:
           circuit:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y.0\\\"}\"}"
-          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y.0\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y.0\\\"}\"}"
+          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y.0\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 4
-            path: circuit.leo
+            path: test
             content: x.y.0
       index:
         value: "0"
@@ -86,20 +86,20 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: circuit.leo
+        path: test
         content: x.y.0
   - ArrayAccess:
       array:
         CircuitMemberAccess:
           circuit:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y[1]\\\"}\"}"
-          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit.leo\\\",\\\"content\\\":\\\"x.y[1]\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y[1]\\\"}\"}"
+          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.y[1]\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 4
-            path: circuit.leo
+            path: test
             content: "x.y[1]"
       index:
         Value:
@@ -109,12 +109,12 @@ outputs:
               line_stop: 1
               col_start: 5
               col_stop: 6
-              path: circuit.leo
+              path: test
               content: "x.y[1]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: circuit.leo
+        path: test
         content: "x.y[1]"

tests/expectations/parser/parser/expression/access/circuit_static.leo.out

@@ -4,59 +4,59 @@ expectation: Pass
 outputs:
   - CircuitStaticFunctionAccess:
       circuit:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y\\\"}\"}"
-      name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y\\\"}\"}"
+      name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 5
-        path: circuit_static.leo
+        path: test
         content: "x::y"
   - CircuitStaticFunctionAccess:
       circuit:
-        Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"X::Y\\\"}\"}"
-      name: "{\"name\":\"Y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"X::Y\\\"}\"}"
+        Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"X::Y\\\"}\"}"
+      name: "{\"name\":\"Y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"X::Y\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 5
-        path: circuit_static.leo
+        path: test
         content: "X::Y"
   - CircuitStaticFunctionAccess:
       circuit:
         CircuitStaticFunctionAccess:
           circuit:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y::z\\\"}\"}"
-          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y::z\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y::z\\\"}\"}"
+          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y::z\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 5
-            path: circuit_static.leo
+            path: test
             content: "x::y::z"
-      name: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y::z\\\"}\"}"
+      name: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":7,\\\"col_stop\\\":8,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y::z\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 8
-        path: circuit_static.leo
+        path: test
         content: "x::y::z"
   - Call:
       function:
         CircuitStaticFunctionAccess:
           circuit:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
-          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
+          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y()\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 5
-            path: circuit_static.leo
+            path: test
             content: "x::y()"
       arguments: []
       span:
@@ -64,20 +64,20 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: circuit_static.leo
+        path: test
         content: "x::y()"
   - TupleAccess:
       tuple:
         CircuitStaticFunctionAccess:
           circuit:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y.0\\\"}\"}"
-          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y.0\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y.0\\\"}\"}"
+          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y.0\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 5
-            path: circuit_static.leo
+            path: test
             content: "x::y.0"
       index:
         value: "0"
@@ -86,20 +86,20 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: circuit_static.leo
+        path: test
         content: "x::y.0"
   - ArrayAccess:
       array:
         CircuitStaticFunctionAccess:
           circuit:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y[1]\\\"}\"}"
-          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_static.leo\\\",\\\"content\\\":\\\"x::y[1]\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y[1]\\\"}\"}"
+          name: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x::y[1]\\\"}\"}"
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 5
-            path: circuit_static.leo
+            path: test
             content: "x::y[1]"
       index:
         Value:
@@ -109,12 +109,12 @@ outputs:
               line_stop: 1
               col_start: 6
               col_stop: 7
-              path: circuit_static.leo
+              path: test
               content: "x::y[1]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 8
-        path: circuit_static.leo
+        path: test
         content: "x::y[1]"

tests/expectations/parser/parser/expression/access/tuple.leo.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - TupleAccess:
       tuple:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"tuple.leo\\\",\\\"content\\\":\\\"x.0\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.0\\\"}\"}"
       index:
         value: "0"
       span:
@@ -12,11 +12,11 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: tuple.leo
+        path: test
         content: x.0
   - TupleAccess:
       tuple:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"tuple.leo\\\",\\\"content\\\":\\\"x.1\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.1\\\"}\"}"
       index:
         value: "1"
       span:
@@ -24,11 +24,11 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: tuple.leo
+        path: test
         content: x.1
   - TupleAccess:
       tuple:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"tuple.leo\\\",\\\"content\\\":\\\"x.2\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.2\\\"}\"}"
       index:
         value: "2"
       span:
@@ -36,13 +36,13 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: tuple.leo
+        path: test
         content: x.2
   - TupleAccess:
       tuple:
         TupleAccess:
           tuple:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"tuple.leo\\\",\\\"content\\\":\\\"x.0.0\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.0.0\\\"}\"}"
           index:
             value: "0"
           span:
@@ -50,7 +50,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 4
-            path: tuple.leo
+            path: test
             content: x.0.0
       index:
         value: "0"
@@ -59,13 +59,13 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: tuple.leo
+        path: test
         content: x.0.0
   - TupleAccess:
       tuple:
         TupleAccess:
           tuple:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"tuple.leo\\\",\\\"content\\\":\\\"x.1.1\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.1.1\\\"}\"}"
           index:
             value: "1"
           span:
@@ -73,7 +73,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 4
-            path: tuple.leo
+            path: test
             content: x.1.1
       index:
         value: "1"
@@ -82,13 +82,13 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: tuple.leo
+        path: test
         content: x.1.1
   - TupleAccess:
       tuple:
         TupleAccess:
           tuple:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"tuple.leo\\\",\\\"content\\\":\\\"x.2.2\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x.2.2\\\"}\"}"
           index:
             value: "2"
           span:
@@ -96,7 +96,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 4
-            path: tuple.leo
+            path: test
             content: x.2.2
       index:
         value: "2"
@@ -105,5 +105,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: tuple.leo
+        path: test
         content: x.2.2

tests/expectations/parser/parser/expression/array_init.leo.out

@@ -12,7 +12,7 @@ outputs:
               line_stop: 1
               col_start: 2
               col_stop: 5
-              path: array_init.leo
+              path: test
               content: "[0u8; 1]"
       dimensions:
         - value: "1"
@@ -21,7 +21,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 9
-        path: array_init.leo
+        path: test
         content: "[0u8; 1]"
   - ArrayInit:
       element:
@@ -32,7 +32,7 @@ outputs:
               line_stop: 1
               col_start: 2
               col_stop: 3
-              path: array_init.leo
+              path: test
               content: "[0; 1]"
       dimensions:
         - value: "1"
@@ -41,7 +41,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: array_init.leo
+        path: test
         content: "[0; 1]"
   - ArrayInit:
       element:
@@ -52,7 +52,7 @@ outputs:
               line_stop: 1
               col_start: 2
               col_stop: 3
-              path: array_init.leo
+              path: test
               content: "[0; (1)]"
       dimensions:
         - value: "1"
@@ -61,7 +61,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 9
-        path: array_init.leo
+        path: test
         content: "[0; (1)]"
   - ArrayInit:
       element:
@@ -72,7 +72,7 @@ outputs:
               line_stop: 1
               col_start: 2
               col_stop: 3
-              path: array_init.leo
+              path: test
               content: "[0; (1, 2)]"
       dimensions:
         - value: "1"
@@ -82,7 +82,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 12
-        path: array_init.leo
+        path: test
         content: "[0; (1, 2)]"
   - ArrayInit:
       element:
@@ -93,7 +93,7 @@ outputs:
               line_stop: 1
               col_start: 2
               col_stop: 3
-              path: array_init.leo
+              path: test
               content: "[0; (1, 2, 3)]"
       dimensions:
         - value: "1"
@@ -104,7 +104,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 15
-        path: array_init.leo
+        path: test
         content: "[0; (1, 2, 3)]"
   - ArrayInit:
       element:
@@ -119,7 +119,7 @@ outputs:
                       line_stop: 1
                       col_start: 4
                       col_stop: 5
-                      path: array_init.leo
+                      path: test
                       content: "[[[0; 3]; 2]; 1]"
               dimensions:
                 - value: "3"
@@ -128,7 +128,7 @@ outputs:
                 line_stop: 1
                 col_start: 3
                 col_stop: 9
-                path: array_init.leo
+                path: test
                 content: "[[[0; 3]; 2]; 1]"
           dimensions:
             - value: "2"
@@ -137,7 +137,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 13
-            path: array_init.leo
+            path: test
             content: "[[[0; 3]; 2]; 1]"
       dimensions:
         - value: "1"
@@ -146,5 +146,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 17
-        path: array_init.leo
+        path: test
         content: "[[[0; 3]; 2]; 1]"

tests/expectations/parser/parser/expression/array_inline.leo.out

@@ -13,7 +13,7 @@ outputs:
                   line_stop: 1
                   col_start: 2
                   col_stop: 5
-                  path: array_inline.leo
+                  path: test
                   content: "[0u8, 1, 2, 3]"
         - Expression:
             Value:
@@ -23,7 +23,7 @@ outputs:
                   line_stop: 1
                   col_start: 7
                   col_stop: 8
-                  path: array_inline.leo
+                  path: test
                   content: "[0u8, 1, 2, 3]"
         - Expression:
             Value:
@@ -33,7 +33,7 @@ outputs:
                   line_stop: 1
                   col_start: 10
                   col_stop: 11
-                  path: array_inline.leo
+                  path: test
                   content: "[0u8, 1, 2, 3]"
         - Expression:
             Value:
@@ -43,14 +43,14 @@ outputs:
                   line_stop: 1
                   col_start: 13
                   col_stop: 14
-                  path: array_inline.leo
+                  path: test
                   content: "[0u8, 1, 2, 3]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 15
-        path: array_inline.leo
+        path: test
         content: "[0u8, 1, 2, 3]"
   - ArrayInline:
       elements:
@@ -62,14 +62,14 @@ outputs:
                   line_stop: 1
                   col_start: 2
                   col_stop: 3
-                  path: array_inline.leo
+                  path: test
                   content: "[1]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: array_inline.leo
+        path: test
         content: "[1]"
   - ArrayInline:
       elements:
@@ -82,14 +82,14 @@ outputs:
                   line_stop: 1
                   col_start: 2
                   col_stop: 5
-                  path: array_inline.leo
+                  path: test
                   content: "[1u8]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: array_inline.leo
+        path: test
         content: "[1u8]"
   - ArrayInline:
       elements:
@@ -102,14 +102,14 @@ outputs:
                   line_stop: 1
                   col_start: 2
                   col_stop: 5
-                  path: array_inline.leo
+                  path: test
                   content: "[1u8,]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: array_inline.leo
+        path: test
         content: "[1u8,]"
   - ArrayInline:
       elements:
@@ -121,7 +121,7 @@ outputs:
                   line_stop: 1
                   col_start: 2
                   col_stop: 3
-                  path: array_inline.leo
+                  path: test
                   content: "[0, 1,]"
         - Expression:
             Value:
@@ -131,14 +131,14 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: array_inline.leo
+                  path: test
                   content: "[0, 1,]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 8
-        path: array_inline.leo
+        path: test
         content: "[0, 1,]"
   - ArrayInline:
       elements:
@@ -150,7 +150,7 @@ outputs:
                   line_stop: 1
                   col_start: 2
                   col_stop: 3
-                  path: array_inline.leo
+                  path: test
                   content: "[0,1,]"
         - Expression:
             Value:
@@ -160,14 +160,14 @@ outputs:
                   line_stop: 1
                   col_start: 4
                   col_stop: 5
-                  path: array_inline.leo
+                  path: test
                   content: "[0,1,]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: array_inline.leo
+        path: test
         content: "[0,1,]"
   - ArrayInline:
       elements: []
@@ -176,7 +176,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 3
-        path: array_inline.leo
+        path: test
         content: "[]"
   - ArrayInline:
       elements:
@@ -191,7 +191,7 @@ outputs:
                           line_stop: 1
                           col_start: 3
                           col_stop: 4
-                          path: array_inline.leo
+                          path: test
                           content: "[[1,2,3],[1,2,3]]"
                 - Expression:
                     Value:
@@ -201,7 +201,7 @@ outputs:
                           line_stop: 1
                           col_start: 5
                           col_stop: 6
-                          path: array_inline.leo
+                          path: test
                           content: "[[1,2,3],[1,2,3]]"
                 - Expression:
                     Value:
@@ -211,14 +211,14 @@ outputs:
                           line_stop: 1
                           col_start: 7
                           col_stop: 8
-                          path: array_inline.leo
+                          path: test
                           content: "[[1,2,3],[1,2,3]]"
               span:
                 line_start: 1
                 line_stop: 1
                 col_start: 2
                 col_stop: 9
-                path: array_inline.leo
+                path: test
                 content: "[[1,2,3],[1,2,3]]"
         - Expression:
             ArrayInline:
@@ -231,7 +231,7 @@ outputs:
                           line_stop: 1
                           col_start: 11
                           col_stop: 12
-                          path: array_inline.leo
+                          path: test
                           content: "[[1,2,3],[1,2,3]]"
                 - Expression:
                     Value:
@@ -241,7 +241,7 @@ outputs:
                           line_stop: 1
                           col_start: 13
                           col_stop: 14
-                          path: array_inline.leo
+                          path: test
                           content: "[[1,2,3],[1,2,3]]"
                 - Expression:
                     Value:
@@ -251,21 +251,21 @@ outputs:
                           line_stop: 1
                           col_start: 15
                           col_stop: 16
-                          path: array_inline.leo
+                          path: test
                           content: "[[1,2,3],[1,2,3]]"
               span:
                 line_start: 1
                 line_stop: 1
                 col_start: 10
                 col_stop: 17
-                path: array_inline.leo
+                path: test
                 content: "[[1,2,3],[1,2,3]]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 18
-        path: array_inline.leo
+        path: test
         content: "[[1,2,3],[1,2,3]]"
   - ArrayInline:
       elements:
@@ -277,14 +277,14 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 4
-                path: array_inline.leo
+                path: test
                 content: "[[]]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 5
-        path: array_inline.leo
+        path: test
         content: "[[]]"
   - ArrayInline:
       elements:
@@ -296,7 +296,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 4
-                path: array_inline.leo
+                path: test
                 content: "[[], []]"
         - Expression:
             ArrayInline:
@@ -306,12 +306,12 @@ outputs:
                 line_stop: 1
                 col_start: 6
                 col_stop: 8
-                path: array_inline.leo
+                path: test
                 content: "[[], []]"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 9
-        path: array_inline.leo
+        path: test
         content: "[[], []]"

tests/expectations/parser/parser/expression/binary/add.leo.out

@@ -11,7 +11,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: add.leo
+              path: test
               content: 1 + 1
       right:
         Value:
@@ -21,7 +21,7 @@ outputs:
               line_stop: 1
               col_start: 5
               col_stop: 6
-              path: add.leo
+              path: test
               content: 1 + 1
       op: Add
       span:
@@ -29,7 +29,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: add.leo
+        path: test
         content: 1 + 1
   - Binary:
       left:
@@ -40,7 +40,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: add.leo
+              path: test
               content: 2+3
       right:
         Value:
@@ -50,7 +50,7 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 4
-              path: add.leo
+              path: test
               content: 2+3
       op: Add
       span:
@@ -58,7 +58,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: add.leo
+        path: test
         content: 2+3
   - Binary:
       left:
@@ -71,7 +71,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: add.leo
+                  path: test
                   content: 1 + 2 + 3
           right:
             Value:
@@ -81,7 +81,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: add.leo
+                  path: test
                   content: 1 + 2 + 3
           op: Add
           span:
@@ -89,7 +89,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: add.leo
+            path: test
             content: 1 + 2 + 3
       right:
         Value:
@@ -99,7 +99,7 @@ outputs:
               line_stop: 1
               col_start: 9
               col_stop: 10
-              path: add.leo
+              path: test
               content: 1 + 2 + 3
       op: Add
       span:
@@ -107,7 +107,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: add.leo
+        path: test
         content: 1 + 2 + 3
   - Binary:
       left:
@@ -120,7 +120,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: add.leo
+                  path: test
                   content: 1 * 2 + 3 * 4
           right:
             Value:
@@ -130,7 +130,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: add.leo
+                  path: test
                   content: 1 * 2 + 3 * 4
           op: Mul
           span:
@@ -138,7 +138,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: add.leo
+            path: test
             content: 1 * 2 + 3 * 4
       right:
         Binary:
@@ -150,7 +150,7 @@ outputs:
                   line_stop: 1
                   col_start: 9
                   col_stop: 10
-                  path: add.leo
+                  path: test
                   content: 1 * 2 + 3 * 4
           right:
             Value:
@@ -160,7 +160,7 @@ outputs:
                   line_stop: 1
                   col_start: 13
                   col_stop: 14
-                  path: add.leo
+                  path: test
                   content: 1 * 2 + 3 * 4
           op: Mul
           span:
@@ -168,7 +168,7 @@ outputs:
             line_stop: 1
             col_start: 9
             col_stop: 14
-            path: add.leo
+            path: test
             content: 1 * 2 + 3 * 4
       op: Add
       span:
@@ -176,7 +176,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 14
-        path: add.leo
+        path: test
         content: 1 * 2 + 3 * 4
   - Binary:
       left:
@@ -189,7 +189,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: add.leo
+                  path: test
                   content: 1 + 2 - 3
           right:
             Value:
@@ -199,7 +199,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: add.leo
+                  path: test
                   content: 1 + 2 - 3
           op: Add
           span:
@@ -207,7 +207,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: add.leo
+            path: test
             content: 1 + 2 - 3
       right:
         Value:
@@ -217,7 +217,7 @@ outputs:
               line_stop: 1
               col_start: 9
               col_stop: 10
-              path: add.leo
+              path: test
               content: 1 + 2 - 3
       op: Sub
       span:
@@ -225,7 +225,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: add.leo
+        path: test
         content: 1 + 2 - 3
   - Binary:
       left:
@@ -240,7 +240,7 @@ outputs:
                       line_stop: 1
                       col_start: 1
                       col_stop: 2
-                      path: add.leo
+                      path: test
                       content: 1 * 2 + 3 * 4 - 5 * 6
               right:
                 Value:
@@ -250,7 +250,7 @@ outputs:
                       line_stop: 1
                       col_start: 5
                       col_stop: 6
-                      path: add.leo
+                      path: test
                       content: 1 * 2 + 3 * 4 - 5 * 6
               op: Mul
               span:
@@ -258,7 +258,7 @@ outputs:
                 line_stop: 1
                 col_start: 1
                 col_stop: 6
-                path: add.leo
+                path: test
                 content: 1 * 2 + 3 * 4 - 5 * 6
           right:
             Binary:
@@ -270,7 +270,7 @@ outputs:
                       line_stop: 1
                       col_start: 9
                       col_stop: 10
-                      path: add.leo
+                      path: test
                       content: 1 * 2 + 3 * 4 - 5 * 6
               right:
                 Value:
@@ -280,7 +280,7 @@ outputs:
                       line_stop: 1
                       col_start: 13
                       col_stop: 14
-                      path: add.leo
+                      path: test
                       content: 1 * 2 + 3 * 4 - 5 * 6
               op: Mul
               span:
@@ -288,7 +288,7 @@ outputs:
                 line_stop: 1
                 col_start: 9
                 col_stop: 14
-                path: add.leo
+                path: test
                 content: 1 * 2 + 3 * 4 - 5 * 6
           op: Add
           span:
@@ -296,7 +296,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 14
-            path: add.leo
+            path: test
             content: 1 * 2 + 3 * 4 - 5 * 6
       right:
         Binary:
@@ -308,7 +308,7 @@ outputs:
                   line_stop: 1
                   col_start: 17
                   col_stop: 18
-                  path: add.leo
+                  path: test
                   content: 1 * 2 + 3 * 4 - 5 * 6
           right:
             Value:
@@ -318,7 +318,7 @@ outputs:
                   line_stop: 1
                   col_start: 21
                   col_stop: 22
-                  path: add.leo
+                  path: test
                   content: 1 * 2 + 3 * 4 - 5 * 6
           op: Mul
           span:
@@ -326,7 +326,7 @@ outputs:
             line_stop: 1
             col_start: 17
             col_stop: 22
-            path: add.leo
+            path: test
             content: 1 * 2 + 3 * 4 - 5 * 6
       op: Sub
       span:
@@ -334,5 +334,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 22
-        path: add.leo
+        path: test
         content: 1 * 2 + 3 * 4 - 5 * 6

tests/expectations/parser/parser/expression/binary/and.leo.out

@@ -11,7 +11,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 5
-              path: and.leo
+              path: test
               content: true && false
       right:
         Value:
@@ -21,7 +21,7 @@ outputs:
               line_stop: 1
               col_start: 9
               col_stop: 14
-              path: and.leo
+              path: test
               content: true && false
       op: And
       span:
@@ -29,7 +29,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 14
-        path: and.leo
+        path: test
         content: true && false
   - Binary:
       left:
@@ -40,7 +40,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 6
-              path: and.leo
+              path: test
               content: false&&true
       right:
         Value:
@@ -50,7 +50,7 @@ outputs:
               line_stop: 1
               col_start: 8
               col_stop: 12
-              path: and.leo
+              path: test
               content: false&&true
       op: And
       span:
@@ -58,7 +58,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 12
-        path: and.leo
+        path: test
         content: false&&true
   - Binary:
       left:
@@ -71,7 +71,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 5
-                  path: and.leo
+                  path: test
                   content: true&&false&&true
           right:
             Value:
@@ -81,7 +81,7 @@ outputs:
                   line_stop: 1
                   col_start: 7
                   col_stop: 12
-                  path: and.leo
+                  path: test
                   content: true&&false&&true
           op: And
           span:
@@ -89,7 +89,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 12
-            path: and.leo
+            path: test
             content: true&&false&&true
       right:
         Value:
@@ -99,7 +99,7 @@ outputs:
               line_stop: 1
               col_start: 14
               col_stop: 18
-              path: and.leo
+              path: test
               content: true&&false&&true
       op: And
       span:
@@ -107,5 +107,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 18
-        path: and.leo
+        path: test
         content: true&&false&&true

tests/expectations/parser/parser/expression/binary/div.leo.out

@@ -11,7 +11,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: div.leo
+              path: test
               content: 1 / 1
       right:
         Value:
@@ -21,7 +21,7 @@ outputs:
               line_stop: 1
               col_start: 5
               col_stop: 6
-              path: div.leo
+              path: test
               content: 1 / 1
       op: Div
       span:
@@ -29,7 +29,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: div.leo
+        path: test
         content: 1 / 1
   - Binary:
       left:
@@ -40,7 +40,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: div.leo
+              path: test
               content: 2/3
       right:
         Value:
@@ -50,7 +50,7 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 4
-              path: div.leo
+              path: test
               content: 2/3
       op: Div
       span:
@@ -58,7 +58,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: div.leo
+        path: test
         content: 2/3
   - Binary:
       left:
@@ -71,7 +71,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: div.leo
+                  path: test
                   content: 1 / 2 / 3
           right:
             Value:
@@ -81,7 +81,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: div.leo
+                  path: test
                   content: 1 / 2 / 3
           op: Div
           span:
@@ -89,7 +89,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: div.leo
+            path: test
             content: 1 / 2 / 3
       right:
         Value:
@@ -99,7 +99,7 @@ outputs:
               line_stop: 1
               col_start: 9
               col_stop: 10
-              path: div.leo
+              path: test
               content: 1 / 2 / 3
       op: Div
       span:
@@ -107,7 +107,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: div.leo
+        path: test
         content: 1 / 2 / 3
   - Binary:
       left:
@@ -120,7 +120,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: div.leo
+                  path: test
                   content: 1 ** 2 / 3 ** 4
           right:
             Value:
@@ -130,7 +130,7 @@ outputs:
                   line_stop: 1
                   col_start: 6
                   col_stop: 7
-                  path: div.leo
+                  path: test
                   content: 1 ** 2 / 3 ** 4
           op: Pow
           span:
@@ -138,7 +138,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 7
-            path: div.leo
+            path: test
             content: 1 ** 2 / 3 ** 4
       right:
         Binary:
@@ -150,7 +150,7 @@ outputs:
                   line_stop: 1
                   col_start: 10
                   col_stop: 11
-                  path: div.leo
+                  path: test
                   content: 1 ** 2 / 3 ** 4
           right:
             Value:
@@ -160,7 +160,7 @@ outputs:
                   line_stop: 1
                   col_start: 15
                   col_stop: 16
-                  path: div.leo
+                  path: test
                   content: 1 ** 2 / 3 ** 4
           op: Pow
           span:
@@ -168,7 +168,7 @@ outputs:
             line_stop: 1
             col_start: 10
             col_stop: 16
-            path: div.leo
+            path: test
             content: 1 ** 2 / 3 ** 4
       op: Div
       span:
@@ -176,5 +176,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 16
-        path: div.leo
+        path: test
         content: 1 ** 2 / 3 ** 4

tests/expectations/parser/parser/expression/binary/eq.leo.out

@@ -11,7 +11,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: eq.leo
+              path: test
               content: 1 == 1
       right:
         Value:
@@ -21,7 +21,7 @@ outputs:
               line_stop: 1
               col_start: 6
               col_stop: 7
-              path: eq.leo
+              path: test
               content: 1 == 1
       op: Eq
       span:
@@ -29,7 +29,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: eq.leo
+        path: test
         content: 1 == 1
   - Binary:
       left:
@@ -40,7 +40,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: eq.leo
+              path: test
               content: 2==3
       right:
         Value:
@@ -50,7 +50,7 @@ outputs:
               line_stop: 1
               col_start: 4
               col_stop: 5
-              path: eq.leo
+              path: test
               content: 2==3
       op: Eq
       span:
@@ -58,7 +58,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 5
-        path: eq.leo
+        path: test
         content: 2==3
   - Binary:
       left:
@@ -71,7 +71,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: eq.leo
+                  path: test
                   content: 1 == 2 == 3
           right:
             Value:
@@ -81,7 +81,7 @@ outputs:
                   line_stop: 1
                   col_start: 6
                   col_stop: 7
-                  path: eq.leo
+                  path: test
                   content: 1 == 2 == 3
           op: Eq
           span:
@@ -89,7 +89,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 7
-            path: eq.leo
+            path: test
             content: 1 == 2 == 3
       right:
         Value:
@@ -99,7 +99,7 @@ outputs:
               line_stop: 1
               col_start: 11
               col_stop: 12
-              path: eq.leo
+              path: test
               content: 1 == 2 == 3
       op: Eq
       span:
@@ -107,7 +107,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 12
-        path: eq.leo
+        path: test
         content: 1 == 2 == 3
   - Binary:
       left:
@@ -120,7 +120,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: eq.leo
+                  path: test
                   content: 1 < 2 == 3 < 4
           right:
             Value:
@@ -130,7 +130,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: eq.leo
+                  path: test
                   content: 1 < 2 == 3 < 4
           op: Lt
           span:
@@ -138,7 +138,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: eq.leo
+            path: test
             content: 1 < 2 == 3 < 4
       right:
         Binary:
@@ -150,7 +150,7 @@ outputs:
                   line_stop: 1
                   col_start: 10
                   col_stop: 11
-                  path: eq.leo
+                  path: test
                   content: 1 < 2 == 3 < 4
           right:
             Value:
@@ -160,7 +160,7 @@ outputs:
                   line_stop: 1
                   col_start: 14
                   col_stop: 15
-                  path: eq.leo
+                  path: test
                   content: 1 < 2 == 3 < 4
           op: Lt
           span:
@@ -168,7 +168,7 @@ outputs:
             line_stop: 1
             col_start: 10
             col_stop: 15
-            path: eq.leo
+            path: test
             content: 1 < 2 == 3 < 4
       op: Eq
       span:
@@ -176,7 +176,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 15
-        path: eq.leo
+        path: test
         content: 1 < 2 == 3 < 4
   - Binary:
       left:
@@ -189,7 +189,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: eq.leo
+                  path: test
                   content: 1 == 2 == 3
           right:
             Value:
@@ -199,7 +199,7 @@ outputs:
                   line_stop: 1
                   col_start: 6
                   col_stop: 7
-                  path: eq.leo
+                  path: test
                   content: 1 == 2 == 3
           op: Eq
           span:
@@ -207,7 +207,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 7
-            path: eq.leo
+            path: test
             content: 1 == 2 == 3
       right:
         Value:
@@ -217,7 +217,7 @@ outputs:
               line_stop: 1
               col_start: 11
               col_stop: 12
-              path: eq.leo
+              path: test
               content: 1 == 2 == 3
       op: Eq
       span:
@@ -225,7 +225,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 12
-        path: eq.leo
+        path: test
         content: 1 == 2 == 3
   - Binary:
       left:
@@ -240,7 +240,7 @@ outputs:
                       line_stop: 1
                       col_start: 1
                       col_stop: 2
-                      path: eq.leo
+                      path: test
                       content: 1 < 2 == 3 < 4 == 5 < 6
               right:
                 Value:
@@ -250,7 +250,7 @@ outputs:
                       line_stop: 1
                       col_start: 5
                       col_stop: 6
-                      path: eq.leo
+                      path: test
                       content: 1 < 2 == 3 < 4 == 5 < 6
               op: Lt
               span:
@@ -258,7 +258,7 @@ outputs:
                 line_stop: 1
                 col_start: 1
                 col_stop: 6
-                path: eq.leo
+                path: test
                 content: 1 < 2 == 3 < 4 == 5 < 6
           right:
             Binary:
@@ -270,7 +270,7 @@ outputs:
                       line_stop: 1
                       col_start: 10
                       col_stop: 11
-                      path: eq.leo
+                      path: test
                       content: 1 < 2 == 3 < 4 == 5 < 6
               right:
                 Value:
@@ -280,7 +280,7 @@ outputs:
                       line_stop: 1
                       col_start: 14
                       col_stop: 15
-                      path: eq.leo
+                      path: test
                       content: 1 < 2 == 3 < 4 == 5 < 6
               op: Lt
               span:
@@ -288,7 +288,7 @@ outputs:
                 line_stop: 1
                 col_start: 10
                 col_stop: 15
-                path: eq.leo
+                path: test
                 content: 1 < 2 == 3 < 4 == 5 < 6
           op: Eq
           span:
@@ -296,7 +296,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: eq.leo
+            path: test
             content: 1 < 2 == 3 < 4 == 5 < 6
       right:
         Binary:
@@ -308,7 +308,7 @@ outputs:
                   line_stop: 1
                   col_start: 19
                   col_stop: 20
-                  path: eq.leo
+                  path: test
                   content: 1 < 2 == 3 < 4 == 5 < 6
           right:
             Value:
@@ -318,7 +318,7 @@ outputs:
                   line_stop: 1
                   col_start: 23
                   col_stop: 24
-                  path: eq.leo
+                  path: test
                   content: 1 < 2 == 3 < 4 == 5 < 6
           op: Lt
           span:
@@ -326,7 +326,7 @@ outputs:
             line_stop: 1
             col_start: 19
             col_stop: 24
-            path: eq.leo
+            path: test
             content: 1 < 2 == 3 < 4 == 5 < 6
       op: Eq
       span:
@@ -334,5 +334,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 24
-        path: eq.leo
+        path: test
         content: 1 < 2 == 3 < 4 == 5 < 6

tests/expectations/parser/parser/expression/binary/exp.leo.out

@@ -11,7 +11,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: exp.leo
+              path: test
               content: 1 ** 1
       right:
         Value:
@@ -21,7 +21,7 @@ outputs:
               line_stop: 1
               col_start: 6
               col_stop: 7
-              path: exp.leo
+              path: test
               content: 1 ** 1
       op: Pow
       span:
@@ -29,7 +29,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: exp.leo
+        path: test
         content: 1 ** 1
   - Binary:
       left:
@@ -40,7 +40,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: exp.leo
+              path: test
               content: 2**3
       right:
         Value:
@@ -50,7 +50,7 @@ outputs:
               line_stop: 1
               col_start: 4
               col_stop: 5
-              path: exp.leo
+              path: test
               content: 2**3
       op: Pow
       span:
@@ -58,7 +58,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 5
-        path: exp.leo
+        path: test
         content: 2**3
   - Binary:
       left:
@@ -69,7 +69,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: exp.leo
+              path: test
               content: 1 ** 2 ** 3
       right:
         Binary:
@@ -81,7 +81,7 @@ outputs:
                   line_stop: 1
                   col_start: 6
                   col_stop: 7
-                  path: exp.leo
+                  path: test
                   content: 1 ** 2 ** 3
           right:
             Value:
@@ -91,7 +91,7 @@ outputs:
                   line_stop: 1
                   col_start: 11
                   col_stop: 12
-                  path: exp.leo
+                  path: test
                   content: 1 ** 2 ** 3
           op: Pow
           span:
@@ -99,7 +99,7 @@ outputs:
             line_stop: 1
             col_start: 6
             col_stop: 12
-            path: exp.leo
+            path: test
             content: 1 ** 2 ** 3
       op: Pow
       span:
@@ -107,7 +107,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 12
-        path: exp.leo
+        path: test
         content: 1 ** 2 ** 3
   - Binary:
       left:
@@ -120,7 +120,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: exp.leo
+                  path: test
                   content: 1 as i8 ** 3 as i8
           target_type:
             IntegerType: I8
@@ -129,7 +129,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 8
-            path: exp.leo
+            path: test
             content: 1 as i8 ** 3 as i8
       right:
         Cast:
@@ -141,7 +141,7 @@ outputs:
                   line_stop: 1
                   col_start: 12
                   col_stop: 13
-                  path: exp.leo
+                  path: test
                   content: 1 as i8 ** 3 as i8
           target_type:
             IntegerType: I8
@@ -150,7 +150,7 @@ outputs:
             line_stop: 1
             col_start: 12
             col_stop: 19
-            path: exp.leo
+            path: test
             content: 1 as i8 ** 3 as i8
       op: Pow
       span:
@@ -158,7 +158,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 19
-        path: exp.leo
+        path: test
         content: 1 as i8 ** 3 as i8
   - Binary:
       left:
@@ -171,7 +171,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: exp.leo
+                  path: test
                   content: 1 as i8 ** 3 as i8 ** 5 as i8
           target_type:
             IntegerType: I8
@@ -180,7 +180,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 8
-            path: exp.leo
+            path: test
             content: 1 as i8 ** 3 as i8 ** 5 as i8
       right:
         Binary:
@@ -194,7 +194,7 @@ outputs:
                       line_stop: 1
                       col_start: 12
                       col_stop: 13
-                      path: exp.leo
+                      path: test
                       content: 1 as i8 ** 3 as i8 ** 5 as i8
               target_type:
                 IntegerType: I8
@@ -203,7 +203,7 @@ outputs:
                 line_stop: 1
                 col_start: 12
                 col_stop: 19
-                path: exp.leo
+                path: test
                 content: 1 as i8 ** 3 as i8 ** 5 as i8
           right:
             Cast:
@@ -215,7 +215,7 @@ outputs:
                       line_stop: 1
                       col_start: 23
                       col_stop: 24
-                      path: exp.leo
+                      path: test
                       content: 1 as i8 ** 3 as i8 ** 5 as i8
               target_type:
                 IntegerType: I8
@@ -224,7 +224,7 @@ outputs:
                 line_stop: 1
                 col_start: 23
                 col_stop: 30
-                path: exp.leo
+                path: test
                 content: 1 as i8 ** 3 as i8 ** 5 as i8
           op: Pow
           span:
@@ -232,7 +232,7 @@ outputs:
             line_stop: 1
             col_start: 12
             col_stop: 30
-            path: exp.leo
+            path: test
             content: 1 as i8 ** 3 as i8 ** 5 as i8
       op: Pow
       span:
@@ -240,5 +240,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 30
-        path: exp.leo
+        path: test
         content: 1 as i8 ** 3 as i8 ** 5 as i8

tests/expectations/parser/parser/expression/binary/gt.leo.out

@@ -11,7 +11,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: gt.leo
+              path: test
               content: 1 > 1
       right:
         Value:
@@ -21,7 +21,7 @@ outputs:
               line_stop: 1
               col_start: 5
               col_stop: 6
-              path: gt.leo
+              path: test
               content: 1 > 1
       op: Gt
       span:
@@ -29,7 +29,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: gt.leo
+        path: test
         content: 1 > 1
   - Binary:
       left:
@@ -40,7 +40,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: gt.leo
+              path: test
               content: 2>3
       right:
         Value:
@@ -50,7 +50,7 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 4
-              path: gt.leo
+              path: test
               content: 2>3
       op: Gt
       span:
@@ -58,7 +58,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: gt.leo
+        path: test
         content: 2>3
   - Binary:
       left:
@@ -71,7 +71,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: gt.leo
+                  path: test
                   content: 1 > 2 > 3
           right:
             Value:
@@ -81,7 +81,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: gt.leo
+                  path: test
                   content: 1 > 2 > 3
           op: Gt
           span:
@@ -89,7 +89,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: gt.leo
+            path: test
             content: 1 > 2 > 3
       right:
         Value:
@@ -99,7 +99,7 @@ outputs:
               line_stop: 1
               col_start: 9
               col_stop: 10
-              path: gt.leo
+              path: test
               content: 1 > 2 > 3
       op: Gt
       span:
@@ -107,7 +107,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: gt.leo
+        path: test
         content: 1 > 2 > 3
   - Binary:
       left:
@@ -120,7 +120,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: gt.leo
+                  path: test
                   content: 1 + 2 > 3 + 4
           right:
             Value:
@@ -130,7 +130,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: gt.leo
+                  path: test
                   content: 1 + 2 > 3 + 4
           op: Add
           span:
@@ -138,7 +138,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: gt.leo
+            path: test
             content: 1 + 2 > 3 + 4
       right:
         Binary:
@@ -150,7 +150,7 @@ outputs:
                   line_stop: 1
                   col_start: 9
                   col_stop: 10
-                  path: gt.leo
+                  path: test
                   content: 1 + 2 > 3 + 4
           right:
             Value:
@@ -160,7 +160,7 @@ outputs:
                   line_stop: 1
                   col_start: 13
                   col_stop: 14
-                  path: gt.leo
+                  path: test
                   content: 1 + 2 > 3 + 4
           op: Add
           span:
@@ -168,7 +168,7 @@ outputs:
             line_stop: 1
             col_start: 9
             col_stop: 14
-            path: gt.leo
+            path: test
             content: 1 + 2 > 3 + 4
       op: Gt
       span:
@@ -176,7 +176,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 14
-        path: gt.leo
+        path: test
         content: 1 + 2 > 3 + 4
   - Binary:
       left:
@@ -189,7 +189,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: gt.leo
+                  path: test
                   content: 1 > 2 > 3
           right:
             Value:
@@ -199,7 +199,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: gt.leo
+                  path: test
                   content: 1 > 2 > 3
           op: Gt
           span:
@@ -207,7 +207,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: gt.leo
+            path: test
             content: 1 > 2 > 3
       right:
         Value:
@@ -217,7 +217,7 @@ outputs:
               line_stop: 1
               col_start: 9
               col_stop: 10
-              path: gt.leo
+              path: test
               content: 1 > 2 > 3
       op: Gt
       span:
@@ -225,7 +225,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: gt.leo
+        path: test
         content: 1 > 2 > 3
   - Binary:
       left:
@@ -240,7 +240,7 @@ outputs:
                       line_stop: 1
                       col_start: 1
                       col_stop: 2
-                      path: gt.leo
+                      path: test
                       content: 1 + 2 > 3 + 4 > 5 + 6
               right:
                 Value:
@@ -250,7 +250,7 @@ outputs:
                       line_stop: 1
                       col_start: 5
                       col_stop: 6
-                      path: gt.leo
+                      path: test
                       content: 1 + 2 > 3 + 4 > 5 + 6
               op: Add
               span:
@@ -258,7 +258,7 @@ outputs:
                 line_stop: 1
                 col_start: 1
                 col_stop: 6
-                path: gt.leo
+                path: test
                 content: 1 + 2 > 3 + 4 > 5 + 6
           right:
             Binary:
@@ -270,7 +270,7 @@ outputs:
                       line_stop: 1
                       col_start: 9
                       col_stop: 10
-                      path: gt.leo
+                      path: test
                       content: 1 + 2 > 3 + 4 > 5 + 6
               right:
                 Value:
@@ -280,7 +280,7 @@ outputs:
                       line_stop: 1
                       col_start: 13
                       col_stop: 14
-                      path: gt.leo
+                      path: test
                       content: 1 + 2 > 3 + 4 > 5 + 6
               op: Add
               span:
@@ -288,7 +288,7 @@ outputs:
                 line_stop: 1
                 col_start: 9
                 col_stop: 14
-                path: gt.leo
+                path: test
                 content: 1 + 2 > 3 + 4 > 5 + 6
           op: Gt
           span:
@@ -296,7 +296,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 14
-            path: gt.leo
+            path: test
             content: 1 + 2 > 3 + 4 > 5 + 6
       right:
         Binary:
@@ -308,7 +308,7 @@ outputs:
                   line_stop: 1
                   col_start: 17
                   col_stop: 18
-                  path: gt.leo
+                  path: test
                   content: 1 + 2 > 3 + 4 > 5 + 6
           right:
             Value:
@@ -318,7 +318,7 @@ outputs:
                   line_stop: 1
                   col_start: 21
                   col_stop: 22
-                  path: gt.leo
+                  path: test
                   content: 1 + 2 > 3 + 4 > 5 + 6
           op: Add
           span:
@@ -326,7 +326,7 @@ outputs:
             line_stop: 1
             col_start: 17
             col_stop: 22
-            path: gt.leo
+            path: test
             content: 1 + 2 > 3 + 4 > 5 + 6
       op: Gt
       span:
@@ -334,5 +334,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 22
-        path: gt.leo
+        path: test
         content: 1 + 2 > 3 + 4 > 5 + 6

tests/expectations/parser/parser/expression/binary/gte.leo.out

@@ -11,7 +11,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: gte.leo
+              path: test
               content: 1 >= 1
       right:
         Value:
@@ -21,7 +21,7 @@ outputs:
               line_stop: 1
               col_start: 6
               col_stop: 7
-              path: gte.leo
+              path: test
               content: 1 >= 1
       op: Ge
       span:
@@ -29,7 +29,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: gte.leo
+        path: test
         content: 1 >= 1
   - Binary:
       left:
@@ -40,7 +40,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: gte.leo
+              path: test
               content: 2 >= 3
       right:
         Value:
@@ -50,7 +50,7 @@ outputs:
               line_stop: 1
               col_start: 6
               col_stop: 7
-              path: gte.leo
+              path: test
               content: 2 >= 3
       op: Ge
       span:
@@ -58,7 +58,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: gte.leo
+        path: test
         content: 2 >= 3
   - Binary:
       left:
@@ -71,7 +71,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: gte.leo
+                  path: test
                   content: 1 >= 2 >= 3
           right:
             Value:
@@ -81,7 +81,7 @@ outputs:
                   line_stop: 1
                   col_start: 6
                   col_stop: 7
-                  path: gte.leo
+                  path: test
                   content: 1 >= 2 >= 3
           op: Ge
           span:
@@ -89,7 +89,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 7
-            path: gte.leo
+            path: test
             content: 1 >= 2 >= 3
       right:
         Value:
@@ -99,7 +99,7 @@ outputs:
               line_stop: 1
               col_start: 11
               col_stop: 12
-              path: gte.leo
+              path: test
               content: 1 >= 2 >= 3
       op: Ge
       span:
@@ -107,7 +107,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 12
-        path: gte.leo
+        path: test
         content: 1 >= 2 >= 3
   - Binary:
       left:
@@ -120,7 +120,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: gte.leo
+                  path: test
                   content: 1 + 2 >= 3 + 4
           right:
             Value:
@@ -130,7 +130,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: gte.leo
+                  path: test
                   content: 1 + 2 >= 3 + 4
           op: Add
           span:
@@ -138,7 +138,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: gte.leo
+            path: test
             content: 1 + 2 >= 3 + 4
       right:
         Binary:
@@ -150,7 +150,7 @@ outputs:
                   line_stop: 1
                   col_start: 10
                   col_stop: 11
-                  path: gte.leo
+                  path: test
                   content: 1 + 2 >= 3 + 4
           right:
             Value:
@@ -160,7 +160,7 @@ outputs:
                   line_stop: 1
                   col_start: 14
                   col_stop: 15
-                  path: gte.leo
+                  path: test
                   content: 1 + 2 >= 3 + 4
           op: Add
           span:
@@ -168,7 +168,7 @@ outputs:
             line_stop: 1
             col_start: 10
             col_stop: 15
-            path: gte.leo
+            path: test
             content: 1 + 2 >= 3 + 4
       op: Ge
       span:
@@ -176,7 +176,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 15
-        path: gte.leo
+        path: test
         content: 1 + 2 >= 3 + 4
   - Binary:
       left:
@@ -189,7 +189,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: gte.leo
+                  path: test
                   content: 1 >= 2 >= 3
           right:
             Value:
@@ -199,7 +199,7 @@ outputs:
                   line_stop: 1
                   col_start: 6
                   col_stop: 7
-                  path: gte.leo
+                  path: test
                   content: 1 >= 2 >= 3
           op: Ge
           span:
@@ -207,7 +207,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 7
-            path: gte.leo
+            path: test
             content: 1 >= 2 >= 3
       right:
         Value:
@@ -217,7 +217,7 @@ outputs:
               line_stop: 1
               col_start: 11
               col_stop: 12
-              path: gte.leo
+              path: test
               content: 1 >= 2 >= 3
       op: Ge
       span:
@@ -225,7 +225,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 12
-        path: gte.leo
+        path: test
         content: 1 >= 2 >= 3
   - Binary:
       left:
@@ -240,7 +240,7 @@ outputs:
                       line_stop: 1
                       col_start: 1
                       col_stop: 2
-                      path: gte.leo
+                      path: test
                       content: 1 + 2 >= 3 + 4 >= 5 + 6
               right:
                 Value:
@@ -250,7 +250,7 @@ outputs:
                       line_stop: 1
                       col_start: 5
                       col_stop: 6
-                      path: gte.leo
+                      path: test
                       content: 1 + 2 >= 3 + 4 >= 5 + 6
               op: Add
               span:
@@ -258,7 +258,7 @@ outputs:
                 line_stop: 1
                 col_start: 1
                 col_stop: 6
-                path: gte.leo
+                path: test
                 content: 1 + 2 >= 3 + 4 >= 5 + 6
           right:
             Binary:
@@ -270,7 +270,7 @@ outputs:
                       line_stop: 1
                       col_start: 10
                       col_stop: 11
-                      path: gte.leo
+                      path: test
                       content: 1 + 2 >= 3 + 4 >= 5 + 6
               right:
                 Value:
@@ -280,7 +280,7 @@ outputs:
                       line_stop: 1
                       col_start: 14
                       col_stop: 15
-                      path: gte.leo
+                      path: test
                       content: 1 + 2 >= 3 + 4 >= 5 + 6
               op: Add
               span:
@@ -288,7 +288,7 @@ outputs:
                 line_stop: 1
                 col_start: 10
                 col_stop: 15
-                path: gte.leo
+                path: test
                 content: 1 + 2 >= 3 + 4 >= 5 + 6
           op: Ge
           span:
@@ -296,7 +296,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: gte.leo
+            path: test
             content: 1 + 2 >= 3 + 4 >= 5 + 6
       right:
         Binary:
@@ -308,7 +308,7 @@ outputs:
                   line_stop: 1
                   col_start: 19
                   col_stop: 20
-                  path: gte.leo
+                  path: test
                   content: 1 + 2 >= 3 + 4 >= 5 + 6
           right:
             Value:
@@ -318,7 +318,7 @@ outputs:
                   line_stop: 1
                   col_start: 23
                   col_stop: 24
-                  path: gte.leo
+                  path: test
                   content: 1 + 2 >= 3 + 4 >= 5 + 6
           op: Add
           span:
@@ -326,7 +326,7 @@ outputs:
             line_stop: 1
             col_start: 19
             col_stop: 24
-            path: gte.leo
+            path: test
             content: 1 + 2 >= 3 + 4 >= 5 + 6
       op: Ge
       span:
@@ -334,5 +334,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 24
-        path: gte.leo
+        path: test
         content: 1 + 2 >= 3 + 4 >= 5 + 6

tests/expectations/parser/parser/expression/binary/lt.leo.out

@@ -11,7 +11,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: lt.leo
+              path: test
               content: 1 < 1
       right:
         Value:
@@ -21,7 +21,7 @@ outputs:
               line_stop: 1
               col_start: 5
               col_stop: 6
-              path: lt.leo
+              path: test
               content: 1 < 1
       op: Lt
       span:
@@ -29,7 +29,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: lt.leo
+        path: test
         content: 1 < 1
   - Binary:
       left:
@@ -40,7 +40,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: lt.leo
+              path: test
               content: 2<3
       right:
         Value:
@@ -50,7 +50,7 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 4
-              path: lt.leo
+              path: test
               content: 2<3
       op: Lt
       span:
@@ -58,7 +58,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: lt.leo
+        path: test
         content: 2<3
   - Binary:
       left:
@@ -71,7 +71,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: lt.leo
+                  path: test
                   content: 1 < 2 < 3
           right:
             Value:
@@ -81,7 +81,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: lt.leo
+                  path: test
                   content: 1 < 2 < 3
           op: Lt
           span:
@@ -89,7 +89,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: lt.leo
+            path: test
             content: 1 < 2 < 3
       right:
         Value:
@@ -99,7 +99,7 @@ outputs:
               line_stop: 1
               col_start: 9
               col_stop: 10
-              path: lt.leo
+              path: test
               content: 1 < 2 < 3
       op: Lt
       span:
@@ -107,7 +107,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: lt.leo
+        path: test
         content: 1 < 2 < 3
   - Binary:
       left:
@@ -120,7 +120,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: lt.leo
+                  path: test
                   content: 1 + 2 < 3 + 4
           right:
             Value:
@@ -130,7 +130,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: lt.leo
+                  path: test
                   content: 1 + 2 < 3 + 4
           op: Add
           span:
@@ -138,7 +138,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: lt.leo
+            path: test
             content: 1 + 2 < 3 + 4
       right:
         Binary:
@@ -150,7 +150,7 @@ outputs:
                   line_stop: 1
                   col_start: 9
                   col_stop: 10
-                  path: lt.leo
+                  path: test
                   content: 1 + 2 < 3 + 4
           right:
             Value:
@@ -160,7 +160,7 @@ outputs:
                   line_stop: 1
                   col_start: 13
                   col_stop: 14
-                  path: lt.leo
+                  path: test
                   content: 1 + 2 < 3 + 4
           op: Add
           span:
@@ -168,7 +168,7 @@ outputs:
             line_stop: 1
             col_start: 9
             col_stop: 14
-            path: lt.leo
+            path: test
             content: 1 + 2 < 3 + 4
       op: Lt
       span:
@@ -176,7 +176,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 14
-        path: lt.leo
+        path: test
         content: 1 + 2 < 3 + 4
   - Binary:
       left:
@@ -189,7 +189,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: lt.leo
+                  path: test
                   content: 1 < 2 < 3
           right:
             Value:
@@ -199,7 +199,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: lt.leo
+                  path: test
                   content: 1 < 2 < 3
           op: Lt
           span:
@@ -207,7 +207,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: lt.leo
+            path: test
             content: 1 < 2 < 3
       right:
         Value:
@@ -217,7 +217,7 @@ outputs:
               line_stop: 1
               col_start: 9
               col_stop: 10
-              path: lt.leo
+              path: test
               content: 1 < 2 < 3
       op: Lt
       span:
@@ -225,7 +225,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: lt.leo
+        path: test
         content: 1 < 2 < 3
   - Binary:
       left:
@@ -240,7 +240,7 @@ outputs:
                       line_stop: 1
                       col_start: 1
                       col_stop: 2
-                      path: lt.leo
+                      path: test
                       content: 1 + 2 < 3 + 4 < 5 + 6
               right:
                 Value:
@@ -250,7 +250,7 @@ outputs:
                       line_stop: 1
                       col_start: 5
                       col_stop: 6
-                      path: lt.leo
+                      path: test
                       content: 1 + 2 < 3 + 4 < 5 + 6
               op: Add
               span:
@@ -258,7 +258,7 @@ outputs:
                 line_stop: 1
                 col_start: 1
                 col_stop: 6
-                path: lt.leo
+                path: test
                 content: 1 + 2 < 3 + 4 < 5 + 6
           right:
             Binary:
@@ -270,7 +270,7 @@ outputs:
                       line_stop: 1
                       col_start: 9
                       col_stop: 10
-                      path: lt.leo
+                      path: test
                       content: 1 + 2 < 3 + 4 < 5 + 6
               right:
                 Value:
@@ -280,7 +280,7 @@ outputs:
                       line_stop: 1
                       col_start: 13
                       col_stop: 14
-                      path: lt.leo
+                      path: test
                       content: 1 + 2 < 3 + 4 < 5 + 6
               op: Add
               span:
@@ -288,7 +288,7 @@ outputs:
                 line_stop: 1
                 col_start: 9
                 col_stop: 14
-                path: lt.leo
+                path: test
                 content: 1 + 2 < 3 + 4 < 5 + 6
           op: Lt
           span:
@@ -296,7 +296,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 14
-            path: lt.leo
+            path: test
             content: 1 + 2 < 3 + 4 < 5 + 6
       right:
         Binary:
@@ -308,7 +308,7 @@ outputs:
                   line_stop: 1
                   col_start: 17
                   col_stop: 18
-                  path: lt.leo
+                  path: test
                   content: 1 + 2 < 3 + 4 < 5 + 6
           right:
             Value:
@@ -318,7 +318,7 @@ outputs:
                   line_stop: 1
                   col_start: 21
                   col_stop: 22
-                  path: lt.leo
+                  path: test
                   content: 1 + 2 < 3 + 4 < 5 + 6
           op: Add
           span:
@@ -326,7 +326,7 @@ outputs:
             line_stop: 1
             col_start: 17
             col_stop: 22
-            path: lt.leo
+            path: test
             content: 1 + 2 < 3 + 4 < 5 + 6
       op: Lt
       span:
@@ -334,5 +334,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 22
-        path: lt.leo
+        path: test
         content: 1 + 2 < 3 + 4 < 5 + 6

tests/expectations/parser/parser/expression/binary/lte.leo.out

@@ -11,7 +11,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: lte.leo
+              path: test
               content: 1 <= 1
       right:
         Value:
@@ -21,7 +21,7 @@ outputs:
               line_stop: 1
               col_start: 6
               col_stop: 7
-              path: lte.leo
+              path: test
               content: 1 <= 1
       op: Le
       span:
@@ -29,7 +29,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: lte.leo
+        path: test
         content: 1 <= 1
   - Binary:
       left:
@@ -40,7 +40,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: lte.leo
+              path: test
               content: 2 <= 3
       right:
         Value:
@@ -50,7 +50,7 @@ outputs:
               line_stop: 1
               col_start: 6
               col_stop: 7
-              path: lte.leo
+              path: test
               content: 2 <= 3
       op: Le
       span:
@@ -58,7 +58,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: lte.leo
+        path: test
         content: 2 <= 3
   - Binary:
       left:
@@ -71,7 +71,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: lte.leo
+                  path: test
                   content: 1 <= 2 <= 3
           right:
             Value:
@@ -81,7 +81,7 @@ outputs:
                   line_stop: 1
                   col_start: 6
                   col_stop: 7
-                  path: lte.leo
+                  path: test
                   content: 1 <= 2 <= 3
           op: Le
           span:
@@ -89,7 +89,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 7
-            path: lte.leo
+            path: test
             content: 1 <= 2 <= 3
       right:
         Value:
@@ -99,7 +99,7 @@ outputs:
               line_stop: 1
               col_start: 11
               col_stop: 12
-              path: lte.leo
+              path: test
               content: 1 <= 2 <= 3
       op: Le
       span:
@@ -107,7 +107,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 12
-        path: lte.leo
+        path: test
         content: 1 <= 2 <= 3
   - Binary:
       left:
@@ -120,7 +120,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: lte.leo
+                  path: test
                   content: 1 + 2 <= 3 + 4
           right:
             Value:
@@ -130,7 +130,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: lte.leo
+                  path: test
                   content: 1 + 2 <= 3 + 4
           op: Add
           span:
@@ -138,7 +138,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: lte.leo
+            path: test
             content: 1 + 2 <= 3 + 4
       right:
         Binary:
@@ -150,7 +150,7 @@ outputs:
                   line_stop: 1
                   col_start: 10
                   col_stop: 11
-                  path: lte.leo
+                  path: test
                   content: 1 + 2 <= 3 + 4
           right:
             Value:
@@ -160,7 +160,7 @@ outputs:
                   line_stop: 1
                   col_start: 14
                   col_stop: 15
-                  path: lte.leo
+                  path: test
                   content: 1 + 2 <= 3 + 4
           op: Add
           span:
@@ -168,7 +168,7 @@ outputs:
             line_stop: 1
             col_start: 10
             col_stop: 15
-            path: lte.leo
+            path: test
             content: 1 + 2 <= 3 + 4
       op: Le
       span:
@@ -176,7 +176,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 15
-        path: lte.leo
+        path: test
         content: 1 + 2 <= 3 + 4
   - Binary:
       left:
@@ -189,7 +189,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: lte.leo
+                  path: test
                   content: 1 <= 2 <= 3
           right:
             Value:
@@ -199,7 +199,7 @@ outputs:
                   line_stop: 1
                   col_start: 6
                   col_stop: 7
-                  path: lte.leo
+                  path: test
                   content: 1 <= 2 <= 3
           op: Le
           span:
@@ -207,7 +207,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 7
-            path: lte.leo
+            path: test
             content: 1 <= 2 <= 3
       right:
         Value:
@@ -217,7 +217,7 @@ outputs:
               line_stop: 1
               col_start: 11
               col_stop: 12
-              path: lte.leo
+              path: test
               content: 1 <= 2 <= 3
       op: Le
       span:
@@ -225,7 +225,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 12
-        path: lte.leo
+        path: test
         content: 1 <= 2 <= 3
   - Binary:
       left:
@@ -240,7 +240,7 @@ outputs:
                       line_stop: 1
                       col_start: 1
                       col_stop: 2
-                      path: lte.leo
+                      path: test
                       content: 1 + 2 <= 3 + 4 <= 5 + 6
               right:
                 Value:
@@ -250,7 +250,7 @@ outputs:
                       line_stop: 1
                       col_start: 5
                       col_stop: 6
-                      path: lte.leo
+                      path: test
                       content: 1 + 2 <= 3 + 4 <= 5 + 6
               op: Add
               span:
@@ -258,7 +258,7 @@ outputs:
                 line_stop: 1
                 col_start: 1
                 col_stop: 6
-                path: lte.leo
+                path: test
                 content: 1 + 2 <= 3 + 4 <= 5 + 6
           right:
             Binary:
@@ -270,7 +270,7 @@ outputs:
                       line_stop: 1
                       col_start: 10
                       col_stop: 11
-                      path: lte.leo
+                      path: test
                       content: 1 + 2 <= 3 + 4 <= 5 + 6
               right:
                 Value:
@@ -280,7 +280,7 @@ outputs:
                       line_stop: 1
                       col_start: 14
                       col_stop: 15
-                      path: lte.leo
+                      path: test
                       content: 1 + 2 <= 3 + 4 <= 5 + 6
               op: Add
               span:
@@ -288,7 +288,7 @@ outputs:
                 line_stop: 1
                 col_start: 10
                 col_stop: 15
-                path: lte.leo
+                path: test
                 content: 1 + 2 <= 3 + 4 <= 5 + 6
           op: Le
           span:
@@ -296,7 +296,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: lte.leo
+            path: test
             content: 1 + 2 <= 3 + 4 <= 5 + 6
       right:
         Binary:
@@ -308,7 +308,7 @@ outputs:
                   line_stop: 1
                   col_start: 19
                   col_stop: 20
-                  path: lte.leo
+                  path: test
                   content: 1 + 2 <= 3 + 4 <= 5 + 6
           right:
             Value:
@@ -318,7 +318,7 @@ outputs:
                   line_stop: 1
                   col_start: 23
                   col_stop: 24
-                  path: lte.leo
+                  path: test
                   content: 1 + 2 <= 3 + 4 <= 5 + 6
           op: Add
           span:
@@ -326,7 +326,7 @@ outputs:
             line_stop: 1
             col_start: 19
             col_stop: 24
-            path: lte.leo
+            path: test
             content: 1 + 2 <= 3 + 4 <= 5 + 6
       op: Le
       span:
@@ -334,5 +334,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 24
-        path: lte.leo
+        path: test
         content: 1 + 2 <= 3 + 4 <= 5 + 6

tests/expectations/parser/parser/expression/binary/mul.leo.out

@@ -11,7 +11,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: mul.leo
+              path: test
               content: 1 * 1
       right:
         Value:
@@ -21,7 +21,7 @@ outputs:
               line_stop: 1
               col_start: 5
               col_stop: 6
-              path: mul.leo
+              path: test
               content: 1 * 1
       op: Mul
       span:
@@ -29,7 +29,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: mul.leo
+        path: test
         content: 1 * 1
   - Binary:
       left:
@@ -40,7 +40,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: mul.leo
+              path: test
               content: 2*3
       right:
         Value:
@@ -50,7 +50,7 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 4
-              path: mul.leo
+              path: test
               content: 2*3
       op: Mul
       span:
@@ -58,7 +58,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: mul.leo
+        path: test
         content: 2*3
   - Binary:
       left:
@@ -71,7 +71,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: mul.leo
+                  path: test
                   content: 1 * 2 * 3
           right:
             Value:
@@ -81,7 +81,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: mul.leo
+                  path: test
                   content: 1 * 2 * 3
           op: Mul
           span:
@@ -89,7 +89,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: mul.leo
+            path: test
             content: 1 * 2 * 3
       right:
         Value:
@@ -99,7 +99,7 @@ outputs:
               line_stop: 1
               col_start: 9
               col_stop: 10
-              path: mul.leo
+              path: test
               content: 1 * 2 * 3
       op: Mul
       span:
@@ -107,7 +107,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: mul.leo
+        path: test
         content: 1 * 2 * 3
   - Binary:
       left:
@@ -120,7 +120,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: mul.leo
+                  path: test
                   content: 1 ** 2 * 3 ** 4
           right:
             Value:
@@ -130,7 +130,7 @@ outputs:
                   line_stop: 1
                   col_start: 6
                   col_stop: 7
-                  path: mul.leo
+                  path: test
                   content: 1 ** 2 * 3 ** 4
           op: Pow
           span:
@@ -138,7 +138,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 7
-            path: mul.leo
+            path: test
             content: 1 ** 2 * 3 ** 4
       right:
         Binary:
@@ -150,7 +150,7 @@ outputs:
                   line_stop: 1
                   col_start: 10
                   col_stop: 11
-                  path: mul.leo
+                  path: test
                   content: 1 ** 2 * 3 ** 4
           right:
             Value:
@@ -160,7 +160,7 @@ outputs:
                   line_stop: 1
                   col_start: 15
                   col_stop: 16
-                  path: mul.leo
+                  path: test
                   content: 1 ** 2 * 3 ** 4
           op: Pow
           span:
@@ -168,7 +168,7 @@ outputs:
             line_stop: 1
             col_start: 10
             col_stop: 16
-            path: mul.leo
+            path: test
             content: 1 ** 2 * 3 ** 4
       op: Mul
       span:
@@ -176,7 +176,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 16
-        path: mul.leo
+        path: test
         content: 1 ** 2 * 3 ** 4
   - Binary:
       left:
@@ -191,7 +191,7 @@ outputs:
                       line_stop: 1
                       col_start: 1
                       col_stop: 2
-                      path: mul.leo
+                      path: test
                       content: 1 ** 2 * 3 ** 4 / 5 ** 6
               right:
                 Value:
@@ -201,7 +201,7 @@ outputs:
                       line_stop: 1
                       col_start: 6
                       col_stop: 7
-                      path: mul.leo
+                      path: test
                       content: 1 ** 2 * 3 ** 4 / 5 ** 6
               op: Pow
               span:
@@ -209,7 +209,7 @@ outputs:
                 line_stop: 1
                 col_start: 1
                 col_stop: 7
-                path: mul.leo
+                path: test
                 content: 1 ** 2 * 3 ** 4 / 5 ** 6
           right:
             Binary:
@@ -221,7 +221,7 @@ outputs:
                       line_stop: 1
                       col_start: 10
                       col_stop: 11
-                      path: mul.leo
+                      path: test
                       content: 1 ** 2 * 3 ** 4 / 5 ** 6
               right:
                 Value:
@@ -231,7 +231,7 @@ outputs:
                       line_stop: 1
                       col_start: 15
                       col_stop: 16
-                      path: mul.leo
+                      path: test
                       content: 1 ** 2 * 3 ** 4 / 5 ** 6
               op: Pow
               span:
@@ -239,7 +239,7 @@ outputs:
                 line_stop: 1
                 col_start: 10
                 col_stop: 16
-                path: mul.leo
+                path: test
                 content: 1 ** 2 * 3 ** 4 / 5 ** 6
           op: Mul
           span:
@@ -247,7 +247,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 16
-            path: mul.leo
+            path: test
             content: 1 ** 2 * 3 ** 4 / 5 ** 6
       right:
         Binary:
@@ -259,7 +259,7 @@ outputs:
                   line_stop: 1
                   col_start: 19
                   col_stop: 20
-                  path: mul.leo
+                  path: test
                   content: 1 ** 2 * 3 ** 4 / 5 ** 6
           right:
             Value:
@@ -269,7 +269,7 @@ outputs:
                   line_stop: 1
                   col_start: 24
                   col_stop: 25
-                  path: mul.leo
+                  path: test
                   content: 1 ** 2 * 3 ** 4 / 5 ** 6
           op: Pow
           span:
@@ -277,7 +277,7 @@ outputs:
             line_stop: 1
             col_start: 19
             col_stop: 25
-            path: mul.leo
+            path: test
             content: 1 ** 2 * 3 ** 4 / 5 ** 6
       op: Div
       span:
@@ -285,5 +285,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 25
-        path: mul.leo
+        path: test
         content: 1 ** 2 * 3 ** 4 / 5 ** 6

tests/expectations/parser/parser/expression/binary/ne.leo.out

@@ -11,7 +11,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: ne.leo
+              path: test
               content: 1 != 1
       right:
         Value:
@@ -21,7 +21,7 @@ outputs:
               line_stop: 1
               col_start: 6
               col_stop: 7
-              path: ne.leo
+              path: test
               content: 1 != 1
       op: Ne
       span:
@@ -29,7 +29,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 7
-        path: ne.leo
+        path: test
         content: 1 != 1
   - Binary:
       left:
@@ -40,7 +40,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: ne.leo
+              path: test
               content: 2!=3
       right:
         Value:
@@ -50,7 +50,7 @@ outputs:
               line_stop: 1
               col_start: 4
               col_stop: 5
-              path: ne.leo
+              path: test
               content: 2!=3
       op: Ne
       span:
@@ -58,7 +58,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 5
-        path: ne.leo
+        path: test
         content: 2!=3
   - Binary:
       left:
@@ -71,7 +71,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: ne.leo
+                  path: test
                   content: 1 != 2 != 3
           right:
             Value:
@@ -81,7 +81,7 @@ outputs:
                   line_stop: 1
                   col_start: 6
                   col_stop: 7
-                  path: ne.leo
+                  path: test
                   content: 1 != 2 != 3
           op: Ne
           span:
@@ -89,7 +89,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 7
-            path: ne.leo
+            path: test
             content: 1 != 2 != 3
       right:
         Value:
@@ -99,7 +99,7 @@ outputs:
               line_stop: 1
               col_start: 11
               col_stop: 12
-              path: ne.leo
+              path: test
               content: 1 != 2 != 3
       op: Ne
       span:
@@ -107,7 +107,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 12
-        path: ne.leo
+        path: test
         content: 1 != 2 != 3
   - Binary:
       left:
@@ -120,7 +120,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: ne.leo
+                  path: test
                   content: 1 < 2 != 3 < 4
           right:
             Value:
@@ -130,7 +130,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: ne.leo
+                  path: test
                   content: 1 < 2 != 3 < 4
           op: Lt
           span:
@@ -138,7 +138,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: ne.leo
+            path: test
             content: 1 < 2 != 3 < 4
       right:
         Binary:
@@ -150,7 +150,7 @@ outputs:
                   line_stop: 1
                   col_start: 10
                   col_stop: 11
-                  path: ne.leo
+                  path: test
                   content: 1 < 2 != 3 < 4
           right:
             Value:
@@ -160,7 +160,7 @@ outputs:
                   line_stop: 1
                   col_start: 14
                   col_stop: 15
-                  path: ne.leo
+                  path: test
                   content: 1 < 2 != 3 < 4
           op: Lt
           span:
@@ -168,7 +168,7 @@ outputs:
             line_stop: 1
             col_start: 10
             col_stop: 15
-            path: ne.leo
+            path: test
             content: 1 < 2 != 3 < 4
       op: Ne
       span:
@@ -176,7 +176,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 15
-        path: ne.leo
+        path: test
         content: 1 < 2 != 3 < 4
   - Binary:
       left:
@@ -189,7 +189,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: ne.leo
+                  path: test
                   content: 1 != 2 != 3
           right:
             Value:
@@ -199,7 +199,7 @@ outputs:
                   line_stop: 1
                   col_start: 6
                   col_stop: 7
-                  path: ne.leo
+                  path: test
                   content: 1 != 2 != 3
           op: Ne
           span:
@@ -207,7 +207,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 7
-            path: ne.leo
+            path: test
             content: 1 != 2 != 3
       right:
         Value:
@@ -217,7 +217,7 @@ outputs:
               line_stop: 1
               col_start: 11
               col_stop: 12
-              path: ne.leo
+              path: test
               content: 1 != 2 != 3
       op: Ne
       span:
@@ -225,7 +225,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 12
-        path: ne.leo
+        path: test
         content: 1 != 2 != 3
   - Binary:
       left:
@@ -240,7 +240,7 @@ outputs:
                       line_stop: 1
                       col_start: 1
                       col_stop: 2
-                      path: ne.leo
+                      path: test
                       content: 1 < 2 != 3 < 4 != 5 < 6
               right:
                 Value:
@@ -250,7 +250,7 @@ outputs:
                       line_stop: 1
                       col_start: 5
                       col_stop: 6
-                      path: ne.leo
+                      path: test
                       content: 1 < 2 != 3 < 4 != 5 < 6
               op: Lt
               span:
@@ -258,7 +258,7 @@ outputs:
                 line_stop: 1
                 col_start: 1
                 col_stop: 6
-                path: ne.leo
+                path: test
                 content: 1 < 2 != 3 < 4 != 5 < 6
           right:
             Binary:
@@ -270,7 +270,7 @@ outputs:
                       line_stop: 1
                       col_start: 10
                       col_stop: 11
-                      path: ne.leo
+                      path: test
                       content: 1 < 2 != 3 < 4 != 5 < 6
               right:
                 Value:
@@ -280,7 +280,7 @@ outputs:
                       line_stop: 1
                       col_start: 14
                       col_stop: 15
-                      path: ne.leo
+                      path: test
                       content: 1 < 2 != 3 < 4 != 5 < 6
               op: Lt
               span:
@@ -288,7 +288,7 @@ outputs:
                 line_stop: 1
                 col_start: 10
                 col_stop: 15
-                path: ne.leo
+                path: test
                 content: 1 < 2 != 3 < 4 != 5 < 6
           op: Ne
           span:
@@ -296,7 +296,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: ne.leo
+            path: test
             content: 1 < 2 != 3 < 4 != 5 < 6
       right:
         Binary:
@@ -308,7 +308,7 @@ outputs:
                   line_stop: 1
                   col_start: 19
                   col_stop: 20
-                  path: ne.leo
+                  path: test
                   content: 1 < 2 != 3 < 4 != 5 < 6
           right:
             Value:
@@ -318,7 +318,7 @@ outputs:
                   line_stop: 1
                   col_start: 23
                   col_stop: 24
-                  path: ne.leo
+                  path: test
                   content: 1 < 2 != 3 < 4 != 5 < 6
           op: Lt
           span:
@@ -326,7 +326,7 @@ outputs:
             line_stop: 1
             col_start: 19
             col_stop: 24
-            path: ne.leo
+            path: test
             content: 1 < 2 != 3 < 4 != 5 < 6
       op: Ne
       span:
@@ -334,5 +334,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 24
-        path: ne.leo
+        path: test
         content: 1 < 2 != 3 < 4 != 5 < 6

tests/expectations/parser/parser/expression/binary/or.leo.out

@@ -11,7 +11,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: or.leo
+              path: test
               content: 1 + 1
       right:
         Value:
@@ -21,7 +21,7 @@ outputs:
               line_stop: 1
               col_start: 5
               col_stop: 6
-              path: or.leo
+              path: test
               content: 1 + 1
       op: Add
       span:
@@ -29,7 +29,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: or.leo
+        path: test
         content: 1 + 1
   - Binary:
       left:
@@ -40,7 +40,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: or.leo
+              path: test
               content: 2+3
       right:
         Value:
@@ -50,7 +50,7 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 4
-              path: or.leo
+              path: test
               content: 2+3
       op: Add
       span:
@@ -58,7 +58,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: or.leo
+        path: test
         content: 2+3
   - Binary:
       left:
@@ -71,7 +71,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: or.leo
+                  path: test
                   content: 1 + 2 + 3
           right:
             Value:
@@ -81,7 +81,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: or.leo
+                  path: test
                   content: 1 + 2 + 3
           op: Add
           span:
@@ -89,7 +89,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: or.leo
+            path: test
             content: 1 + 2 + 3
       right:
         Value:
@@ -99,7 +99,7 @@ outputs:
               line_stop: 1
               col_start: 9
               col_stop: 10
-              path: or.leo
+              path: test
               content: 1 + 2 + 3
       op: Add
       span:
@@ -107,7 +107,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: or.leo
+        path: test
         content: 1 + 2 + 3
   - Binary:
       left:
@@ -120,7 +120,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: or.leo
+                  path: test
                   content: 1 * 2 + 3 * 4
           right:
             Value:
@@ -130,7 +130,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: or.leo
+                  path: test
                   content: 1 * 2 + 3 * 4
           op: Mul
           span:
@@ -138,7 +138,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: or.leo
+            path: test
             content: 1 * 2 + 3 * 4
       right:
         Binary:
@@ -150,7 +150,7 @@ outputs:
                   line_stop: 1
                   col_start: 9
                   col_stop: 10
-                  path: or.leo
+                  path: test
                   content: 1 * 2 + 3 * 4
           right:
             Value:
@@ -160,7 +160,7 @@ outputs:
                   line_stop: 1
                   col_start: 13
                   col_stop: 14
-                  path: or.leo
+                  path: test
                   content: 1 * 2 + 3 * 4
           op: Mul
           span:
@@ -168,7 +168,7 @@ outputs:
             line_stop: 1
             col_start: 9
             col_stop: 14
-            path: or.leo
+            path: test
             content: 1 * 2 + 3 * 4
       op: Add
       span:
@@ -176,7 +176,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 14
-        path: or.leo
+        path: test
         content: 1 * 2 + 3 * 4
   - Binary:
       left:
@@ -189,7 +189,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: or.leo
+                  path: test
                   content: 1 + 2 - 3
           right:
             Value:
@@ -199,7 +199,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: or.leo
+                  path: test
                   content: 1 + 2 - 3
           op: Add
           span:
@@ -207,7 +207,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: or.leo
+            path: test
             content: 1 + 2 - 3
       right:
         Value:
@@ -217,7 +217,7 @@ outputs:
               line_stop: 1
               col_start: 9
               col_stop: 10
-              path: or.leo
+              path: test
               content: 1 + 2 - 3
       op: Sub
       span:
@@ -225,7 +225,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: or.leo
+        path: test
         content: 1 + 2 - 3
   - Binary:
       left:
@@ -240,7 +240,7 @@ outputs:
                       line_stop: 1
                       col_start: 1
                       col_stop: 2
-                      path: or.leo
+                      path: test
                       content: 1 * 2 + 3 * 4 - 5 * 6
               right:
                 Value:
@@ -250,7 +250,7 @@ outputs:
                       line_stop: 1
                       col_start: 5
                       col_stop: 6
-                      path: or.leo
+                      path: test
                       content: 1 * 2 + 3 * 4 - 5 * 6
               op: Mul
               span:
@@ -258,7 +258,7 @@ outputs:
                 line_stop: 1
                 col_start: 1
                 col_stop: 6
-                path: or.leo
+                path: test
                 content: 1 * 2 + 3 * 4 - 5 * 6
           right:
             Binary:
@@ -270,7 +270,7 @@ outputs:
                       line_stop: 1
                       col_start: 9
                       col_stop: 10
-                      path: or.leo
+                      path: test
                       content: 1 * 2 + 3 * 4 - 5 * 6
               right:
                 Value:
@@ -280,7 +280,7 @@ outputs:
                       line_stop: 1
                       col_start: 13
                       col_stop: 14
-                      path: or.leo
+                      path: test
                       content: 1 * 2 + 3 * 4 - 5 * 6
               op: Mul
               span:
@@ -288,7 +288,7 @@ outputs:
                 line_stop: 1
                 col_start: 9
                 col_stop: 14
-                path: or.leo
+                path: test
                 content: 1 * 2 + 3 * 4 - 5 * 6
           op: Add
           span:
@@ -296,7 +296,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 14
-            path: or.leo
+            path: test
             content: 1 * 2 + 3 * 4 - 5 * 6
       right:
         Binary:
@@ -308,7 +308,7 @@ outputs:
                   line_stop: 1
                   col_start: 17
                   col_stop: 18
-                  path: or.leo
+                  path: test
                   content: 1 * 2 + 3 * 4 - 5 * 6
           right:
             Value:
@@ -318,7 +318,7 @@ outputs:
                   line_stop: 1
                   col_start: 21
                   col_stop: 22
-                  path: or.leo
+                  path: test
                   content: 1 * 2 + 3 * 4 - 5 * 6
           op: Mul
           span:
@@ -326,7 +326,7 @@ outputs:
             line_stop: 1
             col_start: 17
             col_stop: 22
-            path: or.leo
+            path: test
             content: 1 * 2 + 3 * 4 - 5 * 6
       op: Sub
       span:
@@ -334,5 +334,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 22
-        path: or.leo
+        path: test
         content: 1 * 2 + 3 * 4 - 5 * 6

tests/expectations/parser/parser/expression/binary/sub.leo.out

@@ -11,7 +11,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: sub.leo
+              path: test
               content: 1 - 1
       right:
         Value:
@@ -21,7 +21,7 @@ outputs:
               line_stop: 1
               col_start: 5
               col_stop: 6
-              path: sub.leo
+              path: test
               content: 1 - 1
       op: Sub
       span:
@@ -29,7 +29,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: sub.leo
+        path: test
         content: 1 - 1
   - Binary:
       left:
@@ -40,7 +40,7 @@ outputs:
               line_stop: 1
               col_start: 1
               col_stop: 2
-              path: sub.leo
+              path: test
               content: 2-3
       right:
         Value:
@@ -50,7 +50,7 @@ outputs:
               line_stop: 1
               col_start: 3
               col_stop: 4
-              path: sub.leo
+              path: test
               content: 2-3
       op: Sub
       span:
@@ -58,7 +58,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: sub.leo
+        path: test
         content: 2-3
   - Binary:
       left:
@@ -71,7 +71,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: sub.leo
+                  path: test
                   content: 1 - 2 - 3
           right:
             Value:
@@ -81,7 +81,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: sub.leo
+                  path: test
                   content: 1 - 2 - 3
           op: Sub
           span:
@@ -89,7 +89,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: sub.leo
+            path: test
             content: 1 - 2 - 3
       right:
         Value:
@@ -99,7 +99,7 @@ outputs:
               line_stop: 1
               col_start: 9
               col_stop: 10
-              path: sub.leo
+              path: test
               content: 1 - 2 - 3
       op: Sub
       span:
@@ -107,7 +107,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: sub.leo
+        path: test
         content: 1 - 2 - 3
   - Binary:
       left:
@@ -120,7 +120,7 @@ outputs:
                   line_stop: 1
                   col_start: 1
                   col_stop: 2
-                  path: sub.leo
+                  path: test
                   content: 1 * 2 - 3 * 4
           right:
             Value:
@@ -130,7 +130,7 @@ outputs:
                   line_stop: 1
                   col_start: 5
                   col_stop: 6
-                  path: sub.leo
+                  path: test
                   content: 1 * 2 - 3 * 4
           op: Mul
           span:
@@ -138,7 +138,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 6
-            path: sub.leo
+            path: test
             content: 1 * 2 - 3 * 4
       right:
         Binary:
@@ -150,7 +150,7 @@ outputs:
                   line_stop: 1
                   col_start: 9
                   col_stop: 10
-                  path: sub.leo
+                  path: test
                   content: 1 * 2 - 3 * 4
           right:
             Value:
@@ -160,7 +160,7 @@ outputs:
                   line_stop: 1
                   col_start: 13
                   col_stop: 14
-                  path: sub.leo
+                  path: test
                   content: 1 * 2 - 3 * 4
           op: Mul
           span:
@@ -168,7 +168,7 @@ outputs:
             line_stop: 1
             col_start: 9
             col_stop: 14
-            path: sub.leo
+            path: test
             content: 1 * 2 - 3 * 4
       op: Sub
       span:
@@ -176,5 +176,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 14
-        path: sub.leo
+        path: test
         content: 1 * 2 - 3 * 4

tests/expectations/parser/parser/expression/cast.leo.out

@@ -4,7 +4,7 @@ expectation: Pass
 outputs:
   - Cast:
       inner:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x as u8\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x as u8\\\"}\"}"
       target_type:
         IntegerType: U8
       span:
@@ -12,23 +12,23 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 8
-        path: cast.leo
+        path: test
         content: x as u8
   - Cast:
       inner:
-        Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"y as id\\\"}\"}"
+        Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"y as id\\\"}\"}"
       target_type:
-        Circuit: "{\"name\":\"id\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":8,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"y as id\\\"}\"}"
+        Circuit: "{\"name\":\"id\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":8,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"y as id\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 8
-        path: cast.leo
+        path: test
         content: y as id
   - Cast:
       inner:
-        Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"z as u32\\\"}\"}"
+        Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"z as u32\\\"}\"}"
       target_type:
         IntegerType: U32
       span:
@@ -36,11 +36,11 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 9
-        path: cast.leo
+        path: test
         content: z as u32
   - Cast:
       inner:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x as i128\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x as i128\\\"}\"}"
       target_type:
         IntegerType: I128
       span:
@@ -48,13 +48,13 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: cast.leo
+        path: test
         content: x as i128
   - Cast:
       inner:
         Cast:
           inner:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x as u8 as u128\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x as u8 as u128\\\"}\"}"
           target_type:
             IntegerType: U8
           span:
@@ -62,7 +62,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 8
-            path: cast.leo
+            path: test
             content: x as u8 as u128
       target_type:
         IntegerType: U128
@@ -71,39 +71,39 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 16
-        path: cast.leo
+        path: test
         content: x as u8 as u128
   - Cast:
       inner:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x as field\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x as field\\\"}\"}"
       target_type: Field
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 11
-        path: cast.leo
+        path: test
         content: x as field
   - Cast:
       inner:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x as group\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x as group\\\"}\"}"
       target_type: Group
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 11
-        path: cast.leo
+        path: test
         content: x as group
   - Binary:
       left:
-        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x ** y as u32 ** z\\\"}\"}"
+        Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x ** y as u32 ** z\\\"}\"}"
       right:
         Binary:
           left:
             Cast:
               inner:
-                Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x ** y as u32 ** z\\\"}\"}"
+                Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x ** y as u32 ** z\\\"}\"}"
               target_type:
                 IntegerType: U32
               span:
@@ -111,17 +111,17 @@ outputs:
                 line_stop: 1
                 col_start: 6
                 col_stop: 14
-                path: cast.leo
+                path: test
                 content: x ** y as u32 ** z
           right:
-            Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":18,\\\"col_stop\\\":19,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"x ** y as u32 ** z\\\"}\"}"
+            Identifier: "{\"name\":\"z\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":18,\\\"col_stop\\\":19,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x ** y as u32 ** z\\\"}\"}"
           op: Pow
           span:
             line_start: 1
             line_stop: 1
             col_start: 6
             col_stop: 19
-            path: cast.leo
+            path: test
             content: x ** y as u32 ** z
       op: Pow
       span:
@@ -129,7 +129,7 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 19
-        path: cast.leo
+        path: test
         content: x ** y as u32 ** z
   - Value:
       Implicit:
@@ -144,14 +144,14 @@ outputs:
       inner:
         Unary:
           inner:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":2,\\\"col_stop\\\":3,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"!x as u32\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":2,\\\"col_stop\\\":3,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"!x as u32\\\"}\"}"
           op: Not
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 3
-            path: cast.leo
+            path: test
             content: "!x as u32"
       target_type:
         IntegerType: U32
@@ -160,20 +160,20 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: cast.leo
+        path: test
         content: "!x as u32"
   - Cast:
       inner:
         Unary:
           inner:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":2,\\\"col_stop\\\":3,\\\"path\\\":\\\"cast.leo\\\",\\\"content\\\":\\\"-x as u32\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":2,\\\"col_stop\\\":3,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"-x as u32\\\"}\"}"
           op: Negate
           span:
             line_start: 1
             line_stop: 1
             col_start: 1
             col_stop: 3
-            path: cast.leo
+            path: test
             content: "-x as u32"
       target_type:
         IntegerType: U32
@@ -182,5 +182,5 @@ outputs:
         line_stop: 1
         col_start: 1
         col_stop: 10
-        path: cast.leo
+        path: test
         content: "-x as u32"

tests/expectations/parser/parser/expression/circuit_init.leo.out

@@ -3,111 +3,111 @@ namespace: ParseExpression
 expectation: Pass
 outputs:
   - CircuitInit:
-      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x {}\\\"}\"}"
+      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x {}\\\"}\"}"
       members: []
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 5
-        path: circuit_init.leo
+        path: test
         content: "x {}"
   - CircuitInit:
-      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x {y}\\\"}\"}"
+      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x {y}\\\"}\"}"
       members:
-        - identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x {y}\\\"}\"}"
+        - identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":4,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x {y}\\\"}\"}"
           expression: ~
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 6
-        path: circuit_init.leo
+        path: test
         content: "x {y}"
   - CircuitInit:
-      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y}\\\"}\"}"
+      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y}\\\"}\"}"
       members:
-        - identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y}\\\"}\"}"
+        - identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y}\\\"}\"}"
           expression: ~
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 5
-        path: circuit_init.leo
+        path: test
         content: "x{y}"
   - CircuitInit:
-      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{}\\\"}\"}"
+      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{}\\\"}\"}"
       members: []
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 4
-        path: circuit_init.leo
+        path: test
         content: "x{}"
   - CircuitInit:
-      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: y}\\\"}\"}"
+      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: y}\\\"}\"}"
       members:
-        - identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: y}\\\"}\"}"
+        - identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: y}\\\"}\"}"
           expression:
-            Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: y}\\\"}\"}"
+            Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: y}\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 8
-        path: circuit_init.leo
+        path: test
         content: "x{y: y}"
   - CircuitInit:
-      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: x}\\\"}\"}"
+      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: x}\\\"}\"}"
       members:
-        - identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: x}\\\"}\"}"
+        - identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: x}\\\"}\"}"
           expression:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: x}\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: x}\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 8
-        path: circuit_init.leo
+        path: test
         content: "x{y: x}"
   - CircuitInit:
-      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: x,}\\\"}\"}"
+      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: x,}\\\"}\"}"
       members:
-        - identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: x,}\\\"}\"}"
+        - identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: x,}\\\"}\"}"
           expression:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y: x,}\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":6,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y: x,}\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 9
-        path: circuit_init.leo
+        path: test
         content: "x{y: x,}"
   - CircuitInit:
-      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
+      name: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
       members:
-        - identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
+        - identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":3,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
           expression:
-            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
-        - identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":8,\\\"col_stop\\\":9,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
+            Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
+        - identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":8,\\\"col_stop\\\":9,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
           expression:
-            Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
+            Identifier: "{\"name\":\"y\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x{y:x, x:y,}\\\"}\"}"
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 13
-        path: circuit_init.leo
+        path: test
         content: "x{y:x, x:y,}"
   - CircuitInit:
-      name: "{\"name\":\"Self\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"circuit_init.leo\\\",\\\"content\\\":\\\"Self {}\\\"}\"}"
+      name: "{\"name\":\"Self\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"Self {}\\\"}\"}"
       members: []
       span:
         line_start: 1
         line_stop: 1
         col_start: 1
         col_stop: 8
-        path: circuit_init.leo
+        path: test
         content: "Self {}"

tests/expectations/parser/parser/expression/ident.leo.out

@@ -2,22 +2,22 @@
 namespace: ParseExpression
 expectation: Pass
 outputs:
-  - Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"x\\\"}\"}"
-  - Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"X\\\"}\"}"
-  - Identifier: "{\"name\":\"xxx\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":4,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"xxx\\\"}\"}"
-  - Identifier: "{\"name\":\"XXX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":4,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"XXX\\\"}\"}"
-  - Identifier: "{\"name\":\"x1\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"x1\\\"}\"}"
-  - Identifier: "{\"name\":\"xu32\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"xu32\\\"}\"}"
-  - Identifier: "{\"name\":\"testx\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"testx\\\"}\"}"
-  - Identifier: "{\"name\":\"truex\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"truex\\\"}\"}"
-  - Identifier: "{\"name\":\"TRUE\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"TRUE\\\"}\"}"
-  - Identifier: "{\"name\":\"testX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"testX\\\"}\"}"
-  - Identifier: "{\"name\":\"letX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"letX\\\"}\"}"
-  - Identifier: "{\"name\":\"constX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":7,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"constX\\\"}\"}"
-  - Identifier: "{\"name\":\"test_test\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":10,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"test_test\\\"}\"}"
-  - Identifier: "{\"name\":\"self\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"self\\\"}\"}"
-  - Identifier: "{\"name\":\"Self\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"Self\\\"}\"}"
-  - Identifier: "{\"name\":\"input\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"input\\\"}\"}"
-  - Identifier: "{\"name\":\"selfX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"selfX\\\"}\"}"
-  - Identifier: "{\"name\":\"SelfX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"SelfX\\\"}\"}"
-  - Identifier: "{\"name\":\"inputX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":7,\\\"path\\\":\\\"ident.leo\\\",\\\"content\\\":\\\"inputX\\\"}\"}"
+  - Identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x\\\"}\"}"
+  - Identifier: "{\"name\":\"X\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":2,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"X\\\"}\"}"
+  - Identifier: "{\"name\":\"xxx\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"xxx\\\"}\"}"
+  - Identifier: "{\"name\":\"XXX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":4,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"XXX\\\"}\"}"
+  - Identifier: "{\"name\":\"x1\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":3,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"x1\\\"}\"}"
+  - Identifier: "{\"name\":\"xu32\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"xu32\\\"}\"}"
+  - Identifier: "{\"name\":\"testx\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"testx\\\"}\"}"
+  - Identifier: "{\"name\":\"truex\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"truex\\\"}\"}"
+  - Identifier: "{\"name\":\"TRUE\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"TRUE\\\"}\"}"
+  - Identifier: "{\"name\":\"testX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"testX\\\"}\"}"
+  - Identifier: "{\"name\":\"letX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"letX\\\"}\"}"
+  - Identifier: "{\"name\":\"constX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"constX\\\"}\"}"
+  - Identifier: "{\"name\":\"test_test\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":10,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"test_test\\\"}\"}"
+  - Identifier: "{\"name\":\"self\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"self\\\"}\"}"
+  - Identifier: "{\"name\":\"Self\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":5,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"Self\\\"}\"}"
+  - Identifier: "{\"name\":\"input\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"input\\\"}\"}"
+  - Identifier: "{\"name\":\"selfX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"selfX\\\"}\"}"
+  - Identifier: "{\"name\":\"SelfX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":6,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"SelfX\\\"}\"}"
+  - Identifier: "{\"name\":\"inputX\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":1,\\\"col_stop\\\":7,\\\"path\\\":\\\"test\\\",\\\"content\\\":\\\"inputX\\\"}\"}"

tests/expectations/parser/parser/expression/literal/address_parse.leo.out

@@ -9,7 +9,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 64
-          path: address_parse.leo
+          path: test
           content: aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j8
   - Value:
       Address:
@@ -18,7 +18,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 64
-          path: address_parse.leo
+          path: test
           content: aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57j9
   - Value:
       Address:
@@ -27,7 +27,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 64
-          path: address_parse.leo
+          path: test
           content: aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8sta57d9
   - Value:
       Address:
@@ -36,5 +36,5 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 64
-          path: address_parse.leo
+          path: test
           content: aleo1aleo1qnr4dkkvkgfqph0vzc3y6z2eu975wnpz2925ntjccd5cfqxtyu8st

tests/expectations/parser/parser/expression/literal/bool_parse.leo.out

@@ -9,7 +9,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 5
-          path: bool_parse.leo
+          path: test
           content: "true"
   - Value:
       Boolean:
@@ -18,5 +18,5 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 6
-          path: bool_parse.leo
+          path: test
           content: "false"

tests/expectations/parser/parser/expression/literal/group.leo.out

@@ -12,7 +12,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 12
-            path: group.leo
+            path: test
             content: "(+, _)group"
   - Value:
       Group:
@@ -24,7 +24,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 12
-            path: group.leo
+            path: test
             content: "(_, -)group"
   - Value:
       Group:
@@ -36,7 +36,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 12
-            path: group.leo
+            path: test
             content: "(+, -)group"
   - Value:
       Group:
@@ -48,7 +48,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 12
-            path: group.leo
+            path: test
             content: "(-, +)group"
   - Value:
       Group:
@@ -60,7 +60,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 12
-            path: group.leo
+            path: test
             content: "(+, +)group"
   - Value:
       Group:
@@ -72,7 +72,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 12
-            path: group.leo
+            path: test
             content: "(-, -)group"
   - Value:
       Group:
@@ -84,7 +84,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 12
-            path: group.leo
+            path: test
             content: "(_, _)group"
   - Value:
       Group:
@@ -96,7 +96,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123,-456)group"
           y:
             Number:
@@ -105,14 +105,14 @@ outputs:
                 line_stop: 1
                 col_start: 7
                 col_stop: 10
-                path: group.leo
+                path: test
                 content: "(123,-456)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 16
-            path: group.leo
+            path: test
             content: "(123,-456)group"
   - Value:
       Group:
@@ -124,7 +124,7 @@ outputs:
                 line_stop: 1
                 col_start: 3
                 col_stop: 6
-                path: group.leo
+                path: test
                 content: "(-123,456)group"
           y:
             Number:
@@ -133,14 +133,14 @@ outputs:
                 line_stop: 1
                 col_start: 7
                 col_stop: 10
-                path: group.leo
+                path: test
                 content: "(-123,456)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 16
-            path: group.leo
+            path: test
             content: "(-123,456)group"
   - Value:
       Group:
@@ -152,7 +152,7 @@ outputs:
                 line_stop: 1
                 col_start: 3
                 col_stop: 6
-                path: group.leo
+                path: test
                 content: "(-123,456)group"
           y:
             Number:
@@ -161,14 +161,14 @@ outputs:
                 line_stop: 1
                 col_start: 7
                 col_stop: 10
-                path: group.leo
+                path: test
                 content: "(-123,456)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 16
-            path: group.leo
+            path: test
             content: "(-123,456)group"
   - Value:
       Group:
@@ -180,7 +180,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123, _)group"
           y: Inferred
           span:
@@ -188,7 +188,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 14
-            path: group.leo
+            path: test
             content: "(123, _)group"
   - Value:
       Group:
@@ -200,7 +200,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123, -)group"
           y: SignLow
           span:
@@ -208,7 +208,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 14
-            path: group.leo
+            path: test
             content: "(123, -)group"
   - Value:
       Group:
@@ -220,7 +220,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123, -)group"
           y: SignLow
           span:
@@ -228,7 +228,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 14
-            path: group.leo
+            path: test
             content: "(123, -)group"
   - Value:
       Group:
@@ -240,7 +240,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123, +)group"
           y: SignHigh
           span:
@@ -248,7 +248,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 14
-            path: group.leo
+            path: test
             content: "(123, +)group"
   - Value:
       Group:
@@ -260,7 +260,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123, +)group"
           y: SignHigh
           span:
@@ -268,7 +268,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 14
-            path: group.leo
+            path: test
             content: "(123, +)group"
   - Value:
       Group:
@@ -280,7 +280,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123, -)group"
           y: SignLow
           span:
@@ -288,7 +288,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 14
-            path: group.leo
+            path: test
             content: "(123, -)group"
   - Value:
       Group:
@@ -300,7 +300,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123, _)group"
           y: Inferred
           span:
@@ -308,7 +308,7 @@ outputs:
             line_stop: 1
             col_start: 2
             col_stop: 14
-            path: group.leo
+            path: test
             content: "(123, _)group"
   - Value:
       Group:
@@ -321,14 +321,14 @@ outputs:
                 line_stop: 1
                 col_start: 5
                 col_stop: 8
-                path: group.leo
+                path: test
                 content: "(+, 345)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 14
-            path: group.leo
+            path: test
             content: "(+, 345)group"
   - Value:
       Group:
@@ -341,14 +341,14 @@ outputs:
                 line_stop: 1
                 col_start: 5
                 col_stop: 8
-                path: group.leo
+                path: test
                 content: "(_, 345)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 14
-            path: group.leo
+            path: test
             content: "(_, 345)group"
   - Value:
       Group:
@@ -361,14 +361,14 @@ outputs:
                 line_stop: 1
                 col_start: 5
                 col_stop: 8
-                path: group.leo
+                path: test
                 content: "(+, 345)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 14
-            path: group.leo
+            path: test
             content: "(+, 345)group"
   - Value:
       Group:
@@ -381,14 +381,14 @@ outputs:
                 line_stop: 1
                 col_start: 5
                 col_stop: 8
-                path: group.leo
+                path: test
                 content: "(-, 345)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 14
-            path: group.leo
+            path: test
             content: "(-, 345)group"
   - Value:
       Group:
@@ -401,14 +401,14 @@ outputs:
                 line_stop: 1
                 col_start: 5
                 col_stop: 8
-                path: group.leo
+                path: test
                 content: "(+, 345)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 14
-            path: group.leo
+            path: test
             content: "(+, 345)group"
   - Value:
       Group:
@@ -421,14 +421,14 @@ outputs:
                 line_stop: 1
                 col_start: 5
                 col_stop: 8
-                path: group.leo
+                path: test
                 content: "(-, 345)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 14
-            path: group.leo
+            path: test
             content: "(-, 345)group"
   - Value:
       Group:
@@ -441,14 +441,14 @@ outputs:
                 line_stop: 1
                 col_start: 5
                 col_stop: 8
-                path: group.leo
+                path: test
                 content: "(_, 345)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 14
-            path: group.leo
+            path: test
             content: "(_, 345)group"
   - Value:
       Group:
@@ -460,7 +460,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123, 456)group"
           y:
             Number:
@@ -469,14 +469,14 @@ outputs:
                 line_stop: 1
                 col_start: 7
                 col_stop: 10
-                path: group.leo
+                path: test
                 content: "(123, 456)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 16
-            path: group.leo
+            path: test
             content: "(123, 456)group"
   - Value:
       Group:
@@ -488,7 +488,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123, 456)group"
           y:
             Number:
@@ -497,14 +497,14 @@ outputs:
                 line_stop: 1
                 col_start: 7
                 col_stop: 10
-                path: group.leo
+                path: test
                 content: "(123, 456)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 16
-            path: group.leo
+            path: test
             content: "(123, 456)group"
   - Value:
       Group:
@@ -516,7 +516,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123, 456)group"
           y:
             Number:
@@ -525,14 +525,14 @@ outputs:
                 line_stop: 1
                 col_start: 7
                 col_stop: 10
-                path: group.leo
+                path: test
                 content: "(123, 456)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 16
-            path: group.leo
+            path: test
             content: "(123, 456)group"
   - Value:
       Group:
@@ -544,7 +544,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123, 456)group"
           y:
             Number:
@@ -553,14 +553,14 @@ outputs:
                 line_stop: 1
                 col_start: 7
                 col_stop: 10
-                path: group.leo
+                path: test
                 content: "(123, 456)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 16
-            path: group.leo
+            path: test
             content: "(123, 456)group"
   - Value:
       Group:
@@ -572,7 +572,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123, 456)group"
           y:
             Number:
@@ -581,14 +581,14 @@ outputs:
                 line_stop: 1
                 col_start: 7
                 col_stop: 10
-                path: group.leo
+                path: test
                 content: "(123, 456)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 16
-            path: group.leo
+            path: test
             content: "(123, 456)group"
   - Value:
       Group:
@@ -600,7 +600,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123, 456)group"
           y:
             Number:
@@ -609,14 +609,14 @@ outputs:
                 line_stop: 1
                 col_start: 7
                 col_stop: 10
-                path: group.leo
+                path: test
                 content: "(123, 456)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 16
-            path: group.leo
+            path: test
             content: "(123, 456)group"
   - Value:
       Group:
@@ -628,7 +628,7 @@ outputs:
                 line_stop: 1
                 col_start: 2
                 col_stop: 5
-                path: group.leo
+                path: test
                 content: "(123, 456)group"
           y:
             Number:
@@ -637,12 +637,12 @@ outputs:
                 line_stop: 1
                 col_start: 7
                 col_stop: 10
-                path: group.leo
+                path: test
                 content: "(123, 456)group"
           span:
             line_start: 1
             line_stop: 1
             col_start: 2
             col_stop: 16
-            path: group.leo
+            path: test
             content: "(123, 456)group"

tests/expectations/parser/parser/expression/literal/int_parse/field.leo.out

@@ -9,7 +9,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 9
-          path: field.leo
+          path: test
           content: 123field
   - Value:
       Implicit:
@@ -18,7 +18,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 4
-          path: field.leo
+          path: test
           content: "123"
   - Value:
       Field:
@@ -27,7 +27,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 9
-          path: field.leo
+          path: test
           content: 456field
   - Value:
       Field:
@@ -36,7 +36,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 86
-          path: field.leo
+          path: test
           content: 87377802873778028737780287377802873778028737780287377802873778028737780287377802field
   - Value:
       Field:
@@ -45,7 +45,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 406
-          path: field.leo
+          path: test
           content: 8737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802field
   - Value:
       Field:
@@ -54,7 +54,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 340130024field
   - Value:
       Field:
@@ -63,7 +63,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 158951116field
   - Value:
       Field:
@@ -72,7 +72,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 155529659field
   - Value:
       Field:
@@ -81,7 +81,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 642023166field
   - Value:
       Field:
@@ -90,7 +90,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 228481736field
   - Value:
       Field:
@@ -99,7 +99,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 469712960field
   - Value:
       Field:
@@ -108,7 +108,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 929437719field
   - Value:
       Field:
@@ -117,7 +117,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 721072814field
   - Value:
       Field:
@@ -126,7 +126,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 363254789field
   - Value:
       Field:
@@ -135,7 +135,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 906732565field
   - Value:
       Field:
@@ -144,7 +144,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 288246391field
   - Value:
       Field:
@@ -153,7 +153,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 724940549field
   - Value:
       Field:
@@ -162,7 +162,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 487101620field
   - Value:
       Field:
@@ -171,7 +171,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 261373583field
   - Value:
       Field:
@@ -180,7 +180,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 891163927field
   - Value:
       Field:
@@ -189,7 +189,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 743967544field
   - Value:
       Field:
@@ -198,7 +198,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: field.leo
+          path: test
           content: 8372586field
   - Value:
       Field:
@@ -207,7 +207,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 461793278field
   - Value:
       Field:
@@ -216,7 +216,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 806307045field
   - Value:
       Field:
@@ -225,7 +225,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 122764546field
   - Value:
       Field:
@@ -234,7 +234,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 356336181field
   - Value:
       Field:
@@ -243,7 +243,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 158370903field
   - Value:
       Field:
@@ -252,7 +252,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 774460877field
   - Value:
       Field:
@@ -261,7 +261,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 557174131field
   - Value:
       Field:
@@ -270,7 +270,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 492401267field
   - Value:
       Field:
@@ -279,7 +279,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 893445620field
   - Value:
       Field:
@@ -288,7 +288,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 957757048field
   - Value:
       Field:
@@ -297,7 +297,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 721540649field
   - Value:
       Field:
@@ -306,7 +306,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 390746493field
   - Value:
       Field:
@@ -315,7 +315,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 211251725field
   - Value:
       Field:
@@ -324,7 +324,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 938266114field
   - Value:
       Field:
@@ -333,7 +333,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 156985870field
   - Value:
       Field:
@@ -342,7 +342,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 703831126field
   - Value:
       Field:
@@ -351,7 +351,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 729964155field
   - Value:
       Field:
@@ -360,7 +360,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 988151305field
   - Value:
       Field:
@@ -369,7 +369,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 320872435field
   - Value:
       Field:
@@ -378,7 +378,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 719287167field
   - Value:
       Field:
@@ -387,7 +387,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 152289486field
   - Value:
       Field:
@@ -396,7 +396,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 740067975field
   - Value:
       Field:
@@ -405,7 +405,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 728627816field
   - Value:
       Field:
@@ -414,7 +414,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 385008978field
   - Value:
       Field:
@@ -423,7 +423,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 553967635field
   - Value:
       Field:
@@ -432,7 +432,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: field.leo
+          path: test
           content: 71980713field
   - Value:
       Field:
@@ -441,7 +441,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 519444716field
   - Value:
       Field:
@@ -450,7 +450,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 116499965field
   - Value:
       Field:
@@ -459,7 +459,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 717422268field
   - Value:
       Field:
@@ -468,7 +468,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: field.leo
+          path: test
           content: 18966279field
   - Value:
       Field:
@@ -477,7 +477,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: field.leo
+          path: test
           content: 22458638field
   - Value:
       Field:
@@ -486,7 +486,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 857282620field
   - Value:
       Field:
@@ -495,7 +495,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 920675898field
   - Value:
       Field:
@@ -504,7 +504,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 762235516field
   - Value:
       Field:
@@ -513,7 +513,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 469018377field
   - Value:
       Field:
@@ -522,7 +522,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 199986521field
   - Value:
       Field:
@@ -531,7 +531,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 536679358field
   - Value:
       Field:
@@ -540,7 +540,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 591399452field
   - Value:
       Field:
@@ -549,7 +549,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: field.leo
+          path: test
           content: 83083158field
   - Value:
       Field:
@@ -558,7 +558,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 599449051field
   - Value:
       Field:
@@ -567,7 +567,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 445442318field
   - Value:
       Field:
@@ -576,7 +576,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 585486590field
   - Value:
       Field:
@@ -585,7 +585,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 209278800field
   - Value:
       Field:
@@ -594,7 +594,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 873568117field
   - Value:
       Field:
@@ -603,7 +603,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 664470940field
   - Value:
       Field:
@@ -612,7 +612,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 465262783field
   - Value:
       Field:
@@ -621,7 +621,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 605652874field
   - Value:
       Field:
@@ -630,7 +630,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 376803940field
   - Value:
       Field:
@@ -639,7 +639,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 965247040field
   - Value:
       Field:
@@ -648,7 +648,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 598474509field
   - Value:
       Field:
@@ -657,7 +657,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 845119918field
   - Value:
       Field:
@@ -666,7 +666,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 648159133field
   - Value:
       Field:
@@ -675,7 +675,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 669051032field
   - Value:
       Field:
@@ -684,7 +684,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 800600261field
   - Value:
       Field:
@@ -693,7 +693,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 434689764field
   - Value:
       Field:
@@ -702,7 +702,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 520060080field
   - Value:
       Field:
@@ -711,7 +711,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 804659385field
   - Value:
       Field:
@@ -720,7 +720,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 537828058field
   - Value:
       Field:
@@ -729,7 +729,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 716600292field
   - Value:
       Field:
@@ -738,7 +738,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 387020273field
   - Value:
       Field:
@@ -747,7 +747,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 199375617field
   - Value:
       Field:
@@ -756,7 +756,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 680337189field
   - Value:
       Field:
@@ -765,7 +765,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 818479931field
   - Value:
       Field:
@@ -774,7 +774,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 893693281field
   - Value:
       Field:
@@ -783,7 +783,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: field.leo
+          path: test
           content: 87377802field
   - Value:
       Field:
@@ -792,7 +792,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: field.leo
+          path: test
           content: 84699261field
   - Value:
       Field:
@@ -801,7 +801,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 292826090field
   - Value:
       Field:
@@ -810,7 +810,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 569171405field
   - Value:
       Field:
@@ -819,7 +819,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 387436237field
   - Value:
       Field:
@@ -828,7 +828,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 150682190field
   - Value:
       Field:
@@ -837,7 +837,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 888770419field
   - Value:
       Field:
@@ -846,7 +846,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 824696431field
   - Value:
       Field:
@@ -855,7 +855,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 765659803field
   - Value:
       Field:
@@ -864,7 +864,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 270163693field
   - Value:
       Field:
@@ -873,7 +873,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 427940240field
   - Value:
       Field:
@@ -882,7 +882,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 504997332field
   - Value:
       Field:
@@ -891,7 +891,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 337808338field
   - Value:
       Field:
@@ -900,7 +900,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 907200008field
   - Value:
       Field:
@@ -909,7 +909,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 757177889field
   - Value:
       Field:
@@ -918,7 +918,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 696697188field
   - Value:
       Field:
@@ -927,7 +927,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: field.leo
+          path: test
           content: 41376051field
   - Value:
       Field:
@@ -936,7 +936,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 496293518field
   - Value:
       Field:
@@ -945,5 +945,5 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 15
-          path: field.leo
+          path: test
           content: 251218820field

tests/expectations/parser/parser/expression/literal/int_parse/i128.leo.out

@@ -10,7 +10,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 8
-          path: i128.leo
+          path: test
           content: 123i128
   - Value:
       Implicit:
@@ -19,7 +19,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 4
-          path: i128.leo
+          path: test
           content: "123"
   - Value:
       Integer:
@@ -29,7 +29,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 8
-          path: i128.leo
+          path: test
           content: 456i128
   - Value:
       Integer:
@@ -39,7 +39,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 85
-          path: i128.leo
+          path: test
           content: 87377802873778028737780287377802873778028737780287377802873778028737780287377802i128
   - Value:
       Integer:
@@ -49,7 +49,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 405
-          path: i128.leo
+          path: test
           content: 8737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802i128
   - Value:
       Integer:
@@ -59,7 +59,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 340130024i128
   - Value:
       Integer:
@@ -69,7 +69,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 158951116i128
   - Value:
       Integer:
@@ -79,7 +79,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 155529659i128
   - Value:
       Integer:
@@ -89,7 +89,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 642023166i128
   - Value:
       Integer:
@@ -99,7 +99,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 228481736i128
   - Value:
       Integer:
@@ -109,7 +109,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 469712960i128
   - Value:
       Integer:
@@ -119,7 +119,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 929437719i128
   - Value:
       Integer:
@@ -129,7 +129,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 721072814i128
   - Value:
       Integer:
@@ -139,7 +139,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 363254789i128
   - Value:
       Integer:
@@ -149,7 +149,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 906732565i128
   - Value:
       Integer:
@@ -159,7 +159,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 288246391i128
   - Value:
       Integer:
@@ -169,7 +169,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 724940549i128
   - Value:
       Integer:
@@ -179,7 +179,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 487101620i128
   - Value:
       Integer:
@@ -189,7 +189,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 261373583i128
   - Value:
       Integer:
@@ -199,7 +199,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 891163927i128
   - Value:
       Integer:
@@ -209,7 +209,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 743967544i128
   - Value:
       Integer:
@@ -219,7 +219,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i128.leo
+          path: test
           content: 8372586i128
   - Value:
       Integer:
@@ -229,7 +229,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 461793278i128
   - Value:
       Integer:
@@ -239,7 +239,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 806307045i128
   - Value:
       Integer:
@@ -249,7 +249,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 122764546i128
   - Value:
       Integer:
@@ -259,7 +259,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 356336181i128
   - Value:
       Integer:
@@ -269,7 +269,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 158370903i128
   - Value:
       Integer:
@@ -279,7 +279,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 774460877i128
   - Value:
       Integer:
@@ -289,7 +289,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 557174131i128
   - Value:
       Integer:
@@ -299,7 +299,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 492401267i128
   - Value:
       Integer:
@@ -309,7 +309,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 893445620i128
   - Value:
       Integer:
@@ -319,7 +319,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 957757048i128
   - Value:
       Integer:
@@ -329,7 +329,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 721540649i128
   - Value:
       Integer:
@@ -339,7 +339,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 390746493i128
   - Value:
       Integer:
@@ -349,7 +349,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 211251725i128
   - Value:
       Integer:
@@ -359,7 +359,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 938266114i128
   - Value:
       Integer:
@@ -369,7 +369,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 156985870i128
   - Value:
       Integer:
@@ -379,7 +379,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 703831126i128
   - Value:
       Integer:
@@ -389,7 +389,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 729964155i128
   - Value:
       Integer:
@@ -399,7 +399,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 988151305i128
   - Value:
       Integer:
@@ -409,7 +409,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 320872435i128
   - Value:
       Integer:
@@ -419,7 +419,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 719287167i128
   - Value:
       Integer:
@@ -429,7 +429,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 152289486i128
   - Value:
       Integer:
@@ -439,7 +439,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 740067975i128
   - Value:
       Integer:
@@ -449,7 +449,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 728627816i128
   - Value:
       Integer:
@@ -459,7 +459,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 385008978i128
   - Value:
       Integer:
@@ -469,7 +469,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 553967635i128
   - Value:
       Integer:
@@ -479,7 +479,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i128.leo
+          path: test
           content: 71980713i128
   - Value:
       Integer:
@@ -489,7 +489,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 519444716i128
   - Value:
       Integer:
@@ -499,7 +499,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 116499965i128
   - Value:
       Integer:
@@ -509,7 +509,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 717422268i128
   - Value:
       Integer:
@@ -519,7 +519,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i128.leo
+          path: test
           content: 18966279i128
   - Value:
       Integer:
@@ -529,7 +529,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i128.leo
+          path: test
           content: 22458638i128
   - Value:
       Integer:
@@ -539,7 +539,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 857282620i128
   - Value:
       Integer:
@@ -549,7 +549,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 920675898i128
   - Value:
       Integer:
@@ -559,7 +559,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 762235516i128
   - Value:
       Integer:
@@ -569,7 +569,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 469018377i128
   - Value:
       Integer:
@@ -579,7 +579,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 199986521i128
   - Value:
       Integer:
@@ -589,7 +589,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 536679358i128
   - Value:
       Integer:
@@ -599,7 +599,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 591399452i128
   - Value:
       Integer:
@@ -609,7 +609,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i128.leo
+          path: test
           content: 83083158i128
   - Value:
       Integer:
@@ -619,7 +619,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 599449051i128
   - Value:
       Integer:
@@ -629,7 +629,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 445442318i128
   - Value:
       Integer:
@@ -639,7 +639,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 585486590i128
   - Value:
       Integer:
@@ -649,7 +649,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 209278800i128
   - Value:
       Integer:
@@ -659,7 +659,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 873568117i128
   - Value:
       Integer:
@@ -669,7 +669,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 664470940i128
   - Value:
       Integer:
@@ -679,7 +679,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 465262783i128
   - Value:
       Integer:
@@ -689,7 +689,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 605652874i128
   - Value:
       Integer:
@@ -699,7 +699,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 376803940i128
   - Value:
       Integer:
@@ -709,7 +709,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 965247040i128
   - Value:
       Integer:
@@ -719,7 +719,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 598474509i128
   - Value:
       Integer:
@@ -729,7 +729,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 845119918i128
   - Value:
       Integer:
@@ -739,7 +739,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 648159133i128
   - Value:
       Integer:
@@ -749,7 +749,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 669051032i128
   - Value:
       Integer:
@@ -759,7 +759,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 800600261i128
   - Value:
       Integer:
@@ -769,7 +769,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 434689764i128
   - Value:
       Integer:
@@ -779,7 +779,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 520060080i128
   - Value:
       Integer:
@@ -789,7 +789,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 804659385i128
   - Value:
       Integer:
@@ -799,7 +799,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 537828058i128
   - Value:
       Integer:
@@ -809,7 +809,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 716600292i128
   - Value:
       Integer:
@@ -819,7 +819,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 387020273i128
   - Value:
       Integer:
@@ -829,7 +829,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 199375617i128
   - Value:
       Integer:
@@ -839,7 +839,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 680337189i128
   - Value:
       Integer:
@@ -849,7 +849,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 818479931i128
   - Value:
       Integer:
@@ -859,7 +859,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 893693281i128
   - Value:
       Integer:
@@ -869,7 +869,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i128.leo
+          path: test
           content: 87377802i128
   - Value:
       Integer:
@@ -879,7 +879,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i128.leo
+          path: test
           content: 84699261i128
   - Value:
       Integer:
@@ -889,7 +889,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 292826090i128
   - Value:
       Integer:
@@ -899,7 +899,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 569171405i128
   - Value:
       Integer:
@@ -909,7 +909,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 387436237i128
   - Value:
       Integer:
@@ -919,7 +919,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 150682190i128
   - Value:
       Integer:
@@ -929,7 +929,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 888770419i128
   - Value:
       Integer:
@@ -939,7 +939,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 824696431i128
   - Value:
       Integer:
@@ -949,7 +949,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 765659803i128
   - Value:
       Integer:
@@ -959,7 +959,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 270163693i128
   - Value:
       Integer:
@@ -969,7 +969,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 427940240i128
   - Value:
       Integer:
@@ -979,7 +979,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 504997332i128
   - Value:
       Integer:
@@ -989,7 +989,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 337808338i128
   - Value:
       Integer:
@@ -999,7 +999,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 907200008i128
   - Value:
       Integer:
@@ -1009,7 +1009,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 757177889i128
   - Value:
       Integer:
@@ -1019,7 +1019,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 696697188i128
   - Value:
       Integer:
@@ -1029,7 +1029,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i128.leo
+          path: test
           content: 41376051i128
   - Value:
       Integer:
@@ -1039,7 +1039,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 496293518i128
   - Value:
       Integer:
@@ -1049,5 +1049,5 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: i128.leo
+          path: test
           content: 251218820i128

tests/expectations/parser/parser/expression/literal/int_parse/i16.leo.out

@@ -10,7 +10,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 7
-          path: i16.leo
+          path: test
           content: 123i16
   - Value:
       Implicit:
@@ -19,7 +19,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 4
-          path: i16.leo
+          path: test
           content: "123"
   - Value:
       Integer:
@@ -29,7 +29,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 7
-          path: i16.leo
+          path: test
           content: 456i16
   - Value:
       Integer:
@@ -39,7 +39,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 84
-          path: i16.leo
+          path: test
           content: 87377802873778028737780287377802873778028737780287377802873778028737780287377802i16
   - Value:
       Integer:
@@ -49,7 +49,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 404
-          path: i16.leo
+          path: test
           content: 8737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802i16
   - Value:
       Integer:
@@ -59,7 +59,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 340130024i16
   - Value:
       Integer:
@@ -69,7 +69,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 158951116i16
   - Value:
       Integer:
@@ -79,7 +79,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 155529659i16
   - Value:
       Integer:
@@ -89,7 +89,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 642023166i16
   - Value:
       Integer:
@@ -99,7 +99,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 228481736i16
   - Value:
       Integer:
@@ -109,7 +109,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 469712960i16
   - Value:
       Integer:
@@ -119,7 +119,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 929437719i16
   - Value:
       Integer:
@@ -129,7 +129,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 721072814i16
   - Value:
       Integer:
@@ -139,7 +139,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 363254789i16
   - Value:
       Integer:
@@ -149,7 +149,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 906732565i16
   - Value:
       Integer:
@@ -159,7 +159,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 288246391i16
   - Value:
       Integer:
@@ -169,7 +169,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 724940549i16
   - Value:
       Integer:
@@ -179,7 +179,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 487101620i16
   - Value:
       Integer:
@@ -189,7 +189,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 261373583i16
   - Value:
       Integer:
@@ -199,7 +199,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 891163927i16
   - Value:
       Integer:
@@ -209,7 +209,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 743967544i16
   - Value:
       Integer:
@@ -219,7 +219,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 11
-          path: i16.leo
+          path: test
           content: 8372586i16
   - Value:
       Integer:
@@ -229,7 +229,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 461793278i16
   - Value:
       Integer:
@@ -239,7 +239,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 806307045i16
   - Value:
       Integer:
@@ -249,7 +249,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 122764546i16
   - Value:
       Integer:
@@ -259,7 +259,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 356336181i16
   - Value:
       Integer:
@@ -269,7 +269,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 158370903i16
   - Value:
       Integer:
@@ -279,7 +279,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 774460877i16
   - Value:
       Integer:
@@ -289,7 +289,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 557174131i16
   - Value:
       Integer:
@@ -299,7 +299,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 492401267i16
   - Value:
       Integer:
@@ -309,7 +309,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 893445620i16
   - Value:
       Integer:
@@ -319,7 +319,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 957757048i16
   - Value:
       Integer:
@@ -329,7 +329,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 721540649i16
   - Value:
       Integer:
@@ -339,7 +339,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 390746493i16
   - Value:
       Integer:
@@ -349,7 +349,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 211251725i16
   - Value:
       Integer:
@@ -359,7 +359,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 938266114i16
   - Value:
       Integer:
@@ -369,7 +369,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 156985870i16
   - Value:
       Integer:
@@ -379,7 +379,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 703831126i16
   - Value:
       Integer:
@@ -389,7 +389,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 729964155i16
   - Value:
       Integer:
@@ -399,7 +399,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 988151305i16
   - Value:
       Integer:
@@ -409,7 +409,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 320872435i16
   - Value:
       Integer:
@@ -419,7 +419,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 719287167i16
   - Value:
       Integer:
@@ -429,7 +429,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 152289486i16
   - Value:
       Integer:
@@ -439,7 +439,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 740067975i16
   - Value:
       Integer:
@@ -449,7 +449,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 728627816i16
   - Value:
       Integer:
@@ -459,7 +459,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 385008978i16
   - Value:
       Integer:
@@ -469,7 +469,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 553967635i16
   - Value:
       Integer:
@@ -479,7 +479,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i16.leo
+          path: test
           content: 71980713i16
   - Value:
       Integer:
@@ -489,7 +489,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 519444716i16
   - Value:
       Integer:
@@ -499,7 +499,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 116499965i16
   - Value:
       Integer:
@@ -509,7 +509,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 717422268i16
   - Value:
       Integer:
@@ -519,7 +519,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i16.leo
+          path: test
           content: 18966279i16
   - Value:
       Integer:
@@ -529,7 +529,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i16.leo
+          path: test
           content: 22458638i16
   - Value:
       Integer:
@@ -539,7 +539,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 857282620i16
   - Value:
       Integer:
@@ -549,7 +549,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 920675898i16
   - Value:
       Integer:
@@ -559,7 +559,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 762235516i16
   - Value:
       Integer:
@@ -569,7 +569,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 469018377i16
   - Value:
       Integer:
@@ -579,7 +579,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 199986521i16
   - Value:
       Integer:
@@ -589,7 +589,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 536679358i16
   - Value:
       Integer:
@@ -599,7 +599,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 591399452i16
   - Value:
       Integer:
@@ -609,7 +609,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i16.leo
+          path: test
           content: 83083158i16
   - Value:
       Integer:
@@ -619,7 +619,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 599449051i16
   - Value:
       Integer:
@@ -629,7 +629,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 445442318i16
   - Value:
       Integer:
@@ -639,7 +639,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 585486590i16
   - Value:
       Integer:
@@ -649,7 +649,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 209278800i16
   - Value:
       Integer:
@@ -659,7 +659,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 873568117i16
   - Value:
       Integer:
@@ -669,7 +669,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 664470940i16
   - Value:
       Integer:
@@ -679,7 +679,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 465262783i16
   - Value:
       Integer:
@@ -689,7 +689,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 605652874i16
   - Value:
       Integer:
@@ -699,7 +699,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 376803940i16
   - Value:
       Integer:
@@ -709,7 +709,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 965247040i16
   - Value:
       Integer:
@@ -719,7 +719,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 598474509i16
   - Value:
       Integer:
@@ -729,7 +729,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 845119918i16
   - Value:
       Integer:
@@ -739,7 +739,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 648159133i16
   - Value:
       Integer:
@@ -749,7 +749,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 669051032i16
   - Value:
       Integer:
@@ -759,7 +759,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 800600261i16
   - Value:
       Integer:
@@ -769,7 +769,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 434689764i16
   - Value:
       Integer:
@@ -779,7 +779,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 520060080i16
   - Value:
       Integer:
@@ -789,7 +789,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 804659385i16
   - Value:
       Integer:
@@ -799,7 +799,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 537828058i16
   - Value:
       Integer:
@@ -809,7 +809,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 716600292i16
   - Value:
       Integer:
@@ -819,7 +819,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 387020273i16
   - Value:
       Integer:
@@ -829,7 +829,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 199375617i16
   - Value:
       Integer:
@@ -839,7 +839,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 680337189i16
   - Value:
       Integer:
@@ -849,7 +849,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 818479931i16
   - Value:
       Integer:
@@ -859,7 +859,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 893693281i16
   - Value:
       Integer:
@@ -869,7 +869,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i16.leo
+          path: test
           content: 87377802i16
   - Value:
       Integer:
@@ -879,7 +879,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i16.leo
+          path: test
           content: 84699261i16
   - Value:
       Integer:
@@ -889,7 +889,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 292826090i16
   - Value:
       Integer:
@@ -899,7 +899,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 569171405i16
   - Value:
       Integer:
@@ -909,7 +909,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 387436237i16
   - Value:
       Integer:
@@ -919,7 +919,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 150682190i16
   - Value:
       Integer:
@@ -929,7 +929,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 888770419i16
   - Value:
       Integer:
@@ -939,7 +939,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 824696431i16
   - Value:
       Integer:
@@ -949,7 +949,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 765659803i16
   - Value:
       Integer:
@@ -959,7 +959,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 270163693i16
   - Value:
       Integer:
@@ -969,7 +969,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 427940240i16
   - Value:
       Integer:
@@ -979,7 +979,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 504997332i16
   - Value:
       Integer:
@@ -989,7 +989,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 337808338i16
   - Value:
       Integer:
@@ -999,7 +999,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 907200008i16
   - Value:
       Integer:
@@ -1009,7 +1009,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 757177889i16
   - Value:
       Integer:
@@ -1019,7 +1019,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 696697188i16
   - Value:
       Integer:
@@ -1029,7 +1029,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i16.leo
+          path: test
           content: 41376051i16
   - Value:
       Integer:
@@ -1039,7 +1039,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 496293518i16
   - Value:
       Integer:
@@ -1049,5 +1049,5 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i16.leo
+          path: test
           content: 251218820i16

tests/expectations/parser/parser/expression/literal/int_parse/i32.leo.out

@@ -10,7 +10,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 7
-          path: i32.leo
+          path: test
           content: 123i32
   - Value:
       Implicit:
@@ -19,7 +19,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 4
-          path: i32.leo
+          path: test
           content: "123"
   - Value:
       Integer:
@@ -29,7 +29,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 7
-          path: i32.leo
+          path: test
           content: 456i32
   - Value:
       Integer:
@@ -39,7 +39,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 84
-          path: i32.leo
+          path: test
           content: 87377802873778028737780287377802873778028737780287377802873778028737780287377802i32
   - Value:
       Integer:
@@ -49,7 +49,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 404
-          path: i32.leo
+          path: test
           content: 8737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802i32
   - Value:
       Integer:
@@ -59,7 +59,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 340130024i32
   - Value:
       Integer:
@@ -69,7 +69,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 158951116i32
   - Value:
       Integer:
@@ -79,7 +79,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 155529659i32
   - Value:
       Integer:
@@ -89,7 +89,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 642023166i32
   - Value:
       Integer:
@@ -99,7 +99,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 228481736i32
   - Value:
       Integer:
@@ -109,7 +109,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 469712960i32
   - Value:
       Integer:
@@ -119,7 +119,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 929437719i32
   - Value:
       Integer:
@@ -129,7 +129,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 721072814i32
   - Value:
       Integer:
@@ -139,7 +139,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 363254789i32
   - Value:
       Integer:
@@ -149,7 +149,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 906732565i32
   - Value:
       Integer:
@@ -159,7 +159,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 288246391i32
   - Value:
       Integer:
@@ -169,7 +169,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 724940549i32
   - Value:
       Integer:
@@ -179,7 +179,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 487101620i32
   - Value:
       Integer:
@@ -189,7 +189,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 261373583i32
   - Value:
       Integer:
@@ -199,7 +199,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 891163927i32
   - Value:
       Integer:
@@ -209,7 +209,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 743967544i32
   - Value:
       Integer:
@@ -219,7 +219,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 11
-          path: i32.leo
+          path: test
           content: 8372586i32
   - Value:
       Integer:
@@ -229,7 +229,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 461793278i32
   - Value:
       Integer:
@@ -239,7 +239,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 806307045i32
   - Value:
       Integer:
@@ -249,7 +249,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 122764546i32
   - Value:
       Integer:
@@ -259,7 +259,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 356336181i32
   - Value:
       Integer:
@@ -269,7 +269,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 158370903i32
   - Value:
       Integer:
@@ -279,7 +279,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 774460877i32
   - Value:
       Integer:
@@ -289,7 +289,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 557174131i32
   - Value:
       Integer:
@@ -299,7 +299,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 492401267i32
   - Value:
       Integer:
@@ -309,7 +309,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 893445620i32
   - Value:
       Integer:
@@ -319,7 +319,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 957757048i32
   - Value:
       Integer:
@@ -329,7 +329,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 721540649i32
   - Value:
       Integer:
@@ -339,7 +339,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 390746493i32
   - Value:
       Integer:
@@ -349,7 +349,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 211251725i32
   - Value:
       Integer:
@@ -359,7 +359,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 938266114i32
   - Value:
       Integer:
@@ -369,7 +369,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 156985870i32
   - Value:
       Integer:
@@ -379,7 +379,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 703831126i32
   - Value:
       Integer:
@@ -389,7 +389,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 729964155i32
   - Value:
       Integer:
@@ -399,7 +399,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 988151305i32
   - Value:
       Integer:
@@ -409,7 +409,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 320872435i32
   - Value:
       Integer:
@@ -419,7 +419,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 719287167i32
   - Value:
       Integer:
@@ -429,7 +429,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 152289486i32
   - Value:
       Integer:
@@ -439,7 +439,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 740067975i32
   - Value:
       Integer:
@@ -449,7 +449,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 728627816i32
   - Value:
       Integer:
@@ -459,7 +459,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 385008978i32
   - Value:
       Integer:
@@ -469,7 +469,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 553967635i32
   - Value:
       Integer:
@@ -479,7 +479,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i32.leo
+          path: test
           content: 71980713i32
   - Value:
       Integer:
@@ -489,7 +489,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 519444716i32
   - Value:
       Integer:
@@ -499,7 +499,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 116499965i32
   - Value:
       Integer:
@@ -509,7 +509,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 717422268i32
   - Value:
       Integer:
@@ -519,7 +519,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i32.leo
+          path: test
           content: 18966279i32
   - Value:
       Integer:
@@ -529,7 +529,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i32.leo
+          path: test
           content: 22458638i32
   - Value:
       Integer:
@@ -539,7 +539,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 857282620i32
   - Value:
       Integer:
@@ -549,7 +549,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 920675898i32
   - Value:
       Integer:
@@ -559,7 +559,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 762235516i32
   - Value:
       Integer:
@@ -569,7 +569,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 469018377i32
   - Value:
       Integer:
@@ -579,7 +579,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 199986521i32
   - Value:
       Integer:
@@ -589,7 +589,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 536679358i32
   - Value:
       Integer:
@@ -599,7 +599,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 591399452i32
   - Value:
       Integer:
@@ -609,7 +609,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i32.leo
+          path: test
           content: 83083158i32
   - Value:
       Integer:
@@ -619,7 +619,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 599449051i32
   - Value:
       Integer:
@@ -629,7 +629,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 445442318i32
   - Value:
       Integer:
@@ -639,7 +639,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 585486590i32
   - Value:
       Integer:
@@ -649,7 +649,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 209278800i32
   - Value:
       Integer:
@@ -659,7 +659,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 873568117i32
   - Value:
       Integer:
@@ -669,7 +669,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 664470940i32
   - Value:
       Integer:
@@ -679,7 +679,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 465262783i32
   - Value:
       Integer:
@@ -689,7 +689,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 605652874i32
   - Value:
       Integer:
@@ -699,7 +699,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 376803940i32
   - Value:
       Integer:
@@ -709,7 +709,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 965247040i32
   - Value:
       Integer:
@@ -719,7 +719,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 598474509i32
   - Value:
       Integer:
@@ -729,7 +729,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 845119918i32
   - Value:
       Integer:
@@ -739,7 +739,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 648159133i32
   - Value:
       Integer:
@@ -749,7 +749,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 669051032i32
   - Value:
       Integer:
@@ -759,7 +759,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 800600261i32
   - Value:
       Integer:
@@ -769,7 +769,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 434689764i32
   - Value:
       Integer:
@@ -779,7 +779,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 520060080i32
   - Value:
       Integer:
@@ -789,7 +789,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 804659385i32
   - Value:
       Integer:
@@ -799,7 +799,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 537828058i32
   - Value:
       Integer:
@@ -809,7 +809,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 716600292i32
   - Value:
       Integer:
@@ -819,7 +819,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 387020273i32
   - Value:
       Integer:
@@ -829,7 +829,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 199375617i32
   - Value:
       Integer:
@@ -839,7 +839,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 680337189i32
   - Value:
       Integer:
@@ -849,7 +849,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 818479931i32
   - Value:
       Integer:
@@ -859,7 +859,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 893693281i32
   - Value:
       Integer:
@@ -869,7 +869,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i32.leo
+          path: test
           content: 87377802i32
   - Value:
       Integer:
@@ -879,7 +879,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i32.leo
+          path: test
           content: 84699261i32
   - Value:
       Integer:
@@ -889,7 +889,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 292826090i32
   - Value:
       Integer:
@@ -899,7 +899,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 569171405i32
   - Value:
       Integer:
@@ -909,7 +909,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 387436237i32
   - Value:
       Integer:
@@ -919,7 +919,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 150682190i32
   - Value:
       Integer:
@@ -929,7 +929,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 888770419i32
   - Value:
       Integer:
@@ -939,7 +939,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 824696431i32
   - Value:
       Integer:
@@ -949,7 +949,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 765659803i32
   - Value:
       Integer:
@@ -959,7 +959,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 270163693i32
   - Value:
       Integer:
@@ -969,7 +969,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 427940240i32
   - Value:
       Integer:
@@ -979,7 +979,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 504997332i32
   - Value:
       Integer:
@@ -989,7 +989,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 337808338i32
   - Value:
       Integer:
@@ -999,7 +999,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 907200008i32
   - Value:
       Integer:
@@ -1009,7 +1009,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 757177889i32
   - Value:
       Integer:
@@ -1019,7 +1019,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 696697188i32
   - Value:
       Integer:
@@ -1029,7 +1029,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i32.leo
+          path: test
           content: 41376051i32
   - Value:
       Integer:
@@ -1039,7 +1039,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 496293518i32
   - Value:
       Integer:
@@ -1049,5 +1049,5 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i32.leo
+          path: test
           content: 251218820i32

tests/expectations/parser/parser/expression/literal/int_parse/i64.leo.out

@@ -10,7 +10,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 7
-          path: i64.leo
+          path: test
           content: 123i64
   - Value:
       Implicit:
@@ -19,7 +19,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 4
-          path: i64.leo
+          path: test
           content: "123"
   - Value:
       Integer:
@@ -29,7 +29,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 7
-          path: i64.leo
+          path: test
           content: 456i64
   - Value:
       Integer:
@@ -39,7 +39,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 84
-          path: i64.leo
+          path: test
           content: 87377802873778028737780287377802873778028737780287377802873778028737780287377802i64
   - Value:
       Integer:
@@ -49,7 +49,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 404
-          path: i64.leo
+          path: test
           content: 8737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802i64
   - Value:
       Integer:
@@ -59,7 +59,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 340130024i64
   - Value:
       Integer:
@@ -69,7 +69,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 158951116i64
   - Value:
       Integer:
@@ -79,7 +79,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 155529659i64
   - Value:
       Integer:
@@ -89,7 +89,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 642023166i64
   - Value:
       Integer:
@@ -99,7 +99,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 228481736i64
   - Value:
       Integer:
@@ -109,7 +109,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 469712960i64
   - Value:
       Integer:
@@ -119,7 +119,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 929437719i64
   - Value:
       Integer:
@@ -129,7 +129,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 721072814i64
   - Value:
       Integer:
@@ -139,7 +139,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 363254789i64
   - Value:
       Integer:
@@ -149,7 +149,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 906732565i64
   - Value:
       Integer:
@@ -159,7 +159,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 288246391i64
   - Value:
       Integer:
@@ -169,7 +169,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 724940549i64
   - Value:
       Integer:
@@ -179,7 +179,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 487101620i64
   - Value:
       Integer:
@@ -189,7 +189,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 261373583i64
   - Value:
       Integer:
@@ -199,7 +199,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 891163927i64
   - Value:
       Integer:
@@ -209,7 +209,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 743967544i64
   - Value:
       Integer:
@@ -219,7 +219,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 11
-          path: i64.leo
+          path: test
           content: 8372586i64
   - Value:
       Integer:
@@ -229,7 +229,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 461793278i64
   - Value:
       Integer:
@@ -239,7 +239,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 806307045i64
   - Value:
       Integer:
@@ -249,7 +249,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 122764546i64
   - Value:
       Integer:
@@ -259,7 +259,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 356336181i64
   - Value:
       Integer:
@@ -269,7 +269,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 158370903i64
   - Value:
       Integer:
@@ -279,7 +279,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 774460877i64
   - Value:
       Integer:
@@ -289,7 +289,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 557174131i64
   - Value:
       Integer:
@@ -299,7 +299,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 492401267i64
   - Value:
       Integer:
@@ -309,7 +309,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 893445620i64
   - Value:
       Integer:
@@ -319,7 +319,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 957757048i64
   - Value:
       Integer:
@@ -329,7 +329,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 721540649i64
   - Value:
       Integer:
@@ -339,7 +339,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 390746493i64
   - Value:
       Integer:
@@ -349,7 +349,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 211251725i64
   - Value:
       Integer:
@@ -359,7 +359,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 938266114i64
   - Value:
       Integer:
@@ -369,7 +369,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 156985870i64
   - Value:
       Integer:
@@ -379,7 +379,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 703831126i64
   - Value:
       Integer:
@@ -389,7 +389,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 729964155i64
   - Value:
       Integer:
@@ -399,7 +399,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 988151305i64
   - Value:
       Integer:
@@ -409,7 +409,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 320872435i64
   - Value:
       Integer:
@@ -419,7 +419,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 719287167i64
   - Value:
       Integer:
@@ -429,7 +429,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 152289486i64
   - Value:
       Integer:
@@ -439,7 +439,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 740067975i64
   - Value:
       Integer:
@@ -449,7 +449,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 728627816i64
   - Value:
       Integer:
@@ -459,7 +459,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 385008978i64
   - Value:
       Integer:
@@ -469,7 +469,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 553967635i64
   - Value:
       Integer:
@@ -479,7 +479,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i64.leo
+          path: test
           content: 71980713i64
   - Value:
       Integer:
@@ -489,7 +489,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 519444716i64
   - Value:
       Integer:
@@ -499,7 +499,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 116499965i64
   - Value:
       Integer:
@@ -509,7 +509,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 717422268i64
   - Value:
       Integer:
@@ -519,7 +519,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i64.leo
+          path: test
           content: 18966279i64
   - Value:
       Integer:
@@ -529,7 +529,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i64.leo
+          path: test
           content: 22458638i64
   - Value:
       Integer:
@@ -539,7 +539,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 857282620i64
   - Value:
       Integer:
@@ -549,7 +549,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 920675898i64
   - Value:
       Integer:
@@ -559,7 +559,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 762235516i64
   - Value:
       Integer:
@@ -569,7 +569,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 469018377i64
   - Value:
       Integer:
@@ -579,7 +579,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 199986521i64
   - Value:
       Integer:
@@ -589,7 +589,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 536679358i64
   - Value:
       Integer:
@@ -599,7 +599,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 591399452i64
   - Value:
       Integer:
@@ -609,7 +609,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i64.leo
+          path: test
           content: 83083158i64
   - Value:
       Integer:
@@ -619,7 +619,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 599449051i64
   - Value:
       Integer:
@@ -629,7 +629,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 445442318i64
   - Value:
       Integer:
@@ -639,7 +639,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 585486590i64
   - Value:
       Integer:
@@ -649,7 +649,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 209278800i64
   - Value:
       Integer:
@@ -659,7 +659,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 873568117i64
   - Value:
       Integer:
@@ -669,7 +669,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 664470940i64
   - Value:
       Integer:
@@ -679,7 +679,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 465262783i64
   - Value:
       Integer:
@@ -689,7 +689,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 605652874i64
   - Value:
       Integer:
@@ -699,7 +699,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 376803940i64
   - Value:
       Integer:
@@ -709,7 +709,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 965247040i64
   - Value:
       Integer:
@@ -719,7 +719,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 598474509i64
   - Value:
       Integer:
@@ -729,7 +729,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 845119918i64
   - Value:
       Integer:
@@ -739,7 +739,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 648159133i64
   - Value:
       Integer:
@@ -749,7 +749,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 669051032i64
   - Value:
       Integer:
@@ -759,7 +759,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 800600261i64
   - Value:
       Integer:
@@ -769,7 +769,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 434689764i64
   - Value:
       Integer:
@@ -779,7 +779,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 520060080i64
   - Value:
       Integer:
@@ -789,7 +789,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 804659385i64
   - Value:
       Integer:
@@ -799,7 +799,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 537828058i64
   - Value:
       Integer:
@@ -809,7 +809,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 716600292i64
   - Value:
       Integer:
@@ -819,7 +819,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 387020273i64
   - Value:
       Integer:
@@ -829,7 +829,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 199375617i64
   - Value:
       Integer:
@@ -839,7 +839,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 680337189i64
   - Value:
       Integer:
@@ -849,7 +849,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 818479931i64
   - Value:
       Integer:
@@ -859,7 +859,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 893693281i64
   - Value:
       Integer:
@@ -869,7 +869,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i64.leo
+          path: test
           content: 87377802i64
   - Value:
       Integer:
@@ -879,7 +879,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i64.leo
+          path: test
           content: 84699261i64
   - Value:
       Integer:
@@ -889,7 +889,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 292826090i64
   - Value:
       Integer:
@@ -899,7 +899,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 569171405i64
   - Value:
       Integer:
@@ -909,7 +909,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 387436237i64
   - Value:
       Integer:
@@ -919,7 +919,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 150682190i64
   - Value:
       Integer:
@@ -929,7 +929,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 888770419i64
   - Value:
       Integer:
@@ -939,7 +939,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 824696431i64
   - Value:
       Integer:
@@ -949,7 +949,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 765659803i64
   - Value:
       Integer:
@@ -959,7 +959,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 270163693i64
   - Value:
       Integer:
@@ -969,7 +969,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 427940240i64
   - Value:
       Integer:
@@ -979,7 +979,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 504997332i64
   - Value:
       Integer:
@@ -989,7 +989,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 337808338i64
   - Value:
       Integer:
@@ -999,7 +999,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 907200008i64
   - Value:
       Integer:
@@ -1009,7 +1009,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 757177889i64
   - Value:
       Integer:
@@ -1019,7 +1019,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 696697188i64
   - Value:
       Integer:
@@ -1029,7 +1029,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i64.leo
+          path: test
           content: 41376051i64
   - Value:
       Integer:
@@ -1039,7 +1039,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 496293518i64
   - Value:
       Integer:
@@ -1049,5 +1049,5 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: i64.leo
+          path: test
           content: 251218820i64

tests/expectations/parser/parser/expression/literal/int_parse/i8.leo.out

@@ -10,7 +10,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 6
-          path: i8.leo
+          path: test
           content: 123i8
   - Value:
       Implicit:
@@ -19,7 +19,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 4
-          path: i8.leo
+          path: test
           content: "123"
   - Value:
       Integer:
@@ -29,7 +29,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 6
-          path: i8.leo
+          path: test
           content: 456i8
   - Value:
       Integer:
@@ -39,7 +39,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 83
-          path: i8.leo
+          path: test
           content: 87377802873778028737780287377802873778028737780287377802873778028737780287377802i8
   - Value:
       Integer:
@@ -49,7 +49,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 403
-          path: i8.leo
+          path: test
           content: 8737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802i8
   - Value:
       Integer:
@@ -59,7 +59,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 340130024i8
   - Value:
       Integer:
@@ -69,7 +69,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 158951116i8
   - Value:
       Integer:
@@ -79,7 +79,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 155529659i8
   - Value:
       Integer:
@@ -89,7 +89,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 642023166i8
   - Value:
       Integer:
@@ -99,7 +99,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 228481736i8
   - Value:
       Integer:
@@ -109,7 +109,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 469712960i8
   - Value:
       Integer:
@@ -119,7 +119,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 929437719i8
   - Value:
       Integer:
@@ -129,7 +129,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 721072814i8
   - Value:
       Integer:
@@ -139,7 +139,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 363254789i8
   - Value:
       Integer:
@@ -149,7 +149,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 906732565i8
   - Value:
       Integer:
@@ -159,7 +159,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 288246391i8
   - Value:
       Integer:
@@ -169,7 +169,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 724940549i8
   - Value:
       Integer:
@@ -179,7 +179,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 487101620i8
   - Value:
       Integer:
@@ -189,7 +189,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 261373583i8
   - Value:
       Integer:
@@ -199,7 +199,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 891163927i8
   - Value:
       Integer:
@@ -209,7 +209,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 743967544i8
   - Value:
       Integer:
@@ -219,7 +219,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: i8.leo
+          path: test
           content: 8372586i8
   - Value:
       Integer:
@@ -229,7 +229,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 461793278i8
   - Value:
       Integer:
@@ -239,7 +239,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 806307045i8
   - Value:
       Integer:
@@ -249,7 +249,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 122764546i8
   - Value:
       Integer:
@@ -259,7 +259,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 356336181i8
   - Value:
       Integer:
@@ -269,7 +269,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 158370903i8
   - Value:
       Integer:
@@ -279,7 +279,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 774460877i8
   - Value:
       Integer:
@@ -289,7 +289,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 557174131i8
   - Value:
       Integer:
@@ -299,7 +299,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 492401267i8
   - Value:
       Integer:
@@ -309,7 +309,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 893445620i8
   - Value:
       Integer:
@@ -319,7 +319,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 957757048i8
   - Value:
       Integer:
@@ -329,7 +329,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 721540649i8
   - Value:
       Integer:
@@ -339,7 +339,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 390746493i8
   - Value:
       Integer:
@@ -349,7 +349,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 211251725i8
   - Value:
       Integer:
@@ -359,7 +359,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 938266114i8
   - Value:
       Integer:
@@ -369,7 +369,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 156985870i8
   - Value:
       Integer:
@@ -379,7 +379,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 703831126i8
   - Value:
       Integer:
@@ -389,7 +389,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 729964155i8
   - Value:
       Integer:
@@ -399,7 +399,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 988151305i8
   - Value:
       Integer:
@@ -409,7 +409,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 320872435i8
   - Value:
       Integer:
@@ -419,7 +419,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 719287167i8
   - Value:
       Integer:
@@ -429,7 +429,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 152289486i8
   - Value:
       Integer:
@@ -439,7 +439,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 740067975i8
   - Value:
       Integer:
@@ -449,7 +449,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 728627816i8
   - Value:
       Integer:
@@ -459,7 +459,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 385008978i8
   - Value:
       Integer:
@@ -469,7 +469,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 553967635i8
   - Value:
       Integer:
@@ -479,7 +479,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 11
-          path: i8.leo
+          path: test
           content: 71980713i8
   - Value:
       Integer:
@@ -489,7 +489,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 519444716i8
   - Value:
       Integer:
@@ -499,7 +499,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 116499965i8
   - Value:
       Integer:
@@ -509,7 +509,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 717422268i8
   - Value:
       Integer:
@@ -519,7 +519,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 11
-          path: i8.leo
+          path: test
           content: 18966279i8
   - Value:
       Integer:
@@ -529,7 +529,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 11
-          path: i8.leo
+          path: test
           content: 22458638i8
   - Value:
       Integer:
@@ -539,7 +539,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 857282620i8
   - Value:
       Integer:
@@ -549,7 +549,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 920675898i8
   - Value:
       Integer:
@@ -559,7 +559,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 762235516i8
   - Value:
       Integer:
@@ -569,7 +569,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 469018377i8
   - Value:
       Integer:
@@ -579,7 +579,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 199986521i8
   - Value:
       Integer:
@@ -589,7 +589,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 536679358i8
   - Value:
       Integer:
@@ -599,7 +599,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 591399452i8
   - Value:
       Integer:
@@ -609,7 +609,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 11
-          path: i8.leo
+          path: test
           content: 83083158i8
   - Value:
       Integer:
@@ -619,7 +619,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 599449051i8
   - Value:
       Integer:
@@ -629,7 +629,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 445442318i8
   - Value:
       Integer:
@@ -639,7 +639,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 585486590i8
   - Value:
       Integer:
@@ -649,7 +649,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 209278800i8
   - Value:
       Integer:
@@ -659,7 +659,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 873568117i8
   - Value:
       Integer:
@@ -669,7 +669,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 664470940i8
   - Value:
       Integer:
@@ -679,7 +679,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 465262783i8
   - Value:
       Integer:
@@ -689,7 +689,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 605652874i8
   - Value:
       Integer:
@@ -699,7 +699,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 376803940i8
   - Value:
       Integer:
@@ -709,7 +709,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 965247040i8
   - Value:
       Integer:
@@ -719,7 +719,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 598474509i8
   - Value:
       Integer:
@@ -729,7 +729,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 845119918i8
   - Value:
       Integer:
@@ -739,7 +739,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 648159133i8
   - Value:
       Integer:
@@ -749,7 +749,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 669051032i8
   - Value:
       Integer:
@@ -759,7 +759,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 800600261i8
   - Value:
       Integer:
@@ -769,7 +769,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 434689764i8
   - Value:
       Integer:
@@ -779,7 +779,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 520060080i8
   - Value:
       Integer:
@@ -789,7 +789,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 804659385i8
   - Value:
       Integer:
@@ -799,7 +799,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 537828058i8
   - Value:
       Integer:
@@ -809,7 +809,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 716600292i8
   - Value:
       Integer:
@@ -819,7 +819,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 387020273i8
   - Value:
       Integer:
@@ -829,7 +829,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 199375617i8
   - Value:
       Integer:
@@ -839,7 +839,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 680337189i8
   - Value:
       Integer:
@@ -849,7 +849,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 818479931i8
   - Value:
       Integer:
@@ -859,7 +859,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 893693281i8
   - Value:
       Integer:
@@ -869,7 +869,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 11
-          path: i8.leo
+          path: test
           content: 87377802i8
   - Value:
       Integer:
@@ -879,7 +879,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 11
-          path: i8.leo
+          path: test
           content: 84699261i8
   - Value:
       Integer:
@@ -889,7 +889,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 292826090i8
   - Value:
       Integer:
@@ -899,7 +899,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 569171405i8
   - Value:
       Integer:
@@ -909,7 +909,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 387436237i8
   - Value:
       Integer:
@@ -919,7 +919,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 150682190i8
   - Value:
       Integer:
@@ -929,7 +929,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 888770419i8
   - Value:
       Integer:
@@ -939,7 +939,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 824696431i8
   - Value:
       Integer:
@@ -949,7 +949,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 765659803i8
   - Value:
       Integer:
@@ -959,7 +959,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 270163693i8
   - Value:
       Integer:
@@ -969,7 +969,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 427940240i8
   - Value:
       Integer:
@@ -979,7 +979,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 504997332i8
   - Value:
       Integer:
@@ -989,7 +989,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 337808338i8
   - Value:
       Integer:
@@ -999,7 +999,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 907200008i8
   - Value:
       Integer:
@@ -1009,7 +1009,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 757177889i8
   - Value:
       Integer:
@@ -1019,7 +1019,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 696697188i8
   - Value:
       Integer:
@@ -1029,7 +1029,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 11
-          path: i8.leo
+          path: test
           content: 41376051i8
   - Value:
       Integer:
@@ -1039,7 +1039,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 496293518i8
   - Value:
       Integer:
@@ -1049,5 +1049,5 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: i8.leo
+          path: test
           content: 251218820i8

tests/expectations/parser/parser/expression/literal/int_parse/implicit.leo.out

@@ -9,7 +9,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 4
-          path: implicit.leo
+          path: test
           content: "123"
   - Value:
       Implicit:
@@ -18,7 +18,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 4
-          path: implicit.leo
+          path: test
           content: "123"
   - Value:
       Implicit:
@@ -27,7 +27,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 4
-          path: implicit.leo
+          path: test
           content: "456"
   - Value:
       Implicit:
@@ -36,7 +36,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 81
-          path: implicit.leo
+          path: test
           content: "87377802873778028737780287377802873778028737780287377802873778028737780287377802"
   - Value:
       Implicit:
@@ -45,7 +45,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 401
-          path: implicit.leo
+          path: test
           content: "8737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802"
   - Value:
       Implicit:
@@ -54,7 +54,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "340130024"
   - Value:
       Implicit:
@@ -63,7 +63,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "158951116"
   - Value:
       Implicit:
@@ -72,7 +72,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "155529659"
   - Value:
       Implicit:
@@ -81,7 +81,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "642023166"
   - Value:
       Implicit:
@@ -90,7 +90,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "228481736"
   - Value:
       Implicit:
@@ -99,7 +99,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "469712960"
   - Value:
       Implicit:
@@ -108,7 +108,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "929437719"
   - Value:
       Implicit:
@@ -117,7 +117,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "721072814"
   - Value:
       Implicit:
@@ -126,7 +126,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "363254789"
   - Value:
       Implicit:
@@ -135,7 +135,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "906732565"
   - Value:
       Implicit:
@@ -144,7 +144,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "288246391"
   - Value:
       Implicit:
@@ -153,7 +153,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "724940549"
   - Value:
       Implicit:
@@ -162,7 +162,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "487101620"
   - Value:
       Implicit:
@@ -171,7 +171,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "261373583"
   - Value:
       Implicit:
@@ -180,7 +180,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "891163927"
   - Value:
       Implicit:
@@ -189,7 +189,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "743967544"
   - Value:
       Implicit:
@@ -198,7 +198,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 8
-          path: implicit.leo
+          path: test
           content: "8372586"
   - Value:
       Implicit:
@@ -207,7 +207,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "461793278"
   - Value:
       Implicit:
@@ -216,7 +216,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "806307045"
   - Value:
       Implicit:
@@ -225,7 +225,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "122764546"
   - Value:
       Implicit:
@@ -234,7 +234,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "356336181"
   - Value:
       Implicit:
@@ -243,7 +243,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "158370903"
   - Value:
       Implicit:
@@ -252,7 +252,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "774460877"
   - Value:
       Implicit:
@@ -261,7 +261,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "557174131"
   - Value:
       Implicit:
@@ -270,7 +270,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "492401267"
   - Value:
       Implicit:
@@ -279,7 +279,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "893445620"
   - Value:
       Implicit:
@@ -288,7 +288,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "957757048"
   - Value:
       Implicit:
@@ -297,7 +297,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "721540649"
   - Value:
       Implicit:
@@ -306,7 +306,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "390746493"
   - Value:
       Implicit:
@@ -315,7 +315,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "211251725"
   - Value:
       Implicit:
@@ -324,7 +324,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "938266114"
   - Value:
       Implicit:
@@ -333,7 +333,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "156985870"
   - Value:
       Implicit:
@@ -342,7 +342,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "703831126"
   - Value:
       Implicit:
@@ -351,7 +351,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "729964155"
   - Value:
       Implicit:
@@ -360,7 +360,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "988151305"
   - Value:
       Implicit:
@@ -369,7 +369,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "320872435"
   - Value:
       Implicit:
@@ -378,7 +378,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "719287167"
   - Value:
       Implicit:
@@ -387,7 +387,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "152289486"
   - Value:
       Implicit:
@@ -396,7 +396,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "740067975"
   - Value:
       Implicit:
@@ -405,7 +405,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "728627816"
   - Value:
       Implicit:
@@ -414,7 +414,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "385008978"
   - Value:
       Implicit:
@@ -423,7 +423,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "553967635"
   - Value:
       Implicit:
@@ -432,7 +432,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 9
-          path: implicit.leo
+          path: test
           content: "71980713"
   - Value:
       Implicit:
@@ -441,7 +441,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "519444716"
   - Value:
       Implicit:
@@ -450,7 +450,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "116499965"
   - Value:
       Implicit:
@@ -459,7 +459,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "717422268"
   - Value:
       Implicit:
@@ -468,7 +468,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 9
-          path: implicit.leo
+          path: test
           content: "18966279"
   - Value:
       Implicit:
@@ -477,7 +477,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 9
-          path: implicit.leo
+          path: test
           content: "22458638"
   - Value:
       Implicit:
@@ -486,7 +486,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "857282620"
   - Value:
       Implicit:
@@ -495,7 +495,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "920675898"
   - Value:
       Implicit:
@@ -504,7 +504,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "762235516"
   - Value:
       Implicit:
@@ -513,7 +513,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "469018377"
   - Value:
       Implicit:
@@ -522,7 +522,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "199986521"
   - Value:
       Implicit:
@@ -531,7 +531,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "536679358"
   - Value:
       Implicit:
@@ -540,7 +540,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "591399452"
   - Value:
       Implicit:
@@ -549,7 +549,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 9
-          path: implicit.leo
+          path: test
           content: "83083158"
   - Value:
       Implicit:
@@ -558,7 +558,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "599449051"
   - Value:
       Implicit:
@@ -567,7 +567,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "445442318"
   - Value:
       Implicit:
@@ -576,7 +576,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "585486590"
   - Value:
       Implicit:
@@ -585,7 +585,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "209278800"
   - Value:
       Implicit:
@@ -594,7 +594,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "873568117"
   - Value:
       Implicit:
@@ -603,7 +603,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "664470940"
   - Value:
       Implicit:
@@ -612,7 +612,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "465262783"
   - Value:
       Implicit:
@@ -621,7 +621,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "605652874"
   - Value:
       Implicit:
@@ -630,7 +630,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "376803940"
   - Value:
       Implicit:
@@ -639,7 +639,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "965247040"
   - Value:
       Implicit:
@@ -648,7 +648,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "598474509"
   - Value:
       Implicit:
@@ -657,7 +657,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "845119918"
   - Value:
       Implicit:
@@ -666,7 +666,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "648159133"
   - Value:
       Implicit:
@@ -675,7 +675,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "669051032"
   - Value:
       Implicit:
@@ -684,7 +684,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "800600261"
   - Value:
       Implicit:
@@ -693,7 +693,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "434689764"
   - Value:
       Implicit:
@@ -702,7 +702,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "520060080"
   - Value:
       Implicit:
@@ -711,7 +711,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "804659385"
   - Value:
       Implicit:
@@ -720,7 +720,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "537828058"
   - Value:
       Implicit:
@@ -729,7 +729,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "716600292"
   - Value:
       Implicit:
@@ -738,7 +738,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "387020273"
   - Value:
       Implicit:
@@ -747,7 +747,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "199375617"
   - Value:
       Implicit:
@@ -756,7 +756,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "680337189"
   - Value:
       Implicit:
@@ -765,7 +765,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "818479931"
   - Value:
       Implicit:
@@ -774,7 +774,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "893693281"
   - Value:
       Implicit:
@@ -783,7 +783,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 9
-          path: implicit.leo
+          path: test
           content: "87377802"
   - Value:
       Implicit:
@@ -792,7 +792,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 9
-          path: implicit.leo
+          path: test
           content: "84699261"
   - Value:
       Implicit:
@@ -801,7 +801,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "292826090"
   - Value:
       Implicit:
@@ -810,7 +810,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "569171405"
   - Value:
       Implicit:
@@ -819,7 +819,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "387436237"
   - Value:
       Implicit:
@@ -828,7 +828,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "150682190"
   - Value:
       Implicit:
@@ -837,7 +837,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "888770419"
   - Value:
       Implicit:
@@ -846,7 +846,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "824696431"
   - Value:
       Implicit:
@@ -855,7 +855,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "765659803"
   - Value:
       Implicit:
@@ -864,7 +864,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "270163693"
   - Value:
       Implicit:
@@ -873,7 +873,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "427940240"
   - Value:
       Implicit:
@@ -882,7 +882,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "504997332"
   - Value:
       Implicit:
@@ -891,7 +891,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "337808338"
   - Value:
       Implicit:
@@ -900,7 +900,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "907200008"
   - Value:
       Implicit:
@@ -909,7 +909,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "757177889"
   - Value:
       Implicit:
@@ -918,7 +918,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "696697188"
   - Value:
       Implicit:
@@ -927,7 +927,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 9
-          path: implicit.leo
+          path: test
           content: "41376051"
   - Value:
       Implicit:
@@ -936,7 +936,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "496293518"
   - Value:
       Implicit:
@@ -945,5 +945,5 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 10
-          path: implicit.leo
+          path: test
           content: "251218820"

tests/expectations/parser/parser/expression/literal/int_parse/mono_group.leo.out

@@ -10,7 +10,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 9
-            path: mono_group.leo
+            path: test
             content: 123group
   - Value:
       Implicit:
@@ -19,7 +19,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 4
-          path: mono_group.leo
+          path: test
           content: "123"
   - Value:
       Group:
@@ -29,7 +29,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 9
-            path: mono_group.leo
+            path: test
             content: 456group
   - Value:
       Group:
@@ -39,7 +39,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 86
-            path: mono_group.leo
+            path: test
             content: 87377802873778028737780287377802873778028737780287377802873778028737780287377802group
   - Value:
       Group:
@@ -49,7 +49,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 406
-            path: mono_group.leo
+            path: test
             content: 8737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802group
   - Value:
       Group:
@@ -59,7 +59,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 340130024group
   - Value:
       Group:
@@ -69,7 +69,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 158951116group
   - Value:
       Group:
@@ -79,7 +79,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 155529659group
   - Value:
       Group:
@@ -89,7 +89,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 642023166group
   - Value:
       Group:
@@ -99,7 +99,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 228481736group
   - Value:
       Group:
@@ -109,7 +109,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 469712960group
   - Value:
       Group:
@@ -119,7 +119,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 929437719group
   - Value:
       Group:
@@ -129,7 +129,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 721072814group
   - Value:
       Group:
@@ -139,7 +139,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 363254789group
   - Value:
       Group:
@@ -149,7 +149,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 906732565group
   - Value:
       Group:
@@ -159,7 +159,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 288246391group
   - Value:
       Group:
@@ -169,7 +169,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 724940549group
   - Value:
       Group:
@@ -179,7 +179,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 487101620group
   - Value:
       Group:
@@ -189,7 +189,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 261373583group
   - Value:
       Group:
@@ -199,7 +199,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 891163927group
   - Value:
       Group:
@@ -209,7 +209,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 743967544group
   - Value:
       Group:
@@ -219,7 +219,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 13
-            path: mono_group.leo
+            path: test
             content: 8372586group
   - Value:
       Group:
@@ -229,7 +229,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 461793278group
   - Value:
       Group:
@@ -239,7 +239,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 806307045group
   - Value:
       Group:
@@ -249,7 +249,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 122764546group
   - Value:
       Group:
@@ -259,7 +259,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 356336181group
   - Value:
       Group:
@@ -269,7 +269,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 158370903group
   - Value:
       Group:
@@ -279,7 +279,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 774460877group
   - Value:
       Group:
@@ -289,7 +289,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 557174131group
   - Value:
       Group:
@@ -299,7 +299,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 492401267group
   - Value:
       Group:
@@ -309,7 +309,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 893445620group
   - Value:
       Group:
@@ -319,7 +319,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 957757048group
   - Value:
       Group:
@@ -329,7 +329,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 721540649group
   - Value:
       Group:
@@ -339,7 +339,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 390746493group
   - Value:
       Group:
@@ -349,7 +349,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 211251725group
   - Value:
       Group:
@@ -359,7 +359,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 938266114group
   - Value:
       Group:
@@ -369,7 +369,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 156985870group
   - Value:
       Group:
@@ -379,7 +379,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 703831126group
   - Value:
       Group:
@@ -389,7 +389,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 729964155group
   - Value:
       Group:
@@ -399,7 +399,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 988151305group
   - Value:
       Group:
@@ -409,7 +409,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 320872435group
   - Value:
       Group:
@@ -419,7 +419,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 719287167group
   - Value:
       Group:
@@ -429,7 +429,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 152289486group
   - Value:
       Group:
@@ -439,7 +439,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 740067975group
   - Value:
       Group:
@@ -449,7 +449,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 728627816group
   - Value:
       Group:
@@ -459,7 +459,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 385008978group
   - Value:
       Group:
@@ -469,7 +469,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 553967635group
   - Value:
       Group:
@@ -479,7 +479,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 14
-            path: mono_group.leo
+            path: test
             content: 71980713group
   - Value:
       Group:
@@ -489,7 +489,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 519444716group
   - Value:
       Group:
@@ -499,7 +499,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 116499965group
   - Value:
       Group:
@@ -509,7 +509,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 717422268group
   - Value:
       Group:
@@ -519,7 +519,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 14
-            path: mono_group.leo
+            path: test
             content: 18966279group
   - Value:
       Group:
@@ -529,7 +529,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 14
-            path: mono_group.leo
+            path: test
             content: 22458638group
   - Value:
       Group:
@@ -539,7 +539,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 857282620group
   - Value:
       Group:
@@ -549,7 +549,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 920675898group
   - Value:
       Group:
@@ -559,7 +559,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 762235516group
   - Value:
       Group:
@@ -569,7 +569,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 469018377group
   - Value:
       Group:
@@ -579,7 +579,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 199986521group
   - Value:
       Group:
@@ -589,7 +589,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 536679358group
   - Value:
       Group:
@@ -599,7 +599,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 591399452group
   - Value:
       Group:
@@ -609,7 +609,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 14
-            path: mono_group.leo
+            path: test
             content: 83083158group
   - Value:
       Group:
@@ -619,7 +619,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 599449051group
   - Value:
       Group:
@@ -629,7 +629,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 445442318group
   - Value:
       Group:
@@ -639,7 +639,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 585486590group
   - Value:
       Group:
@@ -649,7 +649,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 209278800group
   - Value:
       Group:
@@ -659,7 +659,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 873568117group
   - Value:
       Group:
@@ -669,7 +669,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 664470940group
   - Value:
       Group:
@@ -679,7 +679,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 465262783group
   - Value:
       Group:
@@ -689,7 +689,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 605652874group
   - Value:
       Group:
@@ -699,7 +699,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 376803940group
   - Value:
       Group:
@@ -709,7 +709,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 965247040group
   - Value:
       Group:
@@ -719,7 +719,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 598474509group
   - Value:
       Group:
@@ -729,7 +729,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 845119918group
   - Value:
       Group:
@@ -739,7 +739,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 648159133group
   - Value:
       Group:
@@ -749,7 +749,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 669051032group
   - Value:
       Group:
@@ -759,7 +759,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 800600261group
   - Value:
       Group:
@@ -769,7 +769,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 434689764group
   - Value:
       Group:
@@ -779,7 +779,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 520060080group
   - Value:
       Group:
@@ -789,7 +789,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 804659385group
   - Value:
       Group:
@@ -799,7 +799,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 537828058group
   - Value:
       Group:
@@ -809,7 +809,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 716600292group
   - Value:
       Group:
@@ -819,7 +819,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 387020273group
   - Value:
       Group:
@@ -829,7 +829,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 199375617group
   - Value:
       Group:
@@ -839,7 +839,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 680337189group
   - Value:
       Group:
@@ -849,7 +849,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 818479931group
   - Value:
       Group:
@@ -859,7 +859,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 893693281group
   - Value:
       Group:
@@ -869,7 +869,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 14
-            path: mono_group.leo
+            path: test
             content: 87377802group
   - Value:
       Group:
@@ -879,7 +879,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 14
-            path: mono_group.leo
+            path: test
             content: 84699261group
   - Value:
       Group:
@@ -889,7 +889,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 292826090group
   - Value:
       Group:
@@ -899,7 +899,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 569171405group
   - Value:
       Group:
@@ -909,7 +909,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 387436237group
   - Value:
       Group:
@@ -919,7 +919,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 150682190group
   - Value:
       Group:
@@ -929,7 +929,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 888770419group
   - Value:
       Group:
@@ -939,7 +939,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 824696431group
   - Value:
       Group:
@@ -949,7 +949,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 765659803group
   - Value:
       Group:
@@ -959,7 +959,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 270163693group
   - Value:
       Group:
@@ -969,7 +969,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 427940240group
   - Value:
       Group:
@@ -979,7 +979,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 504997332group
   - Value:
       Group:
@@ -989,7 +989,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 337808338group
   - Value:
       Group:
@@ -999,7 +999,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 907200008group
   - Value:
       Group:
@@ -1009,7 +1009,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 757177889group
   - Value:
       Group:
@@ -1019,7 +1019,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 696697188group
   - Value:
       Group:
@@ -1029,7 +1029,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 14
-            path: mono_group.leo
+            path: test
             content: 41376051group
   - Value:
       Group:
@@ -1039,7 +1039,7 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 496293518group
   - Value:
       Group:
@@ -1049,5 +1049,5 @@ outputs:
             line_stop: 1
             col_start: 1
             col_stop: 15
-            path: mono_group.leo
+            path: test
             content: 251218820group

tests/expectations/parser/parser/expression/literal/int_parse/u128.leo.out

@@ -10,7 +10,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 8
-          path: u128.leo
+          path: test
           content: 123u128
   - Value:
       Implicit:
@@ -19,7 +19,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 4
-          path: u128.leo
+          path: test
           content: "123"
   - Value:
       Integer:
@@ -29,7 +29,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 8
-          path: u128.leo
+          path: test
           content: 456u128
   - Value:
       Integer:
@@ -39,7 +39,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 85
-          path: u128.leo
+          path: test
           content: 87377802873778028737780287377802873778028737780287377802873778028737780287377802u128
   - Value:
       Integer:
@@ -49,7 +49,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 405
-          path: u128.leo
+          path: test
           content: 8737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802873778028737780287377802u128
   - Value:
       Integer:
@@ -59,7 +59,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 340130024u128
   - Value:
       Integer:
@@ -69,7 +69,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 158951116u128
   - Value:
       Integer:
@@ -79,7 +79,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 155529659u128
   - Value:
       Integer:
@@ -89,7 +89,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 642023166u128
   - Value:
       Integer:
@@ -99,7 +99,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 228481736u128
   - Value:
       Integer:
@@ -109,7 +109,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 469712960u128
   - Value:
       Integer:
@@ -119,7 +119,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 929437719u128
   - Value:
       Integer:
@@ -129,7 +129,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 721072814u128
   - Value:
       Integer:
@@ -139,7 +139,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 363254789u128
   - Value:
       Integer:
@@ -149,7 +149,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 906732565u128
   - Value:
       Integer:
@@ -159,7 +159,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 288246391u128
   - Value:
       Integer:
@@ -169,7 +169,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 724940549u128
   - Value:
       Integer:
@@ -179,7 +179,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 487101620u128
   - Value:
       Integer:
@@ -189,7 +189,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 261373583u128
   - Value:
       Integer:
@@ -199,7 +199,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 891163927u128
   - Value:
       Integer:
@@ -209,7 +209,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 743967544u128
   - Value:
       Integer:
@@ -219,7 +219,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 12
-          path: u128.leo
+          path: test
           content: 8372586u128
   - Value:
       Integer:
@@ -229,7 +229,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 461793278u128
   - Value:
       Integer:
@@ -239,7 +239,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 806307045u128
   - Value:
       Integer:
@@ -249,7 +249,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 122764546u128
   - Value:
       Integer:
@@ -259,7 +259,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 356336181u128
   - Value:
       Integer:
@@ -269,7 +269,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 158370903u128
   - Value:
       Integer:
@@ -279,7 +279,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 774460877u128
   - Value:
       Integer:
@@ -289,7 +289,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 557174131u128
   - Value:
       Integer:
@@ -299,7 +299,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 492401267u128
   - Value:
       Integer:
@@ -309,7 +309,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 893445620u128
   - Value:
       Integer:
@@ -319,7 +319,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 957757048u128
   - Value:
       Integer:
@@ -329,7 +329,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 721540649u128
   - Value:
       Integer:
@@ -339,7 +339,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 390746493u128
   - Value:
       Integer:
@@ -349,7 +349,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 211251725u128
   - Value:
       Integer:
@@ -359,7 +359,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 938266114u128
   - Value:
       Integer:
@@ -369,7 +369,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 156985870u128
   - Value:
       Integer:
@@ -379,7 +379,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 703831126u128
   - Value:
       Integer:
@@ -389,7 +389,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 729964155u128
   - Value:
       Integer:
@@ -399,7 +399,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 988151305u128
   - Value:
       Integer:
@@ -409,7 +409,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 320872435u128
   - Value:
       Integer:
@@ -419,7 +419,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 719287167u128
   - Value:
       Integer:
@@ -429,7 +429,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 152289486u128
   - Value:
       Integer:
@@ -439,7 +439,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 740067975u128
   - Value:
       Integer:
@@ -449,7 +449,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 728627816u128
   - Value:
       Integer:
@@ -459,7 +459,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 385008978u128
   - Value:
       Integer:
@@ -469,7 +469,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 553967635u128
   - Value:
       Integer:
@@ -479,7 +479,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: u128.leo
+          path: test
           content: 71980713u128
   - Value:
       Integer:
@@ -489,7 +489,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 519444716u128
   - Value:
       Integer:
@@ -499,7 +499,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 116499965u128
   - Value:
       Integer:
@@ -509,7 +509,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 717422268u128
   - Value:
       Integer:
@@ -519,7 +519,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: u128.leo
+          path: test
           content: 18966279u128
   - Value:
       Integer:
@@ -529,7 +529,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: u128.leo
+          path: test
           content: 22458638u128
   - Value:
       Integer:
@@ -539,7 +539,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 857282620u128
   - Value:
       Integer:
@@ -549,7 +549,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 920675898u128
   - Value:
       Integer:
@@ -559,7 +559,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 762235516u128
   - Value:
       Integer:
@@ -569,7 +569,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 469018377u128
   - Value:
       Integer:
@@ -579,7 +579,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 199986521u128
   - Value:
       Integer:
@@ -589,7 +589,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 536679358u128
   - Value:
       Integer:
@@ -599,7 +599,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 591399452u128
   - Value:
       Integer:
@@ -609,7 +609,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: u128.leo
+          path: test
           content: 83083158u128
   - Value:
       Integer:
@@ -619,7 +619,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 599449051u128
   - Value:
       Integer:
@@ -629,7 +629,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 445442318u128
   - Value:
       Integer:
@@ -639,7 +639,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 585486590u128
   - Value:
       Integer:
@@ -649,7 +649,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 209278800u128
   - Value:
       Integer:
@@ -659,7 +659,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 873568117u128
   - Value:
       Integer:
@@ -669,7 +669,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 664470940u128
   - Value:
       Integer:
@@ -679,7 +679,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 465262783u128
   - Value:
       Integer:
@@ -689,7 +689,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 605652874u128
   - Value:
       Integer:
@@ -699,7 +699,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 376803940u128
   - Value:
       Integer:
@@ -709,7 +709,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 965247040u128
   - Value:
       Integer:
@@ -719,7 +719,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 598474509u128
   - Value:
       Integer:
@@ -729,7 +729,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 845119918u128
   - Value:
       Integer:
@@ -739,7 +739,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 648159133u128
   - Value:
       Integer:
@@ -749,7 +749,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 669051032u128
   - Value:
       Integer:
@@ -759,7 +759,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 800600261u128
   - Value:
       Integer:
@@ -769,7 +769,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 434689764u128
   - Value:
       Integer:
@@ -779,7 +779,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 520060080u128
   - Value:
       Integer:
@@ -789,7 +789,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 804659385u128
   - Value:
       Integer:
@@ -799,7 +799,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 537828058u128
   - Value:
       Integer:
@@ -809,7 +809,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 716600292u128
   - Value:
       Integer:
@@ -819,7 +819,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 387020273u128
   - Value:
       Integer:
@@ -829,7 +829,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 199375617u128
   - Value:
       Integer:
@@ -839,7 +839,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 680337189u128
   - Value:
       Integer:
@@ -849,7 +849,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 818479931u128
   - Value:
       Integer:
@@ -859,7 +859,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 893693281u128
   - Value:
       Integer:
@@ -869,7 +869,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: u128.leo
+          path: test
           content: 87377802u128
   - Value:
       Integer:
@@ -879,7 +879,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: u128.leo
+          path: test
           content: 84699261u128
   - Value:
       Integer:
@@ -889,7 +889,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 292826090u128
   - Value:
       Integer:
@@ -899,7 +899,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 569171405u128
   - Value:
       Integer:
@@ -909,7 +909,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 387436237u128
   - Value:
       Integer:
@@ -919,7 +919,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 150682190u128
   - Value:
       Integer:
@@ -929,7 +929,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 888770419u128
   - Value:
       Integer:
@@ -939,7 +939,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 824696431u128
   - Value:
       Integer:
@@ -949,7 +949,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 765659803u128
   - Value:
       Integer:
@@ -959,7 +959,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 270163693u128
   - Value:
       Integer:
@@ -969,7 +969,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 427940240u128
   - Value:
       Integer:
@@ -979,7 +979,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 504997332u128
   - Value:
       Integer:
@@ -989,7 +989,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 337808338u128
   - Value:
       Integer:
@@ -999,7 +999,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 907200008u128
   - Value:
       Integer:
@@ -1009,7 +1009,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 757177889u128
   - Value:
       Integer:
@@ -1019,7 +1019,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 696697188u128
   - Value:
       Integer:
@@ -1029,7 +1029,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 13
-          path: u128.leo
+          path: test
           content: 41376051u128
   - Value:
       Integer:
@@ -1039,7 +1039,7 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 496293518u128
   - Value:
       Integer:
@@ -1049,5 +1049,5 @@ outputs:
           line_stop: 1
           col_start: 1
           col_stop: 14
-          path: u128.leo
+          path: test
           content: 251218820u128