From 2942bf85fe86c0debe9636825cd732d326a44aa4 Mon Sep 17 00:00:00 2001 From: damirka Date: Tue, 7 Sep 2021 19:33:02 +0300 Subject: [PATCH 01/25] staging commit for the sizeof operator --- asg/src/expression/mod.rs | 17 ++++ asg/src/expression/sizeof.rs | 102 +++++++++++++++++++++ asg/src/reducer/monoidal_director.rs | 7 ++ asg/src/reducer/monoidal_reducer.rs | 4 + asg/src/reducer/reconstructing_director.rs | 1 + asg/src/reducer/visitor.rs | 4 + asg/src/reducer/visitor_director.rs | 11 +++ ast/src/expression/mod.rs | 6 ++ ast/src/expression/sizeof.rs | 41 +++++++++ ast/src/reducer/reconstructing_director.rs | 1 + compiler/src/expression/expression.rs | 3 + compiler/src/expression/mod.rs | 3 + compiler/src/expression/operator/mod.rs | 18 ++++ compiler/src/expression/operator/sizeof.rs | 47 ++++++++++ parser/src/parser/expression.rs | 4 + parser/src/tokenizer/lexer.rs | 1 + parser/src/tokenizer/token.rs | 6 ++ 17 files changed, 276 insertions(+) create mode 100644 asg/src/expression/sizeof.rs create mode 100644 ast/src/expression/sizeof.rs create mode 100644 compiler/src/expression/operator/mod.rs create mode 100644 compiler/src/expression/operator/sizeof.rs diff --git a/asg/src/expression/mod.rs b/asg/src/expression/mod.rs index f72d3c8b43..34c0c959bd 100644 --- a/asg/src/expression/mod.rs +++ b/asg/src/expression/mod.rs @@ -65,6 +65,9 @@ pub use variable_ref::*; mod cast; pub use cast::*; +mod sizeof; +pub use sizeof::*; + use crate::{ConstValue, FromAst, Node, PartialType, Scope, Type}; use leo_errors::{Result, Span}; @@ -76,6 +79,7 @@ pub enum Expression<'a> { Unary(UnaryExpression<'a>), Ternary(TernaryExpression<'a>), Cast(CastExpression<'a>), + SizeOf(SizeOfExpression<'a>), ArrayInline(ArrayInlineExpression<'a>), ArrayInit(ArrayInitExpression<'a>), @@ -107,6 +111,7 @@ impl<'a> Node for Expression<'a> { Unary(x) => x.span(), Ternary(x) => x.span(), Cast(x) => x.span(), + SizeOf(x) => x.span(), ArrayInline(x) => x.span(), ArrayInit(x) => x.span(), ArrayAccess(x) => x.span(), @@ -141,6 +146,7 @@ impl<'a> ExpressionNode<'a> for Expression<'a> { Unary(x) => x.set_parent(parent), Ternary(x) => x.set_parent(parent), Cast(x) => x.set_parent(parent), + SizeOf(x) => x.set_parent(parent), ArrayInline(x) => x.set_parent(parent), ArrayInit(x) => x.set_parent(parent), ArrayAccess(x) => x.set_parent(parent), @@ -162,6 +168,7 @@ impl<'a> ExpressionNode<'a> for Expression<'a> { Unary(x) => x.get_parent(), Ternary(x) => x.get_parent(), Cast(x) => x.get_parent(), + SizeOf(x) => x.get_parent(), ArrayInline(x) => x.get_parent(), ArrayInit(x) => x.get_parent(), ArrayAccess(x) => x.get_parent(), @@ -183,6 +190,7 @@ impl<'a> ExpressionNode<'a> for Expression<'a> { Unary(x) => x.enforce_parents(expr), Ternary(x) => x.enforce_parents(expr), Cast(x) => x.enforce_parents(expr), + SizeOf(x) => x.enforce_parents(expr), ArrayInline(x) => x.enforce_parents(expr), ArrayInit(x) => x.enforce_parents(expr), ArrayAccess(x) => x.enforce_parents(expr), @@ -204,6 +212,7 @@ impl<'a> ExpressionNode<'a> for Expression<'a> { Unary(x) => x.get_type(), Ternary(x) => x.get_type(), Cast(x) => x.get_type(), + SizeOf(x) => x.get_type(), ArrayInline(x) => x.get_type(), ArrayInit(x) => x.get_type(), ArrayAccess(x) => x.get_type(), @@ -225,6 +234,7 @@ impl<'a> ExpressionNode<'a> for Expression<'a> { Unary(x) => x.is_mut_ref(), Ternary(x) => x.is_mut_ref(), Cast(x) => x.is_mut_ref(), + SizeOf(x) => x.is_mut_ref(), ArrayInline(x) => x.is_mut_ref(), ArrayInit(x) => x.is_mut_ref(), ArrayAccess(x) => x.is_mut_ref(), @@ -246,6 +256,7 @@ impl<'a> ExpressionNode<'a> for Expression<'a> { Unary(x) => x.const_value(), Ternary(x) => x.const_value(), Cast(x) => x.const_value(), + SizeOf(x) => x.const_value(), ArrayInline(x) => x.const_value(), ArrayInit(x) => x.const_value(), ArrayAccess(x) => x.const_value(), @@ -267,6 +278,7 @@ impl<'a> ExpressionNode<'a> for Expression<'a> { Unary(x) => x.is_consty(), Ternary(x) => x.is_consty(), Cast(x) => x.is_consty(), + SizeOf(x) => x.is_consty(), ArrayInline(x) => x.is_consty(), ArrayInit(x) => x.is_consty(), ArrayAccess(x) => x.is_consty(), @@ -305,6 +317,10 @@ impl<'a> FromAst<'a, leo_ast::Expression> for &'a Expression<'a> { .context .alloc_expression(CastExpression::from_ast(scope, cast, expected_type).map(Expression::Cast)?), + SizeOf(sizeof) => scope + .context + .alloc_expression(SizeOfExpression::from_ast(scope, sizeof, expected_type).map(Expression::SizeOf)?), + ArrayInline(array_inline) => scope.context.alloc_expression( ArrayInlineExpression::from_ast(scope, array_inline, expected_type).map(Expression::ArrayInline)?, ), @@ -357,6 +373,7 @@ impl<'a> Into for &Expression<'a> { Unary(x) => leo_ast::Expression::Unary(x.into()), Ternary(x) => leo_ast::Expression::Ternary(x.into()), Cast(x) => leo_ast::Expression::Cast(x.into()), + SizeOf(x) => leo_ast::Expression::SizeOf(x.into()), ArrayInline(x) => leo_ast::Expression::ArrayInline(x.into()), ArrayInit(x) => leo_ast::Expression::ArrayInit(x.into()), ArrayAccess(x) => leo_ast::Expression::ArrayAccess(x.into()), diff --git a/asg/src/expression/sizeof.rs b/asg/src/expression/sizeof.rs new file mode 100644 index 0000000000..bc580eeae1 --- /dev/null +++ b/asg/src/expression/sizeof.rs @@ -0,0 +1,102 @@ +// 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 . + +use crate::{ConstValue, Expression, ExpressionNode, FromAst, IntegerType, Node, PartialType, Scope, Type}; +pub use leo_ast::UnaryOperation; +use leo_errors::{Result, Span}; + +use std::cell::Cell; + +#[derive(Clone)] +pub struct SizeOfExpression<'a> { + pub parent: Cell>>, + pub span: Option, + pub inner: Cell<&'a Expression<'a>>, +} + +impl<'a> Node for SizeOfExpression<'a> { + fn span(&self) -> Option<&Span> { + self.span.as_ref() + } +} + +impl<'a> ExpressionNode<'a> for SizeOfExpression<'a> { + fn set_parent(&self, parent: &'a Expression<'a>) { + self.parent.replace(Some(parent)); + } + + fn get_parent(&self) -> Option<&'a Expression<'a>> { + self.parent.get() + } + + fn enforce_parents(&self, expr: &'a Expression<'a>) { + self.inner.get().set_parent(expr); + } + + fn get_type(&self) -> Option> { + // TODO: make decision on get type method + // Should it be always u32? For indexes? + // How type casts are applied to this? + Some(Type::Integer(IntegerType::U32)) + } + + fn is_mut_ref(&self) -> bool { + false + } + + fn const_value(&self) -> Option { + let _value = self.inner.get().const_value()?; + // match value { + // ConstValue::Int(int) => match &self.target_type { + // Type::Integer(target) => Some(ConstValue::Int(int.cast_to(target))), + // _ => None, + // }, + // _ => None, + // } + + // TODO: IMPLEMENT CONST VALUE + None + } + + fn is_consty(&self) -> bool { + true + } +} + +impl<'a> FromAst<'a, leo_ast::SizeOfExpression> for SizeOfExpression<'a> { + fn from_ast( + scope: &'a Scope<'a>, + value: &leo_ast::SizeOfExpression, + _expected_type: Option>, + ) -> Result> { + let inner = <&Expression<'a>>::from_ast(scope, &*value.inner, None)?; + + Ok(SizeOfExpression { + parent: Cell::new(None), + span: Some(value.span.clone()), + inner: Cell::new(inner), + }) + } +} + +impl<'a> Into for &SizeOfExpression<'a> { + fn into(self) -> leo_ast::SizeOfExpression { + leo_ast::SizeOfExpression { + inner: Box::new(self.inner.get().into()), + span: self.span.clone().unwrap_or_default(), + } + } +} diff --git a/asg/src/reducer/monoidal_director.rs b/asg/src/reducer/monoidal_director.rs index 858a1bb256..182f2aca05 100644 --- a/asg/src/reducer/monoidal_director.rs +++ b/asg/src/reducer/monoidal_director.rs @@ -48,6 +48,7 @@ impl<'a, T: Monoid, R: MonoidalReducerExpression<'a, T>> MonoidalDirector<'a, T, Expression::CircuitInit(e) => self.reduce_circuit_init(e), Expression::Ternary(e) => self.reduce_ternary_expression(e), Expression::Cast(e) => self.reduce_cast_expression(e), + Expression::SizeOf(e) => self.reduce_sizeof_expression(e), Expression::Constant(e) => self.reduce_constant(e), Expression::TupleAccess(e) => self.reduce_tuple_access(e), Expression::TupleInit(e) => self.reduce_tuple_init(e), @@ -138,6 +139,12 @@ impl<'a, T: Monoid, R: MonoidalReducerExpression<'a, T>> MonoidalDirector<'a, T, self.reducer.reduce_cast_expression(input, inner) } + pub fn reduce_sizeof_expression(&mut self, input: &SizeOfExpression<'a>) -> T { + let inner = self.reduce_expression(input.inner.get()); + + self.reducer.reduce_sizeof_expression(input, inner) + } + pub fn reduce_constant(&mut self, input: &Constant<'a>) -> T { self.reducer.reduce_constant(input) } diff --git a/asg/src/reducer/monoidal_reducer.rs b/asg/src/reducer/monoidal_reducer.rs index 9510417241..d6b5cac1fc 100644 --- a/asg/src/reducer/monoidal_reducer.rs +++ b/asg/src/reducer/monoidal_reducer.rs @@ -68,6 +68,10 @@ pub trait MonoidalReducerExpression<'a, T: Monoid> { inner } + fn reduce_sizeof_expression(&mut self, input: &SizeOfExpression<'a>, inner: T) -> T { + inner + } + fn reduce_constant(&mut self, input: &Constant<'a>) -> T { T::default() } diff --git a/asg/src/reducer/reconstructing_director.rs b/asg/src/reducer/reconstructing_director.rs index 2027597162..708c35a0fe 100644 --- a/asg/src/reducer/reconstructing_director.rs +++ b/asg/src/reducer/reconstructing_director.rs @@ -48,6 +48,7 @@ impl<'a, R: ReconstructingReducerExpression<'a>> ReconstructingDirector<'a, R> { Expression::CircuitInit(e) => self.reduce_circuit_init(e), Expression::Ternary(e) => self.reduce_ternary_expression(e), Expression::Cast(e) => self.reduce_cast_expression(e), + Expression::SizeOf(e) => Expression::SizeOf(e), //self.reduce_sizeof_expression(e), // TODO: implement REDUCER Expression::Constant(e) => self.reduce_constant(e), Expression::TupleAccess(e) => self.reduce_tuple_access(e), Expression::TupleInit(e) => self.reduce_tuple_init(e), diff --git a/asg/src/reducer/visitor.rs b/asg/src/reducer/visitor.rs index 1e0b46fd9e..d577e958bb 100644 --- a/asg/src/reducer/visitor.rs +++ b/asg/src/reducer/visitor.rs @@ -76,6 +76,10 @@ pub trait ExpressionVisitor<'a> { Default::default() } + fn visit_sizeof_expression(&mut self, input: &SizeOfExpression<'a>) -> VisitResult { + Default::default() + } + fn visit_constant(&mut self, input: &Constant<'a>) -> VisitResult { Default::default() } diff --git a/asg/src/reducer/visitor_director.rs b/asg/src/reducer/visitor_director.rs index 2d238e67aa..5c56607b3e 100644 --- a/asg/src/reducer/visitor_director.rs +++ b/asg/src/reducer/visitor_director.rs @@ -61,6 +61,7 @@ impl<'a, R: ExpressionVisitor<'a>> VisitorDirector<'a, R> { Expression::CircuitInit(e) => self.visit_circuit_init(e), Expression::Ternary(e) => self.visit_ternary_expression(e), Expression::Cast(e) => self.visit_cast_expression(e), + Expression::SizeOf(e) => self.visit_sizeof_expression(e), Expression::Constant(e) => self.visit_constant(e), Expression::TupleAccess(e) => self.visit_tuple_access(e), Expression::TupleInit(e) => self.visit_tuple_init(e), @@ -195,6 +196,16 @@ impl<'a, R: ExpressionVisitor<'a>> VisitorDirector<'a, R> { } } + pub fn visit_sizeof_expression(&mut self, input: &SizeOfExpression<'a>) -> ConcreteVisitResult { + match self.visitor.visit_sizeof_expression(input) { + VisitResult::VisitChildren => { + self.visit_expression(&input.inner)?; + Ok(()) + } + x => x.into(), + } + } + pub fn visit_constant(&mut self, input: &Constant<'a>) -> ConcreteVisitResult { self.visitor.visit_constant(input).into() } diff --git a/ast/src/expression/mod.rs b/ast/src/expression/mod.rs index f79926d0f5..7196ee4915 100644 --- a/ast/src/expression/mod.rs +++ b/ast/src/expression/mod.rs @@ -54,6 +54,8 @@ mod call; pub use call::*; mod cast; pub use cast::*; +mod sizeof; +pub use sizeof::*; /// Expression that evaluates to a value #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] @@ -64,6 +66,7 @@ pub enum Expression { Unary(UnaryExpression), Ternary(TernaryExpression), Cast(CastExpression), + SizeOf(SizeOfExpression), ArrayInline(ArrayInlineExpression), ArrayInit(ArrayInitExpression), @@ -100,6 +103,7 @@ impl Node for Expression { CircuitStaticFunctionAccess(n) => n.span(), Call(n) => n.span(), Cast(n) => n.span(), + SizeOf(n) => n.span(), } } @@ -122,6 +126,7 @@ impl Node for Expression { CircuitStaticFunctionAccess(n) => n.set_span(span), Call(n) => n.set_span(span), Cast(n) => n.set_span(span), + SizeOf(n) => n.set_span(span), } } } @@ -146,6 +151,7 @@ impl fmt::Display for Expression { CircuitStaticFunctionAccess(n) => n.fmt(f), Call(n) => n.fmt(f), Cast(n) => n.fmt(f), + SizeOf(n) => n.fmt(f), } } } diff --git a/ast/src/expression/sizeof.rs b/ast/src/expression/sizeof.rs new file mode 100644 index 0000000000..8b41f11f2d --- /dev/null +++ b/ast/src/expression/sizeof.rs @@ -0,0 +1,41 @@ +// 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 . + +// use crate::Type; + +use super::*; + +#[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] +pub struct SizeOfExpression { + pub inner: Box, + pub span: Span, +} + +impl fmt::Display for SizeOfExpression { + fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { + write!(f, "sizeof {}", self.inner) + } +} + +impl Node for SizeOfExpression { + fn span(&self) -> &Span { + &self.span + } + + fn set_span(&mut self, span: Span) { + self.span = span; + } +} diff --git a/ast/src/reducer/reconstructing_director.rs b/ast/src/reducer/reconstructing_director.rs index 22246090d9..384a3192ff 100644 --- a/ast/src/reducer/reconstructing_director.rs +++ b/ast/src/reducer/reconstructing_director.rs @@ -57,6 +57,7 @@ impl ReconstructingDirector { Expression::Unary(unary) => Expression::Unary(self.reduce_unary(unary)?), Expression::Ternary(ternary) => Expression::Ternary(self.reduce_ternary(ternary)?), Expression::Cast(cast) => Expression::Cast(self.reduce_cast(cast)?), + Expression::SizeOf(sizeof) => Expression::SizeOf(sizeof.clone()), // Expression::SizeOf(self.reduce_sizeof(sizeof)?), // TODO: add reducer Expression::ArrayInline(array_inline) => Expression::ArrayInline(self.reduce_array_inline(array_inline)?), Expression::ArrayInit(array_init) => Expression::ArrayInit(self.reduce_array_init(array_init)?), diff --git a/compiler/src/expression/expression.rs b/compiler/src/expression/expression.rs index 4191a95a2c..0f85165252 100644 --- a/compiler/src/expression/expression.rs +++ b/compiler/src/expression/expression.rs @@ -98,6 +98,9 @@ impl<'a, F: PrimeField, G: GroupType> ConstrainedProgram<'a, F, G> { // Cast Expression::Cast(_) => unimplemented!("casts not implemented"), + // SizeOf + Expression::SizeOf(sizeof) => self.enforce_sizeof(cs, sizeof, span), + // Variables Expression::VariableRef(variable_ref) => self.evaluate_ref(variable_ref), diff --git a/compiler/src/expression/mod.rs b/compiler/src/expression/mod.rs index 77de89cff7..6db73571d6 100644 --- a/compiler/src/expression/mod.rs +++ b/compiler/src/expression/mod.rs @@ -43,6 +43,9 @@ pub use self::variable_ref::*; pub mod logical; pub use self::logical::*; +pub mod operator; +pub use self::operator::*; + pub mod relational; pub use self::relational::*; diff --git a/compiler/src/expression/operator/mod.rs b/compiler/src/expression/operator/mod.rs new file mode 100644 index 0000000000..773e668d58 --- /dev/null +++ b/compiler/src/expression/operator/mod.rs @@ -0,0 +1,18 @@ +// 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 . + +pub mod sizeof; +pub use self::sizeof::*; diff --git a/compiler/src/expression/operator/sizeof.rs b/compiler/src/expression/operator/sizeof.rs new file mode 100644 index 0000000000..2f26634b96 --- /dev/null +++ b/compiler/src/expression/operator/sizeof.rs @@ -0,0 +1,47 @@ +// 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 . + +//! Enforces a sizeof operator in a compiled Leo program. + +use crate::{ + program::ConstrainedProgram, + value::{ConstrainedValue, Integer}, + GroupType, +}; +use leo_asg::{ConstInt, SizeOfExpression}; +use leo_errors::{Result, Span}; + +use snarkvm_fields::PrimeField; +use snarkvm_r1cs::ConstraintSystem; + +impl<'a, F: PrimeField, G: GroupType> ConstrainedProgram<'a, F, G> { + /// Enforce array expressions + pub fn enforce_sizeof>( + &mut self, + cs: &mut CS, + sizeof: &'a SizeOfExpression<'a>, + _span: &Span, + ) -> Result> { + let value = self.enforce_expression(cs, sizeof.inner.get())?; + + Ok(match value { + ConstrainedValue::Array(array) => { + ConstrainedValue::Integer(Integer::new(&ConstInt::U32(array.len() as u32))) + } + _ => unimplemented!("sizeof can only be used for arrays"), + }) + } +} diff --git a/parser/src/parser/expression.rs b/parser/src/parser/expression.rs index 2f9cf4929f..233e253f3b 100644 --- a/parser/src/parser/expression.rs +++ b/parser/src/parser/expression.rs @@ -727,6 +727,10 @@ impl ParserContext { }; Expression::Identifier(ident) } + Token::SizeOf => Expression::SizeOf(SizeOfExpression { + span, + inner: Box::new(self.parse_primary_expression()?), + }), token => { return Err(ParserError::unexpected_str(token, "expression", &span).into()); } diff --git a/parser/src/tokenizer/lexer.rs b/parser/src/tokenizer/lexer.rs index 3b02c3775e..455b125028 100644 --- a/parser/src/tokenizer/lexer.rs +++ b/parser/src/tokenizer/lexer.rs @@ -519,6 +519,7 @@ impl Token { "string" => Token::String, "true" => Token::True, "type" => Token::Type, + "sizeof" => Token::SizeOf, "u8" => Token::U8, "u16" => Token::U16, "u32" => Token::U32, diff --git a/parser/src/tokenizer/token.rs b/parser/src/tokenizer/token.rs index 16d1edc190..6c5f0ff981 100644 --- a/parser/src/tokenizer/token.rs +++ b/parser/src/tokenizer/token.rs @@ -139,6 +139,10 @@ pub enum Token { Static, String, Type, + + // Operators + SizeOf, + // Not yet in ABNF // BitAnd, // BitAndEq, @@ -195,6 +199,7 @@ pub const KEYWORD_TOKENS: &[Token] = &[ Token::String, Token::True, Token::Type, + Token::SizeOf, Token::U8, Token::U16, Token::U32, @@ -307,6 +312,7 @@ impl fmt::Display for Token { Static => write!(f, "static"), String => write!(f, "string"), Type => write!(f, "type"), + SizeOf => write!(f, "sizeof"), Eof => write!(f, ""), // BitAnd => write!(f, "&"), // BitAndEq => write!(f, "&="), From ba65b4f4d55607bd4648fcbd3e94d5fcdf24f5b2 Mon Sep 17 00:00:00 2001 From: Alessandro Coglio Date: Thu, 9 Sep 2021 11:55:30 -0700 Subject: [PATCH 02/25] [ABNF] Improve rules for array expressions. Extending array dimensions for types to allow underscore has the unintended effect of allowing that also for expressions. This is not necessarily an error, as the static semantics can rule out underscores from array expressions. However, it is a simple syntactic constraint that is best captured by the grammar. This commit differentiate array dimensions for types and array dimensions for expressions, using them in the appropriate places. --- grammar/abnf-grammar.txt | 14 +++++++++----- 1 file changed, 9 insertions(+), 5 deletions(-) diff --git a/grammar/abnf-grammar.txt b/grammar/abnf-grammar.txt index d0fb9dc44c..62b038e09c 100644 --- a/grammar/abnf-grammar.txt +++ b/grammar/abnf-grammar.txt @@ -669,12 +669,13 @@ tuple-type = "(" [ type 1*( "," type ) ] ")" ; or a tuple of one or more dimensions. ; Each dimension is either a natural or is unspecified. -array-type = "[" type ";" array-dimensions "]" +array-type = "[" type ";" array-type-dimensions "]" -array-dimension = natural / "_" +array-type-dimension = natural / "_" -array-dimensions = array-dimension - / "(" array-dimension *( "," array-dimension ) ")" +array-type-dimensions = array-type-dimension + / "(" array-type-dimension + *( "," array-type-dimension ) ")" ; The keyword `Self` denotes the enclosing circuit type. ; It is only allowed inside a circuit type declaration. @@ -767,7 +768,10 @@ array-inline-construction = "[" array-inline-element = expression / "..." expression -array-repeat-construction = "[" expression ";" array-dimensions "]" +array-repeat-construction = "[" expression ";" array-expression-dimensions "]" + +array-expression-dimensions = natural + / "(" natural *( "," natural ) ")" array-construction = array-inline-construction / array-repeat-construction From 1c4c7622f3508cbb340ae6b499bfdf1178d10e30 Mon Sep 17 00:00:00 2001 From: Alessandro Coglio Date: Thu, 9 Sep 2021 12:00:22 -0700 Subject: [PATCH 03/25] [ABNF] Re-generate markdown file. --- grammar/README.md | 100 +++++++++++++++++++++++++--------------------- 1 file changed, 55 insertions(+), 45 deletions(-) diff --git a/grammar/README.md b/grammar/README.md index e0a413f4a8..92704a39e4 100644 --- a/grammar/README.md +++ b/grammar/README.md @@ -476,7 +476,7 @@ Line terminators form whitespace, along with spaces and horizontal tabs. whitespace = space / horizontal-tab / newline ``` -Go to: _[newline](#user-content-newline), [space](#user-content-space), [horizontal-tab](#user-content-horizontal-tab)_; +Go to: _[newline](#user-content-newline), [horizontal-tab](#user-content-horizontal-tab), [space](#user-content-space)_; There are two kinds of comments in Leo, as in other languages. @@ -494,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)_; @@ -590,7 +590,7 @@ lowercase-letter = %x61-7A ; a-z letter = uppercase-letter / lowercase-letter ``` -Go to: _[lowercase-letter](#user-content-lowercase-letter), [uppercase-letter](#user-content-uppercase-letter)_; +Go to: _[uppercase-letter](#user-content-uppercase-letter), [lowercase-letter](#user-content-lowercase-letter)_; The following rules defines (ASCII) decimal, octal, and hexadecimal digits. @@ -774,7 +774,7 @@ character-literal-element = not-single-quote-or-backslash / unicode-character-escape ``` -Go to: _[ascii-character-escape](#user-content-ascii-character-escape), [simple-character-escape](#user-content-simple-character-escape), [unicode-character-escape](#user-content-unicode-character-escape), [not-single-quote-or-backslash](#user-content-not-single-quote-or-backslash)_; +Go to: _[simple-character-escape](#user-content-simple-character-escape), [unicode-character-escape](#user-content-unicode-character-escape), [not-single-quote-or-backslash](#user-content-not-single-quote-or-backslash), [ascii-character-escape](#user-content-ascii-character-escape)_; @@ -829,7 +829,7 @@ simple-character-escape = single-quote-escape / null-character-escape ``` -Go to: _[line-feed-escape](#user-content-line-feed-escape), [carriage-return-escape](#user-content-carriage-return-escape), [double-quote-escape](#user-content-double-quote-escape), [backslash-escape](#user-content-backslash-escape), [null-character-escape](#user-content-null-character-escape), [single-quote-escape](#user-content-single-quote-escape), [horizontal-tab-escape](#user-content-horizontal-tab-escape)_; +Go to: _[carriage-return-escape](#user-content-carriage-return-escape), [backslash-escape](#user-content-backslash-escape), [line-feed-escape](#user-content-line-feed-escape), [horizontal-tab-escape](#user-content-horizontal-tab-escape), [null-character-escape](#user-content-null-character-escape), [single-quote-escape](#user-content-single-quote-escape), [double-quote-escape](#user-content-double-quote-escape)_; @@ -865,7 +865,7 @@ string-literal-element = not-double-quote-or-backslash / unicode-character-escape ``` -Go to: _[simple-character-escape](#user-content-simple-character-escape), [unicode-character-escape](#user-content-unicode-character-escape), [not-double-quote-or-backslash](#user-content-not-double-quote-or-backslash), [ascii-character-escape](#user-content-ascii-character-escape)_; +Go to: _[unicode-character-escape](#user-content-unicode-character-escape), [not-double-quote-or-backslash](#user-content-not-double-quote-or-backslash), [simple-character-escape](#user-content-simple-character-escape), [ascii-character-escape](#user-content-ascii-character-escape)_; The ones above are all the atomic literals @@ -885,7 +885,7 @@ atomic-literal = untyped-literal / string-literal ``` -Go to: _[character-literal](#user-content-character-literal), [unsigned-literal](#user-content-unsigned-literal), [signed-literal](#user-content-signed-literal), [address-literal](#user-content-address-literal), [field-literal](#user-content-field-literal), [untyped-literal](#user-content-untyped-literal), [product-group-literal](#user-content-product-group-literal), [string-literal](#user-content-string-literal), [boolean-literal](#user-content-boolean-literal)_; +Go to: _[untyped-literal](#user-content-untyped-literal), [character-literal](#user-content-character-literal), [unsigned-literal](#user-content-unsigned-literal), [boolean-literal](#user-content-boolean-literal), [signed-literal](#user-content-signed-literal), [address-literal](#user-content-address-literal), [field-literal](#user-content-field-literal), [string-literal](#user-content-string-literal), [product-group-literal](#user-content-product-group-literal)_; After defining the (mostly) alphanumeric tokens above, @@ -929,7 +929,7 @@ token = keyword / symbol ``` -Go to: _[identifier](#user-content-identifier), [annotation-name](#user-content-annotation-name), [package-name](#user-content-package-name), [keyword](#user-content-keyword), [symbol](#user-content-symbol), [atomic-literal](#user-content-atomic-literal)_; +Go to: _[symbol](#user-content-symbol), [keyword](#user-content-keyword), [identifier](#user-content-identifier), [atomic-literal](#user-content-atomic-literal), [package-name](#user-content-package-name), [annotation-name](#user-content-annotation-name)_; Tokens, comments, and whitespace are lexemes, i.e. lexical units. @@ -939,7 +939,7 @@ Tokens, comments, and whitespace are lexemes, i.e. lexical units. lexeme = token / comment / whitespace ``` -Go to: _[token](#user-content-token), [whitespace](#user-content-whitespace), [comment](#user-content-comment)_; +Go to: _[token](#user-content-token), [comment](#user-content-comment), [whitespace](#user-content-whitespace)_; @@ -996,7 +996,7 @@ group-type = %s"group" arithmetic-type = integer-type / field-type / group-type ``` -Go to: _[field-type](#user-content-field-type), [group-type](#user-content-group-type), [integer-type](#user-content-integer-type)_; +Go to: _[integer-type](#user-content-integer-type), [field-type](#user-content-field-type), [group-type](#user-content-group-type)_; The arithmetic types, along with the boolean, address, and character types, @@ -1022,7 +1022,7 @@ character-type = %s"char" scalar-type = boolean-type / arithmetic-type / address-type / character-type ``` -Go to: _[boolean-type](#user-content-boolean-type), [arithmetic-type](#user-content-arithmetic-type), [character-type](#user-content-character-type), [address-type](#user-content-address-type)_; +Go to: _[character-type](#user-content-character-type), [arithmetic-type](#user-content-arithmetic-type), [boolean-type](#user-content-boolean-type), [address-type](#user-content-address-type)_; A tuple type consists of zero, two, or more component types. @@ -1043,27 +1043,28 @@ Each dimension is either a natural or is unspecified. ```abnf -array-type = "[" type ";" array-dimensions "]" +array-type = "[" type ";" array-type-dimensions "]" ``` -Go to: _[array-dimensions](#user-content-array-dimensions), [type](#user-content-type)_; +Go to: _[type](#user-content-type), [array-type-dimensions](#user-content-array-type-dimensions)_; - + ```abnf -array-dimension = natural / "_" +array-type-dimension = natural / "_" ``` Go to: _[natural](#user-content-natural)_; - + ```abnf -array-dimensions = array-dimension - / "(" array-dimension *( "," array-dimension ) ")" +array-type-dimensions = array-type-dimension + / "(" array-type-dimension + *( "," array-type-dimension ) ")" ``` -Go to: _[array-dimension](#user-content-array-dimension)_; +Go to: _[array-type-dimension](#user-content-array-type-dimension)_; The keyword `Self` denotes the enclosing circuit type. @@ -1089,7 +1090,7 @@ form all the types. type = scalar-type / tuple-type / array-type / identifier / self-type ``` -Go to: _[array-type](#user-content-array-type), [scalar-type](#user-content-scalar-type), [tuple-type](#user-content-tuple-type), [identifier](#user-content-identifier), [self-type](#user-content-self-type)_; +Go to: _[scalar-type](#user-content-scalar-type), [array-type](#user-content-array-type), [tuple-type](#user-content-tuple-type), [self-type](#user-content-self-type), [identifier](#user-content-identifier)_; It is convenient to introduce a rule for types that are @@ -1178,7 +1179,7 @@ primary-expression = identifier / circuit-expression ``` -Go to: _[tuple-expression](#user-content-tuple-expression), [array-expression](#user-content-array-expression), [identifier](#user-content-identifier), [literal](#user-content-literal), [expression](#user-content-expression), [circuit-expression](#user-content-circuit-expression)_; +Go to: _[identifier](#user-content-identifier), [array-expression](#user-content-array-expression), [literal](#user-content-literal), [expression](#user-content-expression), [tuple-expression](#user-content-tuple-expression), [circuit-expression](#user-content-circuit-expression)_; Tuple expressions construct tuples. @@ -1228,10 +1229,19 @@ Go to: _[expression](#user-content-expression)_; ```abnf -array-repeat-construction = "[" expression ";" array-dimensions "]" +array-repeat-construction = "[" expression ";" array-expression-dimensions "]" ``` -Go to: _[expression](#user-content-expression), [array-dimensions](#user-content-array-dimensions)_; +Go to: _[expression](#user-content-expression), [array-expression-dimensions](#user-content-array-expression-dimensions)_; + + + +```abnf +array-expression-dimensions = natural + / "(" natural *( "," natural ) ")" +``` + +Go to: _[natural](#user-content-natural)_; @@ -1239,7 +1249,7 @@ Go to: _[expression](#user-content-expression), [array-dimensions](#user-content 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)_; @@ -1267,7 +1277,7 @@ circuit-construction = identifier-or-self-type "{" "}" ``` -Go to: _[identifier-or-self-type](#user-content-identifier-or-self-type), [circuit-inline-element](#user-content-circuit-inline-element)_; +Go to: _[circuit-inline-element](#user-content-circuit-inline-element), [identifier-or-self-type](#user-content-identifier-or-self-type)_; @@ -1275,7 +1285,7 @@ Go to: _[identifier-or-self-type](#user-content-identifier-or-self-type), [circu circuit-inline-element = identifier ":" expression / identifier ``` -Go to: _[identifier](#user-content-identifier), [expression](#user-content-expression)_; +Go to: _[expression](#user-content-expression), [identifier](#user-content-identifier)_; @@ -1326,7 +1336,7 @@ postfix-expression = primary-expression / postfix-expression "[" [expression] ".." [expression] "]" ``` -Go to: _[function-arguments](#user-content-function-arguments), [primary-expression](#user-content-primary-expression), [expression](#user-content-expression), [postfix-expression](#user-content-postfix-expression), [identifier](#user-content-identifier), [natural](#user-content-natural), [identifier-or-self-type](#user-content-identifier-or-self-type)_; +Go to: _[identifier](#user-content-identifier), [natural](#user-content-natural), [expression](#user-content-expression), [primary-expression](#user-content-primary-expression), [identifier-or-self-type](#user-content-identifier-or-self-type), [postfix-expression](#user-content-postfix-expression), [function-arguments](#user-content-function-arguments)_; Unary operators have the highest operator precedence. @@ -1340,7 +1350,7 @@ 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, @@ -1354,7 +1364,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. @@ -1417,7 +1427,7 @@ conjunctive-expression = equality-expression / conjunctive-expression "&&" equality-expression ``` -Go to: _[equality-expression](#user-content-equality-expression), [conjunctive-expression](#user-content-conjunctive-expression)_; +Go to: _[conjunctive-expression](#user-content-conjunctive-expression), [equality-expression](#user-content-equality-expression)_; Next come disjunctive expressions, left-associative. @@ -1441,7 +1451,7 @@ conditional-expression = disjunctive-expression ":" conditional-expression ``` -Go to: _[expression](#user-content-expression), [disjunctive-expression](#user-content-disjunctive-expression), [conditional-expression](#user-content-conditional-expression)_; +Go to: _[disjunctive-expression](#user-content-disjunctive-expression), [expression](#user-content-expression), [conditional-expression](#user-content-conditional-expression)_; Those above are all the expressions. @@ -1474,7 +1484,7 @@ statement = expression-statement / block ``` -Go to: _[loop-statement](#user-content-loop-statement), [expression-statement](#user-content-expression-statement), [console-statement](#user-content-console-statement), [block](#user-content-block), [return-statement](#user-content-return-statement), [variable-declaration](#user-content-variable-declaration), [constant-declaration](#user-content-constant-declaration), [assignment-statement](#user-content-assignment-statement), [conditional-statement](#user-content-conditional-statement)_; +Go to: _[loop-statement](#user-content-loop-statement), [expression-statement](#user-content-expression-statement), [return-statement](#user-content-return-statement), [conditional-statement](#user-content-conditional-statement), [assignment-statement](#user-content-assignment-statement), [variable-declaration](#user-content-variable-declaration), [console-statement](#user-content-console-statement), [constant-declaration](#user-content-constant-declaration), [block](#user-content-block)_; @@ -1517,7 +1527,7 @@ variable-declaration = %s"let" identifier-or-identifiers [ ":" type ] "=" expression ";" ``` -Go to: _[identifier-or-identifiers](#user-content-identifier-or-identifiers), [type](#user-content-type), [expression](#user-content-expression)_; +Go to: _[identifier-or-identifiers](#user-content-identifier-or-identifiers), [expression](#user-content-expression), [type](#user-content-type)_; @@ -1526,7 +1536,7 @@ constant-declaration = %s"const" identifier-or-identifiers [ ":" type ] "=" expression ";" ``` -Go to: _[expression](#user-content-expression), [type](#user-content-type), [identifier-or-identifiers](#user-content-identifier-or-identifiers)_; +Go to: _[identifier-or-identifiers](#user-content-identifier-or-identifiers), [type](#user-content-type), [expression](#user-content-expression)_; @@ -1559,7 +1569,7 @@ conditional-statement = branch / branch %s"else" conditional-statement ``` -Go to: _[block](#user-content-block), [conditional-statement](#user-content-conditional-statement), [branch](#user-content-branch)_; +Go to: _[branch](#user-content-branch), [block](#user-content-block), [conditional-statement](#user-content-conditional-statement)_; A loop statement implicitly defines a loop variable @@ -1572,7 +1582,7 @@ loop-statement = %s"for" identifier %s"in" expression ".." [ "=" ] expression block ``` -Go to: _[expression](#user-content-expression), [identifier](#user-content-identifier), [block](#user-content-block)_; +Go to: _[block](#user-content-block), [expression](#user-content-expression), [identifier](#user-content-identifier)_; An assignment statement is straightforward. @@ -1589,7 +1599,7 @@ assignment-operator = "=" / "+=" / "-=" / "*=" / "/=" / "**=" assignment-statement = expression assignment-operator expression ";" ``` -Go to: _[expression](#user-content-expression), [assignment-operator](#user-content-assignment-operator)_; +Go to: _[assignment-operator](#user-content-assignment-operator), [expression](#user-content-expression)_; Console statements start with the `console` keyword, @@ -1616,7 +1626,7 @@ console-call = assert-call / print-call ``` -Go to: _[print-call](#user-content-print-call), [assert-call](#user-content-assert-call)_; +Go to: _[assert-call](#user-content-assert-call), [print-call](#user-content-print-call)_; @@ -1645,7 +1655,7 @@ Go to: _[string-literal](#user-content-string-literal)_; print-call = print-function print-arguments ``` -Go to: _[print-arguments](#user-content-print-arguments), [print-function](#user-content-print-function)_; +Go to: _[print-function](#user-content-print-function), [print-arguments](#user-content-print-arguments)_; An annotation consists of an annotation name (which starts with `@`) @@ -1658,7 +1668,7 @@ annotation = annotation-name [ "(" identifier *( "," identifier ) ")" ] ``` -Go to: _[annotation-name](#user-content-annotation-name), [identifier](#user-content-identifier)_; +Go to: _[identifier](#user-content-identifier), [annotation-name](#user-content-annotation-name)_; A function declaration defines a function. @@ -1675,7 +1685,7 @@ function-declaration = *annotation %s"function" identifier block ``` -Go to: _[identifier](#user-content-identifier), [type](#user-content-type), [block](#user-content-block), [function-parameters](#user-content-function-parameters)_; +Go to: _[type](#user-content-type), [identifier](#user-content-identifier), [function-parameters](#user-content-function-parameters), [block](#user-content-block)_; @@ -1754,7 +1764,7 @@ circuit-declaration = %s"circuit" identifier *member-function-declaration "}" ``` -Go to: _[identifier](#user-content-identifier), [member-variable-declarations](#user-content-member-variable-declarations)_; +Go to: _[member-variable-declarations](#user-content-member-variable-declarations), [identifier](#user-content-identifier)_; An import declaration consists of the `import` keyword @@ -1776,7 +1786,7 @@ by using an explicit package name before the package path. import-declaration = %s"import" package-name "." package-path ";" ``` -Go to: _[package-name](#user-content-package-name), [package-path](#user-content-package-path)_; +Go to: _[package-path](#user-content-package-path), [package-name](#user-content-package-name)_; @@ -1787,7 +1797,7 @@ package-path = "*" / "(" package-path *( "," package-path ) [","] ")" ``` -Go to: _[package-path](#user-content-package-path), [identifier](#user-content-identifier), [package-name](#user-content-package-name)_; +Go to: _[package-name](#user-content-package-name), [package-path](#user-content-package-path), [identifier](#user-content-identifier)_; A type alias declaration defines an identifier to stand for a type. @@ -1813,7 +1823,7 @@ declaration = import-declaration / type-alias-declaration ``` -Go to: _[circuit-declaration](#user-content-circuit-declaration), [import-declaration](#user-content-import-declaration), [function-declaration](#user-content-function-declaration), [constant-declaration](#user-content-constant-declaration), [type-alias-declaration](#user-content-type-alias-declaration)_; +Go to: _[circuit-declaration](#user-content-circuit-declaration), [type-alias-declaration](#user-content-type-alias-declaration), [function-declaration](#user-content-function-declaration), [constant-declaration](#user-content-constant-declaration), [import-declaration](#user-content-import-declaration)_; From 64e88404d25d42d131a6a9b9669552b3270525a4 Mon Sep 17 00:00:00 2001 From: gluaxspeed Date: Fri, 10 Sep 2021 05:55:07 -0700 Subject: [PATCH 04/25] prelude stuff auto included --- Cargo.lock | 50 +- Cargo.toml | 5 + asg/src/program/mod.rs | 23 +- ast-passes/Cargo.toml | 4 + ast-passes/src/import_resolution/importer.rs | 6 +- ast-passes/src/import_resolution/resolver.rs | 33 +- ast/src/lib.rs | 12 - compiler/src/compiler.rs | 11 +- compiler/src/test.rs | 4 +- imports/Cargo.toml | 4 - imports/src/parser/import_parser.rs | 10 +- imports/src/parser/parse_package.rs | 4 +- leo/commands/test.rs | 3 +- package/src/root/lock_file.rs | 7 +- parser/src/tokenizer/lexer.rs | 1 - parser/src/tokenizer/token.rs | 3 - stdlib/Cargo.toml | 37 ++ stdlib/LICENSE.md | 596 ++++++++++++++++++ stdlib/README.md | 1 + stdlib/prelude/string.leo | 1 + stdlib/src/lib.rs | 71 +++ stdlib/unstable/blake2s.leo | 5 + tests/compiler/core/core_circuit_invalid.leo | 8 - .../compiler/core/core_circuit_star_fail.leo | 8 - .../core/core_unstable_package_invalid.leo | 8 - .../definition/out_of_order_with_import.leo | 4 +- tests/compiler/{core => stdlib}/blake2s.leo | 2 +- .../compiler/stdlib/core_circuit_invalid.leo | 8 + .../stdlib/core_circuit_star_fail.leo | 8 + .../{core => stdlib}/core_package_invalid.leo | 2 +- .../stdlib/core_unstable_package_invalid.leo | 8 + .../_blake2s/arguments_length_fail.leo | 0 .../unstable/_blake2s/arguments_type_fail.leo | 0 .../unstable/_blake2s/blake2s_input.leo | 0 .../unstable/_blake2s/blake2s_random.leo | 0 .../unstable/_blake2s/inputs/valid_input.in | 0 .../packages/unstable/_blake2s/mod.rs | 0 .../_blake2s/outputs/valid_output.out | 0 tests/compiler/stdlib/strings.leo | 15 + .../{core => stdlib}/unstable_blake2s.leo | 2 +- .../compiler/compiler/address/branch.leo.out | 6 +- .../compiler/compiler/address/equal.leo.out | 6 +- .../compiler/compiler/address/index.leo.out | 6 +- .../compiler/compiler/address/ternary.leo.out | 6 +- .../compiler/compiler/aliases/arith.leo.out | 6 +- .../compiler/compiler/aliases/basic.leo.out | 6 +- .../compiler/compiler/aliases/circuit.leo.out | 6 +- .../compiler/aliases/fn_return.leo.out | 6 +- .../compiler/aliases/shadowing_arg.leo.out | 6 +- .../aliases/shadowing_var_allowed.leo.out | 6 +- .../compiler/array/complex_access.leo.out | 6 +- .../compiler/array/equal_initializer.leo.out | 6 +- .../array/equal_initializer_2.leo.out | 6 +- .../compiler/array/input_nested_3x2.leo.out | 6 +- .../compiler/array/input_tuple_3x2.leo.out | 6 +- .../compiler/array/multi_initializer.leo.out | 6 +- .../compiler/compiler/array/nested.leo.out | 6 +- .../compiler/array/nested_3x2_value.leo.out | 6 +- .../compiler/compiler/array/registers.leo.out | 6 +- .../compiler/compiler/array/slice.leo.out | 6 +- .../compiler/array/slice_lower.leo.out | 6 +- .../compiler/compiler/array/spread.leo.out | 6 +- .../compiler/array/ternary_in_array.leo.out | 6 +- .../compiler/array/tuple_3x2_value.leo.out | 6 +- .../compiler/array/type_input_3x2.leo.out | 6 +- .../compiler/array/type_input_4x3x2.leo.out | 6 +- .../type_nested_value_nested_3x2.leo.out | 6 +- .../type_nested_value_nested_4x3x2.leo.out | 6 +- .../array/type_nested_value_tuple_3x2.leo.out | 6 +- .../type_nested_value_tuple_4x3x2.leo.out | 6 +- .../array/type_tuple_value_nested_3x2.leo.out | 6 +- .../type_tuple_value_nested_4x3x2.leo.out | 6 +- .../array/type_tuple_value_tuple_3x2.leo.out | 6 +- .../type_tuple_value_tuple_4x3x2.leo.out | 6 +- .../array_without_size/definition.leo.out | 6 +- .../array_without_size/function_input.leo.out | 6 +- .../array_without_size/type_alias.leo.out | 6 +- .../compiler/compiler/boolean/and.leo.out | 6 +- .../compiler/boolean/conditional.leo.out | 6 +- .../compiler/compiler/boolean/equal.leo.out | 6 +- .../compiler/boolean/not_equal.leo.out | 6 +- .../compiler/compiler/boolean/or.leo.out | 6 +- .../compiler/compiler/char/circuit.leo.out | 6 +- .../compiler/compiler/char/neq.leo.out | 6 +- .../compiler/char/nonprinting.leo.out | 6 +- .../compiler/compiler/char/out.leo.out | 6 +- .../big_self_in_circuit_replacement.leo.out | 6 +- .../circuits/const_self_variable.leo.out | 6 +- ...ne_circuit_inside_circuit_function.leo.out | 6 +- .../circuits/duplicate_name_context.leo.out | 6 +- .../compiler/compiler/circuits/inline.leo.out | 6 +- .../circuits/inline_member_pass.leo.out | 6 +- .../compiler/circuits/member_function.leo.out | 6 +- .../circuits/member_function_nested.leo.out | 6 +- .../circuits/member_static_function.leo.out | 6 +- .../member_static_function_nested.leo.out | 6 +- .../compiler/circuits/member_variable.leo.out | 6 +- .../member_variable_and_function.leo.out | 6 +- .../circuits/mut_self_variable.leo.out | 6 +- .../circuits/mut_self_variable_branch.leo.out | 6 +- .../mut_self_variable_conditional.leo.out | 6 +- .../compiler/circuits/mut_variable.leo.out | 6 +- .../mutable_call_immutable_context.leo.out | 6 +- .../compiler/circuits/pedersen_mock.leo.out | 6 +- .../circuits/return_self_type_array.leo.out | 6 +- .../circuits/return_self_type_tuple.leo.out | 6 +- .../compiler/circuits/self_member.leo.out | 6 +- .../compiler/compiler/console/assert.leo.out | 6 +- .../console/conditional_assert.leo.out | 6 +- .../compiler/compiler/console/error.leo.out | 6 +- .../compiler/compiler/console/log.leo.out | 6 +- .../compiler/console/log_conditional.leo.out | 6 +- .../compiler/console/log_input.leo.out | 6 +- .../compiler/console/log_parameter.leo.out | 6 +- .../console/log_parameter_many.leo.out | 6 +- .../compiler/definition/out_of_order.leo.out | 6 +- .../out_of_order_with_import.leo.out | 8 +- .../compiler/compiler/field/add.leo.out | 6 +- .../compiler/compiler/field/div.leo.out | 6 +- .../compiler/compiler/field/eq.leo.out | 6 +- .../compiler/compiler/field/field.leo.out | 6 +- .../compiler/compiler/field/mul.leo.out | 6 +- .../compiler/compiler/field/negate.leo.out | 6 +- .../compiler/function/array_input.leo.out | 6 +- .../function/array_params_direct_call.leo.out | 6 +- .../function/conditional_return.leo.out | 6 +- .../compiler/compiler/function/empty.leo.out | 6 +- .../compiler/function/iteration.leo.out | 6 +- .../function/iteration_repeated.leo.out | 6 +- .../function/multiple_returns.leo.out | 6 +- .../function/multiple_returns_main.leo.out | 6 +- .../compiler/function/newlines.leo.out | 6 +- .../compiler/function/repeated.leo.out | 6 +- .../compiler/compiler/function/return.leo.out | 6 +- .../function/return_array_nested_pass.leo.out | 6 +- .../function/return_array_tuple_pass.leo.out | 6 +- .../compiler/function/return_tuple.leo.out | 6 +- .../function/return_tuple_conditional.leo.out | 6 +- .../compiler/function/value_unchanged.leo.out | 6 +- .../global_consts/global_const_types.leo.out | 6 +- .../tests/import_dependency_folder.leo.out | 6 +- .../compiler/import_local/import_all.leo.out | 6 +- .../compiler/import_local/import_as.leo.out | 6 +- .../compiler/import_local/import_dir.leo.out | 6 +- .../import_local/import_files.leo.out | 6 +- .../compiler/import_local/import_many.leo.out | 6 +- .../import_local/import_weird_names.leo.out | 6 +- .../import_weird_names_nested.leo.out | 6 +- .../input_files/program_input/main.leo.out | 6 +- .../program_input/main_array.leo.out | 6 +- .../program_input/main_char.leo.out | 6 +- .../program_input/main_field.leo.out | 6 +- .../program_input/main_group.leo.out | 6 +- .../main_multi_dimension_array.leo.out | 6 +- .../program_input/main_multiple.leo.out | 6 +- .../program_input/main_string.leo.out | 6 +- .../program_input/main_tuple.leo.out | 6 +- .../basic.leo.out | 6 +- .../token_withdraw.leo.out | 6 +- .../program_input_constants/main.leo.out | 6 +- .../main_array.leo.out | 6 +- .../program_input_constants/main_char.leo.out | 6 +- .../main_field.leo.out | 6 +- .../main_group.leo.out | 6 +- .../main_multi_dimension_array.leo.out | 6 +- .../main_multiple.leo.out | 6 +- .../main_string.leo.out | 6 +- .../main_tuple.leo.out | 6 +- .../program_registers/registers_array.leo.out | 6 +- .../program_registers/registers_pass.leo.out | 6 +- .../program_state/access_all.leo.out | 6 +- .../program_state/access_state.leo.out | 6 +- .../input_files/program_state/basic.leo.out | 6 +- .../compiler/integers/i128/add.leo.out | 6 +- .../integers/i128/console_assert.leo.out | 6 +- .../compiler/integers/i128/div.leo.out | 6 +- .../compiler/integers/i128/eq.leo.out | 6 +- .../compiler/integers/i128/ge.leo.out | 6 +- .../compiler/integers/i128/gt.leo.out | 6 +- .../compiler/integers/i128/le.leo.out | 6 +- .../compiler/integers/i128/lt.leo.out | 6 +- .../compiler/integers/i128/max.leo.out | 6 +- .../compiler/integers/i128/min.leo.out | 6 +- .../compiler/integers/i128/mul.leo.out | 6 +- .../compiler/integers/i128/ne.leo.out | 6 +- .../compiler/integers/i128/negate.leo.out | 6 +- .../compiler/integers/i128/negate_min.leo.out | 6 +- .../integers/i128/negate_zero.leo.out | 6 +- .../compiler/integers/i128/sub.leo.out | 6 +- .../compiler/integers/i128/ternary.leo.out | 6 +- .../compiler/integers/i16/add.leo.out | 6 +- .../integers/i16/console_assert.leo.out | 6 +- .../compiler/integers/i16/div.leo.out | 6 +- .../compiler/compiler/integers/i16/eq.leo.out | 6 +- .../compiler/compiler/integers/i16/ge.leo.out | 6 +- .../compiler/compiler/integers/i16/gt.leo.out | 6 +- .../compiler/compiler/integers/i16/le.leo.out | 6 +- .../compiler/compiler/integers/i16/lt.leo.out | 6 +- .../compiler/integers/i16/max.leo.out | 6 +- .../compiler/integers/i16/min.leo.out | 6 +- .../compiler/integers/i16/mul.leo.out | 6 +- .../compiler/compiler/integers/i16/ne.leo.out | 6 +- .../compiler/integers/i16/negate.leo.out | 6 +- .../compiler/integers/i16/negate_min.leo.out | 6 +- .../compiler/integers/i16/negate_zero.leo.out | 6 +- .../compiler/integers/i16/sub.leo.out | 6 +- .../compiler/integers/i16/ternary.leo.out | 6 +- .../compiler/integers/i32/add.leo.out | 6 +- .../integers/i32/console_assert.leo.out | 6 +- .../compiler/integers/i32/div.leo.out | 6 +- .../compiler/compiler/integers/i32/eq.leo.out | 6 +- .../compiler/compiler/integers/i32/ge.leo.out | 6 +- .../compiler/compiler/integers/i32/gt.leo.out | 6 +- .../compiler/compiler/integers/i32/le.leo.out | 6 +- .../compiler/compiler/integers/i32/lt.leo.out | 6 +- .../compiler/integers/i32/max.leo.out | 6 +- .../compiler/integers/i32/min.leo.out | 6 +- .../compiler/integers/i32/mul.leo.out | 6 +- .../compiler/compiler/integers/i32/ne.leo.out | 6 +- .../compiler/integers/i32/negate.leo.out | 6 +- .../compiler/integers/i32/negate_min.leo.out | 6 +- .../compiler/integers/i32/negate_zero.leo.out | 6 +- .../compiler/integers/i32/sub.leo.out | 6 +- .../compiler/integers/i32/ternary.leo.out | 6 +- .../compiler/integers/i64/add.leo.out | 6 +- .../integers/i64/console_assert.leo.out | 6 +- .../compiler/integers/i64/div.leo.out | 6 +- .../compiler/compiler/integers/i64/eq.leo.out | 6 +- .../compiler/compiler/integers/i64/ge.leo.out | 6 +- .../compiler/compiler/integers/i64/gt.leo.out | 6 +- .../compiler/compiler/integers/i64/le.leo.out | 6 +- .../compiler/compiler/integers/i64/lt.leo.out | 6 +- .../compiler/integers/i64/max.leo.out | 6 +- .../compiler/integers/i64/min.leo.out | 6 +- .../compiler/integers/i64/mul.leo.out | 6 +- .../compiler/compiler/integers/i64/ne.leo.out | 6 +- .../compiler/integers/i64/negate.leo.out | 6 +- .../compiler/integers/i64/negate_min.leo.out | 6 +- .../compiler/integers/i64/negate_zero.leo.out | 6 +- .../compiler/integers/i64/sub.leo.out | 6 +- .../compiler/integers/i64/ternary.leo.out | 6 +- .../compiler/compiler/integers/i8/add.leo.out | 6 +- .../integers/i8/console_assert.leo.out | 6 +- .../compiler/compiler/integers/i8/div.leo.out | 6 +- .../compiler/compiler/integers/i8/eq.leo.out | 6 +- .../compiler/compiler/integers/i8/ge.leo.out | 6 +- .../compiler/compiler/integers/i8/gt.leo.out | 6 +- .../compiler/compiler/integers/i8/le.leo.out | 6 +- .../compiler/compiler/integers/i8/lt.leo.out | 6 +- .../compiler/compiler/integers/i8/max.leo.out | 6 +- .../compiler/compiler/integers/i8/min.leo.out | 6 +- .../compiler/compiler/integers/i8/mul.leo.out | 6 +- .../compiler/compiler/integers/i8/ne.leo.out | 6 +- .../compiler/integers/i8/negate.leo.out | 6 +- .../compiler/integers/i8/negate_zero.leo.out | 6 +- .../compiler/compiler/integers/i8/sub.leo.out | 6 +- .../compiler/integers/i8/ternary.leo.out | 6 +- .../compiler/integers/u128/add.leo.out | 6 +- .../integers/u128/console_assert.leo.out | 6 +- .../compiler/integers/u128/div.leo.out | 6 +- .../compiler/integers/u128/eq.leo.out | 6 +- .../compiler/integers/u128/ge.leo.out | 6 +- .../compiler/integers/u128/gt.leo.out | 6 +- .../compiler/integers/u128/input.leo.out | 6 +- .../compiler/integers/u128/le.leo.out | 6 +- .../compiler/integers/u128/lt.leo.out | 6 +- .../compiler/integers/u128/max.leo.out | 6 +- .../compiler/integers/u128/min.leo.out | 6 +- .../compiler/integers/u128/mul.leo.out | 6 +- .../compiler/integers/u128/ne.leo.out | 6 +- .../compiler/integers/u128/sub.leo.out | 6 +- .../compiler/integers/u128/ternary.leo.out | 6 +- .../compiler/integers/u16/add.leo.out | 6 +- .../integers/u16/console_assert.leo.out | 6 +- .../compiler/integers/u16/div.leo.out | 6 +- .../compiler/compiler/integers/u16/eq.leo.out | 6 +- .../compiler/compiler/integers/u16/ge.leo.out | 6 +- .../compiler/compiler/integers/u16/gt.leo.out | 6 +- .../compiler/integers/u16/input.leo.out | 6 +- .../compiler/compiler/integers/u16/le.leo.out | 6 +- .../compiler/compiler/integers/u16/lt.leo.out | 6 +- .../compiler/integers/u16/max.leo.out | 6 +- .../compiler/integers/u16/min.leo.out | 6 +- .../compiler/integers/u16/mul.leo.out | 6 +- .../compiler/compiler/integers/u16/ne.leo.out | 6 +- .../compiler/integers/u16/sub.leo.out | 6 +- .../compiler/integers/u16/ternary.leo.out | 6 +- .../compiler/integers/u32/add.leo.out | 6 +- .../integers/u32/console_assert.leo.out | 6 +- .../compiler/integers/u32/div.leo.out | 6 +- .../compiler/compiler/integers/u32/eq.leo.out | 6 +- .../compiler/compiler/integers/u32/ge.leo.out | 6 +- .../compiler/compiler/integers/u32/gt.leo.out | 6 +- .../compiler/integers/u32/input.leo.out | 6 +- .../compiler/compiler/integers/u32/le.leo.out | 6 +- .../compiler/compiler/integers/u32/lt.leo.out | 6 +- .../compiler/integers/u32/max.leo.out | 6 +- .../compiler/integers/u32/min.leo.out | 6 +- .../compiler/integers/u32/mul.leo.out | 6 +- .../compiler/compiler/integers/u32/ne.leo.out | 6 +- .../compiler/integers/u32/sub.leo.out | 6 +- .../compiler/integers/u32/ternary.leo.out | 6 +- .../compiler/integers/u64/add.leo.out | 6 +- .../integers/u64/console_assert.leo.out | 6 +- .../compiler/integers/u64/div.leo.out | 6 +- .../compiler/compiler/integers/u64/eq.leo.out | 6 +- .../compiler/compiler/integers/u64/ge.leo.out | 6 +- .../compiler/compiler/integers/u64/gt.leo.out | 6 +- .../compiler/integers/u64/input.leo.out | 6 +- .../compiler/compiler/integers/u64/le.leo.out | 6 +- .../compiler/compiler/integers/u64/lt.leo.out | 6 +- .../compiler/integers/u64/max.leo.out | 6 +- .../compiler/integers/u64/min.leo.out | 6 +- .../compiler/integers/u64/mul.leo.out | 6 +- .../compiler/compiler/integers/u64/ne.leo.out | 6 +- .../compiler/integers/u64/sub.leo.out | 6 +- .../compiler/integers/u64/ternary.leo.out | 6 +- .../compiler/compiler/integers/u8/add.leo.out | 6 +- .../integers/u8/console_assert.leo.out | 6 +- .../compiler/compiler/integers/u8/div.leo.out | 6 +- .../compiler/compiler/integers/u8/eq.leo.out | 6 +- .../compiler/compiler/integers/u8/ge.leo.out | 6 +- .../compiler/compiler/integers/u8/gt.leo.out | 6 +- .../compiler/integers/u8/input.leo.out | 6 +- .../compiler/compiler/integers/u8/le.leo.out | 6 +- .../compiler/compiler/integers/u8/lt.leo.out | 6 +- .../compiler/compiler/integers/u8/max.leo.out | 6 +- .../compiler/compiler/integers/u8/min.leo.out | 6 +- .../compiler/compiler/integers/u8/mul.leo.out | 6 +- .../compiler/compiler/integers/u8/ne.leo.out | 6 +- .../compiler/compiler/integers/u8/sub.leo.out | 6 +- .../compiler/integers/u8/ternary.leo.out | 6 +- .../compiler/mutability/array_dyn_mut.leo.out | 6 +- .../mutability/array_dyn_mut_indirect.leo.out | 6 +- .../compiler/mutability/array_mut.leo.out | 6 +- .../mutability/array_splice_mut.leo.out | 6 +- .../mutability/array_tuple_mut.leo.out | 6 +- .../mutability/circuit_function_mut.leo.out | 6 +- .../mutability/circuit_variable_mut.leo.out | 6 +- .../compiler/mutability/cond_mut.leo.out | 6 +- .../mutability/function_input_mut.leo.out | 6 +- .../compiler/mutability/let_mut.leo.out | 6 +- .../mutability/let_mut_nested.leo.out | 6 +- .../compiler/compiler/mutability/swap.leo.out | 6 +- .../compiler/statements/all_loops.leo.out | 6 +- .../compiler/statements/block.leo.out | 6 +- .../compiler/statements/chain.leo.out | 6 +- .../statements/compound_assignment.leo.out | 6 +- .../compiler/statements/for_loop.leo.out | 6 +- .../statements/iteration_basic.leo.out | 6 +- .../statements/iteration_variable.leo.out | 6 +- .../statements/multiple_returns.leo.out | 6 +- .../compiler/statements/mutate.leo.out | 6 +- .../compiler/statements/nested_mutate.leo.out | 6 +- .../compiler/statements/reverse_loops.leo.out | 6 +- .../compiler/statements/reverse_one.leo.out | 6 +- .../ternary_explicit_and_implicit.leo.out | 6 +- .../stdlib/core_circuit_invalid.leo.out | 5 + .../stdlib/core_circuit_star_fail.leo.out | 5 + .../stdlib/core_package_invalid.leo.out | 5 + .../core_unstable_package_invalid.leo.out | 5 + .../compiler/compiler/string/circuit.leo.out | 6 +- .../compiler/compiler/string/equality.leo.out | 6 +- .../compiler/compiler/string/replace.leo.out | 6 +- .../string/string_transformation.leo.out | 6 +- .../compiler/compiler/tuples/access.leo.out | 6 +- .../compiler/compiler/tuples/basic.leo.out | 6 +- .../compiler/tuples/dependent.leo.out | 6 +- .../compiler/tuples/destructured.leo.out | 6 +- .../compiler/tuples/nested_access.leo.out | 6 +- 370 files changed, 1858 insertions(+), 1084 deletions(-) create mode 100644 stdlib/Cargo.toml create mode 100644 stdlib/LICENSE.md create mode 100644 stdlib/README.md create mode 100644 stdlib/prelude/string.leo create mode 100644 stdlib/src/lib.rs create mode 100644 stdlib/unstable/blake2s.leo delete mode 100644 tests/compiler/core/core_circuit_invalid.leo delete mode 100644 tests/compiler/core/core_circuit_star_fail.leo delete mode 100644 tests/compiler/core/core_unstable_package_invalid.leo rename tests/compiler/{core => stdlib}/blake2s.leo (57%) create mode 100644 tests/compiler/stdlib/core_circuit_invalid.leo create mode 100644 tests/compiler/stdlib/core_circuit_star_fail.leo rename tests/compiler/{core => stdlib}/core_package_invalid.leo (50%) create mode 100644 tests/compiler/stdlib/core_unstable_package_invalid.leo rename tests/compiler/{core => stdlib}/packages/unstable/_blake2s/arguments_length_fail.leo (100%) rename tests/compiler/{core => stdlib}/packages/unstable/_blake2s/arguments_type_fail.leo (100%) rename tests/compiler/{core => stdlib}/packages/unstable/_blake2s/blake2s_input.leo (100%) rename tests/compiler/{core => stdlib}/packages/unstable/_blake2s/blake2s_random.leo (100%) rename tests/compiler/{core => stdlib}/packages/unstable/_blake2s/inputs/valid_input.in (100%) rename tests/compiler/{core => stdlib}/packages/unstable/_blake2s/mod.rs (100%) rename tests/compiler/{core => stdlib}/packages/unstable/_blake2s/outputs/valid_output.out (100%) create mode 100644 tests/compiler/stdlib/strings.leo rename tests/compiler/{core => stdlib}/unstable_blake2s.leo (90%) create mode 100644 tests/expectations/compiler/compiler/stdlib/core_circuit_invalid.leo.out create mode 100644 tests/expectations/compiler/compiler/stdlib/core_circuit_star_fail.leo.out create mode 100644 tests/expectations/compiler/compiler/stdlib/core_package_invalid.leo.out create mode 100644 tests/expectations/compiler/compiler/stdlib/core_unstable_package_invalid.leo.out diff --git a/Cargo.lock b/Cargo.lock index b484086af6..27f60ff0d4 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -925,6 +925,12 @@ version = "0.25.0" source = "registry+https://github.com/rust-lang/crates.io-index" checksum = "f0a01e0497841a3b2db4f8afa483cce65f7e96a3498bd6c541734792aeac8fe7" +[[package]] +name = "glob" +version = "0.3.0" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "9b919933a397b79c37e33b77bb2aa3dc8eb6e165ad809e58ff75bc7db2e34574" + [[package]] name = "h2" version = "0.3.3" @@ -1065,6 +1071,30 @@ dependencies = [ "unicode-normalization", ] +[[package]] +name = "include_dir" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "24b56e147e6187d61e9d0f039f10e070d0c0a887e24fe0bb9ca3f29bfde62cab" +dependencies = [ + "glob", + "include_dir_impl", + "proc-macro-hack", +] + +[[package]] +name = "include_dir_impl" +version = "0.6.2" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "0a0c890c85da4bab7bce4204c707396bbd3c6c8a681716a51c8814cfc2b682df" +dependencies = [ + "anyhow", + "proc-macro-hack", + "proc-macro2 1.0.27", + "quote 1.0.9", + "syn 1.0.73", +] + [[package]] name = "indenter" version = "0.3.3" @@ -1239,6 +1269,7 @@ dependencies = [ "leo-ast", "leo-errors", "leo-parser", + "leo-stdlib", ] [[package]] @@ -1300,7 +1331,6 @@ name = "leo-imports" version = "1.5.3" dependencies = [ "indexmap", - "leo-asg", "leo-ast", "leo-ast-passes", "leo-errors", @@ -1342,6 +1372,7 @@ dependencies = [ "leo-package", "leo-parser", "leo-state", + "leo-stdlib", "leo-synthesizer", "notify", "rand 0.8.4", @@ -1416,6 +1447,17 @@ dependencies = [ "snarkvm-utilities", ] +[[package]] +name = "leo-stdlib" +version = "1.5.3" +dependencies = [ + "include_dir", + "indexmap", + "leo-ast", + "leo-errors", + "leo-parser", +] + [[package]] name = "leo-synthesizer" version = "1.5.3" @@ -1993,6 +2035,12 @@ dependencies = [ "version_check", ] +[[package]] +name = "proc-macro-hack" +version = "0.5.19" +source = "registry+https://github.com/rust-lang/crates.io-index" +checksum = "dbf0c48bc1d91375ae5c3cd81e3722dff1abcf81a30960240640d223f59fe0e5" + [[package]] name = "proc-macro2" version = "0.4.30" diff --git a/Cargo.toml b/Cargo.toml index 78687f1ac9..cff7176398 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -39,6 +39,7 @@ members = [ "package", "parser", "state", + "stdlib", "synthesizer", "test-framework" ] @@ -75,6 +76,10 @@ version = "1.5.3" path = "./state" version = "1.5.3" +[dependencies.leo-stdlib] +path = "./stdlib" +version = "1.5.3" + [dependencies.leo-synthesizer] path = "./synthesizer" version = "1.5.3" diff --git a/asg/src/program/mod.rs b/asg/src/program/mod.rs index 51261a54b3..7187a1916d 100644 --- a/asg/src/program/mod.rs +++ b/asg/src/program/mod.rs @@ -163,10 +163,26 @@ impl<'a> Program<'a> { /// 4. resolve all asg nodes /// pub fn new(context: AsgContext<'a>, program: &leo_ast::Program) -> Result> { + let mut imported_aliases: IndexMap> = IndexMap::new(); + let mut imported_functions: IndexMap> = IndexMap::new(); + let mut imported_circuits: IndexMap> = IndexMap::new(); + let mut imported_global_consts: IndexMap> = IndexMap::new(); + // Convert each sub AST. + // Import all prelude symbols on the way. let mut imported_modules: IndexMap, Program> = IndexMap::new(); for (package, program) in program.imports.iter() { - imported_modules.insert(package.clone(), Program::new(context, program)?); + let sub_program = Program::new(context, program)?; + imported_modules.insert(package.clone(), sub_program.clone()); + + let pretty_package = package.join("."); + + if pretty_package.contains("std.prelude") { + imported_aliases.extend(sub_program.aliases.clone().into_iter()); + imported_functions.extend(sub_program.functions.clone().into_iter()); + imported_circuits.extend(sub_program.circuits.clone().into_iter()); + imported_global_consts.extend(sub_program.global_consts.clone().into_iter()); + } } let mut imported_symbols: Vec<(Vec, ImportSymbol, Span)> = vec![]; @@ -179,11 +195,6 @@ impl<'a> Program<'a> { deduplicated_imports.insert(package.clone(), span.clone()); } - let mut imported_aliases: IndexMap> = IndexMap::new(); - let mut imported_functions: IndexMap> = IndexMap::new(); - let mut imported_circuits: IndexMap> = IndexMap::new(); - let mut imported_global_consts: IndexMap> = IndexMap::new(); - for (package, symbol, span) in imported_symbols.into_iter() { let pretty_package = package.join("."); diff --git a/ast-passes/Cargo.toml b/ast-passes/Cargo.toml index 97ffab78ab..7b9394a61e 100644 --- a/ast-passes/Cargo.toml +++ b/ast-passes/Cargo.toml @@ -34,3 +34,7 @@ version = "1.5.3" [dependencies.leo-parser] path = "../parser" version = "1.5.3" + +[dependencies.leo-stdlib] +path = "../stdlib" +version = "1.5.3" \ No newline at end of file diff --git a/ast-passes/src/import_resolution/importer.rs b/ast-passes/src/import_resolution/importer.rs index 428f4411dc..808341433e 100644 --- a/ast-passes/src/import_resolution/importer.rs +++ b/ast-passes/src/import_resolution/importer.rs @@ -28,6 +28,9 @@ impl Importer { where T: ImportResolver, { + let mut ast = program.clone(); + ast.imports.extend(leo_stdlib::resolve_prelude_modules()?); + let mut imported_symbols: Vec<(Vec, ImportSymbol, Span)> = vec![]; for import_statement in program.import_statements.iter() { resolve_import_package(&mut imported_symbols, vec![], &import_statement.package_or_packages); @@ -53,8 +56,7 @@ impl Importer { resolved_packages.insert(package.clone(), resolved_package); } - let mut ast = program; - ast.imports = resolved_packages; + ast.imports.extend(resolved_packages); Ok(Ast::new(ast)) } diff --git a/ast-passes/src/import_resolution/resolver.rs b/ast-passes/src/import_resolution/resolver.rs index 8af14f51e5..18beccafd2 100644 --- a/ast-passes/src/import_resolution/resolver.rs +++ b/ast-passes/src/import_resolution/resolver.rs @@ -16,6 +16,7 @@ use leo_ast::Program; use leo_errors::{Result, Span}; +use leo_stdlib::resolve_stdlib_module; use indexmap::IndexMap; @@ -43,8 +44,8 @@ impl<'a, T: ImportResolver> CoreImportResolver<'a, T> { impl<'a, T: ImportResolver> ImportResolver for CoreImportResolver<'a, T> { fn resolve_package(&mut self, package_segments: &[&str], span: &Span) -> Result> { - if !package_segments.is_empty() && package_segments.get(0).unwrap() == &"core" { - Ok(resolve_core_module(&*package_segments[1..].join("."))?) + if !package_segments.is_empty() && package_segments.get(0).unwrap() == &"std" { + Ok(resolve_stdlib_module(&*package_segments[1..].join("."))?) } else { self.inner.resolve_package(package_segments, span) } @@ -60,31 +61,3 @@ impl ImportResolver for MockedImportResolver { Ok(self.packages.get(&package_segments.join(".")).cloned()) } } - -// TODO: Remove this. -pub fn load_ast(content: &str) -> Result { - // Parses the Leo file and constructs a grammar ast. - Ok(leo_parser::parse_ast("input.leo", content)?.into_repr()) -} - -// TODO: We should merge this with core -// TODO: Make asg deep copy so we can cache resolved core modules -// TODO: Figure out how to do headers without bogus returns -pub fn resolve_core_module(module: &str) -> Result> { - match module { - "unstable.blake2s" => { - let ast = load_ast( - r#" - circuit Blake2s { - function hash(seed: [u8; 32], message: [u8; 32]) -> [u8; 32] { - return [0; 32]; - } - } - "#, - )?; - ast.set_core_mapping("blake2s"); - Ok(Some(ast)) - } - _ => Ok(None), - } -} diff --git a/ast/src/lib.rs b/ast/src/lib.rs index ea4edb0320..65f5b94881 100644 --- a/ast/src/lib.rs +++ b/ast/src/lib.rs @@ -89,18 +89,6 @@ impl Ast { Self { ast: program } } - /* /// Mutates the program ast by resolving the imports. - pub fn importer(&mut self, importer: T) -> Result<()> { - self.ast = ReconstructingDirector::new(Importer::new(importer)).reduce_program(self.as_repr())?; - Ok(()) - } - - /// Mutates the program ast by preforming canonicalization on it. - pub fn canonicalize(&mut self) -> Result<()> { - self.ast = ReconstructingDirector::new(Canonicalizer::default()).reduce_program(self.as_repr())?; - Ok(()) - } */ - /// Returns a reference to the inner program AST representation. pub fn as_repr(&self) -> &Program { &self.ast diff --git a/compiler/src/compiler.rs b/compiler/src/compiler.rs index 7d83268e48..f09fead1ef 100644 --- a/compiler/src/compiler.rs +++ b/compiler/src/compiler.rs @@ -35,12 +35,13 @@ use snarkvm_r1cs::{ConstraintSynthesizer, ConstraintSystem, SynthesisError}; use sha2::{Digest, Sha256}; use std::{ - collections::HashMap, fs, marker::PhantomData, path::{Path, PathBuf}, }; +use indexmap::IndexMap; + thread_local! { static THREAD_GLOBAL_CONTEXT: AsgContext<'static> = { let leaked = Box::leak(Box::new(leo_asg::new_alloc_context())); @@ -64,7 +65,7 @@ pub struct Compiler<'a, F: PrimeField, G: GroupType> { context: AsgContext<'a>, asg: Option>, options: CompilerOptions, - imports_map: HashMap, + imports_map: IndexMap, ast_snapshot_options: AstSnapshotOptions, _engine: PhantomData, _group: PhantomData, @@ -80,7 +81,7 @@ impl<'a, F: PrimeField, G: GroupType> Compiler<'a, F, G> { output_directory: PathBuf, context: AsgContext<'a>, options: Option, - imports_map: HashMap, + imports_map: IndexMap, ast_snapshot_options: Option, ) -> Self { Self { @@ -112,7 +113,7 @@ impl<'a, F: PrimeField, G: GroupType> Compiler<'a, F, G> { output_directory: PathBuf, context: AsgContext<'a>, options: Option, - imports_map: HashMap, + imports_map: IndexMap, ast_snapshot_options: Option, ) -> Result { let mut compiler = Self::new( @@ -153,7 +154,7 @@ impl<'a, F: PrimeField, G: GroupType> Compiler<'a, F, G> { state_path: &Path, context: AsgContext<'a>, options: Option, - imports_map: HashMap, + imports_map: IndexMap, ast_snapshot_options: Option, ) -> Result { let mut compiler = Self::new( diff --git a/compiler/src/test.rs b/compiler/src/test.rs index 789445acf6..89fd7b1fb2 100644 --- a/compiler/src/test.rs +++ b/compiler/src/test.rs @@ -15,7 +15,6 @@ // along with the Leo library. If not, see . use std::{ - collections::HashMap, fs, path::{Path, PathBuf}, }; @@ -32,6 +31,7 @@ use serde_yaml::Value; use snarkvm_curves::{bls12_377::Bls12_377, edwards_bls12::Fq}; use crate::{compiler::Compiler, targets::edwards_bls12::EdwardsGroupType, AstSnapshotOptions, Output}; +use indexmap::IndexMap; pub type EdwardsTestCompiler = Compiler<'static, Fq, EdwardsGroupType>; // pub type EdwardsConstrainedValue = ConstrainedValue<'static, Fq, EdwardsGroupType>; @@ -53,7 +53,7 @@ fn new_compiler(path: PathBuf, theorem_options: Option) -> E output_dir, make_test_context(), None, - HashMap::new(), + IndexMap::new(), theorem_options, ) } diff --git a/imports/Cargo.toml b/imports/Cargo.toml index 8ee88e8a4e..144f002abe 100644 --- a/imports/Cargo.toml +++ b/imports/Cargo.toml @@ -29,10 +29,6 @@ version = "1.5.3" path = "../errors" version = "1.5.3" -[dependencies.leo-asg] -path = "../asg" -version = "1.5.3" - [dependencies.leo-parser] path = "../parser" version = "1.5.3" diff --git a/imports/src/parser/import_parser.rs b/imports/src/parser/import_parser.rs index 9fb64a942c..d1603cae63 100644 --- a/imports/src/parser/import_parser.rs +++ b/imports/src/parser/import_parser.rs @@ -19,7 +19,7 @@ use leo_ast_passes::ImportResolver; use leo_errors::{ImportError, LeoError, Result, Span}; use indexmap::{IndexMap, IndexSet}; -use std::{collections::HashMap, path::PathBuf}; +use std::path::PathBuf; /// Stores imported packages. /// @@ -30,11 +30,11 @@ pub struct ImportParser { program_path: PathBuf, partial_imports: IndexSet, imports: IndexMap, - pub imports_map: HashMap, + pub imports_map: IndexMap, } impl ImportParser { - pub fn new(program_path: PathBuf, imports_map: HashMap) -> Self { + pub fn new(program_path: PathBuf, imports_map: IndexMap) -> Self { ImportParser { program_path, partial_imports: Default::default(), @@ -50,17 +50,21 @@ impl ImportResolver for ImportParser { if self.partial_imports.contains(&full_path) { return Err(ImportError::recursive_imports(full_path, span).into()); } + if let Some(program) = self.imports.get(&full_path) { return Ok(Some(program.clone())); } + let path = self.program_path.clone(); self.partial_imports.insert(full_path.clone()); let mut imports = self.clone(); // Self::default() was previously let program = imports .parse_package(path, package_segments, span) .map_err(|x| -> LeoError { x })?; + self.partial_imports.remove(&full_path); self.imports.insert(full_path, program.clone()); + Ok(Some(program)) } } diff --git a/imports/src/parser/parse_package.rs b/imports/src/parser/parse_package.rs index c041fe57d9..ccc592059c 100644 --- a/imports/src/parser/parse_package.rs +++ b/imports/src/parser/parse_package.rs @@ -51,9 +51,9 @@ impl ImportParser { let package_name = segments[0]; // Fetch a core package - let core_package = package_name.eq("core"); + let core_package = package_name.eq("std"); if core_package { - panic!("attempted to import core package from filesystem"); + panic!("attempted to import std package from filesystem"); } // Trim path if importing from another file diff --git a/leo/commands/test.rs b/leo/commands/test.rs index aa7cef20e3..95f863fafb 100644 --- a/leo/commands/test.rs +++ b/leo/commands/test.rs @@ -27,6 +27,7 @@ use leo_package::{ source::{MainFile, MAIN_FILENAME, SOURCE_DIRECTORY_NAME}, }; +use indexmap::IndexMap; use snarkvm_curves::edwards_bls12::Fq; use std::{convert::TryFrom, path::PathBuf, time::Instant}; use structopt::StructOpt; @@ -109,7 +110,7 @@ impl Command for Test { output_directory.clone(), thread_leaked_context(), Some(self.compiler_options.clone().into()), - std::collections::HashMap::new(), + IndexMap::new(), Some(self.compiler_options.clone().into()), )?; diff --git a/package/src/root/lock_file.rs b/package/src/root/lock_file.rs index 82b00c5f8f..3846a45bf5 100644 --- a/package/src/root/lock_file.rs +++ b/package/src/root/lock_file.rs @@ -21,7 +21,6 @@ use indexmap::IndexMap; use serde::{Deserialize, Serialize}; use std::{ borrow::Cow, - collections::HashMap, convert::TryFrom, fmt::{self, Display}, fs::File, @@ -74,11 +73,11 @@ impl LockFile { Ok(toml::to_string(self).map_err(PackageError::failed_to_serialize_lock_file)?) } - /// Form a HashMap of kind: + /// Form a IndexMap of kind: /// ``` imported_name => package_name ``` /// for all imported packages. - pub fn to_import_map(&self) -> HashMap { - let mut result = HashMap::new(); + pub fn to_import_map(&self) -> IndexMap { + let mut result = IndexMap::new(); for package in self.package.iter() { match &package.import_name { Some(name) => result.insert(name.clone(), package.to_string()), diff --git a/parser/src/tokenizer/lexer.rs b/parser/src/tokenizer/lexer.rs index 3b02c3775e..4770d3ef95 100644 --- a/parser/src/tokenizer/lexer.rs +++ b/parser/src/tokenizer/lexer.rs @@ -516,7 +516,6 @@ impl Token { "Self" => Token::BigSelf, "self" => Token::LittleSelf, "static" => Token::Static, - "string" => Token::String, "true" => Token::True, "type" => Token::Type, "u8" => Token::U8, diff --git a/parser/src/tokenizer/token.rs b/parser/src/tokenizer/token.rs index 16d1edc190..f66820c17e 100644 --- a/parser/src/tokenizer/token.rs +++ b/parser/src/tokenizer/token.rs @@ -137,7 +137,6 @@ pub enum Token { Mut, Return, Static, - String, Type, // Not yet in ABNF // BitAnd, @@ -192,7 +191,6 @@ pub const KEYWORD_TOKENS: &[Token] = &[ Token::BigSelf, Token::LittleSelf, Token::Static, - Token::String, Token::True, Token::Type, Token::U8, @@ -305,7 +303,6 @@ impl fmt::Display for Token { Mut => write!(f, "mut"), Return => write!(f, "return"), Static => write!(f, "static"), - String => write!(f, "string"), Type => write!(f, "type"), Eof => write!(f, ""), // BitAnd => write!(f, "&"), diff --git a/stdlib/Cargo.toml b/stdlib/Cargo.toml new file mode 100644 index 0000000000..abe318cd28 --- /dev/null +++ b/stdlib/Cargo.toml @@ -0,0 +1,37 @@ +[package] +name = "leo-stdlib" +version = "1.5.3" +authors = [ "The Aleo Team " ] +description = "The Leo programming language" +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" + +[lib] +path = "src/lib.rs" + +[dependencies] +indexmap = "1.7.0" +include_dir = "0.6.1" + +[dependencies.leo-ast] +path = "../ast" +version = "1.5.3" + +[dependencies.leo-errors] +path = "../errors" +version = "1.5.3" + +[dependencies.leo-parser] +path = "../parser" +version = "1.5.3" diff --git a/stdlib/LICENSE.md b/stdlib/LICENSE.md new file mode 100644 index 0000000000..b95c626e2a --- /dev/null +++ b/stdlib/LICENSE.md @@ -0,0 +1,596 @@ +GNU General Public License +========================== + +Version 3, 29 June 2007 + +Copyright © 2007 Free Software Foundation, Inc. <> + +Everyone is permitted to copy and distribute verbatim copies of this license +document, but changing it is not allowed. + +## Preamble + +The GNU General Public License is a free, copyleft license for software and other +kinds of works. + +The licenses for most software and other practical works are designed to take away +your freedom to share and change the works. By contrast, the GNU General Public +License is intended to guarantee your freedom to share and change all versions of a +program--to make sure it remains free software for all its users. We, the Free +Software Foundation, use the GNU General Public License for most of our software; it +applies also to any other work released this way by its authors. You can apply it to +your programs, too. + +When we speak of free software, we are referring to freedom, not price. Our General +Public Licenses are designed to make sure that you have the freedom to distribute +copies of free software (and charge for them if you wish), that you receive source +code or can get it if you want it, that you can change the software or use pieces of +it in new free programs, and that you know you can do these things. + +To protect your rights, we need to prevent others from denying you these rights or +asking you to surrender the rights. Therefore, you have certain responsibilities if +you distribute copies of the software, or if you modify it: responsibilities to +respect the freedom of others. + +For example, if you distribute copies of such a program, whether gratis or for a fee, +you must pass on to the recipients the same freedoms that you received. You must make +sure that they, too, receive or can get the source code. And you must show them these +terms so they know their rights. + +Developers that use the GNU GPL protect your rights with two steps: **(1)** assert +copyright on the software, and **(2)** offer you this License giving you legal permission +to copy, distribute and/or modify it. + +For the developers' and authors' protection, the GPL clearly explains that there is +no warranty for this free software. For both users' and authors' sake, the GPL +requires that modified versions be marked as changed, so that their problems will not +be attributed erroneously to authors of previous versions. + +Some devices are designed to deny users access to install or run modified versions of +the software inside them, although the manufacturer can do so. This is fundamentally +incompatible with the aim of protecting users' freedom to change the software. The +systematic pattern of such abuse occurs in the area of products for individuals to +use, which is precisely where it is most unacceptable. Therefore, we have designed +this version of the GPL to prohibit the practice for those products. If such problems +arise substantially in other domains, we stand ready to extend this provision to +those domains in future versions of the GPL, as needed to protect the freedom of +users. + +Finally, every program is threatened constantly by software patents. States should +not allow patents to restrict development and use of software on general-purpose +computers, but in those that do, we wish to avoid the special danger that patents +applied to a free program could make it effectively proprietary. To prevent this, the +GPL assures that patents cannot be used to render the program non-free. + +The precise terms and conditions for copying, distribution and modification follow. + +## TERMS AND CONDITIONS + +### 0. Definitions + +“This License” refers to version 3 of the GNU General Public License. + +“Copyright” also means copyright-like laws that apply to other kinds of +works, such as semiconductor masks. + +“The Program” refers to any copyrightable work licensed under this +License. Each licensee is addressed as “you”. “Licensees” and +“recipients” may be individuals or organizations. + +To “modify” a work means to copy from or adapt all or part of the work in +a fashion requiring copyright permission, other than the making of an exact copy. The +resulting work is called a “modified version” of the earlier work or a +work “based on” the earlier work. + +A “covered work” means either the unmodified Program or a work based on +the Program. + +To “propagate” a work means to do anything with it that, without +permission, would make you directly or secondarily liable for infringement under +applicable copyright law, except executing it on a computer or modifying a private +copy. Propagation includes copying, distribution (with or without modification), +making available to the public, and in some countries other activities as well. + +To “convey” a work means any kind of propagation that enables other +parties to make or receive copies. Mere interaction with a user through a computer +network, with no transfer of a copy, is not conveying. + +An interactive user interface displays “Appropriate Legal Notices” to the +extent that it includes a convenient and prominently visible feature that **(1)** +displays an appropriate copyright notice, and **(2)** tells the user that there is no +warranty for the work (except to the extent that warranties are provided), that +licensees may convey the work under this License, and how to view a copy of this +License. If the interface presents a list of user commands or options, such as a +menu, a prominent item in the list meets this criterion. + +### 1. Source Code + +The “source code” for a work means the preferred form of the work for +making modifications to it. “Object code” means any non-source form of a +work. + +A “Standard Interface” means an interface that either is an official +standard defined by a recognized standards body, or, in the case of interfaces +specified for a particular programming language, one that is widely used among +developers working in that language. + +The “System Libraries” of an executable work include anything, other than +the work as a whole, that **(a)** is included in the normal form of packaging a Major +Component, but which is not part of that Major Component, and **(b)** serves only to +enable use of the work with that Major Component, or to implement a Standard +Interface for which an implementation is available to the public in source code form. +A “Major Component”, in this context, means a major essential component +(kernel, window system, and so on) of the specific operating system (if any) on which +the executable work runs, or a compiler used to produce the work, or an object code +interpreter used to run it. + +The “Corresponding Source” for a work in object code form means all the +source code needed to generate, install, and (for an executable work) run the object +code and to modify the work, including scripts to control those activities. However, +it does not include the work's System Libraries, or general-purpose tools or +generally available free programs which are used unmodified in performing those +activities but which are not part of the work. For example, Corresponding Source +includes interface definition files associated with source files for the work, and +the source code for shared libraries and dynamically linked subprograms that the work +is specifically designed to require, such as by intimate data communication or +control flow between those subprograms and other parts of the work. + +The Corresponding Source need not include anything that users can regenerate +automatically from other parts of the Corresponding Source. + +The Corresponding Source for a work in source code form is that same work. + +### 2. Basic Permissions + +All rights granted under this License are granted for the term of copyright on the +Program, and are irrevocable provided the stated conditions are met. This License +explicitly affirms your unlimited permission to run the unmodified Program. The +output from running a covered work is covered by this License only if the output, +given its content, constitutes a covered work. This License acknowledges your rights +of fair use or other equivalent, as provided by copyright law. + +You may make, run and propagate covered works that you do not convey, without +conditions so long as your license otherwise remains in force. You may convey covered +works to others for the sole purpose of having them make modifications exclusively +for you, or provide you with facilities for running those works, provided that you +comply with the terms of this License in conveying all material for which you do not +control copyright. Those thus making or running the covered works for you must do so +exclusively on your behalf, under your direction and control, on terms that prohibit +them from making any copies of your copyrighted material outside their relationship +with you. + +Conveying under any other circumstances is permitted solely under the conditions +stated below. Sublicensing is not allowed; section 10 makes it unnecessary. + +### 3. Protecting Users' Legal Rights From Anti-Circumvention Law + +No covered work shall be deemed part of an effective technological measure under any +applicable law fulfilling obligations under article 11 of the WIPO copyright treaty +adopted on 20 December 1996, or similar laws prohibiting or restricting circumvention +of such measures. + +When you convey a covered work, you waive any legal power to forbid circumvention of +technological measures to the extent such circumvention is effected by exercising +rights under this License with respect to the covered work, and you disclaim any +intention to limit operation or modification of the work as a means of enforcing, +against the work's users, your or third parties' legal rights to forbid circumvention +of technological measures. + +### 4. Conveying Verbatim Copies + +You may convey verbatim copies of the Program's source code as you receive it, in any +medium, provided that you conspicuously and appropriately publish on each copy an +appropriate copyright notice; keep intact all notices stating that this License and +any non-permissive terms added in accord with section 7 apply to the code; keep +intact all notices of the absence of any warranty; and give all recipients a copy of +this License along with the Program. + +You may charge any price or no price for each copy that you convey, and you may offer +support or warranty protection for a fee. + +### 5. Conveying Modified Source Versions + +You may convey a work based on the Program, or the modifications to produce it from +the Program, in the form of source code under the terms of section 4, provided that +you also meet all of these conditions: + +* **a)** The work must carry prominent notices stating that you modified it, and giving a +relevant date. +* **b)** The work must carry prominent notices stating that it is released under this +License and any conditions added under section 7. This requirement modifies the +requirement in section 4 to “keep intact all notices”. +* **c)** You must license the entire work, as a whole, under this License to anyone who +comes into possession of a copy. This License will therefore apply, along with any +applicable section 7 additional terms, to the whole of the work, and all its parts, +regardless of how they are packaged. This License gives no permission to license the +work in any other way, but it does not invalidate such permission if you have +separately received it. +* **d)** If the work has interactive user interfaces, each must display Appropriate Legal +Notices; however, if the Program has interactive interfaces that do not display +Appropriate Legal Notices, your work need not make them do so. + +A compilation of a covered work with other separate and independent works, which are +not by their nature extensions of the covered work, and which are not combined with +it such as to form a larger program, in or on a volume of a storage or distribution +medium, is called an “aggregate” if the compilation and its resulting +copyright are not used to limit the access or legal rights of the compilation's users +beyond what the individual works permit. Inclusion of a covered work in an aggregate +does not cause this License to apply to the other parts of the aggregate. + +### 6. Conveying Non-Source Forms + +You may convey a covered work in object code form under the terms of sections 4 and +5, provided that you also convey the machine-readable Corresponding Source under the +terms of this License, in one of these ways: + +* **a)** Convey the object code in, or embodied in, a physical product (including a +physical distribution medium), accompanied by the Corresponding Source fixed on a +durable physical medium customarily used for software interchange. +* **b)** Convey the object code in, or embodied in, a physical product (including a +physical distribution medium), accompanied by a written offer, valid for at least +three years and valid for as long as you offer spare parts or customer support for +that product model, to give anyone who possesses the object code either **(1)** a copy of +the Corresponding Source for all the software in the product that is covered by this +License, on a durable physical medium customarily used for software interchange, for +a price no more than your reasonable cost of physically performing this conveying of +source, or **(2)** access to copy the Corresponding Source from a network server at no +charge. +* **c)** Convey individual copies of the object code with a copy of the written offer to +provide the Corresponding Source. This alternative is allowed only occasionally and +noncommercially, and only if you received the object code with such an offer, in +accord with subsection 6b. +* **d)** Convey the object code by offering access from a designated place (gratis or for +a charge), and offer equivalent access to the Corresponding Source in the same way +through the same place at no further charge. You need not require recipients to copy +the Corresponding Source along with the object code. If the place to copy the object +code is a network server, the Corresponding Source may be on a different server +(operated by you or a third party) that supports equivalent copying facilities, +provided you maintain clear directions next to the object code saying where to find +the Corresponding Source. Regardless of what server hosts the Corresponding Source, +you remain obligated to ensure that it is available for as long as needed to satisfy +these requirements. +* **e)** Convey the object code using peer-to-peer transmission, provided you inform +other peers where the object code and Corresponding Source of the work are being +offered to the general public at no charge under subsection 6d. + +A separable portion of the object code, whose source code is excluded from the +Corresponding Source as a System Library, need not be included in conveying the +object code work. + +A “User Product” is either **(1)** a “consumer product”, which +means any tangible personal property which is normally used for personal, family, or +household purposes, or **(2)** anything designed or sold for incorporation into a +dwelling. In determining whether a product is a consumer product, doubtful cases +shall be resolved in favor of coverage. For a particular product received by a +particular user, “normally used” refers to a typical or common use of +that class of product, regardless of the status of the particular user or of the way +in which the particular user actually uses, or expects or is expected to use, the +product. A product is a consumer product regardless of whether the product has +substantial commercial, industrial or non-consumer uses, unless such uses represent +the only significant mode of use of the product. + +“Installation Information” for a User Product means any methods, +procedures, authorization keys, or other information required to install and execute +modified versions of a covered work in that User Product from a modified version of +its Corresponding Source. The information must suffice to ensure that the continued +functioning of the modified object code is in no case prevented or interfered with +solely because modification has been made. + +If you convey an object code work under this section in, or with, or specifically for +use in, a User Product, and the conveying occurs as part of a transaction in which +the right of possession and use of the User Product is transferred to the recipient +in perpetuity or for a fixed term (regardless of how the transaction is +characterized), the Corresponding Source conveyed under this section must be +accompanied by the Installation Information. But this requirement does not apply if +neither you nor any third party retains the ability to install modified object code +on the User Product (for example, the work has been installed in ROM). + +The requirement to provide Installation Information does not include a requirement to +continue to provide support service, warranty, or updates for a work that has been +modified or installed by the recipient, or for the User Product in which it has been +modified or installed. Access to a network may be denied when the modification itself +materially and adversely affects the operation of the network or violates the rules +and protocols for communication across the network. + +Corresponding Source conveyed, and Installation Information provided, in accord with +this section must be in a format that is publicly documented (and with an +implementation available to the public in source code form), and must require no +special password or key for unpacking, reading or copying. + +### 7. Additional Terms + +“Additional permissions” are terms that supplement the terms of this +License by making exceptions from one or more of its conditions. Additional +permissions that are applicable to the entire Program shall be treated as though they +were included in this License, to the extent that they are valid under applicable +law. If additional permissions apply only to part of the Program, that part may be +used separately under those permissions, but the entire Program remains governed by +this License without regard to the additional permissions. + +When you convey a copy of a covered work, you may at your option remove any +additional permissions from that copy, or from any part of it. (Additional +permissions may be written to require their own removal in certain cases when you +modify the work.) You may place additional permissions on material, added by you to a +covered work, for which you have or can give appropriate copyright permission. + +Notwithstanding any other provision of this License, for material you add to a +covered work, you may (if authorized by the copyright holders of that material) +supplement the terms of this License with terms: + +* **a)** Disclaiming warranty or limiting liability differently from the terms of +sections 15 and 16 of this License; or +* **b)** Requiring preservation of specified reasonable legal notices or author +attributions in that material or in the Appropriate Legal Notices displayed by works +containing it; or +* **c)** Prohibiting misrepresentation of the origin of that material, or requiring that +modified versions of such material be marked in reasonable ways as different from the +original version; or +* **d)** Limiting the use for publicity purposes of names of licensors or authors of the +material; or +* **e)** Declining to grant rights under trademark law for use of some trade names, +trademarks, or service marks; or +* **f)** Requiring indemnification of licensors and authors of that material by anyone +who conveys the material (or modified versions of it) with contractual assumptions of +liability to the recipient, for any liability that these contractual assumptions +directly impose on those licensors and authors. + +All other non-permissive additional terms are considered “further +restrictions” within the meaning of section 10. If the Program as you received +it, or any part of it, contains a notice stating that it is governed by this License +along with a term that is a further restriction, you may remove that term. If a +license document contains a further restriction but permits relicensing or conveying +under this License, you may add to a covered work material governed by the terms of +that license document, provided that the further restriction does not survive such +relicensing or conveying. + +If you add terms to a covered work in accord with this section, you must place, in +the relevant source files, a statement of the additional terms that apply to those +files, or a notice indicating where to find the applicable terms. + +Additional terms, permissive or non-permissive, may be stated in the form of a +separately written license, or stated as exceptions; the above requirements apply +either way. + +### 8. Termination + +You may not propagate or modify a covered work except as expressly provided under +this License. Any attempt otherwise to propagate or modify it is void, and will +automatically terminate your rights under this License (including any patent licenses +granted under the third paragraph of section 11). + +However, if you cease all violation of this License, then your license from a +particular copyright holder is reinstated **(a)** provisionally, unless and until the +copyright holder explicitly and finally terminates your license, and **(b)** permanently, +if the copyright holder fails to notify you of the violation by some reasonable means +prior to 60 days after the cessation. + +Moreover, your license from a particular copyright holder is reinstated permanently +if the copyright holder notifies you of the violation by some reasonable means, this +is the first time you have received notice of violation of this License (for any +work) from that copyright holder, and you cure the violation prior to 30 days after +your receipt of the notice. + +Termination of your rights under this section does not terminate the licenses of +parties who have received copies or rights from you under this License. If your +rights have been terminated and not permanently reinstated, you do not qualify to +receive new licenses for the same material under section 10. + +### 9. Acceptance Not Required for Having Copies + +You are not required to accept this License in order to receive or run a copy of the +Program. Ancillary propagation of a covered work occurring solely as a consequence of +using peer-to-peer transmission to receive a copy likewise does not require +acceptance. However, nothing other than this License grants you permission to +propagate or modify any covered work. These actions infringe copyright if you do not +accept this License. Therefore, by modifying or propagating a covered work, you +indicate your acceptance of this License to do so. + +### 10. Automatic Licensing of Downstream Recipients + +Each time you convey a covered work, the recipient automatically receives a license +from the original licensors, to run, modify and propagate that work, subject to this +License. You are not responsible for enforcing compliance by third parties with this +License. + +An “entity transaction” is a transaction transferring control of an +organization, or substantially all assets of one, or subdividing an organization, or +merging organizations. If propagation of a covered work results from an entity +transaction, each party to that transaction who receives a copy of the work also +receives whatever licenses to the work the party's predecessor in interest had or +could give under the previous paragraph, plus a right to possession of the +Corresponding Source of the work from the predecessor in interest, if the predecessor +has it or can get it with reasonable efforts. + +You may not impose any further restrictions on the exercise of the rights granted or +affirmed under this License. For example, you may not impose a license fee, royalty, +or other charge for exercise of rights granted under this License, and you may not +initiate litigation (including a cross-claim or counterclaim in a lawsuit) alleging +that any patent claim is infringed by making, using, selling, offering for sale, or +importing the Program or any portion of it. + +### 11. Patents + +A “contributor” is a copyright holder who authorizes use under this +License of the Program or a work on which the Program is based. The work thus +licensed is called the contributor's “contributor version”. + +A contributor's “essential patent claims” are all patent claims owned or +controlled by the contributor, whether already acquired or hereafter acquired, that +would be infringed by some manner, permitted by this License, of making, using, or +selling its contributor version, but do not include claims that would be infringed +only as a consequence of further modification of the contributor version. For +purposes of this definition, “control” includes the right to grant patent +sublicenses in a manner consistent with the requirements of this License. + +Each contributor grants you a non-exclusive, worldwide, royalty-free patent license +under the contributor's essential patent claims, to make, use, sell, offer for sale, +import and otherwise run, modify and propagate the contents of its contributor +version. + +In the following three paragraphs, a “patent license” is any express +agreement or commitment, however denominated, not to enforce a patent (such as an +express permission to practice a patent or covenant not to sue for patent +infringement). To “grant” such a patent license to a party means to make +such an agreement or commitment not to enforce a patent against the party. + +If you convey a covered work, knowingly relying on a patent license, and the +Corresponding Source of the work is not available for anyone to copy, free of charge +and under the terms of this License, through a publicly available network server or +other readily accessible means, then you must either **(1)** cause the Corresponding +Source to be so available, or **(2)** arrange to deprive yourself of the benefit of the +patent license for this particular work, or **(3)** arrange, in a manner consistent with +the requirements of this License, to extend the patent license to downstream +recipients. “Knowingly relying” means you have actual knowledge that, but +for the patent license, your conveying the covered work in a country, or your +recipient's use of the covered work in a country, would infringe one or more +identifiable patents in that country that you have reason to believe are valid. + +If, pursuant to or in connection with a single transaction or arrangement, you +convey, or propagate by procuring conveyance of, a covered work, and grant a patent +license to some of the parties receiving the covered work authorizing them to use, +propagate, modify or convey a specific copy of the covered work, then the patent +license you grant is automatically extended to all recipients of the covered work and +works based on it. + +A patent license is “discriminatory” if it does not include within the +scope of its coverage, prohibits the exercise of, or is conditioned on the +non-exercise of one or more of the rights that are specifically granted under this +License. You may not convey a covered work if you are a party to an arrangement with +a third party that is in the business of distributing software, under which you make +payment to the third party based on the extent of your activity of conveying the +work, and under which the third party grants, to any of the parties who would receive +the covered work from you, a discriminatory patent license **(a)** in connection with +copies of the covered work conveyed by you (or copies made from those copies), or **(b)** +primarily for and in connection with specific products or compilations that contain +the covered work, unless you entered into that arrangement, or that patent license +was granted, prior to 28 March 2007. + +Nothing in this License shall be construed as excluding or limiting any implied +license or other defenses to infringement that may otherwise be available to you +under applicable patent law. + +### 12. No Surrender of Others' Freedom + +If conditions are imposed on you (whether by court order, agreement or otherwise) +that contradict the conditions of this License, they do not excuse you from the +conditions of this License. If you cannot convey a covered work so as to satisfy +simultaneously your obligations under this License and any other pertinent +obligations, then as a consequence you may not convey it at all. For example, if you +agree to terms that obligate you to collect a royalty for further conveying from +those to whom you convey the Program, the only way you could satisfy both those terms +and this License would be to refrain entirely from conveying the Program. + +### 13. Use with the GNU Affero General Public License + +Notwithstanding any other provision of this License, you have permission to link or +combine any covered work with a work licensed under version 3 of the GNU Affero +General Public License into a single combined work, and to convey the resulting work. +The terms of this License will continue to apply to the part which is the covered +work, but the special requirements of the GNU Affero General Public License, section +13, concerning interaction through a network will apply to the combination as such. + +### 14. Revised Versions of this License + +The Free Software Foundation may publish revised and/or new versions of the GNU +General Public License from time to time. Such new versions will be similar in spirit +to the present version, but may differ in detail to address new problems or concerns. + +Each version is given a distinguishing version number. If the Program specifies that +a certain numbered version of the GNU General Public License “or any later +version” applies to it, you have the option of following the terms and +conditions either of that numbered version or of any later version published by the +Free Software Foundation. If the Program does not specify a version number of the GNU +General Public License, you may choose any version ever published by the Free +Software Foundation. + +If the Program specifies that a proxy can decide which future versions of the GNU +General Public License can be used, that proxy's public statement of acceptance of a +version permanently authorizes you to choose that version for the Program. + +Later license versions may give you additional or different permissions. However, no +additional obligations are imposed on any author or copyright holder as a result of +your choosing to follow a later version. + +### 15. Disclaimer of Warranty + +THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY APPLICABLE LAW. +EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR OTHER PARTIES +PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY OF ANY KIND, EITHER +EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF +MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE ENTIRE RISK AS TO THE +QUALITY AND PERFORMANCE OF THE PROGRAM IS WITH YOU. SHOULD THE PROGRAM PROVE +DEFECTIVE, YOU ASSUME THE COST OF ALL NECESSARY SERVICING, REPAIR OR CORRECTION. + +### 16. Limitation of Liability + +IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING WILL ANY +COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS THE PROGRAM AS +PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY GENERAL, SPECIAL, +INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE +PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE +OR LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE +WITH ANY OTHER PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE +POSSIBILITY OF SUCH DAMAGES. + +### 17. Interpretation of Sections 15 and 16 + +If the disclaimer of warranty and limitation of liability provided above cannot be +given local legal effect according to their terms, reviewing courts shall apply local +law that most closely approximates an absolute waiver of all civil liability in +connection with the Program, unless a warranty or assumption of liability accompanies +a copy of the Program in return for a fee. + +_END OF TERMS AND CONDITIONS_ + +## How to Apply These Terms to Your New Programs + +If you develop a new program, and you want it to be of the greatest possible use to +the public, the best way to achieve this is to make it free software which everyone +can redistribute and change under these terms. + +To do so, attach the following notices to the program. It is safest to attach them +to the start of each source file to most effectively state the exclusion of warranty; +and each file should have at least the “copyright” line and a pointer to +where the full notice is found. + + + Copyright (C) + + This program 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. + + This program 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 this program. If not, see . + +Also add information on how to contact you by electronic and paper mail. + +If the program does terminal interaction, make it output a short notice like this +when it starts in an interactive mode: + + Copyright (C) + This program comes with ABSOLUTELY NO WARRANTY; for details type 'show w'. + This is free software, and you are welcome to redistribute it + under certain conditions; type 'show c' for details. + +The hypothetical commands `show w` and `show c` should show the appropriate parts of +the General Public License. Of course, your program's commands might be different; +for a GUI interface, you would use an “about box”. + +You should also get your employer (if you work as a programmer) or school, if any, to +sign a “copyright disclaimer” for the program, if necessary. For more +information on this, and how to apply and follow the GNU GPL, see +<>. + +The GNU General Public License does not permit incorporating your program into +proprietary programs. If your program is a subroutine library, you may consider it +more useful to permit linking proprietary applications with the library. If this is +what you want to do, use the GNU Lesser General Public License instead of this +License. But first, please read +<>. diff --git a/stdlib/README.md b/stdlib/README.md new file mode 100644 index 0000000000..c8542eb8cd --- /dev/null +++ b/stdlib/README.md @@ -0,0 +1 @@ +# leo-ast-passes diff --git a/stdlib/prelude/string.leo b/stdlib/prelude/string.leo new file mode 100644 index 0000000000..368506f062 --- /dev/null +++ b/stdlib/prelude/string.leo @@ -0,0 +1 @@ +type string = [char; _]; \ No newline at end of file diff --git a/stdlib/src/lib.rs b/stdlib/src/lib.rs new file mode 100644 index 0000000000..82b82607bf --- /dev/null +++ b/stdlib/src/lib.rs @@ -0,0 +1,71 @@ +// 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 . + +#![doc = include_str!("../README.md")] + +use leo_ast::Program; +use leo_errors::Result; + +#[macro_use] +extern crate include_dir; + +use include_dir::Dir; +use indexmap::IndexMap; + +static STDLIB: Dir = include_dir!("."); + +fn resolve_file(file: &str, mapping: &str) -> Result> { + let resolved = if let Some(resolved) = STDLIB.get_file(&file).map(|f| f.contents_utf8()).flatten() { + resolved + } else { + return Ok(None); + }; + + let ast = leo_parser::parse_ast(&file, resolved)?.into_repr(); + ast.set_core_mapping(mapping); + + Ok(Some(ast)) +} + +pub fn resolve_prelude_modules() -> Result, Program>> { + let mut preludes: IndexMap, Program> = IndexMap::new(); + + for module in STDLIB.find("prelude/*.leo").unwrap() { + let path = module.path().to_str().unwrap().replace("\\", "/"); + let program = resolve_file(&path, "")?.unwrap(); + + let removed_extension = path.replace(".leo", ""); + let mut parts: Vec = vec![String::from("std")]; + parts.append( + &mut removed_extension + .split('/') + .map(str::to_string) + .collect::>(), + ); + preludes.insert(parts, program); + } + + Ok(preludes) +} + +pub fn resolve_stdlib_module(module: &str) -> Result> { + let mut file_path = module.replace(".", "/"); + file_path.push_str(".leo"); + + let mapping = if module == "unstable.blake2s" { module } else { "" }; + + resolve_file(&file_path, mapping) +} diff --git a/stdlib/unstable/blake2s.leo b/stdlib/unstable/blake2s.leo new file mode 100644 index 0000000000..65f5055082 --- /dev/null +++ b/stdlib/unstable/blake2s.leo @@ -0,0 +1,5 @@ +circuit Blake2s { + function hash(seed: [u8; 32], message: [u8; 32]) -> [u8; 32] { + return [0; 32]; + } +} \ No newline at end of file diff --git a/tests/compiler/core/core_circuit_invalid.leo b/tests/compiler/core/core_circuit_invalid.leo deleted file mode 100644 index f5c6762e8b..0000000000 --- a/tests/compiler/core/core_circuit_invalid.leo +++ /dev/null @@ -1,8 +0,0 @@ -/* -namespace: Compile -expectation: Fail -*/ - -import core.unstable.blake2s.BadCircuit; // `BadCircuit` is not included in the blake2s package - -function main() {} diff --git a/tests/compiler/core/core_circuit_star_fail.leo b/tests/compiler/core/core_circuit_star_fail.leo deleted file mode 100644 index f0831b33e3..0000000000 --- a/tests/compiler/core/core_circuit_star_fail.leo +++ /dev/null @@ -1,8 +0,0 @@ -/* -namespace: Compile -expectation: Fail -*/ - -import core.*; // You cannot import all dependencies from core at once - -function main() {} diff --git a/tests/compiler/core/core_unstable_package_invalid.leo b/tests/compiler/core/core_unstable_package_invalid.leo deleted file mode 100644 index 6c22b34fa7..0000000000 --- a/tests/compiler/core/core_unstable_package_invalid.leo +++ /dev/null @@ -1,8 +0,0 @@ -/* -namespace: Compile -expectation: Fail -*/ - -import core.unstable.bad_circuit; // `bad_circuit` is not a core unstable package - -function main() {} diff --git a/tests/compiler/definition/out_of_order_with_import.leo b/tests/compiler/definition/out_of_order_with_import.leo index 4af7ca1b8a..33aa621c8d 100644 --- a/tests/compiler/definition/out_of_order_with_import.leo +++ b/tests/compiler/definition/out_of_order_with_import.leo @@ -11,7 +11,7 @@ function main(y: bool) -> bool { return y == true; } -// use core import to test import order -import core.unstable.blake2s.Blake2s; +// use std import to test import order +import std.unstable.blake2s.Blake2s; circuit Foo {} diff --git a/tests/compiler/core/blake2s.leo b/tests/compiler/stdlib/blake2s.leo similarity index 57% rename from tests/compiler/core/blake2s.leo rename to tests/compiler/stdlib/blake2s.leo index 2786313eba..ca313661a6 100644 --- a/tests/compiler/core/blake2s.leo +++ b/tests/compiler/stdlib/blake2s.leo @@ -3,7 +3,7 @@ // input_files: // - input/dummy.in -import core.unstable.blake2s.BadCircuit; // `BadCircuit` is not included in the blake2s package +import std.unstable.blake2s.BadCircuit; // `BadCircuit` is not included in the blake2s package function main() -> bool { return false; diff --git a/tests/compiler/stdlib/core_circuit_invalid.leo b/tests/compiler/stdlib/core_circuit_invalid.leo new file mode 100644 index 0000000000..a98b491050 --- /dev/null +++ b/tests/compiler/stdlib/core_circuit_invalid.leo @@ -0,0 +1,8 @@ +/* +namespace: Compile +expectation: Fail +*/ + +import std.unstable.blake2s.BadCircuit; // `BadCircuit` is not included in the blake2s package + +function main() {} diff --git a/tests/compiler/stdlib/core_circuit_star_fail.leo b/tests/compiler/stdlib/core_circuit_star_fail.leo new file mode 100644 index 0000000000..c3446ab5dc --- /dev/null +++ b/tests/compiler/stdlib/core_circuit_star_fail.leo @@ -0,0 +1,8 @@ +/* +namespace: Compile +expectation: Fail +*/ + +import std.*; // You cannot import all dependencies from core at once + +function main() {} diff --git a/tests/compiler/core/core_package_invalid.leo b/tests/compiler/stdlib/core_package_invalid.leo similarity index 50% rename from tests/compiler/core/core_package_invalid.leo rename to tests/compiler/stdlib/core_package_invalid.leo index d4ef2e220e..8f797c9cb7 100644 --- a/tests/compiler/core/core_package_invalid.leo +++ b/tests/compiler/stdlib/core_package_invalid.leo @@ -3,6 +3,6 @@ namespace: Compile expectation: Fail */ -import core.bad_circuit; // `bad_circuit` is not a core package +import std.bad_circuit; // `bad_circuit` is not a core package function main() {} diff --git a/tests/compiler/stdlib/core_unstable_package_invalid.leo b/tests/compiler/stdlib/core_unstable_package_invalid.leo new file mode 100644 index 0000000000..d01040a92c --- /dev/null +++ b/tests/compiler/stdlib/core_unstable_package_invalid.leo @@ -0,0 +1,8 @@ +/* +namespace: Compile +expectation: Fail +*/ + +import std.unstable.bad_circuit; // `bad_circuit` is not a core unstable package + +function main() {} diff --git a/tests/compiler/core/packages/unstable/_blake2s/arguments_length_fail.leo b/tests/compiler/stdlib/packages/unstable/_blake2s/arguments_length_fail.leo similarity index 100% rename from tests/compiler/core/packages/unstable/_blake2s/arguments_length_fail.leo rename to tests/compiler/stdlib/packages/unstable/_blake2s/arguments_length_fail.leo diff --git a/tests/compiler/core/packages/unstable/_blake2s/arguments_type_fail.leo b/tests/compiler/stdlib/packages/unstable/_blake2s/arguments_type_fail.leo similarity index 100% rename from tests/compiler/core/packages/unstable/_blake2s/arguments_type_fail.leo rename to tests/compiler/stdlib/packages/unstable/_blake2s/arguments_type_fail.leo diff --git a/tests/compiler/core/packages/unstable/_blake2s/blake2s_input.leo b/tests/compiler/stdlib/packages/unstable/_blake2s/blake2s_input.leo similarity index 100% rename from tests/compiler/core/packages/unstable/_blake2s/blake2s_input.leo rename to tests/compiler/stdlib/packages/unstable/_blake2s/blake2s_input.leo diff --git a/tests/compiler/core/packages/unstable/_blake2s/blake2s_random.leo b/tests/compiler/stdlib/packages/unstable/_blake2s/blake2s_random.leo similarity index 100% rename from tests/compiler/core/packages/unstable/_blake2s/blake2s_random.leo rename to tests/compiler/stdlib/packages/unstable/_blake2s/blake2s_random.leo diff --git a/tests/compiler/core/packages/unstable/_blake2s/inputs/valid_input.in b/tests/compiler/stdlib/packages/unstable/_blake2s/inputs/valid_input.in similarity index 100% rename from tests/compiler/core/packages/unstable/_blake2s/inputs/valid_input.in rename to tests/compiler/stdlib/packages/unstable/_blake2s/inputs/valid_input.in diff --git a/tests/compiler/core/packages/unstable/_blake2s/mod.rs b/tests/compiler/stdlib/packages/unstable/_blake2s/mod.rs similarity index 100% rename from tests/compiler/core/packages/unstable/_blake2s/mod.rs rename to tests/compiler/stdlib/packages/unstable/_blake2s/mod.rs diff --git a/tests/compiler/core/packages/unstable/_blake2s/outputs/valid_output.out b/tests/compiler/stdlib/packages/unstable/_blake2s/outputs/valid_output.out similarity index 100% rename from tests/compiler/core/packages/unstable/_blake2s/outputs/valid_output.out rename to tests/compiler/stdlib/packages/unstable/_blake2s/outputs/valid_output.out diff --git a/tests/compiler/stdlib/strings.leo b/tests/compiler/stdlib/strings.leo new file mode 100644 index 0000000000..fb821df58c --- /dev/null +++ b/tests/compiler/stdlib/strings.leo @@ -0,0 +1,15 @@ +// namespace: Compile +// expectation: Pass +// inputs: +// - hello.in: | +// [main] +// hello: [char; 5] = "hello"; + +// [registers] +// r0: bool = true; + +function main(hello: [char; 5]) -> bool { + let hello2: string = "hello"; + + return hello == hello2; +} \ No newline at end of file diff --git a/tests/compiler/core/unstable_blake2s.leo b/tests/compiler/stdlib/unstable_blake2s.leo similarity index 90% rename from tests/compiler/core/unstable_blake2s.leo rename to tests/compiler/stdlib/unstable_blake2s.leo index 6776d8a6ea..7526c3ee45 100644 --- a/tests/compiler/core/unstable_blake2s.leo +++ b/tests/compiler/stdlib/unstable_blake2s.leo @@ -8,7 +8,7 @@ // [registers] // r0: [u8; 32] = [0; 32]; -import core.unstable.blake2s.Blake2s; +import std.unstable.blake2s.Blake2s; function main(message: [u8; 32]) -> [u8; 32] { const seed: [u8; 32] = [1; 32]; diff --git a/tests/expectations/compiler/compiler/address/branch.leo.out b/tests/expectations/compiler/compiler/address/branch.leo.out index 39b1bdba4b..1b7f6be5ef 100644 --- a/tests/expectations/compiler/compiler/address/branch.leo.out +++ b/tests/expectations/compiler/compiler/address/branch.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 32dcc6719d7d1214782cd1ffe02f067eec8adbf1f3820546e539887d4f1334c8 - imports_resolved_ast: 32dcc6719d7d1214782cd1ffe02f067eec8adbf1f3820546e539887d4f1334c8 - canonicalized_ast: 32dcc6719d7d1214782cd1ffe02f067eec8adbf1f3820546e539887d4f1334c8 - type_inferenced_ast: 996f46f1dba11bdde037a8e033ca97870871eb89d4e3e402b59f99fcc0c35323 + imports_resolved_ast: 4e707995ef2cb41edba1339c811ae476bf30a2f65bb09137372a2a0931285260 + canonicalized_ast: 4e707995ef2cb41edba1339c811ae476bf30a2f65bb09137372a2a0931285260 + type_inferenced_ast: e3d743b0cc61c5e785559f469d394ae364f0a338cff37974bfc926497013bdd1 diff --git a/tests/expectations/compiler/compiler/address/equal.leo.out b/tests/expectations/compiler/compiler/address/equal.leo.out index 72f8327413..180d8b66f8 100644 --- a/tests/expectations/compiler/compiler/address/equal.leo.out +++ b/tests/expectations/compiler/compiler/address/equal.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "false" initial_ast: d9d5346dff8f825d58daabb3a4fe2fcd1471a3fb3c80e46e5583c4f6cdb12b2b - imports_resolved_ast: d9d5346dff8f825d58daabb3a4fe2fcd1471a3fb3c80e46e5583c4f6cdb12b2b - canonicalized_ast: d9d5346dff8f825d58daabb3a4fe2fcd1471a3fb3c80e46e5583c4f6cdb12b2b - type_inferenced_ast: 32a303da117b08aebfb74f7454cd80dfe28b07fd464a61b6d6a3ce23d451f135 + imports_resolved_ast: e5e91879622f5e63f1b465a8d1d99b9ad10e128d3b04493def195d81e5c728f3 + canonicalized_ast: e5e91879622f5e63f1b465a8d1d99b9ad10e128d3b04493def195d81e5c728f3 + type_inferenced_ast: 436fd5fbf72020d63c2f462dd271dbeeca6161c68f625e53ab5f827cda3d3d3e diff --git a/tests/expectations/compiler/compiler/address/index.leo.out b/tests/expectations/compiler/compiler/address/index.leo.out index 67a9431af8..7598b4f2b6 100644 --- a/tests/expectations/compiler/compiler/address/index.leo.out +++ b/tests/expectations/compiler/compiler/address/index.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 9961e21337ff8eed0a27fff91fc442c2530a1bfaf80da6d497a93a371896b1f8 - imports_resolved_ast: 9961e21337ff8eed0a27fff91fc442c2530a1bfaf80da6d497a93a371896b1f8 - canonicalized_ast: 9961e21337ff8eed0a27fff91fc442c2530a1bfaf80da6d497a93a371896b1f8 - type_inferenced_ast: cc47000b2cf462f5cb891467cc99f2d21c44ced2198e988dc3de59f166aa1603 + imports_resolved_ast: 763fdfbdda86ca59a4e8c18f0e9e7f87516725d886468a7bf5b5d37bfde140f8 + canonicalized_ast: 763fdfbdda86ca59a4e8c18f0e9e7f87516725d886468a7bf5b5d37bfde140f8 + type_inferenced_ast: 6acc95039938704a57b102cb2b3e61cde8375cc1e7595394b759dfc23a4fbedb diff --git a/tests/expectations/compiler/compiler/address/ternary.leo.out b/tests/expectations/compiler/compiler/address/ternary.leo.out index 55dabfd5e7..ae84a98163 100644 --- a/tests/expectations/compiler/compiler/address/ternary.leo.out +++ b/tests/expectations/compiler/compiler/address/ternary.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "false" initial_ast: 6f8e7a94ccb702790204360959a2673abf6b53027fccaaa9feed8a4e41ee05c1 - imports_resolved_ast: 6f8e7a94ccb702790204360959a2673abf6b53027fccaaa9feed8a4e41ee05c1 - canonicalized_ast: 6f8e7a94ccb702790204360959a2673abf6b53027fccaaa9feed8a4e41ee05c1 - type_inferenced_ast: 91e597663c88fbfd0c6ff787d109f5a71d5357c44d5306f7149714cda86475ae + imports_resolved_ast: e3570e385d638499b9ce95f0266f87e1c5bd72f7ddcd2718fee3f8f7080cf218 + canonicalized_ast: e3570e385d638499b9ce95f0266f87e1c5bd72f7ddcd2718fee3f8f7080cf218 + type_inferenced_ast: c29bc0a2616f928552e44d4e46c363c5707b986737e825855fd0a6165bfa55f3 diff --git a/tests/expectations/compiler/compiler/aliases/arith.leo.out b/tests/expectations/compiler/compiler/aliases/arith.leo.out index f0d844fe99..2f1c4a8c21 100644 --- a/tests/expectations/compiler/compiler/aliases/arith.leo.out +++ b/tests/expectations/compiler/compiler/aliases/arith.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 6349e2684562bad873bcf643e01eeb02039295bd41e2df77f1fefc7bb3f2d3bb - imports_resolved_ast: 6349e2684562bad873bcf643e01eeb02039295bd41e2df77f1fefc7bb3f2d3bb - canonicalized_ast: 6349e2684562bad873bcf643e01eeb02039295bd41e2df77f1fefc7bb3f2d3bb - type_inferenced_ast: 508686ddeb2f8fad60d9ad58639b5a761e6c5f5b61e105803eb8a98d8065a2ad + imports_resolved_ast: 2b00607e4a777539b2abb677ac95108208d03409adb6b672e00d26cada45b1e6 + canonicalized_ast: 2b00607e4a777539b2abb677ac95108208d03409adb6b672e00d26cada45b1e6 + type_inferenced_ast: f0a02b6b326925afb8b1f8fbdafb5686687e695eb4420010d2c8d1564ac0a7b2 diff --git a/tests/expectations/compiler/compiler/aliases/basic.leo.out b/tests/expectations/compiler/compiler/aliases/basic.leo.out index 237825d43d..f5c1b703ed 100644 --- a/tests/expectations/compiler/compiler/aliases/basic.leo.out +++ b/tests/expectations/compiler/compiler/aliases/basic.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 9f78c996da10363fb594947ca29fef29e35a7032761ce87f69f3ae454650d47e - imports_resolved_ast: 9f78c996da10363fb594947ca29fef29e35a7032761ce87f69f3ae454650d47e - canonicalized_ast: 9f78c996da10363fb594947ca29fef29e35a7032761ce87f69f3ae454650d47e - type_inferenced_ast: 103314a18ce6036da1ab4cc32c025b694cf799492460ab9553dfbd5232544a89 + imports_resolved_ast: 32e35e00fe92c3cd71959cacb44d76f19782e5fcdeb57b839f1ff6a37dee3964 + canonicalized_ast: 32e35e00fe92c3cd71959cacb44d76f19782e5fcdeb57b839f1ff6a37dee3964 + type_inferenced_ast: d6afa34bd1c84c58bb1920be76e893f16a0a7ba1a952493679d2e219b70ac13d diff --git a/tests/expectations/compiler/compiler/aliases/circuit.leo.out b/tests/expectations/compiler/compiler/aliases/circuit.leo.out index 530d901e79..ead6b8f2a7 100644 --- a/tests/expectations/compiler/compiler/aliases/circuit.leo.out +++ b/tests/expectations/compiler/compiler/aliases/circuit.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: ee817c17e6bef3b458e14d3a81c087ed6a75c4554bc70b62466e8d8e43ff1b5e - imports_resolved_ast: ee817c17e6bef3b458e14d3a81c087ed6a75c4554bc70b62466e8d8e43ff1b5e - canonicalized_ast: ee817c17e6bef3b458e14d3a81c087ed6a75c4554bc70b62466e8d8e43ff1b5e - type_inferenced_ast: b15c7e773ebb56e339f750401241e38aab4ab8950c20a70acc293afc1b91d917 + imports_resolved_ast: 4c477f127d0f5044d37279a8892ad04dafccb200665044e341f74e2e10152de6 + canonicalized_ast: 4c477f127d0f5044d37279a8892ad04dafccb200665044e341f74e2e10152de6 + type_inferenced_ast: 9c27915c9e63f5a0a05ead01b6a1564c53956ecbc6e90cb7b33f074d423add24 diff --git a/tests/expectations/compiler/compiler/aliases/fn_return.leo.out b/tests/expectations/compiler/compiler/aliases/fn_return.leo.out index 3d3f415760..43a82217e9 100644 --- a/tests/expectations/compiler/compiler/aliases/fn_return.leo.out +++ b/tests/expectations/compiler/compiler/aliases/fn_return.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 8d5ed3110bc3a61ddee37408133fcc1f77209b65bb83d230729203009e093f40 - imports_resolved_ast: 8d5ed3110bc3a61ddee37408133fcc1f77209b65bb83d230729203009e093f40 - canonicalized_ast: 8d5ed3110bc3a61ddee37408133fcc1f77209b65bb83d230729203009e093f40 - type_inferenced_ast: bc54ad21e90ab297b40ff570dfc379cbca61fdc9e20bd6899f4b964f726954b0 + imports_resolved_ast: 3bf9b1a7fe682434578831c20f0ab67ef37aa3a069bc302a99bd8976678158c3 + canonicalized_ast: 3bf9b1a7fe682434578831c20f0ab67ef37aa3a069bc302a99bd8976678158c3 + type_inferenced_ast: 397cf0ec0e99c094c9d2aa4f1a67df6564a2f6ff5c9a2bd82b47fac583598dca diff --git a/tests/expectations/compiler/compiler/aliases/shadowing_arg.leo.out b/tests/expectations/compiler/compiler/aliases/shadowing_arg.leo.out index 5c4e3edf6f..36ecadef97 100644 --- a/tests/expectations/compiler/compiler/aliases/shadowing_arg.leo.out +++ b/tests/expectations/compiler/compiler/aliases/shadowing_arg.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: f7b2eb89c51644dc8596988bcc66fbfe471489887c6f46b78ca417746c7ef442 - imports_resolved_ast: f7b2eb89c51644dc8596988bcc66fbfe471489887c6f46b78ca417746c7ef442 - canonicalized_ast: f7b2eb89c51644dc8596988bcc66fbfe471489887c6f46b78ca417746c7ef442 - type_inferenced_ast: f24ef5063928ee7998b53e5e66064c56c01bd99d55b736309d3a1d11ff2fec05 + imports_resolved_ast: 01a3839714be9b09a1ab61b19adde2a8f45ba6eeb0181f3f746dcf2646f73c7c + canonicalized_ast: 01a3839714be9b09a1ab61b19adde2a8f45ba6eeb0181f3f746dcf2646f73c7c + type_inferenced_ast: 4f5b9e0532f6476cb6a3f11c4c08d4c59b3e67db76f4358b77e77c6d8fdd8a22 diff --git a/tests/expectations/compiler/compiler/aliases/shadowing_var_allowed.leo.out b/tests/expectations/compiler/compiler/aliases/shadowing_var_allowed.leo.out index 6027b63169..e4949fffc9 100644 --- a/tests/expectations/compiler/compiler/aliases/shadowing_var_allowed.leo.out +++ b/tests/expectations/compiler/compiler/aliases/shadowing_var_allowed.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 66ead06ceac4fea6a24fe071a955986722a53975fa98d2ad2909a83fa8ba8525 - imports_resolved_ast: 66ead06ceac4fea6a24fe071a955986722a53975fa98d2ad2909a83fa8ba8525 - canonicalized_ast: 66ead06ceac4fea6a24fe071a955986722a53975fa98d2ad2909a83fa8ba8525 - type_inferenced_ast: 1e73226b2cbbd5c7a36ffe70b778e0e544976d2e09a1f0ba3f2b486d1b604d58 + imports_resolved_ast: 2f34d52f534da1c7ec6ebe99be8cec87483f1a73d4cfa9d1d70d40db6304922f + canonicalized_ast: 2f34d52f534da1c7ec6ebe99be8cec87483f1a73d4cfa9d1d70d40db6304922f + type_inferenced_ast: 26402d98870ae4395a8b7cacf9d25e9cc0920c42dbc7bf48c944ec220138289e diff --git a/tests/expectations/compiler/compiler/array/complex_access.leo.out b/tests/expectations/compiler/compiler/array/complex_access.leo.out index 358b65def2..506eddee57 100644 --- a/tests/expectations/compiler/compiler/array/complex_access.leo.out +++ b/tests/expectations/compiler/compiler/array/complex_access.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 843884ddf198fe566cea0f8e84a2902f720d6211c9d8bad98299eea4da846870 - imports_resolved_ast: 843884ddf198fe566cea0f8e84a2902f720d6211c9d8bad98299eea4da846870 - canonicalized_ast: c30721e60523bc31af9a9bf342d9b89bf92a26e3886394cc0c1a574560715bdf - type_inferenced_ast: baed608da257be0625cd54a796c2f89e9aec8b1ff60f23c7657a0c4fc260e1d1 + imports_resolved_ast: 984f2f99c58550a478b8abd5d9f84e88052dbf1ed92b79d1de2d6d251148ddd7 + canonicalized_ast: 1dee4c73f9faa33e13c2b98aecba1ce88ab110fde39b7a573e06969f8dbf84d5 + type_inferenced_ast: 3bb764584aaa81586edbf85ae1e7ae0774d2e03599c04279f8451205b71e16a4 diff --git a/tests/expectations/compiler/compiler/array/equal_initializer.leo.out b/tests/expectations/compiler/compiler/array/equal_initializer.leo.out index 300b2e071b..3fe8ab995d 100644 --- a/tests/expectations/compiler/compiler/array/equal_initializer.leo.out +++ b/tests/expectations/compiler/compiler/array/equal_initializer.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "false" initial_ast: aa24022f240400d709b97a44c143ce481109bb0a66926aa5c97cf2e2d06dea2a - imports_resolved_ast: aa24022f240400d709b97a44c143ce481109bb0a66926aa5c97cf2e2d06dea2a - canonicalized_ast: ace5006c27d2e3784fb73d52adc641f6285a041452ba0d23de5983c5eede1139 - type_inferenced_ast: 611bc2fab64e417c9cfad3c59ca333561b8167a6fc7be957d972d96125e040ba + imports_resolved_ast: eeccd5c884082a153d06ec18d0eefe48c7c10c7f8b2ca4eb8bf07c6135756892 + canonicalized_ast: 2871e0b38129c9fe8ffb798df90cac534f0c43d2c4bd7b78575ed3e7756027dc + type_inferenced_ast: fdee9f43afe71741d8b1783392ce434f30f252d2602902dc964112949c772109 diff --git a/tests/expectations/compiler/compiler/array/equal_initializer_2.leo.out b/tests/expectations/compiler/compiler/array/equal_initializer_2.leo.out index bb5e60688e..aaf6ccdbec 100644 --- a/tests/expectations/compiler/compiler/array/equal_initializer_2.leo.out +++ b/tests/expectations/compiler/compiler/array/equal_initializer_2.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 307b6817fa2a5005462686901129e97bf75c00bf14568fafbe1de2c8afc1804d - imports_resolved_ast: 307b6817fa2a5005462686901129e97bf75c00bf14568fafbe1de2c8afc1804d - canonicalized_ast: cbaa304ba210d8155762701d8e6a2ddca3eaffb008a813ed7a60db1fb0043f10 - type_inferenced_ast: 47e371ce112ac17fd65bfd100d24829e8c4819e1f96cc715b8c6245f01d608bb + imports_resolved_ast: 82b0b35a7fdddad336498a8ed852d07f0baa33083ce2777b41ffc40a4e969e12 + canonicalized_ast: 5cf7e51b880f36efee857debac30612d0f1dc8457529dec4693e1071d56858fe + type_inferenced_ast: 113469cf66301a79575823164b365ea8f8cf627df758c1454ff31f42b36ac35e diff --git a/tests/expectations/compiler/compiler/array/input_nested_3x2.leo.out b/tests/expectations/compiler/compiler/array/input_nested_3x2.leo.out index 3445cbb64c..bdb6da3840 100644 --- a/tests/expectations/compiler/compiler/array/input_nested_3x2.leo.out +++ b/tests/expectations/compiler/compiler/array/input_nested_3x2.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 6d5be1a3d383ecafa89b5327d3a4b9bce9a459f6c0241cb01f408566ec4a1cc4 - imports_resolved_ast: 6d5be1a3d383ecafa89b5327d3a4b9bce9a459f6c0241cb01f408566ec4a1cc4 - canonicalized_ast: eb64230be87deb03ac7f076961a82194a15afd964aa6966a10314b38def69684 - type_inferenced_ast: e7985a24db781a3e42c9b2a67d1e8febc78fc2ad4e388a90207d00eb89734ffd + imports_resolved_ast: 1b2fa78c990dfcaaa8deffd18ce45ca76561da60d0dba1b3f7825f43ee0ac3ef + canonicalized_ast: 0a756dbc1859bfbdb6b98b587054bf548402da737df3b7e9c2318cb9bbcb4a67 + type_inferenced_ast: 97199b96614f9e92928c536b34760c204383495ff1ea198a7593007de61619cc diff --git a/tests/expectations/compiler/compiler/array/input_tuple_3x2.leo.out b/tests/expectations/compiler/compiler/array/input_tuple_3x2.leo.out index 399ef15a56..c1da1152c4 100644 --- a/tests/expectations/compiler/compiler/array/input_tuple_3x2.leo.out +++ b/tests/expectations/compiler/compiler/array/input_tuple_3x2.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: aa24022f240400d709b97a44c143ce481109bb0a66926aa5c97cf2e2d06dea2a - imports_resolved_ast: aa24022f240400d709b97a44c143ce481109bb0a66926aa5c97cf2e2d06dea2a - canonicalized_ast: ace5006c27d2e3784fb73d52adc641f6285a041452ba0d23de5983c5eede1139 - type_inferenced_ast: 611bc2fab64e417c9cfad3c59ca333561b8167a6fc7be957d972d96125e040ba + imports_resolved_ast: eeccd5c884082a153d06ec18d0eefe48c7c10c7f8b2ca4eb8bf07c6135756892 + canonicalized_ast: 2871e0b38129c9fe8ffb798df90cac534f0c43d2c4bd7b78575ed3e7756027dc + type_inferenced_ast: fdee9f43afe71741d8b1783392ce434f30f252d2602902dc964112949c772109 diff --git a/tests/expectations/compiler/compiler/array/multi_initializer.leo.out b/tests/expectations/compiler/compiler/array/multi_initializer.leo.out index a41e6d561f..8756c4137c 100644 --- a/tests/expectations/compiler/compiler/array/multi_initializer.leo.out +++ b/tests/expectations/compiler/compiler/array/multi_initializer.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 0724c81ae70c56ff047b5d28ef949b72c4b581ce0bb443957064efa1636a3cab - imports_resolved_ast: 0724c81ae70c56ff047b5d28ef949b72c4b581ce0bb443957064efa1636a3cab - canonicalized_ast: ed0b7200a455978fed9b1df0c9e3ab9bf4815d79048f28f4205c69b420ee02df - type_inferenced_ast: 1e5c78e15d8c9328190e95ccbc2e4e105d9ce430b98704a12472e2c3cc870526 + imports_resolved_ast: c90904ba0845fa4b092f69fe81782438ecad5bb883c3fd30d3e5c3670e6a98c9 + canonicalized_ast: 9cd79d308a80e2feafffc66139d517026b15e35b75c7d3eae49ade65bb405338 + type_inferenced_ast: e4fe63ac330b3a7087740c70e01fd18002a310c7f637de76db62f7d43d2d3c5b diff --git a/tests/expectations/compiler/compiler/array/nested.leo.out b/tests/expectations/compiler/compiler/array/nested.leo.out index f0661b99e1..b7a0f4d014 100644 --- a/tests/expectations/compiler/compiler/array/nested.leo.out +++ b/tests/expectations/compiler/compiler/array/nested.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 60d0b81c9f3631aca3c9607df74cfb8e4dbc0d387836398dea86f016fa4210fd - imports_resolved_ast: 60d0b81c9f3631aca3c9607df74cfb8e4dbc0d387836398dea86f016fa4210fd - canonicalized_ast: 6570de0e96b21780ed7793a860948b2c6ff7a92da7ce7f3dd7775ff30d70656f - type_inferenced_ast: ace51ab56a61b988bd2c3f65431e87234a96fa92554d36d4e83d7235832506f6 + imports_resolved_ast: 6e9dfcccc07d698f3b825fe6920bc25f8b97a8fa37b248948fb6d8308d197ff0 + canonicalized_ast: c2aaa302a5e85a3c369c4246cdfcf97c5644d0b2feb6ba164b63e2bba43959f7 + type_inferenced_ast: 7beb03c5d82bd7fa0bbe81a92d730e2f2e8689ed183848f0225638b9a39fe6ca diff --git a/tests/expectations/compiler/compiler/array/nested_3x2_value.leo.out b/tests/expectations/compiler/compiler/array/nested_3x2_value.leo.out index 18f3110b60..75eb1f0f01 100644 --- a/tests/expectations/compiler/compiler/array/nested_3x2_value.leo.out +++ b/tests/expectations/compiler/compiler/array/nested_3x2_value.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 754eca05d485d80c4b710db30efc66f91c0eafdc02c2707f854238863b6c6c02 - imports_resolved_ast: 754eca05d485d80c4b710db30efc66f91c0eafdc02c2707f854238863b6c6c02 - canonicalized_ast: e5554c42dc9a45ab57ea5ac28996969640fb6f8da1ad8db805f65f5d555c8cf4 - type_inferenced_ast: aa30bccd05b7386ffb8a7df7cad89ec39117c6b5fc51a9e68624064832b4f225 + imports_resolved_ast: 74c98b37113df6f99b4ec2dbddb0e7b44c2db43553a1c5dcd168ccff36c067ca + canonicalized_ast: a9bf64a55240d8dffde6ae374972edb8229c9284a50c49f7a8430aaf995e57dc + type_inferenced_ast: 5153c986fce08dc7e5d9d53769de974e358cc7c6b1883e70f4cd4b7c436e76e3 diff --git a/tests/expectations/compiler/compiler/array/registers.leo.out b/tests/expectations/compiler/compiler/array/registers.leo.out index 9a707ce101..72ce5ff65d 100644 --- a/tests/expectations/compiler/compiler/array/registers.leo.out +++ b/tests/expectations/compiler/compiler/array/registers.leo.out @@ -23,6 +23,6 @@ outputs: type: "[u8; 3]" value: "\"123\"" initial_ast: 4e74124bc410534941ef9b79ffb64656d14e145b5a79fbd14419c1aef2f0ef69 - imports_resolved_ast: 4e74124bc410534941ef9b79ffb64656d14e145b5a79fbd14419c1aef2f0ef69 - canonicalized_ast: 4e74124bc410534941ef9b79ffb64656d14e145b5a79fbd14419c1aef2f0ef69 - type_inferenced_ast: de80815f88fb65efa62ce7f5fa23c6fc4f1bbdf601954e94c1212c4eabbee1cb + imports_resolved_ast: db3d3efd3292a3bd16296822fbe5d0b51ccae3379d0307e8bb98b6ca062ea3cd + canonicalized_ast: db3d3efd3292a3bd16296822fbe5d0b51ccae3379d0307e8bb98b6ca062ea3cd + type_inferenced_ast: 81e91909dd86190f8bc2b3b0bcd949c78518b4540a7e8ed6d20ab541b8708345 diff --git a/tests/expectations/compiler/compiler/array/slice.leo.out b/tests/expectations/compiler/compiler/array/slice.leo.out index 48d49f7866..cd2e5820da 100644 --- a/tests/expectations/compiler/compiler/array/slice.leo.out +++ b/tests/expectations/compiler/compiler/array/slice.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 0e4761ba1228f0a490b51ff2c31df33f623a08d32f62833d64859ca103689f4a - imports_resolved_ast: 0e4761ba1228f0a490b51ff2c31df33f623a08d32f62833d64859ca103689f4a - canonicalized_ast: 0e4761ba1228f0a490b51ff2c31df33f623a08d32f62833d64859ca103689f4a - type_inferenced_ast: 1494bb64c16ec2dc03bfb2e37b89f93e02a70860ced1ce0b42b5ee5ead31b0d5 + imports_resolved_ast: 1b2ba53d65d93c8ba810f1b2c241773e9d901aa987885ccd7db7b7ca606c5dc1 + canonicalized_ast: 1b2ba53d65d93c8ba810f1b2c241773e9d901aa987885ccd7db7b7ca606c5dc1 + type_inferenced_ast: 886c9c3d37af3f6d951268eaeddc5c68e1674237dbaf11eb7c76dfdb23e5ece3 diff --git a/tests/expectations/compiler/compiler/array/slice_lower.leo.out b/tests/expectations/compiler/compiler/array/slice_lower.leo.out index 15e2bd02c2..8814e4fba9 100644 --- a/tests/expectations/compiler/compiler/array/slice_lower.leo.out +++ b/tests/expectations/compiler/compiler/array/slice_lower.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 1bf9b30e052d9ecc042a0b20bbc195a98d463ab206963469b9199de462b8be15 - imports_resolved_ast: 1bf9b30e052d9ecc042a0b20bbc195a98d463ab206963469b9199de462b8be15 - canonicalized_ast: 1bf9b30e052d9ecc042a0b20bbc195a98d463ab206963469b9199de462b8be15 - type_inferenced_ast: 6d2531af8ed5b04b23039d0b508cf388135a0fc6e1dc0de3befb4d49ce360fbc + imports_resolved_ast: 5deb917842e525eb21498976389bc21b716fc2c8d01ee15a868ec347da41eefc + canonicalized_ast: 5deb917842e525eb21498976389bc21b716fc2c8d01ee15a868ec347da41eefc + type_inferenced_ast: 1cce48ed4862ddb282cb08be969db4d9be64373e83a9458174f2fd63a5a2e878 diff --git a/tests/expectations/compiler/compiler/array/spread.leo.out b/tests/expectations/compiler/compiler/array/spread.leo.out index 5914e93782..72b64ce113 100644 --- a/tests/expectations/compiler/compiler/array/spread.leo.out +++ b/tests/expectations/compiler/compiler/array/spread.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 140097342b7a16fae8542da5d13eb9c2cb4e1b743fa226e345d815f62d0781bb - imports_resolved_ast: 140097342b7a16fae8542da5d13eb9c2cb4e1b743fa226e345d815f62d0781bb - canonicalized_ast: 140097342b7a16fae8542da5d13eb9c2cb4e1b743fa226e345d815f62d0781bb - type_inferenced_ast: a2442e72c5010224894e46a1c6f245356c0d86428ce617eb31faaf57806ca2df + imports_resolved_ast: 691c76eae0533ac08a723ea21c999e9c8fafb71d81dd5a1ff5cf856d98b79cd9 + canonicalized_ast: 691c76eae0533ac08a723ea21c999e9c8fafb71d81dd5a1ff5cf856d98b79cd9 + type_inferenced_ast: 6bce331b2bcabd251d039695ea7821e39864bf37f9ba255ab743dddba26c6643 diff --git a/tests/expectations/compiler/compiler/array/ternary_in_array.leo.out b/tests/expectations/compiler/compiler/array/ternary_in_array.leo.out index 94a0008165..08d8d2ee0a 100644 --- a/tests/expectations/compiler/compiler/array/ternary_in_array.leo.out +++ b/tests/expectations/compiler/compiler/array/ternary_in_array.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 002cb467a5c1357617b45f955944bb4a79ab465dc13f3eb5eb8db4c158b8c745 - imports_resolved_ast: 002cb467a5c1357617b45f955944bb4a79ab465dc13f3eb5eb8db4c158b8c745 - canonicalized_ast: 002cb467a5c1357617b45f955944bb4a79ab465dc13f3eb5eb8db4c158b8c745 - type_inferenced_ast: 323fc99ac247b37bb395eb08691d451a3b6b563a15bb94b5af6a0193ccc0bd34 + imports_resolved_ast: f6f225fdc57fa21359f0188361043bc7dc653cadec3936d4a94cf0c19058cb89 + canonicalized_ast: f6f225fdc57fa21359f0188361043bc7dc653cadec3936d4a94cf0c19058cb89 + type_inferenced_ast: 9203e04d2522f45db24dfd1582d6d5708256483a9eb52474b1ab006bfa1e8121 diff --git a/tests/expectations/compiler/compiler/array/tuple_3x2_value.leo.out b/tests/expectations/compiler/compiler/array/tuple_3x2_value.leo.out index b3c16f0157..246da1c485 100644 --- a/tests/expectations/compiler/compiler/array/tuple_3x2_value.leo.out +++ b/tests/expectations/compiler/compiler/array/tuple_3x2_value.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 97fd9b78f7912a7627e2b2f5615ae35e39304af6122fab85f9b49fcf6a85d8f2 - imports_resolved_ast: 97fd9b78f7912a7627e2b2f5615ae35e39304af6122fab85f9b49fcf6a85d8f2 - canonicalized_ast: cf8a8faae5f2847199324cbef87583e9af1249c03891ae31f3ce0093879326d5 - type_inferenced_ast: 731117b4aa8260da475471088df325cb540d84c536ce60f3488e01a4428e84ae + imports_resolved_ast: 4132a31ee94a7c187c50f27d1992e25f346bd3c6efabf02106a62a814d9b336a + canonicalized_ast: b130bb4ab886d1d855d1f7afbd6af787f7681fbedbd05fcd1cd2561224695bac + type_inferenced_ast: a6a9b6069b3f805da8a6ea4fe2fb0530a24b19eb9687ef047f8f3b49d5497590 diff --git a/tests/expectations/compiler/compiler/array/type_input_3x2.leo.out b/tests/expectations/compiler/compiler/array/type_input_3x2.leo.out index c4b141e5cf..3c2aad51bd 100644 --- a/tests/expectations/compiler/compiler/array/type_input_3x2.leo.out +++ b/tests/expectations/compiler/compiler/array/type_input_3x2.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 9f2080fab6a85294afa2423cd79482fb3d944c4afab7363e66a4086a120ad34d - imports_resolved_ast: 9f2080fab6a85294afa2423cd79482fb3d944c4afab7363e66a4086a120ad34d - canonicalized_ast: 9f2080fab6a85294afa2423cd79482fb3d944c4afab7363e66a4086a120ad34d - type_inferenced_ast: f8c6b9a9ac418220c87bbd1a99a5eb15817cfa289d822624f2d3cc41e10718b4 + imports_resolved_ast: 266d7ddeb032f20a481e8477ee3ef1c15a33cb2e0fc6f1edd88505a92b6f98c5 + canonicalized_ast: 266d7ddeb032f20a481e8477ee3ef1c15a33cb2e0fc6f1edd88505a92b6f98c5 + type_inferenced_ast: 76a31fb9c0d35124f8af084baf96d54d1578a3234e3672c7003043412b915549 diff --git a/tests/expectations/compiler/compiler/array/type_input_4x3x2.leo.out b/tests/expectations/compiler/compiler/array/type_input_4x3x2.leo.out index 44117e0d63..eeef4de0d3 100644 --- a/tests/expectations/compiler/compiler/array/type_input_4x3x2.leo.out +++ b/tests/expectations/compiler/compiler/array/type_input_4x3x2.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: f61370b311806223d351c6dd611a178362cf8ad6de976d7b0ed709b51fadbecb - imports_resolved_ast: f61370b311806223d351c6dd611a178362cf8ad6de976d7b0ed709b51fadbecb - canonicalized_ast: f61370b311806223d351c6dd611a178362cf8ad6de976d7b0ed709b51fadbecb - type_inferenced_ast: 54531d6afced0deaa59c93b9270768a5e89ea8ea1df34365eb4e440bdf725904 + imports_resolved_ast: 807d9de7b230026104c0b79e1211028db73f43914e40e5f0d11f86b0cf43b35e + canonicalized_ast: 807d9de7b230026104c0b79e1211028db73f43914e40e5f0d11f86b0cf43b35e + type_inferenced_ast: 4a8c4abf672625e2e998c83c7b7247b01d338dc496481b9847973946d45d8f18 diff --git a/tests/expectations/compiler/compiler/array/type_nested_value_nested_3x2.leo.out b/tests/expectations/compiler/compiler/array/type_nested_value_nested_3x2.leo.out index 8c26312c64..647bbdc01c 100644 --- a/tests/expectations/compiler/compiler/array/type_nested_value_nested_3x2.leo.out +++ b/tests/expectations/compiler/compiler/array/type_nested_value_nested_3x2.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 6bacdd1d42bfa807910c0455c68213007d5ca8f15ee1f3c743d946bfbbff79b7 - imports_resolved_ast: 6bacdd1d42bfa807910c0455c68213007d5ca8f15ee1f3c743d946bfbbff79b7 - canonicalized_ast: 6bacdd1d42bfa807910c0455c68213007d5ca8f15ee1f3c743d946bfbbff79b7 - type_inferenced_ast: 1b2a08879a8d42fafc9eecc12b89f0f36719e02205ee48bf6075475e71942132 + imports_resolved_ast: 2abfe6c0c9d3d0d643ddb315c21c3a79ae7f4ffdb8fb3b2d662d9b2487951374 + canonicalized_ast: 2abfe6c0c9d3d0d643ddb315c21c3a79ae7f4ffdb8fb3b2d662d9b2487951374 + type_inferenced_ast: 18da5bbd315adf557e0041af34f6853acf311095e56a249fa1aa734de8d4ab60 diff --git a/tests/expectations/compiler/compiler/array/type_nested_value_nested_4x3x2.leo.out b/tests/expectations/compiler/compiler/array/type_nested_value_nested_4x3x2.leo.out index 45f267cf6d..9ab7637190 100644 --- a/tests/expectations/compiler/compiler/array/type_nested_value_nested_4x3x2.leo.out +++ b/tests/expectations/compiler/compiler/array/type_nested_value_nested_4x3x2.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: c3c30cd2e66f21abef8c49e0ac3d49ed3b607097815c354b14ea9e44d41c0a69 - imports_resolved_ast: c3c30cd2e66f21abef8c49e0ac3d49ed3b607097815c354b14ea9e44d41c0a69 - canonicalized_ast: c3c30cd2e66f21abef8c49e0ac3d49ed3b607097815c354b14ea9e44d41c0a69 - type_inferenced_ast: 557825e28344c8313d9961f9551eabe9c32ee85c524b9b9a6b0fc202c22fa9f3 + imports_resolved_ast: 415d47125939d2d4466c2a940e34039bc6654036793e3828ce266f26e99b68e9 + canonicalized_ast: 415d47125939d2d4466c2a940e34039bc6654036793e3828ce266f26e99b68e9 + type_inferenced_ast: 2c78c46fc265667040e64ad396a702947197f4e1b2fc19af9cafddd8d233bdc9 diff --git a/tests/expectations/compiler/compiler/array/type_nested_value_tuple_3x2.leo.out b/tests/expectations/compiler/compiler/array/type_nested_value_tuple_3x2.leo.out index 8a7be41081..1d1cafb075 100644 --- a/tests/expectations/compiler/compiler/array/type_nested_value_tuple_3x2.leo.out +++ b/tests/expectations/compiler/compiler/array/type_nested_value_tuple_3x2.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 6c062f01a78d515f780a4c13de65d466edda274a2cb519af47a319ed165db0fa - imports_resolved_ast: 6c062f01a78d515f780a4c13de65d466edda274a2cb519af47a319ed165db0fa - canonicalized_ast: 382e9b8b4a635b0be6f62409a20bbdc10d37d08c17658414d1ddef8e6eb00749 - type_inferenced_ast: 13d8af6038fbc63ae76be51f23e43152ab473b895d206160716008da87da3416 + imports_resolved_ast: d89c5ba774b429aed589ec52560063cc1576ccdd92014108eb3996bdc8846748 + canonicalized_ast: 724f20553f461602709c1cd1c0f9c86cd65b7f8281f47ebce221decdaf1d4403 + type_inferenced_ast: bbda06e9afda5ad60c8e4fe0e8e7c7d513c16027bcd5b6efbc2ce981706aa853 diff --git a/tests/expectations/compiler/compiler/array/type_nested_value_tuple_4x3x2.leo.out b/tests/expectations/compiler/compiler/array/type_nested_value_tuple_4x3x2.leo.out index ab9861224d..93b75574ad 100644 --- a/tests/expectations/compiler/compiler/array/type_nested_value_tuple_4x3x2.leo.out +++ b/tests/expectations/compiler/compiler/array/type_nested_value_tuple_4x3x2.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 228ba794b578de8828d761676c15059c51455aff96b02ef3cfafbef53c35454b - imports_resolved_ast: 228ba794b578de8828d761676c15059c51455aff96b02ef3cfafbef53c35454b - canonicalized_ast: 7869bd9531ba014bc2515e13bcafdfed2f9566e7008c1e015d43bb749d8d1d4a - type_inferenced_ast: 84b8976993f08b1b46fef6012018ad050eed6df1e34ae83fc0b57799a1acb395 + imports_resolved_ast: 7ab2c61eaf51aac67c90f364162e209adc4fc89da67e3be674941456289cadfe + canonicalized_ast: d58af0791643776db1c266ea3f78582922d47a5e31cd39b73910139bff6c4aaa + type_inferenced_ast: 38ea7a4cbb6fc2ae4c9671acb4747e5ee3c8b61d17328b18c23b9f4c5dde6466 diff --git a/tests/expectations/compiler/compiler/array/type_tuple_value_nested_3x2.leo.out b/tests/expectations/compiler/compiler/array/type_tuple_value_nested_3x2.leo.out index fc80de0f79..96055280bd 100644 --- a/tests/expectations/compiler/compiler/array/type_tuple_value_nested_3x2.leo.out +++ b/tests/expectations/compiler/compiler/array/type_tuple_value_nested_3x2.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 0ea5856bbe7ad96107544e2b12c7ca54c279c4cd1c8b9610083430600ffa86f9 - imports_resolved_ast: 0ea5856bbe7ad96107544e2b12c7ca54c279c4cd1c8b9610083430600ffa86f9 - canonicalized_ast: 0083c78a81a6ec44627ca89fe949a5301ccaa54ead7104b9a2a3fbd979cf9a2c - type_inferenced_ast: a8b44ce543535e16db5d93df805dc5693d3a1140798cb336d573986de8dfdbca + imports_resolved_ast: c409a94fbb07fd687e830270c28acbbab31d39c646f551834968ff34c974236f + canonicalized_ast: 55407a1c8968dfc96aa4f5f1b3183b6361a6a95b829855cc955d09ac5f428733 + type_inferenced_ast: 83f98c57d8cb35f70a4eed0814e72ee490999e858c3b798c86cd9668894b46d9 diff --git a/tests/expectations/compiler/compiler/array/type_tuple_value_nested_4x3x2.leo.out b/tests/expectations/compiler/compiler/array/type_tuple_value_nested_4x3x2.leo.out index d3e94231c4..5e5d1a2c9a 100644 --- a/tests/expectations/compiler/compiler/array/type_tuple_value_nested_4x3x2.leo.out +++ b/tests/expectations/compiler/compiler/array/type_tuple_value_nested_4x3x2.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: db7e9050580f794aa657700225126e8033c0241240874f6e35df0507469be247 - imports_resolved_ast: db7e9050580f794aa657700225126e8033c0241240874f6e35df0507469be247 - canonicalized_ast: 55304d82a024ad2418e156ad661224040904775f070995bf1b828d1264c3487f - type_inferenced_ast: db99dd94ad4ef9de46304df000494eeda3e8b51835c46e6a3988ee87f91457fa + imports_resolved_ast: 5df26baf4758af1c8c4556520ad08f2940269996b74142d1d1d3d35dd8747e40 + canonicalized_ast: 3767f6efa3939259c0736d50e9924901dafdd2625254c38ad4d300c0a300c886 + type_inferenced_ast: 93ac6b8b3d53c3c0ea5469c3a13ffe5a72fefe403dee16728453c4f182e04a2d diff --git a/tests/expectations/compiler/compiler/array/type_tuple_value_tuple_3x2.leo.out b/tests/expectations/compiler/compiler/array/type_tuple_value_tuple_3x2.leo.out index 41f758d3c4..e8ed85eeb7 100644 --- a/tests/expectations/compiler/compiler/array/type_tuple_value_tuple_3x2.leo.out +++ b/tests/expectations/compiler/compiler/array/type_tuple_value_tuple_3x2.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 2730f954bc76f81d29b02a15f8025d75ca963234716112745b806789bb8eb297 - imports_resolved_ast: 2730f954bc76f81d29b02a15f8025d75ca963234716112745b806789bb8eb297 - canonicalized_ast: 4e07d5e399fa0f60ab84796ecc6195b2a8da0b3a9e725152465512e98f0ca753 - type_inferenced_ast: ea0f726ce456c52c62b73aae38afb74b160ae527480d05f3254c0fdaefdad58e + imports_resolved_ast: b516a9bd2db8c0d95549a81b4437eccb8f911585c380eaf3e1f4778ffc7d6136 + canonicalized_ast: 7d507bbe756202e754f5775dbacbc5ea17403ea6b320b341e0d3670edd980c55 + type_inferenced_ast: 219ac85c47e69d451307b5dbd9735df3880ca3610b656f1ce56b96f77a769292 diff --git a/tests/expectations/compiler/compiler/array/type_tuple_value_tuple_4x3x2.leo.out b/tests/expectations/compiler/compiler/array/type_tuple_value_tuple_4x3x2.leo.out index 5586e09832..662d5494da 100644 --- a/tests/expectations/compiler/compiler/array/type_tuple_value_tuple_4x3x2.leo.out +++ b/tests/expectations/compiler/compiler/array/type_tuple_value_tuple_4x3x2.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 445b35e7d287dc14a77b2c1c4c77d9b7b4fbd6e7c31f6f35c91a446eeca29775 - imports_resolved_ast: 445b35e7d287dc14a77b2c1c4c77d9b7b4fbd6e7c31f6f35c91a446eeca29775 - canonicalized_ast: 48590d7afce08e9e0cd4a45048faa360c18109098b5a9074dfc21b252a47d3e8 - type_inferenced_ast: 0cc5d17973908631180a791f151bdc42aa3e8394b3fbc7607f717bc61baaf904 + imports_resolved_ast: 594999cfccea90f0116cf0e231a7019bfd25ea7ff667d2f79ad1c1b510c823e0 + canonicalized_ast: 76a85bbddcb8c9b32fedbfdd1fe4d69721f4e627fb119aa358c3f18137921f51 + type_inferenced_ast: 3f188b49692f395400046c319dc1c73a235891a8e8a4bcb93b827a433b7de71c diff --git a/tests/expectations/compiler/compiler/array_without_size/definition.leo.out b/tests/expectations/compiler/compiler/array_without_size/definition.leo.out index ce18b13169..64a8782e5d 100644 --- a/tests/expectations/compiler/compiler/array_without_size/definition.leo.out +++ b/tests/expectations/compiler/compiler/array_without_size/definition.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: edf8a3b7372af353b99830752d41d8c04d1863a4d03c754f41aac3545649c644 - imports_resolved_ast: edf8a3b7372af353b99830752d41d8c04d1863a4d03c754f41aac3545649c644 - canonicalized_ast: edf8a3b7372af353b99830752d41d8c04d1863a4d03c754f41aac3545649c644 - type_inferenced_ast: 5479f110a1cbd68040560f64a09663207e756630aa2621a4bb424c48a3cab64d + imports_resolved_ast: f0dbd5c30713c383c8e0a0cc1661540dcc7d2c8ac6411a6a93bed59b6d6ce546 + canonicalized_ast: f0dbd5c30713c383c8e0a0cc1661540dcc7d2c8ac6411a6a93bed59b6d6ce546 + type_inferenced_ast: dd228d9d9fa611408636d6a307fd69cd18e7293a08a611ac2f88883d1b978032 diff --git a/tests/expectations/compiler/compiler/array_without_size/function_input.leo.out b/tests/expectations/compiler/compiler/array_without_size/function_input.leo.out index 17c396727b..65d74670fe 100644 --- a/tests/expectations/compiler/compiler/array_without_size/function_input.leo.out +++ b/tests/expectations/compiler/compiler/array_without_size/function_input.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 5ae730ffb3671acde08944aaa8450a54bb9ce436c92d5c21e7a2a7b9c8d404a7 - imports_resolved_ast: 5ae730ffb3671acde08944aaa8450a54bb9ce436c92d5c21e7a2a7b9c8d404a7 - canonicalized_ast: 5ae730ffb3671acde08944aaa8450a54bb9ce436c92d5c21e7a2a7b9c8d404a7 - type_inferenced_ast: c2b15c1e0644a4af597019f7a56d1c8485723e43089ff0aa8951e3ec31729f1f + imports_resolved_ast: b0a3019e9e93ae0990bce7ffe2b1e075c0ba4f517aacc42c2bd56ebcb15ee1e3 + canonicalized_ast: b0a3019e9e93ae0990bce7ffe2b1e075c0ba4f517aacc42c2bd56ebcb15ee1e3 + type_inferenced_ast: 945eef156080f8d2c99f4f34464861a2376ff7261fb6b393ea7dc2b84f30f328 diff --git a/tests/expectations/compiler/compiler/array_without_size/type_alias.leo.out b/tests/expectations/compiler/compiler/array_without_size/type_alias.leo.out index 23713b3ffe..fc54602e06 100644 --- a/tests/expectations/compiler/compiler/array_without_size/type_alias.leo.out +++ b/tests/expectations/compiler/compiler/array_without_size/type_alias.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 0e8ea2eb2de2ad93883ced129ab7c42674fd476d94ede483f5ea042f8386b730 - imports_resolved_ast: 0e8ea2eb2de2ad93883ced129ab7c42674fd476d94ede483f5ea042f8386b730 - canonicalized_ast: 529ba1d5564ef0c1752343e3e6e8b181f13bec0620c4ecbe23080ef4a080cb2b - type_inferenced_ast: b4d3305f7179dfc2a7a330e538a41e3cdf51f12e4a6545cd57ff9a2e5a9d1db0 + imports_resolved_ast: a86e55392b72b3b309d6223d7304035611b1e397580c16839545579d9a95c9ea + canonicalized_ast: f202f6e13729555eed8c48727e7df16f72ba3addd62dff7269814acf297f98a1 + type_inferenced_ast: bd9592a3af130293e2a71a7dbad84805958d857d41be1b39326b5e12c1f7af81 diff --git a/tests/expectations/compiler/compiler/boolean/and.leo.out b/tests/expectations/compiler/compiler/boolean/and.leo.out index 3c726a7331..664fd94c60 100644 --- a/tests/expectations/compiler/compiler/boolean/and.leo.out +++ b/tests/expectations/compiler/compiler/boolean/and.leo.out @@ -35,6 +35,6 @@ outputs: type: bool value: "true" initial_ast: 2f7c3b9c806a873b6445200eb78a8e0e546ffe64c90fe2133355dd37a342b11b - imports_resolved_ast: 2f7c3b9c806a873b6445200eb78a8e0e546ffe64c90fe2133355dd37a342b11b - canonicalized_ast: 2f7c3b9c806a873b6445200eb78a8e0e546ffe64c90fe2133355dd37a342b11b - type_inferenced_ast: 87b86a66fc6e60502be0b0fb7cf677d5128390aec53f6893827a1bf02fca8370 + imports_resolved_ast: 8c8039a942ada73357ce62cbf478d1252b4c1b022bdf156a8beb8b1f41898efb + canonicalized_ast: 8c8039a942ada73357ce62cbf478d1252b4c1b022bdf156a8beb8b1f41898efb + type_inferenced_ast: 460e99eaaaf5de2d28b19a692c455bb12d3540503624aeffe281057fbeddb352 diff --git a/tests/expectations/compiler/compiler/boolean/conditional.leo.out b/tests/expectations/compiler/compiler/boolean/conditional.leo.out index 51f3b463d5..9995af8f31 100644 --- a/tests/expectations/compiler/compiler/boolean/conditional.leo.out +++ b/tests/expectations/compiler/compiler/boolean/conditional.leo.out @@ -35,6 +35,6 @@ outputs: type: bool value: "true" initial_ast: 5316ba00882aa3f9b538d349ed7141c4ee7c77ec01f6af9911b2652b6cd3e659 - imports_resolved_ast: 5316ba00882aa3f9b538d349ed7141c4ee7c77ec01f6af9911b2652b6cd3e659 - canonicalized_ast: 5316ba00882aa3f9b538d349ed7141c4ee7c77ec01f6af9911b2652b6cd3e659 - type_inferenced_ast: 7933d0a8f47892e42c3c670bc6433e8d820042a7396e10b6a63d22bd5b740f96 + imports_resolved_ast: 96c21aa198ea648d52822abba76f43248dc5701232c0331bdc88b4e7596f894e + canonicalized_ast: 96c21aa198ea648d52822abba76f43248dc5701232c0331bdc88b4e7596f894e + type_inferenced_ast: 9869ac26b6eaa9d2f97d910b061dce142d7ca6a51f3defd813987f0138fb5fc1 diff --git a/tests/expectations/compiler/compiler/boolean/equal.leo.out b/tests/expectations/compiler/compiler/boolean/equal.leo.out index 4f3e535ca9..50f2415105 100644 --- a/tests/expectations/compiler/compiler/boolean/equal.leo.out +++ b/tests/expectations/compiler/compiler/boolean/equal.leo.out @@ -35,6 +35,6 @@ outputs: type: bool value: "true" initial_ast: 08f026e24cab51634a7a2a6f1f3b082eace1d4be649cd9ff7c244194891d7d78 - imports_resolved_ast: 08f026e24cab51634a7a2a6f1f3b082eace1d4be649cd9ff7c244194891d7d78 - canonicalized_ast: 08f026e24cab51634a7a2a6f1f3b082eace1d4be649cd9ff7c244194891d7d78 - type_inferenced_ast: 2112e9f631a77bb16ba1561bbe1028a415413f23fd32d21bfe086e071938c845 + imports_resolved_ast: dac2c874c2a6780c36245c75dc2be130aed8bb563911aaa7d1e30a3a4abd5e01 + canonicalized_ast: dac2c874c2a6780c36245c75dc2be130aed8bb563911aaa7d1e30a3a4abd5e01 + type_inferenced_ast: 647de266dbd67a1f2cbf40904422e699066aa033470501c7b0dac0010e943ce5 diff --git a/tests/expectations/compiler/compiler/boolean/not_equal.leo.out b/tests/expectations/compiler/compiler/boolean/not_equal.leo.out index d31cdae376..979d599890 100644 --- a/tests/expectations/compiler/compiler/boolean/not_equal.leo.out +++ b/tests/expectations/compiler/compiler/boolean/not_equal.leo.out @@ -35,6 +35,6 @@ outputs: type: bool value: "false" initial_ast: 094effa7fe12695679a571f560e1d3e8c299cde8de280f9309010c85f48bab95 - imports_resolved_ast: 094effa7fe12695679a571f560e1d3e8c299cde8de280f9309010c85f48bab95 - canonicalized_ast: 094effa7fe12695679a571f560e1d3e8c299cde8de280f9309010c85f48bab95 - type_inferenced_ast: ab25cb7bf7d8fe3ec64be183550ba8d6acfaf17464cf70ec45c6497fc065ac29 + imports_resolved_ast: 1d9d8399fe44bade2bd762e88a1db5805b26cb47710aea505ca5d33a60daa574 + canonicalized_ast: 1d9d8399fe44bade2bd762e88a1db5805b26cb47710aea505ca5d33a60daa574 + type_inferenced_ast: 8438f2a6c2db2f16ec11a4f12d0085039e6cd22e9106d14c25d1bbfe55c1df9e diff --git a/tests/expectations/compiler/compiler/boolean/or.leo.out b/tests/expectations/compiler/compiler/boolean/or.leo.out index de8536a60d..e85a04e9f2 100644 --- a/tests/expectations/compiler/compiler/boolean/or.leo.out +++ b/tests/expectations/compiler/compiler/boolean/or.leo.out @@ -35,6 +35,6 @@ outputs: type: bool value: "true" initial_ast: e2facdce5f7cdbed4a3215cc258e54418aac4f4b846349b35e1da67b577b76c9 - imports_resolved_ast: e2facdce5f7cdbed4a3215cc258e54418aac4f4b846349b35e1da67b577b76c9 - canonicalized_ast: e2facdce5f7cdbed4a3215cc258e54418aac4f4b846349b35e1da67b577b76c9 - type_inferenced_ast: fb43dcb50c9822e2d4e4f35e9cc73f0893e508161296be5666cd90c4f7a971bc + imports_resolved_ast: c82afe6fc023e46a02cfe669c6d90c6da47e71673b3e60dd40e5e976799865db + canonicalized_ast: c82afe6fc023e46a02cfe669c6d90c6da47e71673b3e60dd40e5e976799865db + type_inferenced_ast: 1af91788f2e6709d95c35e6719238710b4ae2ed6794f59d565c4bfda31aa23d9 diff --git a/tests/expectations/compiler/compiler/char/circuit.leo.out b/tests/expectations/compiler/compiler/char/circuit.leo.out index 50beb63398..bc1ef73265 100644 --- a/tests/expectations/compiler/compiler/char/circuit.leo.out +++ b/tests/expectations/compiler/compiler/char/circuit.leo.out @@ -101,6 +101,6 @@ outputs: type: char value: "'\\u{1f62d}'" initial_ast: 0c2aeb5b47fc21f5aded4e3aebcdf55eb98c10c6b51a2a6dcb98490a96da0c97 - imports_resolved_ast: 0c2aeb5b47fc21f5aded4e3aebcdf55eb98c10c6b51a2a6dcb98490a96da0c97 - canonicalized_ast: 0c2aeb5b47fc21f5aded4e3aebcdf55eb98c10c6b51a2a6dcb98490a96da0c97 - type_inferenced_ast: e9c5fc64aad2390305671ffbe316eee04d5fca7a6f09dcc8c8a69c38db8b3a62 + imports_resolved_ast: dc29924de4b1752b8e29691b4e6938d20048c684a8e01e77b760f75b76507747 + canonicalized_ast: dc29924de4b1752b8e29691b4e6938d20048c684a8e01e77b760f75b76507747 + type_inferenced_ast: 0db49560694863b30bba8e3243ae034956c397249031215042b1615d99d397b7 diff --git a/tests/expectations/compiler/compiler/char/neq.leo.out b/tests/expectations/compiler/compiler/char/neq.leo.out index 70b851fbc6..92343e9b22 100644 --- a/tests/expectations/compiler/compiler/char/neq.leo.out +++ b/tests/expectations/compiler/compiler/char/neq.leo.out @@ -101,6 +101,6 @@ outputs: type: char value: "'a'" initial_ast: ac56e34b2a2cb282d36133df39d80947dfdfc56b5655b3ba9f408ba529c8f505 - imports_resolved_ast: ac56e34b2a2cb282d36133df39d80947dfdfc56b5655b3ba9f408ba529c8f505 - canonicalized_ast: ac56e34b2a2cb282d36133df39d80947dfdfc56b5655b3ba9f408ba529c8f505 - type_inferenced_ast: 2eecf906226893c46f526a72f272a3f11eb34ada7cc4cd573439ebfed44ba170 + imports_resolved_ast: 11a4df3cb6ce54c7ee28b94b4e0a728b7a4895c8907b1a168e4ec726b316f093 + canonicalized_ast: 11a4df3cb6ce54c7ee28b94b4e0a728b7a4895c8907b1a168e4ec726b316f093 + type_inferenced_ast: 5b4c5ecb456864365fb66a730386b7dd6fc25427a1aaea5fb8c7017ede56bc32 diff --git a/tests/expectations/compiler/compiler/char/nonprinting.leo.out b/tests/expectations/compiler/compiler/char/nonprinting.leo.out index 2743086dc3..ea1e444a4f 100644 --- a/tests/expectations/compiler/compiler/char/nonprinting.leo.out +++ b/tests/expectations/compiler/compiler/char/nonprinting.leo.out @@ -20,6 +20,6 @@ outputs: type: bool value: "true" initial_ast: da8550065db88bba8f0a982612194f6122ec97025c4af5d3007d3a4d42519cb9 - imports_resolved_ast: da8550065db88bba8f0a982612194f6122ec97025c4af5d3007d3a4d42519cb9 - canonicalized_ast: da8550065db88bba8f0a982612194f6122ec97025c4af5d3007d3a4d42519cb9 - type_inferenced_ast: b3ea99e7660209825c5bb1abcba8c1835cf96b79c8707e616513122ab10ac0d5 + imports_resolved_ast: fde01d86d58dfcbddd1ab58393dfd3ce4af3df4160b7d2971e983141dee607c5 + canonicalized_ast: fde01d86d58dfcbddd1ab58393dfd3ce4af3df4160b7d2971e983141dee607c5 + type_inferenced_ast: f63a99ba7e7a5d37f93aeadfd01d62be4f4eaffad986054093922499b0c9f062 diff --git a/tests/expectations/compiler/compiler/char/out.leo.out b/tests/expectations/compiler/compiler/char/out.leo.out index e61799dc7c..8c4e8196cc 100644 --- a/tests/expectations/compiler/compiler/char/out.leo.out +++ b/tests/expectations/compiler/compiler/char/out.leo.out @@ -101,6 +101,6 @@ outputs: type: char value: "'\\u{1f62d}'" initial_ast: 6e1cf86d47e056682c6e51dcf0390eb34505b60d50de60970a688f237525bedf - imports_resolved_ast: 6e1cf86d47e056682c6e51dcf0390eb34505b60d50de60970a688f237525bedf - canonicalized_ast: 6e1cf86d47e056682c6e51dcf0390eb34505b60d50de60970a688f237525bedf - type_inferenced_ast: feb16e72f13a884e3303b336f7f20ff8ff4066a8f9861860e28b9c6901215b76 + imports_resolved_ast: e9012d76c33c37f3940fbc8f9d8fe83cb13d8b7bdaa5b8476180128f91132c71 + canonicalized_ast: e9012d76c33c37f3940fbc8f9d8fe83cb13d8b7bdaa5b8476180128f91132c71 + type_inferenced_ast: b19acb9ba2e6e5949839b5fe3d15f52f7187cadbb0602e44b03215f4181a6997 diff --git a/tests/expectations/compiler/compiler/circuits/big_self_in_circuit_replacement.leo.out b/tests/expectations/compiler/compiler/circuits/big_self_in_circuit_replacement.leo.out index 2e4b00f7fa..c8a0f7e9ea 100644 --- a/tests/expectations/compiler/compiler/circuits/big_self_in_circuit_replacement.leo.out +++ b/tests/expectations/compiler/compiler/circuits/big_self_in_circuit_replacement.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: d8ff1c8c84bc93bbd4e712dde7eb3c9dbe433199f5902b6dc3329cf3ca607811 - imports_resolved_ast: d8ff1c8c84bc93bbd4e712dde7eb3c9dbe433199f5902b6dc3329cf3ca607811 - canonicalized_ast: 9ef4d52afc2cbbcaa7759af48d1603feb28287d619293135a7856625a37299f7 - type_inferenced_ast: f3a91e1cd91f60c94ffe809369eeecb2f22996b6f14c1589a5c7a825519a6b1e + imports_resolved_ast: aee1ae257d5270f8a310af0266b7a4226fdc23498e9aedf35633710fa31599a3 + canonicalized_ast: b5525cdb08607392c38fd870e9719b34c3f960a3911e3a2ef50b7ae55f777c9f + type_inferenced_ast: 6e03e1d79176a685668c1a34cec906f22cf7a90a128de24fbc2bcc8aad3598d4 diff --git a/tests/expectations/compiler/compiler/circuits/const_self_variable.leo.out b/tests/expectations/compiler/compiler/circuits/const_self_variable.leo.out index 114074fdf6..686aa2a92d 100644 --- a/tests/expectations/compiler/compiler/circuits/const_self_variable.leo.out +++ b/tests/expectations/compiler/compiler/circuits/const_self_variable.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 50c0f7261d879373f4e01ec3d140a2067ca4e78622c8340e8312d717f6effb05 - imports_resolved_ast: 50c0f7261d879373f4e01ec3d140a2067ca4e78622c8340e8312d717f6effb05 - canonicalized_ast: 50c0f7261d879373f4e01ec3d140a2067ca4e78622c8340e8312d717f6effb05 - type_inferenced_ast: 68174a753a3191ea961db29f62b6557f410ee33c2cad28c43a5098bb6cb230f2 + imports_resolved_ast: d2bdb4665f5a49124335ba3f3fb39d8dc5a6f4d08d53e84fec635cd27d5eb582 + canonicalized_ast: d2bdb4665f5a49124335ba3f3fb39d8dc5a6f4d08d53e84fec635cd27d5eb582 + type_inferenced_ast: edbc4ba37f4a02c487f70b4a0d245154848e54336213420d5ddd2c1f8b966029 diff --git a/tests/expectations/compiler/compiler/circuits/define_circuit_inside_circuit_function.leo.out b/tests/expectations/compiler/compiler/circuits/define_circuit_inside_circuit_function.leo.out index f20fb08065..db518360c7 100644 --- a/tests/expectations/compiler/compiler/circuits/define_circuit_inside_circuit_function.leo.out +++ b/tests/expectations/compiler/compiler/circuits/define_circuit_inside_circuit_function.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: bfd7751e8ea64c6d41af36d968f194a18a5411ac71932a67766f40448ce755f5 - imports_resolved_ast: bfd7751e8ea64c6d41af36d968f194a18a5411ac71932a67766f40448ce755f5 - canonicalized_ast: bfd7751e8ea64c6d41af36d968f194a18a5411ac71932a67766f40448ce755f5 - type_inferenced_ast: c6ca022e97bef335bf6df235875d507240eb48ea28f6504cc17c3d09820430f9 + imports_resolved_ast: 58a6b067cffc10de35b10a84f7e200fe836890c758174c8126cc4a20417a4c24 + canonicalized_ast: 58a6b067cffc10de35b10a84f7e200fe836890c758174c8126cc4a20417a4c24 + type_inferenced_ast: 7b55011299b213dd63dae23315ad0029c6057c46a2ad53f30b28fbdfb5b72934 diff --git a/tests/expectations/compiler/compiler/circuits/duplicate_name_context.leo.out b/tests/expectations/compiler/compiler/circuits/duplicate_name_context.leo.out index d9e1076d49..98c930ca05 100644 --- a/tests/expectations/compiler/compiler/circuits/duplicate_name_context.leo.out +++ b/tests/expectations/compiler/compiler/circuits/duplicate_name_context.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: d8a66347f480161a2215c92d2cf6ded2d0b49fd76b7eb0036d4fa33de371925a - imports_resolved_ast: d8a66347f480161a2215c92d2cf6ded2d0b49fd76b7eb0036d4fa33de371925a - canonicalized_ast: d8a66347f480161a2215c92d2cf6ded2d0b49fd76b7eb0036d4fa33de371925a - type_inferenced_ast: cb82c955829007961356ca2760b6ca84e2ea321cd640e87d4a51fd3ba65eb7a7 + imports_resolved_ast: 23ab7ce1f8ade033ad2c0e0a488e3da059795059ffd85bff240436502baff064 + canonicalized_ast: 23ab7ce1f8ade033ad2c0e0a488e3da059795059ffd85bff240436502baff064 + type_inferenced_ast: f33e938ad318bd26d2249c7aff5880fd78bb95b3cb8b335a8483830a1be47d4e diff --git a/tests/expectations/compiler/compiler/circuits/inline.leo.out b/tests/expectations/compiler/compiler/circuits/inline.leo.out index cfd62ab7e7..beaef76101 100644 --- a/tests/expectations/compiler/compiler/circuits/inline.leo.out +++ b/tests/expectations/compiler/compiler/circuits/inline.leo.out @@ -17,6 +17,6 @@ outputs: type: u32 value: "100" initial_ast: c40a1d60f872fdb03ab7379a3abf43439a100b8f1546b76ffeac60c8739e0d68 - imports_resolved_ast: c40a1d60f872fdb03ab7379a3abf43439a100b8f1546b76ffeac60c8739e0d68 - canonicalized_ast: c40a1d60f872fdb03ab7379a3abf43439a100b8f1546b76ffeac60c8739e0d68 - type_inferenced_ast: 2221472ded58b4a6c77545040ca32138d68eb6f2c3e47b830317872f045f91f8 + imports_resolved_ast: f8c489b07e7dc45c8d42f959cdae47a61101e5fc6110f378af0a34fe41b1777e + canonicalized_ast: f8c489b07e7dc45c8d42f959cdae47a61101e5fc6110f378af0a34fe41b1777e + type_inferenced_ast: 87619e2e5d2e6a22ed58c5d7938062a074faef5e6bc1ee60036a8050e3271c2f diff --git a/tests/expectations/compiler/compiler/circuits/inline_member_pass.leo.out b/tests/expectations/compiler/compiler/circuits/inline_member_pass.leo.out index f3df395a9e..374920d601 100644 --- a/tests/expectations/compiler/compiler/circuits/inline_member_pass.leo.out +++ b/tests/expectations/compiler/compiler/circuits/inline_member_pass.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: cf642f2f983cd8bcd6cbca2d2920f5234d79375601c1da3c06f97b6185a5629d - imports_resolved_ast: cf642f2f983cd8bcd6cbca2d2920f5234d79375601c1da3c06f97b6185a5629d - canonicalized_ast: de45d7a621a1309ca9ae0dd11f4a99e8ff1e0b92c9f990d2f72a6c43067a7611 - type_inferenced_ast: 690a93dcec9c31c26b52ca234ce8e07067649c038e47fd8b7eeef9e36dddf05b + imports_resolved_ast: ec5c0b1e01e74181406efc8a2b698933726e13e92c87e0fac7dcb28901ed9565 + canonicalized_ast: b9cf563cea162726122f7d2f7f264dace0c2d6a75e58c13e745fd849404da067 + type_inferenced_ast: 2e83ce8e0fc851ff003c9e2756c0e0d83364b506e87e2189df473c306814eea8 diff --git a/tests/expectations/compiler/compiler/circuits/member_function.leo.out b/tests/expectations/compiler/compiler/circuits/member_function.leo.out index a0ec36306d..1e326b74f6 100644 --- a/tests/expectations/compiler/compiler/circuits/member_function.leo.out +++ b/tests/expectations/compiler/compiler/circuits/member_function.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 5273a592b167cfe040b2bca7337521084d7a6640651bca584545e9eeb2e4fa88 - imports_resolved_ast: 5273a592b167cfe040b2bca7337521084d7a6640651bca584545e9eeb2e4fa88 - canonicalized_ast: 5273a592b167cfe040b2bca7337521084d7a6640651bca584545e9eeb2e4fa88 - type_inferenced_ast: ee2152aedd637adcfdd84540bfd8814c65cc8552c0bae80a0176b91d70b1266e + imports_resolved_ast: 2b5126eef050bdfdb68da8587756219441517fcd1c704c8f9d1ea102392b1580 + canonicalized_ast: 2b5126eef050bdfdb68da8587756219441517fcd1c704c8f9d1ea102392b1580 + type_inferenced_ast: 4a42f661d6de987682e28824a97d3989ddd5444d51620d77bc6637abd876c425 diff --git a/tests/expectations/compiler/compiler/circuits/member_function_nested.leo.out b/tests/expectations/compiler/compiler/circuits/member_function_nested.leo.out index a71956d836..b785a6918c 100644 --- a/tests/expectations/compiler/compiler/circuits/member_function_nested.leo.out +++ b/tests/expectations/compiler/compiler/circuits/member_function_nested.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 241f1a42877b012b2e2062cefbd83523a5c719557cb422cf1fbd7efb0f7b1796 - imports_resolved_ast: 241f1a42877b012b2e2062cefbd83523a5c719557cb422cf1fbd7efb0f7b1796 - canonicalized_ast: 241f1a42877b012b2e2062cefbd83523a5c719557cb422cf1fbd7efb0f7b1796 - type_inferenced_ast: e063513fb0d009c0cadd36cab9feb4327528bbba45087d7a65e0e97fcd54bb7a + imports_resolved_ast: 43cca11f696228d0707095273602f51aab997eb3f85309f731d0af3a69bdeb47 + canonicalized_ast: 43cca11f696228d0707095273602f51aab997eb3f85309f731d0af3a69bdeb47 + type_inferenced_ast: a81ca1868d802d53a7a541bca7a021ad233d58a2d2ec9ad197ff2f2bcdde8495 diff --git a/tests/expectations/compiler/compiler/circuits/member_static_function.leo.out b/tests/expectations/compiler/compiler/circuits/member_static_function.leo.out index 867b688fa2..97b3909816 100644 --- a/tests/expectations/compiler/compiler/circuits/member_static_function.leo.out +++ b/tests/expectations/compiler/compiler/circuits/member_static_function.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 11dfbfa2561534a1c965d8f8862b23ed56be50986903c139b763f88a1ba3ad8d - imports_resolved_ast: 11dfbfa2561534a1c965d8f8862b23ed56be50986903c139b763f88a1ba3ad8d - canonicalized_ast: 11dfbfa2561534a1c965d8f8862b23ed56be50986903c139b763f88a1ba3ad8d - type_inferenced_ast: 6aab6f0cf6a9237ec02b5ce3f4ad8f24c8faa8ec5ccbc7f3af1023d0269dceea + imports_resolved_ast: e0a8c32b321be274b67e4ec4897857d614924a6cc4a52c30b7d8d7ff848871d3 + canonicalized_ast: e0a8c32b321be274b67e4ec4897857d614924a6cc4a52c30b7d8d7ff848871d3 + type_inferenced_ast: 72b7a987240d2efac67d0d0972f685ddfda6d123035455873cc5d9f1818557b6 diff --git a/tests/expectations/compiler/compiler/circuits/member_static_function_nested.leo.out b/tests/expectations/compiler/compiler/circuits/member_static_function_nested.leo.out index a10fb07f86..ededf3abcc 100644 --- a/tests/expectations/compiler/compiler/circuits/member_static_function_nested.leo.out +++ b/tests/expectations/compiler/compiler/circuits/member_static_function_nested.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 42f603efbf7ee8ca53394266f33fbf09110420c822385179d656861e8ceb4a32 - imports_resolved_ast: 42f603efbf7ee8ca53394266f33fbf09110420c822385179d656861e8ceb4a32 - canonicalized_ast: 92d91209d7675fc14ae1fd44c28d1384f1c56c5852654b4dac46dd123340d9c0 - type_inferenced_ast: 0527005fb0925ac29af65bb0c12c39991d466c20def41ce7e4a2ded51ae233fc + imports_resolved_ast: 5d6286f1296a269e2b39ec7e6a73257317eb6ce37bb11bce26f34b7f7fba3501 + canonicalized_ast: ddea7b51d7e218ff02e44be3737128309dabc76d54838db4967a89e901241899 + type_inferenced_ast: 5c828c5b2324057bd9543a6fafa47f8752cbd33bebf6b5fc186ed121580d791b diff --git a/tests/expectations/compiler/compiler/circuits/member_variable.leo.out b/tests/expectations/compiler/compiler/circuits/member_variable.leo.out index ffa5a78e70..39da943357 100644 --- a/tests/expectations/compiler/compiler/circuits/member_variable.leo.out +++ b/tests/expectations/compiler/compiler/circuits/member_variable.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: cf41b78f9435c6555014db8aeebe662556f4f8547ee0f3a204d6f522fcf72644 - imports_resolved_ast: cf41b78f9435c6555014db8aeebe662556f4f8547ee0f3a204d6f522fcf72644 - canonicalized_ast: cf41b78f9435c6555014db8aeebe662556f4f8547ee0f3a204d6f522fcf72644 - type_inferenced_ast: 2fbe148dcadf6f460f64824e311f1f061265dc81e2eaff555987dbf55094b3a4 + imports_resolved_ast: 82740cfa7a3416a2d5fc9696afe5e9dd2f3e3732d6db958bc47c4be7cb394155 + canonicalized_ast: 82740cfa7a3416a2d5fc9696afe5e9dd2f3e3732d6db958bc47c4be7cb394155 + type_inferenced_ast: 35d4a95f99eb210c60830a0d5127d1824d9478ff97efb0d9d60c5fce6706d83f diff --git a/tests/expectations/compiler/compiler/circuits/member_variable_and_function.leo.out b/tests/expectations/compiler/compiler/circuits/member_variable_and_function.leo.out index ef27e8f875..fe9e7f3d9e 100644 --- a/tests/expectations/compiler/compiler/circuits/member_variable_and_function.leo.out +++ b/tests/expectations/compiler/compiler/circuits/member_variable_and_function.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 622baae85ab7776fc38cff17465e8e0dbcdb98f4ba74e734ca494b696cea8ccd - imports_resolved_ast: 622baae85ab7776fc38cff17465e8e0dbcdb98f4ba74e734ca494b696cea8ccd - canonicalized_ast: 622baae85ab7776fc38cff17465e8e0dbcdb98f4ba74e734ca494b696cea8ccd - type_inferenced_ast: f97b773504a230c42546d6a565b970fbf51ec293c15ee58d4f9dfa40b7a4a988 + imports_resolved_ast: b2b508a4e43faece4959c9f56458ec764fbf80a383f7340745b08c15db9454a8 + canonicalized_ast: b2b508a4e43faece4959c9f56458ec764fbf80a383f7340745b08c15db9454a8 + type_inferenced_ast: 0bb06a7a79b64426e12f01c7a5c018fa3e91379e710e2a1e54a466d8a73c4084 diff --git a/tests/expectations/compiler/compiler/circuits/mut_self_variable.leo.out b/tests/expectations/compiler/compiler/circuits/mut_self_variable.leo.out index f889ea11c9..dcf91f1e0a 100644 --- a/tests/expectations/compiler/compiler/circuits/mut_self_variable.leo.out +++ b/tests/expectations/compiler/compiler/circuits/mut_self_variable.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: ba91ea172a2f753bf4a338f29fff05c358d4dc0cb1c2ef461d492ee4fe2a1114 - imports_resolved_ast: ba91ea172a2f753bf4a338f29fff05c358d4dc0cb1c2ef461d492ee4fe2a1114 - canonicalized_ast: 8d1beaecc785aa79a5a6bec47cf10426b9d3d87ccc15c359f12c7d3ee2a95561 - type_inferenced_ast: d69ef792ee9b73a3d486535216ade98bd500aff7061e5b3cb48e5f1ffd519286 + imports_resolved_ast: ba3070ce50c6368eccce09d73e5b620fb5965ab6cf2eacce7e782fde736eeb7d + canonicalized_ast: 811051cb22f10bf812ac89da97818c36d24519344212ca3f747e49b2b25b4954 + type_inferenced_ast: e161e0325e6db8ff251d1e22a3b184edf5597583db55582f533c4e5eb4560cb9 diff --git a/tests/expectations/compiler/compiler/circuits/mut_self_variable_branch.leo.out b/tests/expectations/compiler/compiler/circuits/mut_self_variable_branch.leo.out index 20613db255..a2c15283e3 100644 --- a/tests/expectations/compiler/compiler/circuits/mut_self_variable_branch.leo.out +++ b/tests/expectations/compiler/compiler/circuits/mut_self_variable_branch.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: fe7ca41c29d33107a4316b9c6788898217129937cbf1de0f2ea7566a360245f0 - imports_resolved_ast: fe7ca41c29d33107a4316b9c6788898217129937cbf1de0f2ea7566a360245f0 - canonicalized_ast: d2b30a9485e7166a0efde9d179432e481a4d40540e1b3eeec043b84d993e66df - type_inferenced_ast: 7f279d6a24e597f0d1e6dbc5d26db3bc0ac6dc8520b7b485f296824c2e872a0e + imports_resolved_ast: d7c50f1b961521f50900e6d406c2184eaf8ef31f0c3bd782318755eb5f7e1f94 + canonicalized_ast: c40ea46fab334f0b0185fcb14e19e34ea1bbe2d32e1a85724141c69da9e6186f + type_inferenced_ast: 9197e7a7747071ecb5e484ef5fa4b0fb8f3fe0be3883a8386d4cfb50ef965f6b diff --git a/tests/expectations/compiler/compiler/circuits/mut_self_variable_conditional.leo.out b/tests/expectations/compiler/compiler/circuits/mut_self_variable_conditional.leo.out index 8532ec1155..6611676f24 100644 --- a/tests/expectations/compiler/compiler/circuits/mut_self_variable_conditional.leo.out +++ b/tests/expectations/compiler/compiler/circuits/mut_self_variable_conditional.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 659e5fcdd16752c6e3504f821a5afd6f0756bd6b8641f127ba049c2a4c83a088 - imports_resolved_ast: 659e5fcdd16752c6e3504f821a5afd6f0756bd6b8641f127ba049c2a4c83a088 - canonicalized_ast: 8cf6113b757cfeee53554c67dd3f380f0f417032b8835259bf30076b19349f61 - type_inferenced_ast: 63445b0618aa26ad71f316dea01a0558be3462295c4ef7ddcc042a6098e80725 + imports_resolved_ast: b4abfbb0da91692077c71aea0c432315e28dfc304640cabb2ca1b57054801a1b + canonicalized_ast: 466ce72aa3d2268ea98766b74302379015127a406e72526fb7bb7602406ab98f + type_inferenced_ast: 9a2a017cd8014367a8f6bdd786bf1b7cdfa937d2565da17c81fb24183676396b diff --git a/tests/expectations/compiler/compiler/circuits/mut_variable.leo.out b/tests/expectations/compiler/compiler/circuits/mut_variable.leo.out index 6cf717c440..8225a20f5b 100644 --- a/tests/expectations/compiler/compiler/circuits/mut_variable.leo.out +++ b/tests/expectations/compiler/compiler/circuits/mut_variable.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 8c4a98dec3d2e9e826e3419c91a251e821861a146325b025c52ff15b5edefe1c - imports_resolved_ast: 8c4a98dec3d2e9e826e3419c91a251e821861a146325b025c52ff15b5edefe1c - canonicalized_ast: 8c4a98dec3d2e9e826e3419c91a251e821861a146325b025c52ff15b5edefe1c - type_inferenced_ast: a88491df0bd761c2c92882182087308683df773c06b6337d47e47658024ba6ea + imports_resolved_ast: 371665605b41146e53ee801468ab487152e021c574689b256da4ffe19967855e + canonicalized_ast: 371665605b41146e53ee801468ab487152e021c574689b256da4ffe19967855e + type_inferenced_ast: f959704a73dfbf9b2c868bd91e0ee6f842b9308fa56fdeb3054ed0a3c26d4aee diff --git a/tests/expectations/compiler/compiler/circuits/mutable_call_immutable_context.leo.out b/tests/expectations/compiler/compiler/circuits/mutable_call_immutable_context.leo.out index 8ca3ebf9a2..387112482f 100644 --- a/tests/expectations/compiler/compiler/circuits/mutable_call_immutable_context.leo.out +++ b/tests/expectations/compiler/compiler/circuits/mutable_call_immutable_context.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 842ec0aa120289fc341e19deefa59c7f78af032b1221b749323e0e4b6ce9023d - imports_resolved_ast: 842ec0aa120289fc341e19deefa59c7f78af032b1221b749323e0e4b6ce9023d - canonicalized_ast: c554b4086bcc2a245ee45c1a7ee7879c23dfab6872c8f0254bd258f1d78854b5 - type_inferenced_ast: 8aca5d3beb3f7988b97d7ee3ed5f5376e508e35b687bc70cc402824e3740afc9 + imports_resolved_ast: 86958433b9d8629c9d5ab9ad5e5ef4eaaa9f0e35f0b779ccc60a62d9c4058960 + canonicalized_ast: 566d34adc815e5adfb60459e7d69f04710d001c62106400e1d17e432532be449 + type_inferenced_ast: 42fb7a9584623b7ac24a109b023bc6e507bcedcf18e272691e8219d23ec44a00 diff --git a/tests/expectations/compiler/compiler/circuits/pedersen_mock.leo.out b/tests/expectations/compiler/compiler/circuits/pedersen_mock.leo.out index fbc3e24305..c129c2c2b1 100644 --- a/tests/expectations/compiler/compiler/circuits/pedersen_mock.leo.out +++ b/tests/expectations/compiler/compiler/circuits/pedersen_mock.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: c341e62f8a3940ddc9527bcd01c814f8d496a1f02ca903b080b6228d155af02b - imports_resolved_ast: c341e62f8a3940ddc9527bcd01c814f8d496a1f02ca903b080b6228d155af02b - canonicalized_ast: 3f982b126b30b7d4e6f69d186eae87e539ac99c186e3ffc95e101996c447aac6 - type_inferenced_ast: ca39452d2a0bfc4763004f6422de9c969c90bef10f6ec1ce47d71ce6fbf14d60 + imports_resolved_ast: a1782c121612ce35b13c9993d0dbe676e48af5ab4da48d9ec044fd24348e18ce + canonicalized_ast: 72b1da9e76745a53e5a91bddce8df1e014fd0b88d295eb9ab7f5b749a44db358 + type_inferenced_ast: 82d4375347e241b94f38215a193d37fc5f1d6dc9e231281516b05e60d076561f diff --git a/tests/expectations/compiler/compiler/circuits/return_self_type_array.leo.out b/tests/expectations/compiler/compiler/circuits/return_self_type_array.leo.out index 02174bccab..29fdb8d2c6 100644 --- a/tests/expectations/compiler/compiler/circuits/return_self_type_array.leo.out +++ b/tests/expectations/compiler/compiler/circuits/return_self_type_array.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 5da09287f1d3a5e4ab57f8da2c8094df25c3b35614791e2f6e84a77b609f29b0 - imports_resolved_ast: 5da09287f1d3a5e4ab57f8da2c8094df25c3b35614791e2f6e84a77b609f29b0 - canonicalized_ast: ef7bf4fbec528e16a88b50e4c5b96f9e16a136fb06b9d7ba145641e22382e166 - type_inferenced_ast: cfec0af03e9a908d876dd84a977fbccb7ddbda93e4f26b2bb7c1e7349ef41c3f + imports_resolved_ast: df18a0cb9640cbb173338d9bb1a626a167218dfdfc16aa92a8d2a2a294f8d4a8 + canonicalized_ast: 2826257744d2a43f5b002ef71e966afca147e383e521a85099c0555568a66ea4 + type_inferenced_ast: d211e29cc13bfdb4bb748c761c4325fc3900cbcae44c63f779e80cc1d0d4ec4e diff --git a/tests/expectations/compiler/compiler/circuits/return_self_type_tuple.leo.out b/tests/expectations/compiler/compiler/circuits/return_self_type_tuple.leo.out index 9b181dcebc..e20185cb96 100644 --- a/tests/expectations/compiler/compiler/circuits/return_self_type_tuple.leo.out +++ b/tests/expectations/compiler/compiler/circuits/return_self_type_tuple.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 1dce719e850f6ca6a091fea163d5d6bb069bcdafeeed0a10fb332ba8837e6e5c - imports_resolved_ast: 1dce719e850f6ca6a091fea163d5d6bb069bcdafeeed0a10fb332ba8837e6e5c - canonicalized_ast: c2e6a47b169e35f9d0eeb382b9ad3fbfb474dcfcce36f518a615bedd50f168dc - type_inferenced_ast: ada2285ca841403ea8f299de603e6f83f001aa7c59f0ccdb798cf3ed874cbe1f + imports_resolved_ast: 4e65ed61dec957f1b1bd1dd837b066f81462f9ef10eba7070666486041f1ba60 + canonicalized_ast: 9be723e8689baa1dd1d80cb61fc493ff914b770d063a3adbaef0989ea4696b19 + type_inferenced_ast: e658ac6c991950a742586fb5d7f5d0bc1e56449282cbe58ce4f9e3627b11d69c diff --git a/tests/expectations/compiler/compiler/circuits/self_member.leo.out b/tests/expectations/compiler/compiler/circuits/self_member.leo.out index 67698dec41..be23b65ede 100644 --- a/tests/expectations/compiler/compiler/circuits/self_member.leo.out +++ b/tests/expectations/compiler/compiler/circuits/self_member.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: c2f6d0da67de691b14cffbdbe20eba613f2ea274c45aba4347045da2446b6af6 - imports_resolved_ast: c2f6d0da67de691b14cffbdbe20eba613f2ea274c45aba4347045da2446b6af6 - canonicalized_ast: c2f6d0da67de691b14cffbdbe20eba613f2ea274c45aba4347045da2446b6af6 - type_inferenced_ast: 66f38055929362798774a530c32dd375c979368f2ed3c7b0345dd8ecfefe3ea7 + imports_resolved_ast: 66b9ad8e1ad5ef5fd0911f2a560d6c9280fa3dc639063046897350d73796823f + canonicalized_ast: 66b9ad8e1ad5ef5fd0911f2a560d6c9280fa3dc639063046897350d73796823f + type_inferenced_ast: a3054f521ff5efaf53f4b3633ab9926cd286095c1a3e06600d4a4a1326a0bb82 diff --git a/tests/expectations/compiler/compiler/console/assert.leo.out b/tests/expectations/compiler/compiler/console/assert.leo.out index 7a1aa047e9..a016a7b963 100644 --- a/tests/expectations/compiler/compiler/console/assert.leo.out +++ b/tests/expectations/compiler/compiler/console/assert.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: bd23695040d06dbd59426b363ea66da8c9344aad064615d1b5beb6326933acbc - imports_resolved_ast: bd23695040d06dbd59426b363ea66da8c9344aad064615d1b5beb6326933acbc - canonicalized_ast: bd23695040d06dbd59426b363ea66da8c9344aad064615d1b5beb6326933acbc - type_inferenced_ast: 198e2817e4d6d454d7e1d1eba8226757d7f044b20e6dd4f6962530b177c469c5 + imports_resolved_ast: b474e083b86cb0c84ab05c5e5c5a86b209eb55209d5ed004aefb7b5c2cbc2dca + canonicalized_ast: b474e083b86cb0c84ab05c5e5c5a86b209eb55209d5ed004aefb7b5c2cbc2dca + type_inferenced_ast: 51ff99948781e4dd6da20d498d981839cf3116646080849d9694feff48113afa diff --git a/tests/expectations/compiler/compiler/console/conditional_assert.leo.out b/tests/expectations/compiler/compiler/console/conditional_assert.leo.out index 1fb87c4c58..19e3cee114 100644 --- a/tests/expectations/compiler/compiler/console/conditional_assert.leo.out +++ b/tests/expectations/compiler/compiler/console/conditional_assert.leo.out @@ -17,6 +17,6 @@ outputs: output: registers: {} initial_ast: a7b374e2c0a97af2160b5f6faeadb17a12e8908c1a7b3d251194e6867fd98f07 - imports_resolved_ast: a7b374e2c0a97af2160b5f6faeadb17a12e8908c1a7b3d251194e6867fd98f07 - canonicalized_ast: ebd1a1f28fafd6fc55c13f4c362ae9a13dee4717e41d99c23fd0d32c5fcdc526 - type_inferenced_ast: eb15aba7bdb3c3a2f776af8cb80f52f44d6d6ab60e5ee3c032ab4ec8a90a2436 + imports_resolved_ast: dabdcc765c43d9b60d2b4acae683e8d085a680ae2dd11c566786b7378d84d6e0 + canonicalized_ast: dbcad56164992471e3ba9deca495baa44c052bb4cb023eb71eeb19f515b2b4c8 + type_inferenced_ast: 436e5bacea4dae2b4fc635a43ef91cfcfaec6931673c32eb1e7a06efcb868ba4 diff --git a/tests/expectations/compiler/compiler/console/error.leo.out b/tests/expectations/compiler/compiler/console/error.leo.out index da322715ae..32c6d190f2 100644 --- a/tests/expectations/compiler/compiler/console/error.leo.out +++ b/tests/expectations/compiler/compiler/console/error.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 2496cb4a0f1486bbacccee48e3b8b93999916e585e238a5c7d63c34235d15a36 - imports_resolved_ast: 2496cb4a0f1486bbacccee48e3b8b93999916e585e238a5c7d63c34235d15a36 - canonicalized_ast: 2496cb4a0f1486bbacccee48e3b8b93999916e585e238a5c7d63c34235d15a36 - type_inferenced_ast: aa056968c0d635d56e2ad011db4df7fec65b62eb7b0ca8ec5c75ca8fca0f33eb + imports_resolved_ast: 8894f10221be9e1faead387fb7e82cd4abc8c45b24131d8cef41fd8e78853381 + canonicalized_ast: 8894f10221be9e1faead387fb7e82cd4abc8c45b24131d8cef41fd8e78853381 + type_inferenced_ast: 11d84a1bbf4a0f44ed51ce0d1c8cb3e7c015195b630db35628483e47515057a5 diff --git a/tests/expectations/compiler/compiler/console/log.leo.out b/tests/expectations/compiler/compiler/console/log.leo.out index 6cf52c9b4d..2cad78f54d 100644 --- a/tests/expectations/compiler/compiler/console/log.leo.out +++ b/tests/expectations/compiler/compiler/console/log.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 8421d5ef70b41b773b771cb1991a5120a556d13127fb1c6cf7bbd6328150c7d5 - imports_resolved_ast: 8421d5ef70b41b773b771cb1991a5120a556d13127fb1c6cf7bbd6328150c7d5 - canonicalized_ast: 8421d5ef70b41b773b771cb1991a5120a556d13127fb1c6cf7bbd6328150c7d5 - type_inferenced_ast: 34e28d45203ffd3ec760af7baf8db09cfb14584107951fc5803122c0fc13f0e2 + imports_resolved_ast: 5806c49385268e8d6ee468f979ff029a9813539e5fca7e01a69f36ef32e3c435 + canonicalized_ast: 5806c49385268e8d6ee468f979ff029a9813539e5fca7e01a69f36ef32e3c435 + type_inferenced_ast: ac8cb61098856685e017bc3556abef5e351fb97c1836fb5057e8dab041e7a932 diff --git a/tests/expectations/compiler/compiler/console/log_conditional.leo.out b/tests/expectations/compiler/compiler/console/log_conditional.leo.out index d2c91fd30b..c6e179c026 100644 --- a/tests/expectations/compiler/compiler/console/log_conditional.leo.out +++ b/tests/expectations/compiler/compiler/console/log_conditional.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 389c0d4a68bf27db627b83d460a2947a2321a76fc73e727806a9fe8c7f63fe88 - imports_resolved_ast: 389c0d4a68bf27db627b83d460a2947a2321a76fc73e727806a9fe8c7f63fe88 - canonicalized_ast: 389c0d4a68bf27db627b83d460a2947a2321a76fc73e727806a9fe8c7f63fe88 - type_inferenced_ast: d5fe9155615c6ca70430e6b33661214f14844a61d5064ad56d388fea147abfd7 + imports_resolved_ast: 08d50ccc2ca7866fac012b49f3188712c1df5c14be8c3dba5c50263a0fa01e5d + canonicalized_ast: 08d50ccc2ca7866fac012b49f3188712c1df5c14be8c3dba5c50263a0fa01e5d + type_inferenced_ast: cba95b7d8b28489bba40f6058992ce90ff655b4e513e36dddb4701bf46dbf43b diff --git a/tests/expectations/compiler/compiler/console/log_input.leo.out b/tests/expectations/compiler/compiler/console/log_input.leo.out index f185bd153a..38b84912aa 100644 --- a/tests/expectations/compiler/compiler/console/log_input.leo.out +++ b/tests/expectations/compiler/compiler/console/log_input.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: de5d7719988638c095aba736ca2e09c2037be42e22c3b29bc2c07705e7bfd6ee - imports_resolved_ast: de5d7719988638c095aba736ca2e09c2037be42e22c3b29bc2c07705e7bfd6ee - canonicalized_ast: de5d7719988638c095aba736ca2e09c2037be42e22c3b29bc2c07705e7bfd6ee - type_inferenced_ast: 8e6fed7036467ea6116184b59b25589393393308a1c1fe963dc0ac4a9e76481a + imports_resolved_ast: 52b3dbae5a042cac36cad9501f7780ab69ae97324471da7e96fc22bca5d92134 + canonicalized_ast: 52b3dbae5a042cac36cad9501f7780ab69ae97324471da7e96fc22bca5d92134 + type_inferenced_ast: cb214d737d6a07b808fac8b24fccfdab28f09302efd3eb98a97016292ba3ff7f diff --git a/tests/expectations/compiler/compiler/console/log_parameter.leo.out b/tests/expectations/compiler/compiler/console/log_parameter.leo.out index 3d65eacddb..37f26f416c 100644 --- a/tests/expectations/compiler/compiler/console/log_parameter.leo.out +++ b/tests/expectations/compiler/compiler/console/log_parameter.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 97523a5fea528d3defe4ddc2fa7b0a8af6b4ea8a364893c62c467f759cb4ee3f - imports_resolved_ast: 97523a5fea528d3defe4ddc2fa7b0a8af6b4ea8a364893c62c467f759cb4ee3f - canonicalized_ast: 97523a5fea528d3defe4ddc2fa7b0a8af6b4ea8a364893c62c467f759cb4ee3f - type_inferenced_ast: 613f187637adb705d9b61d73f3dd074de1443bc619326e2fd51fa8f722579f82 + imports_resolved_ast: b93ee0938f4b7a25549fb71a94c1096b55f17fc94ec9340463ce4e8fedfbad16 + canonicalized_ast: b93ee0938f4b7a25549fb71a94c1096b55f17fc94ec9340463ce4e8fedfbad16 + type_inferenced_ast: 59bab25c60572940968ed18111752437abed0248da6e9271edf5ac1b6a0fe231 diff --git a/tests/expectations/compiler/compiler/console/log_parameter_many.leo.out b/tests/expectations/compiler/compiler/console/log_parameter_many.leo.out index e294fa474c..13f771a67a 100644 --- a/tests/expectations/compiler/compiler/console/log_parameter_many.leo.out +++ b/tests/expectations/compiler/compiler/console/log_parameter_many.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: af681f8f7631db769ad1f0b9822b86407fb04871adb16e1069b83ee85b6cda3e - imports_resolved_ast: af681f8f7631db769ad1f0b9822b86407fb04871adb16e1069b83ee85b6cda3e - canonicalized_ast: af681f8f7631db769ad1f0b9822b86407fb04871adb16e1069b83ee85b6cda3e - type_inferenced_ast: c9824cee4e17d7cdb31526d24ed5aea45f719596b8dad46f4aec822fbff92e50 + imports_resolved_ast: 2fefb062db2ea2ec96f68cfab909a003ac788ea2151d2c632988206d6b9c863e + canonicalized_ast: 2fefb062db2ea2ec96f68cfab909a003ac788ea2151d2c632988206d6b9c863e + type_inferenced_ast: 016f9e2d03254c8939769bf372e195f255909cc61739e80b2c106debecfd3a27 diff --git a/tests/expectations/compiler/compiler/definition/out_of_order.leo.out b/tests/expectations/compiler/compiler/definition/out_of_order.leo.out index ea0de75b49..cf37c150b5 100644 --- a/tests/expectations/compiler/compiler/definition/out_of_order.leo.out +++ b/tests/expectations/compiler/compiler/definition/out_of_order.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 2b8f9e74a55ef80fa57c803636de64003b225c4cc4b826d0feba3be380ec0b32 - imports_resolved_ast: 2b8f9e74a55ef80fa57c803636de64003b225c4cc4b826d0feba3be380ec0b32 - canonicalized_ast: 56bb9f0f648dde5fd777de5bba07c44218022d1b91410b6b111bf49fb119588d - type_inferenced_ast: ef607716cf7d424af7888a58b121cf8c43a173424d06b04d8530f0db96dd2c31 + imports_resolved_ast: 8856a655788a0e779d6178bbc8b32ebca56e9f4ba67133feff65ddea3847fab4 + canonicalized_ast: bb40efcea7122e0c21e3284fd0586a20a2241551426c4c2015537607cf9acdff + type_inferenced_ast: 1afbbffd78dc1e74703ac0744dff0d0da96c073a0b86903cf3ca6063582bd359 diff --git a/tests/expectations/compiler/compiler/definition/out_of_order_with_import.leo.out b/tests/expectations/compiler/compiler/definition/out_of_order_with_import.leo.out index e0d71173c8..26d4d55b20 100644 --- a/tests/expectations/compiler/compiler/definition/out_of_order_with_import.leo.out +++ b/tests/expectations/compiler/compiler/definition/out_of_order_with_import.leo.out @@ -16,7 +16,7 @@ outputs: r0: type: bool value: "true" - initial_ast: 53fcf08b3818e474a00c1cb70aca58d29bb956611ffdd069a242ef2633af6c50 - imports_resolved_ast: 80581d0ec6076d59b9fbaff32b646df1120b6ca28cdfe69482cbec641e7e3a1a - canonicalized_ast: 57c3de1d28c5b809c265e221ad26d3970445174a2edf2b0f22995e4eb6ffd807 - type_inferenced_ast: ca53699361b6d4aa80b2f733df6f39bd1a279d68336c2c6cbf196897a26b5e2a + initial_ast: 6f83048e6a7967f42f9d3175a81a24665e4c929bc5be93edb6a6a472b84c5f5c + imports_resolved_ast: 901b88dfdab5ee8217de9bcc65c2bca30e0144a82aeef4ebd404da6a588ded76 + canonicalized_ast: 90e5b8f3b70577c1a633ad48f9cc848f41460c029c7f8cf212adbf6a62b0df32 + type_inferenced_ast: a381c1677355a34ec0bf76451966437a99e7378b76b4aee56412827ca4742a9b diff --git a/tests/expectations/compiler/compiler/field/add.leo.out b/tests/expectations/compiler/compiler/field/add.leo.out index 2238b1d873..51d8024796 100644 --- a/tests/expectations/compiler/compiler/field/add.leo.out +++ b/tests/expectations/compiler/compiler/field/add.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: dc99169bc40dff6491c84f2b70dc970fb74d8bcb139ce23ab2b0da5bff720430 - imports_resolved_ast: dc99169bc40dff6491c84f2b70dc970fb74d8bcb139ce23ab2b0da5bff720430 - canonicalized_ast: dc99169bc40dff6491c84f2b70dc970fb74d8bcb139ce23ab2b0da5bff720430 - type_inferenced_ast: 50e3aacddace87d41cc0c5ec8b9819a5c40ca1c9c3574ea883b85b8fd77c1cc3 + imports_resolved_ast: 60f8166a16f492ee87cf37aa2691176375b63513ff44cc96f21eedee114b28cd + canonicalized_ast: 60f8166a16f492ee87cf37aa2691176375b63513ff44cc96f21eedee114b28cd + type_inferenced_ast: b807890e82273851f9948d0f92d3a9ace74d351bbf4a1eca9cd8c7f30f8dccea diff --git a/tests/expectations/compiler/compiler/field/div.leo.out b/tests/expectations/compiler/compiler/field/div.leo.out index b39950d9e7..e76cece1c2 100644 --- a/tests/expectations/compiler/compiler/field/div.leo.out +++ b/tests/expectations/compiler/compiler/field/div.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 4f93fba73bf22c15fd88cd83958c1d096f5fcdfbe1c95e871f14cd672e4790e8 - imports_resolved_ast: 4f93fba73bf22c15fd88cd83958c1d096f5fcdfbe1c95e871f14cd672e4790e8 - canonicalized_ast: 4f93fba73bf22c15fd88cd83958c1d096f5fcdfbe1c95e871f14cd672e4790e8 - type_inferenced_ast: 9b23dc524ac18ebeb198dde3e95d00cf452183cbfe0652c232a7ae0b29d4f34e + imports_resolved_ast: 6b9422a90257f831434d94e313d2d10fb388763cbba780287ca316e03d0423a6 + canonicalized_ast: 6b9422a90257f831434d94e313d2d10fb388763cbba780287ca316e03d0423a6 + type_inferenced_ast: 700862a60cf4e937e906ae7cfd4ce62723be45d176e4627f75905ace2a3f3c11 diff --git a/tests/expectations/compiler/compiler/field/eq.leo.out b/tests/expectations/compiler/compiler/field/eq.leo.out index 19bf013d51..40a1904166 100644 --- a/tests/expectations/compiler/compiler/field/eq.leo.out +++ b/tests/expectations/compiler/compiler/field/eq.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 279038173ca3a2bbeaefe14da8c79f4da2a885f59626a7ebc05a512f38a96e79 - imports_resolved_ast: 279038173ca3a2bbeaefe14da8c79f4da2a885f59626a7ebc05a512f38a96e79 - canonicalized_ast: 279038173ca3a2bbeaefe14da8c79f4da2a885f59626a7ebc05a512f38a96e79 - type_inferenced_ast: 0c67233c225770430cb57c611f70eeb248a7892884b140aa4e141c9a46bb48b8 + imports_resolved_ast: 1490a6f02886d98c384793b14568c5db53ee3661a09c2c0abb6dd063633eb014 + canonicalized_ast: 1490a6f02886d98c384793b14568c5db53ee3661a09c2c0abb6dd063633eb014 + type_inferenced_ast: 98e53b900397401af122eb6d5c1845975aab946050d3852f1f7368d5a2e860fc diff --git a/tests/expectations/compiler/compiler/field/field.leo.out b/tests/expectations/compiler/compiler/field/field.leo.out index 3c66b486b6..b4b1522dee 100644 --- a/tests/expectations/compiler/compiler/field/field.leo.out +++ b/tests/expectations/compiler/compiler/field/field.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: ab26194ed8eb600aca9329f95d1d34f567f8f23a7f3abf1bd374d68fedf835ab - imports_resolved_ast: ab26194ed8eb600aca9329f95d1d34f567f8f23a7f3abf1bd374d68fedf835ab - canonicalized_ast: ab26194ed8eb600aca9329f95d1d34f567f8f23a7f3abf1bd374d68fedf835ab - type_inferenced_ast: a129961f338ed15ef697362226422a48534480c0985c5023ea5183e9150cba07 + imports_resolved_ast: 4c93c9243d45f6546f3fba40f623a7e10985035e5b68b580228939205d2c537c + canonicalized_ast: 4c93c9243d45f6546f3fba40f623a7e10985035e5b68b580228939205d2c537c + type_inferenced_ast: 99b25b58380f771417dd620643cbd9bf1d78a829f340c3a849c49e99d42969c1 diff --git a/tests/expectations/compiler/compiler/field/mul.leo.out b/tests/expectations/compiler/compiler/field/mul.leo.out index ca464c6b39..1f32133b70 100644 --- a/tests/expectations/compiler/compiler/field/mul.leo.out +++ b/tests/expectations/compiler/compiler/field/mul.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "false" initial_ast: 8d0d2d5203583fe24eb60eb496dcdc3a83066ad82a8b5e92d35ab6b803e029ea - imports_resolved_ast: 8d0d2d5203583fe24eb60eb496dcdc3a83066ad82a8b5e92d35ab6b803e029ea - canonicalized_ast: 8d0d2d5203583fe24eb60eb496dcdc3a83066ad82a8b5e92d35ab6b803e029ea - type_inferenced_ast: 09780678c1e754f760bf08f1aecc706c058ffa6b73885dd5440f40e6354ac926 + imports_resolved_ast: 2470d9192e9b22fb2c05ae608bf44957cc296ad60383a0e7ef40ad88d8304ad2 + canonicalized_ast: 2470d9192e9b22fb2c05ae608bf44957cc296ad60383a0e7ef40ad88d8304ad2 + type_inferenced_ast: f7178b6185af767640f4296a9afc8b0d199425b02b67fdd67dceb44796b3e82d diff --git a/tests/expectations/compiler/compiler/field/negate.leo.out b/tests/expectations/compiler/compiler/field/negate.leo.out index 542372e6d8..4d8ae81ac1 100644 --- a/tests/expectations/compiler/compiler/field/negate.leo.out +++ b/tests/expectations/compiler/compiler/field/negate.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: cbae2cc36e7902468336fe1356e7de41a43288ebfd6b024251086b9d8a32cec5 - imports_resolved_ast: cbae2cc36e7902468336fe1356e7de41a43288ebfd6b024251086b9d8a32cec5 - canonicalized_ast: cbae2cc36e7902468336fe1356e7de41a43288ebfd6b024251086b9d8a32cec5 - type_inferenced_ast: bd4b2bb9ce68719f78756803cbcde2f7dc0aa09f1f2612fa909bd2df39816dfb + imports_resolved_ast: 95807880f53d5ec00183c231d7cf256fac83490f414bef2aba3c6bd06e9e24b0 + canonicalized_ast: 95807880f53d5ec00183c231d7cf256fac83490f414bef2aba3c6bd06e9e24b0 + type_inferenced_ast: 088708ea39bfb0b925fa63c0c15eb072f3f53598151747177bae7286052a75bc diff --git a/tests/expectations/compiler/compiler/function/array_input.leo.out b/tests/expectations/compiler/compiler/function/array_input.leo.out index 397414838c..941087fd5a 100644 --- a/tests/expectations/compiler/compiler/function/array_input.leo.out +++ b/tests/expectations/compiler/compiler/function/array_input.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: e53134e16501c1dc8fcc1fa68e513aa486d6b4ee2c3ce762da4b45b8f06029d1 - imports_resolved_ast: e53134e16501c1dc8fcc1fa68e513aa486d6b4ee2c3ce762da4b45b8f06029d1 - canonicalized_ast: 9024b75cbe9df679b3b0473589f2a1698bfc340d125c9bd76562d9e92548b945 - type_inferenced_ast: 5c1f49685a0e099ecd11607a35c6e67c97d5dec8551c153cd5789e07006b1318 + imports_resolved_ast: 74641555a4128b775e2322a261a0de7aceb732ab863d80531fb52b195e3235d4 + canonicalized_ast: 03bacaa55f2153a72622a51de06b2fca0534592e3529523f44e5a57b7375be46 + type_inferenced_ast: b94b4180430b30812d24ed23edb3b3622b4504ecb20d852215a26982696577ad diff --git a/tests/expectations/compiler/compiler/function/array_params_direct_call.leo.out b/tests/expectations/compiler/compiler/function/array_params_direct_call.leo.out index c391a82254..8c2641290a 100644 --- a/tests/expectations/compiler/compiler/function/array_params_direct_call.leo.out +++ b/tests/expectations/compiler/compiler/function/array_params_direct_call.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 8541fbc5a256e744d4939e6e221565a0bada891ed6269eceb3a84b288bdeadcc - imports_resolved_ast: 8541fbc5a256e744d4939e6e221565a0bada891ed6269eceb3a84b288bdeadcc - canonicalized_ast: b43be48e63718566c98d68fb855f0de85845855b9eb80f7929205db537bc1da2 - type_inferenced_ast: 558ac6d5261ca88b84d1a26447cf01b6e250fecc219441e0b4cb82d31c2e4dcc + imports_resolved_ast: 86f07b3ecb574ef9eaa3c4238947937863b3286ea4835e9936206bef428f73c2 + canonicalized_ast: d45dfca79ac486cb4051e22a05bd7506c445161f950e6a7c1e877a2b7160071a + type_inferenced_ast: eb74528b685ae313326d66b11bad3cf827b61f5ebb121ef573c506c8991ecbec diff --git a/tests/expectations/compiler/compiler/function/conditional_return.leo.out b/tests/expectations/compiler/compiler/function/conditional_return.leo.out index 268f73fc7a..afd5e3cd02 100644 --- a/tests/expectations/compiler/compiler/function/conditional_return.leo.out +++ b/tests/expectations/compiler/compiler/function/conditional_return.leo.out @@ -17,6 +17,6 @@ outputs: type: u32 value: "4" initial_ast: cf2d49dcd581c923b4ccfeb9c155de0e836fb8725c3c3af7abc5e6334231ba2f - imports_resolved_ast: cf2d49dcd581c923b4ccfeb9c155de0e836fb8725c3c3af7abc5e6334231ba2f - canonicalized_ast: cf2d49dcd581c923b4ccfeb9c155de0e836fb8725c3c3af7abc5e6334231ba2f - type_inferenced_ast: 085d3126391766edfb8cd9b92bff04cb67175fea26de3ff127392f4aab681cf8 + imports_resolved_ast: cdcf08230c307f01d2e451b70ad6831dcf25f8edf3d619a1dce4102803376667 + canonicalized_ast: cdcf08230c307f01d2e451b70ad6831dcf25f8edf3d619a1dce4102803376667 + type_inferenced_ast: c7dfc3e3c55709915d7aa84ff1d9c211fc93e55bd280df82998640d9d847d57c diff --git a/tests/expectations/compiler/compiler/function/empty.leo.out b/tests/expectations/compiler/compiler/function/empty.leo.out index 0cf4e77f14..99c9d7f5b1 100644 --- a/tests/expectations/compiler/compiler/function/empty.leo.out +++ b/tests/expectations/compiler/compiler/function/empty.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: cab7d9499f0129277addc5a322ee12374593a292749c88220555b8ec73a0855a - imports_resolved_ast: cab7d9499f0129277addc5a322ee12374593a292749c88220555b8ec73a0855a - canonicalized_ast: e95711f5d76b04852f206614b42e6e38cc83b307d617e4eaaca8ade4c65e1c7b - type_inferenced_ast: fede77484a950576c3362c642eb3225e51c7a1ad0998950eb77cdd66630f92de + imports_resolved_ast: 0a0f7680874c502028fe5e46cab4df96633e758155cfcc6b72d2687442e08d9b + canonicalized_ast: 0bcd16cda983e97c7395eca58f490f865cc3b15a8f17907a9c1c3c639acfb8cb + type_inferenced_ast: f45bea675ef7638d6e25871ebc2241f38630a17d14e295f124230e4066886e06 diff --git a/tests/expectations/compiler/compiler/function/iteration.leo.out b/tests/expectations/compiler/compiler/function/iteration.leo.out index 07abe01cec..5a6db82973 100644 --- a/tests/expectations/compiler/compiler/function/iteration.leo.out +++ b/tests/expectations/compiler/compiler/function/iteration.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: a608123169470d0c7e940599945a527f8516b010c900464bc649db94167ee6e0 - imports_resolved_ast: a608123169470d0c7e940599945a527f8516b010c900464bc649db94167ee6e0 - canonicalized_ast: 721cf0941964bdfd4835cb367fa7c472ad612ad214686ce4ca7f264faf43b0fd - type_inferenced_ast: ff52c35a361f5669d3f9ba5ec58b740c190bb3737a8e2e0485d41f8ace63a7d4 + imports_resolved_ast: e82f037a8c618251d84c4653e608d558ed5947d9fb464b51bb98afdbcc5ea114 + canonicalized_ast: 31585d0944332f05abfe04a31f8763be546f250e57b1eda2596586325abbb2d3 + type_inferenced_ast: c4448d122eb2a1ba63c379c83458ba4946350d3893022e890f94fd5ed5e42e96 diff --git a/tests/expectations/compiler/compiler/function/iteration_repeated.leo.out b/tests/expectations/compiler/compiler/function/iteration_repeated.leo.out index 6050614409..9b8cd3f72d 100644 --- a/tests/expectations/compiler/compiler/function/iteration_repeated.leo.out +++ b/tests/expectations/compiler/compiler/function/iteration_repeated.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 45b332b088617597f7367003f3cf7c6bf00a69a490f2c64eed1e622eb099d2b6 - imports_resolved_ast: 45b332b088617597f7367003f3cf7c6bf00a69a490f2c64eed1e622eb099d2b6 - canonicalized_ast: 71c61b47872ad3a5e9724e6d7bcb315eb06f00234bcbb2ab801861f9561bc9ff - type_inferenced_ast: 038d42871e44b9d120c49d4465ebf2551af030799827c08363c0a032f3ba712e + imports_resolved_ast: 62252991f94d11ef3332f3c66fdd9543dc5e6d93fa5b7fdb741dff5039e994b1 + canonicalized_ast: 3182172b56ad367567a822d072ee2bd17c4ba31c92ef1ac5c7064234869927a2 + type_inferenced_ast: 5650b4a2d0297bc85a629be0c613abab9a4fb838245693f8dcda8bd6356d7ffe diff --git a/tests/expectations/compiler/compiler/function/multiple_returns.leo.out b/tests/expectations/compiler/compiler/function/multiple_returns.leo.out index 24c8f41281..c0d4087bb9 100644 --- a/tests/expectations/compiler/compiler/function/multiple_returns.leo.out +++ b/tests/expectations/compiler/compiler/function/multiple_returns.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: c43d366baa8a13cae723e98783ec3afc4efd25da0e9c075b2719af866c142c31 - imports_resolved_ast: c43d366baa8a13cae723e98783ec3afc4efd25da0e9c075b2719af866c142c31 - canonicalized_ast: c43d366baa8a13cae723e98783ec3afc4efd25da0e9c075b2719af866c142c31 - type_inferenced_ast: cd99ea6925a98417f259aa058291494bb866060239e6c36715960f75f1497c2a + imports_resolved_ast: 423b12046620c5ade58be4f4630680d749a2140e5ed3340031d8435f34b1763d + canonicalized_ast: 423b12046620c5ade58be4f4630680d749a2140e5ed3340031d8435f34b1763d + type_inferenced_ast: e192b4aaf19771fa088100c94f249e76b99f7476e3c571ed157488de1506f0bd diff --git a/tests/expectations/compiler/compiler/function/multiple_returns_main.leo.out b/tests/expectations/compiler/compiler/function/multiple_returns_main.leo.out index 0b7972b852..22883edc42 100644 --- a/tests/expectations/compiler/compiler/function/multiple_returns_main.leo.out +++ b/tests/expectations/compiler/compiler/function/multiple_returns_main.leo.out @@ -20,6 +20,6 @@ outputs: type: bool value: "true" initial_ast: f8b2853c4b5db8f5e8402455ceae54d8ae421c4b950d15fc88fe9f9c9a9701b8 - imports_resolved_ast: f8b2853c4b5db8f5e8402455ceae54d8ae421c4b950d15fc88fe9f9c9a9701b8 - canonicalized_ast: f8b2853c4b5db8f5e8402455ceae54d8ae421c4b950d15fc88fe9f9c9a9701b8 - type_inferenced_ast: 52232bc9ef6145283b66f274ab534f35ad5cbf76ed6396c34cf0d6bf59b0797c + imports_resolved_ast: 49ddaa94560380853f6c72c023f9a15931d93bac81df4b09e8d60957921aeba3 + canonicalized_ast: 49ddaa94560380853f6c72c023f9a15931d93bac81df4b09e8d60957921aeba3 + type_inferenced_ast: feecbe17368c47e2fb968683d81a4349d667c4918825765d176a3fa9c6847977 diff --git a/tests/expectations/compiler/compiler/function/newlines.leo.out b/tests/expectations/compiler/compiler/function/newlines.leo.out index f786c38c0d..f140f69382 100644 --- a/tests/expectations/compiler/compiler/function/newlines.leo.out +++ b/tests/expectations/compiler/compiler/function/newlines.leo.out @@ -20,6 +20,6 @@ outputs: type: u32 value: "0" initial_ast: 659826ae1cff74192eca6a5936459d0ec78b73a389516602b4d04cf6b80b1004 - imports_resolved_ast: 659826ae1cff74192eca6a5936459d0ec78b73a389516602b4d04cf6b80b1004 - canonicalized_ast: 659826ae1cff74192eca6a5936459d0ec78b73a389516602b4d04cf6b80b1004 - type_inferenced_ast: 9b105138d6298e591c2882c5162f18c4f0dc223ab4128e09ce35b44ad14d2269 + imports_resolved_ast: f2b6d9e4af4e3f7177b5cd4cc65296e5edfb0b522a4f435a16c12043b55fb5ca + canonicalized_ast: f2b6d9e4af4e3f7177b5cd4cc65296e5edfb0b522a4f435a16c12043b55fb5ca + type_inferenced_ast: e47105df76da7c16b8db17178c9ef53b2059aa054154fa40db4e566891d353f2 diff --git a/tests/expectations/compiler/compiler/function/repeated.leo.out b/tests/expectations/compiler/compiler/function/repeated.leo.out index 194613e53c..20d3dd3a2a 100644 --- a/tests/expectations/compiler/compiler/function/repeated.leo.out +++ b/tests/expectations/compiler/compiler/function/repeated.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 46f6995392feecd25891b21595f4c575527c5d589d2fe9da94c6ac4bf8e9e7ea - imports_resolved_ast: 46f6995392feecd25891b21595f4c575527c5d589d2fe9da94c6ac4bf8e9e7ea - canonicalized_ast: 46f6995392feecd25891b21595f4c575527c5d589d2fe9da94c6ac4bf8e9e7ea - type_inferenced_ast: 06a0c346db5203f1f3db18eff7c5cf26f6f82aba1ff8b5696bdce5df09dd1b28 + imports_resolved_ast: 82a8096a70746aab3fe1e45aadd98d5450c85762e65d5fa0393252e9a2ecd70a + canonicalized_ast: 82a8096a70746aab3fe1e45aadd98d5450c85762e65d5fa0393252e9a2ecd70a + type_inferenced_ast: 74346038b4380ca923087a8d54fdd9f60b7879dcfe40fc96e2ce0890ba1382cc diff --git a/tests/expectations/compiler/compiler/function/return.leo.out b/tests/expectations/compiler/compiler/function/return.leo.out index 5a31d2fb98..e45a4cad55 100644 --- a/tests/expectations/compiler/compiler/function/return.leo.out +++ b/tests/expectations/compiler/compiler/function/return.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: e90708076fd49dc98d0de821c59d48efbf93b106e50fb43c10583a29b2c34336 - imports_resolved_ast: e90708076fd49dc98d0de821c59d48efbf93b106e50fb43c10583a29b2c34336 - canonicalized_ast: e90708076fd49dc98d0de821c59d48efbf93b106e50fb43c10583a29b2c34336 - type_inferenced_ast: de9f76b0880df3267d0031ecf46d21907a338ef64455ffac3aaf3ef6111148f6 + imports_resolved_ast: 710a79ace8949e9f1b5d751b400577eac3bcaa9277a2b0c386d316014fa83ac9 + canonicalized_ast: 710a79ace8949e9f1b5d751b400577eac3bcaa9277a2b0c386d316014fa83ac9 + type_inferenced_ast: d8929b56406994ab809c4e34e62f71da85e34a67030d5e0ac357ea4ef5ae434b diff --git a/tests/expectations/compiler/compiler/function/return_array_nested_pass.leo.out b/tests/expectations/compiler/compiler/function/return_array_nested_pass.leo.out index 046e409de6..fb27ddd43f 100644 --- a/tests/expectations/compiler/compiler/function/return_array_nested_pass.leo.out +++ b/tests/expectations/compiler/compiler/function/return_array_nested_pass.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: e6ef0c39821512fd98748cd7d9da04102fff12d3f9332aeb815b36870a3ff0c5 - imports_resolved_ast: e6ef0c39821512fd98748cd7d9da04102fff12d3f9332aeb815b36870a3ff0c5 - canonicalized_ast: ed7a3f6a24fa1a3a9e7b4cc8c97ce09440fb9d46123a4e310e44afb58a1a1de6 - type_inferenced_ast: a0aa0fb8a603954c8370d3520394910163acb807ec344d14b6a26f14f2912262 + imports_resolved_ast: 758824b7553015fda2f0a396e56c8e18813215178c93c282daea0bb843e5f30e + canonicalized_ast: 0a8dd8d2d0780607e11813ffc839e1fa9fb6d00947c0f1eaaceac14328176d70 + type_inferenced_ast: a40dc35882ad8a14b32654c186240a4028337c6f4f341f725b89905812a49403 diff --git a/tests/expectations/compiler/compiler/function/return_array_tuple_pass.leo.out b/tests/expectations/compiler/compiler/function/return_array_tuple_pass.leo.out index b11f8bf73b..0d5597d892 100644 --- a/tests/expectations/compiler/compiler/function/return_array_tuple_pass.leo.out +++ b/tests/expectations/compiler/compiler/function/return_array_tuple_pass.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: eb9e4ceedbd5812235005bd1f6b113fb8558b59f87acb3df796ff08b15ec14ca - imports_resolved_ast: eb9e4ceedbd5812235005bd1f6b113fb8558b59f87acb3df796ff08b15ec14ca - canonicalized_ast: 9d46523fc611325b41481c2084e8eb9215573cc46d69b8aa5082bc9489bd9f44 - type_inferenced_ast: 0f025d6f74e4ca27c52316acd2efcb4cc4158d1ba9ea6f79a46f4e417b918173 + imports_resolved_ast: cd964d9bf84c4e4bc84439cfbd3656b1a89c43135db3b7f00c1f2ce21e6031ab + canonicalized_ast: 9644e693fa77583f2f09d105855200e89cb2799f15c7987d00ba4ddd0a7d852e + type_inferenced_ast: 9de5a9b868919e2142e0941cb4307ece92f4bbee3c4daa8a2d74414afb920c7c diff --git a/tests/expectations/compiler/compiler/function/return_tuple.leo.out b/tests/expectations/compiler/compiler/function/return_tuple.leo.out index 7d3dd37c72..640b8e3b56 100644 --- a/tests/expectations/compiler/compiler/function/return_tuple.leo.out +++ b/tests/expectations/compiler/compiler/function/return_tuple.leo.out @@ -20,6 +20,6 @@ outputs: type: u32 value: "103" initial_ast: 3818078d8b7b34d11b38a9e53d326543a357f4db169acc32a52e2b08a8126602 - imports_resolved_ast: 3818078d8b7b34d11b38a9e53d326543a357f4db169acc32a52e2b08a8126602 - canonicalized_ast: 3818078d8b7b34d11b38a9e53d326543a357f4db169acc32a52e2b08a8126602 - type_inferenced_ast: 3eb5fbe370ce358e9d00865a230bb5eb6f2cfdb85f30408a164da43dfe16277d + imports_resolved_ast: 78ddbabf117579da40738dbd496200228ad81a7f9a6dd8ea0d0fb6df37e5631b + canonicalized_ast: 78ddbabf117579da40738dbd496200228ad81a7f9a6dd8ea0d0fb6df37e5631b + type_inferenced_ast: 3c153b948d21425c0b2e9271c97ca65bee611b63136e907d25a19f556f85d0f1 diff --git a/tests/expectations/compiler/compiler/function/return_tuple_conditional.leo.out b/tests/expectations/compiler/compiler/function/return_tuple_conditional.leo.out index 0d26ed29e9..f2998d3673 100644 --- a/tests/expectations/compiler/compiler/function/return_tuple_conditional.leo.out +++ b/tests/expectations/compiler/compiler/function/return_tuple_conditional.leo.out @@ -20,6 +20,6 @@ outputs: type: u32 value: "1" initial_ast: 6fc23eeb1a55273b0089acff714d6eb2952c3380c262d8e577c123659e501553 - imports_resolved_ast: 6fc23eeb1a55273b0089acff714d6eb2952c3380c262d8e577c123659e501553 - canonicalized_ast: 6fc23eeb1a55273b0089acff714d6eb2952c3380c262d8e577c123659e501553 - type_inferenced_ast: 43750961183eda5acb2302e5a9d9daf2809ee2f34d6ed53ec6494c867d0788a8 + imports_resolved_ast: 6736c957139a8ceae54f9bab3626a2517edc25b1c981c3632a87bbed45a489ad + canonicalized_ast: 6736c957139a8ceae54f9bab3626a2517edc25b1c981c3632a87bbed45a489ad + type_inferenced_ast: 4f2dd7628b318555a6737a6dc6562f04d6a65fc73d51df8cc826f4da878f3522 diff --git a/tests/expectations/compiler/compiler/function/value_unchanged.leo.out b/tests/expectations/compiler/compiler/function/value_unchanged.leo.out index 91e5ab153c..149d9c56d4 100644 --- a/tests/expectations/compiler/compiler/function/value_unchanged.leo.out +++ b/tests/expectations/compiler/compiler/function/value_unchanged.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: d70652e4acf04c7036a90f79e5bd61b60d37c2198fcccff97a9033f5bf3c9a1b - imports_resolved_ast: d70652e4acf04c7036a90f79e5bd61b60d37c2198fcccff97a9033f5bf3c9a1b - canonicalized_ast: ca06a00411c276665b7f9cab072e87bb6c4225406aa58703ace0c9db33c4535d - type_inferenced_ast: 830057c5a032606c73f38792b8efcc8bd99f7e167482875715cd3db538bcd8f1 + imports_resolved_ast: b2eb91a36d64f14631d9b75cb5ffe8d14ff04197b832159ec1fbda6ce111cc3e + canonicalized_ast: 3b4aaba9a992741f6c24eb4bf996429a51414f103d4bc4c781407e1b65db1429 + type_inferenced_ast: 106dfc525b9d52b0cbba9dff5cb13b31ac7e4af930a9cd656f71a6a9fb6c0d25 diff --git a/tests/expectations/compiler/compiler/global_consts/global_const_types.leo.out b/tests/expectations/compiler/compiler/global_consts/global_const_types.leo.out index 6d2ceebc95..d9a7ae7642 100644 --- a/tests/expectations/compiler/compiler/global_consts/global_const_types.leo.out +++ b/tests/expectations/compiler/compiler/global_consts/global_const_types.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "false" initial_ast: d53a0267c4afe271c6488aeda9910433e3a947d96530ea1286eba511e6e8f17e - imports_resolved_ast: d53a0267c4afe271c6488aeda9910433e3a947d96530ea1286eba511e6e8f17e - canonicalized_ast: 86bc6722c866a18e2b4d022e67c82dfa0f20f1b4d86d2869f6267010ef45c0c6 - type_inferenced_ast: 0c7674288e3db92d39726e8d2964f7c03eeb8e27ec54d0cd558b20e976a48686 + imports_resolved_ast: 9de3a50bdfad16a06a4fe614f7a1a5c77ce4c813f7ca201af05d129c4abc942a + canonicalized_ast: 9cc386a3754c6372d2e2c8b01dc201903ab088691ebdef67142f36e6b565cc45 + type_inferenced_ast: 057753d4811964067a59da4de55523c434573abb342e3e73b6666a5f116b7a71 diff --git a/tests/expectations/compiler/compiler/import_dependency/tests/import_dependency_folder.leo.out b/tests/expectations/compiler/compiler/import_dependency/tests/import_dependency_folder.leo.out index 7e534a8e9f..f3b19d814a 100644 --- a/tests/expectations/compiler/compiler/import_dependency/tests/import_dependency_folder.leo.out +++ b/tests/expectations/compiler/compiler/import_dependency/tests/import_dependency_folder.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 879c62f85e5eb066be85524e22d73775a649468ee2d42ff96451abefc1529b28 - imports_resolved_ast: d9bba4501a505c68c5256e0f8177a490126f99945c3f53c42471b466ec0e6377 - canonicalized_ast: cec8aa804ed735a7cf6504445621c5d5fdc214366e665aaf1e8b3d6e5ee1ff75 - type_inferenced_ast: 909a8409502b79921a81e425ca9e748a69411ac5ad0c809249b9b82d635a8533 + imports_resolved_ast: a1068c6d2f52e761df4b4cbf407dce1865a4a4344d2046fe007006e2f466713d + canonicalized_ast: 772294ecbf83d76830e9622cf05971badb043ea4d02e095e903405088f05eb4d + type_inferenced_ast: 9aa256887acb3c89b67f407ec861509b15a2c9fd38282292940da62472514880 diff --git a/tests/expectations/compiler/compiler/import_local/import_all.leo.out b/tests/expectations/compiler/compiler/import_local/import_all.leo.out index ab1034f23d..7ccd97cee2 100644 --- a/tests/expectations/compiler/compiler/import_local/import_all.leo.out +++ b/tests/expectations/compiler/compiler/import_local/import_all.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 44686de6ff7da19563c7435f977498fa070fe70394604f00891ac56919b49fc9 - imports_resolved_ast: 04931e9a33306909e081ee99676f78fea07a00a88fddea1b41b7f49fe01b8b74 - canonicalized_ast: 54f102c09881160287bb9ddd18a8b827b1fbd7a5e7f65a6bf930c2e1d289895a - type_inferenced_ast: 72cfbfa0e53d0f93ef984949371141b4ed9adb0b4663775a0a973cd04681a826 + imports_resolved_ast: 5d63c911ca5214cd40185260007a9f328ee47a122f5ec7f469238f9ba0db7ef1 + canonicalized_ast: 9fd5042bf79e961b7b536ec69d6fbd2268ff4c46829e64ffccb9c3eefb77d201 + type_inferenced_ast: 8f7c872a12a334f0a0c00fdf307b262b4fae0f80698ba8193cbc321b1e81696c diff --git a/tests/expectations/compiler/compiler/import_local/import_as.leo.out b/tests/expectations/compiler/compiler/import_local/import_as.leo.out index c31d7c3d2f..016aefe8d2 100644 --- a/tests/expectations/compiler/compiler/import_local/import_as.leo.out +++ b/tests/expectations/compiler/compiler/import_local/import_as.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 411dd9625db7686b2cdc3546042b29bc1e51d023b14b0b8397c22bb4db825a77 - imports_resolved_ast: 3dfd262969fe1c4bd78e4deb971f29b5afa64b540ef60c0a892399ba9f9d20be - canonicalized_ast: e7d378e3ff24b63d8a6ec0e2ae1c30148ed9f2028eb80bcf224d55efa3303fd1 - type_inferenced_ast: d98bff9e38944b9423e8bf2b463d081920d079db600cc8eec3a4d6ba96716745 + imports_resolved_ast: ec10c51034f5c7fb0edafc18876e276484ca1014c9fc5fc0c8f8bfe373b11c18 + canonicalized_ast: d160725f53cdd867ce6777fdf51f2bd71795828bc4af1fea29ccd012d63884ab + type_inferenced_ast: 29ec388188ee6b5368de80144ff0e487065e5c6333e105dfa6b077dfa84b5966 diff --git a/tests/expectations/compiler/compiler/import_local/import_dir.leo.out b/tests/expectations/compiler/compiler/import_local/import_dir.leo.out index c672b24d18..dfb9942d56 100644 --- a/tests/expectations/compiler/compiler/import_local/import_dir.leo.out +++ b/tests/expectations/compiler/compiler/import_local/import_dir.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 105b64dc1443f190ae9034a4b1f0a7c4fbbb104482aed9b7b843c19d16b3aaa0 - imports_resolved_ast: e7a789c2f6fb7b5c5fdbb5760cd9700ff256985c860df18e7f30dc5df4d392cf - canonicalized_ast: f62ac8e2461d1ba60ecb95399945f0a22999bbac751c56927f505f75138b90c2 - type_inferenced_ast: 3cb02077dd4fffa806a72c61dacca999d404821c3301ea52d2854d86fa65c20a + imports_resolved_ast: 68f057403d794a42149ef5f21c71d6dfed58867436daf713ede79dc43171e982 + canonicalized_ast: 1f6c56e3d02ab2e0e206b47dad4d3615d6fe0ff27682515ba175f0f66c2849ec + type_inferenced_ast: fbcefce30b0b84093f77c99d4152003ee036b0c422a93483bf1428812319d49b diff --git a/tests/expectations/compiler/compiler/import_local/import_files.leo.out b/tests/expectations/compiler/compiler/import_local/import_files.leo.out index 81bd6d66e8..3c6d384d16 100644 --- a/tests/expectations/compiler/compiler/import_local/import_files.leo.out +++ b/tests/expectations/compiler/compiler/import_local/import_files.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 17ec836ed9b5f45fbf2b55fc9f7ae5c75d59902113f3e099141b3acbcf9ccb11 - imports_resolved_ast: ad65dc58d894dad3f8ff60db45610e89f7b7a9ca8bad1bba405d4fbe9b29f240 - canonicalized_ast: 9164f55bdd309c60e5d7cd5842aeb10227fb61884639c7661811b1be9cb134fe - type_inferenced_ast: 741f2ae43a36b8775a733aaaf736ae7df67ec0b8e57bb94425710760b8459d31 + imports_resolved_ast: 38cfea94de85b6085edc1c985da0125bb98f8abef7565e3f33ce068fdcba4d4c + canonicalized_ast: ff2926bb527fd30d73078cbbf3d1a2ac7c3e0b92a0663d2b73b040e5350b89c8 + type_inferenced_ast: 50ce12cda731be1f8de4062e628f5de36e2d9984b49c9795f0759a0433ad4f4d diff --git a/tests/expectations/compiler/compiler/import_local/import_many.leo.out b/tests/expectations/compiler/compiler/import_local/import_many.leo.out index 94fb2be478..81c1c8707b 100644 --- a/tests/expectations/compiler/compiler/import_local/import_many.leo.out +++ b/tests/expectations/compiler/compiler/import_local/import_many.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: ae6826642faa492e34507695dbd11e5b44c319aecb0b1e78b29ce03ae446d907 - imports_resolved_ast: 20295c05b1768223eff4982abafe03e060196400ccf046df15a48a0a87c5fcdb - canonicalized_ast: 20295c05b1768223eff4982abafe03e060196400ccf046df15a48a0a87c5fcdb - type_inferenced_ast: edfcbd28230c0bae0b1e7fd32d8e72898368bc5ea7fe58cc285bb5c7e0588d24 + imports_resolved_ast: 705a7ac9fff8ab3efc75a0731342c74df790f95bd264b43f4cb7c92ef71b9a33 + canonicalized_ast: 705a7ac9fff8ab3efc75a0731342c74df790f95bd264b43f4cb7c92ef71b9a33 + type_inferenced_ast: 21acbf2d18b9d9195c9b70cfe2bc785b4293646da4f92be9be6f426e374b4521 diff --git a/tests/expectations/compiler/compiler/import_local/import_weird_names.leo.out b/tests/expectations/compiler/compiler/import_local/import_weird_names.leo.out index 8932b70d43..7682aeb865 100644 --- a/tests/expectations/compiler/compiler/import_local/import_weird_names.leo.out +++ b/tests/expectations/compiler/compiler/import_local/import_weird_names.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 41aa6d44d33c491b1f66bb2e3d8a6882b43822b211e3e2ac8add332be00535fb - imports_resolved_ast: 1e06d16faa2b57dfac9628bdb7d288a24b8cdaeed152b0bb1c1bbcfdbd54dd72 - canonicalized_ast: 1e06d16faa2b57dfac9628bdb7d288a24b8cdaeed152b0bb1c1bbcfdbd54dd72 - type_inferenced_ast: 27a376c64ada78a53a328326b0a5592bf683dc036cf1a3f5a15621405678a427 + imports_resolved_ast: 53e590f67ba5b14b3f483ba07c36e1e2eb5602817ca50d36b51f1e81b5774d52 + canonicalized_ast: 53e590f67ba5b14b3f483ba07c36e1e2eb5602817ca50d36b51f1e81b5774d52 + type_inferenced_ast: 98a16c2cfb286439208bfc8b824c232f8c8bae99d52862174e9b60a53536f8bd diff --git a/tests/expectations/compiler/compiler/import_local/import_weird_names_nested.leo.out b/tests/expectations/compiler/compiler/import_local/import_weird_names_nested.leo.out index 3a3b98103a..ec06cd8f36 100644 --- a/tests/expectations/compiler/compiler/import_local/import_weird_names_nested.leo.out +++ b/tests/expectations/compiler/compiler/import_local/import_weird_names_nested.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: bb86f336b58de89c79741628133e6aa997f3f49a6f066b8c054261e91e3f18a8 - imports_resolved_ast: 7f53319b8eeb7fd2e7e76e7cbe6f130b3af9918060519cc111a45f9739cd8085 - canonicalized_ast: 7f53319b8eeb7fd2e7e76e7cbe6f130b3af9918060519cc111a45f9739cd8085 - type_inferenced_ast: 1fcfebcdbf04cba7f2878b8efe881f598407a0f15c5419bb7da7a8ea9ec37438 + imports_resolved_ast: 6a56d2eb88cdc380250978e34c8d7448b0d1b040502b0c93f9c4b3c05a4f366f + canonicalized_ast: 6a56d2eb88cdc380250978e34c8d7448b0d1b040502b0c93f9c4b3c05a4f366f + type_inferenced_ast: 7215417fbb391a2ee051b15570db0eaa0d2caa59fe61ddede30a161691fa2015 diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main.leo.out index 718b98b089..40c9b68a38 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input/main.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input/main.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: e729490bdc66ccc317a772b7ccc583a24a5de9dddf0c9d5b1f3eef8623e6a569 - imports_resolved_ast: e729490bdc66ccc317a772b7ccc583a24a5de9dddf0c9d5b1f3eef8623e6a569 - canonicalized_ast: e729490bdc66ccc317a772b7ccc583a24a5de9dddf0c9d5b1f3eef8623e6a569 - type_inferenced_ast: 05f1d5a501376bbcbfac394be538319ab70e516dd9d3b2d7261f840c5c9e5d8d + imports_resolved_ast: 52e8389370ef376ebdc0fa26ba259df930ddf5eec9b86e082f443f90768ad4de + canonicalized_ast: 52e8389370ef376ebdc0fa26ba259df930ddf5eec9b86e082f443f90768ad4de + type_inferenced_ast: d79256646693d328784555aa17a913239b6ac9e1c247ca553bfb6850a21cd6c2 diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main_array.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main_array.leo.out index 870a57e321..779eadad01 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input/main_array.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input/main_array.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: ded49ef329b1c709191a4f6d85c43787e7091b82eb5813f618bf377e7c27a47c - imports_resolved_ast: ded49ef329b1c709191a4f6d85c43787e7091b82eb5813f618bf377e7c27a47c - canonicalized_ast: ded49ef329b1c709191a4f6d85c43787e7091b82eb5813f618bf377e7c27a47c - type_inferenced_ast: 5f12b94ae74deaac2dcc82ae1ee611bd1d1e837a2211722a11cc904790aa4d60 + imports_resolved_ast: be15a09476384ea6a4779aa50375443bab2bd52e3e0643e7b372b9a6886b2a0f + canonicalized_ast: be15a09476384ea6a4779aa50375443bab2bd52e3e0643e7b372b9a6886b2a0f + type_inferenced_ast: 8e5018b45406c1257b792993a7e00be035cc86151cba4dd065511fbd90cb924c diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main_char.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main_char.leo.out index 79d5ab3f9b..2ad53ce9e7 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input/main_char.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input/main_char.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 28776a06ced3fbb9476dd3abdca0d6d5444c621c26b6883f07d03f2d437677b7 - imports_resolved_ast: 28776a06ced3fbb9476dd3abdca0d6d5444c621c26b6883f07d03f2d437677b7 - canonicalized_ast: 28776a06ced3fbb9476dd3abdca0d6d5444c621c26b6883f07d03f2d437677b7 - type_inferenced_ast: 2bca0f0f14ac8d4eb281b8ce8d612c15a4209b765b68140b5a4b7efefdec5eea + imports_resolved_ast: 94c710a594e493e4d8d97c2ba48f96e6ec660fa33c32129a438d7ef021335e95 + canonicalized_ast: 94c710a594e493e4d8d97c2ba48f96e6ec660fa33c32129a438d7ef021335e95 + type_inferenced_ast: 7f532a687037337075ac1a878093c8264b1c0ed564e4ad9bd190a331493443cb diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main_field.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main_field.leo.out index 0dbd0e966a..8206cb2c66 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input/main_field.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input/main_field.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "false" initial_ast: d5808d80af60a541768c6ac9f7ce7371cee9654d6f102c1fa4d9be22169d7fae - imports_resolved_ast: d5808d80af60a541768c6ac9f7ce7371cee9654d6f102c1fa4d9be22169d7fae - canonicalized_ast: d5808d80af60a541768c6ac9f7ce7371cee9654d6f102c1fa4d9be22169d7fae - type_inferenced_ast: 84667daeb71be0318df27b0172d186013b8eaae16a75a3676d7f4a6366ef9dbc + imports_resolved_ast: 6f2571e5ecbf98ddcf2a8ba463876227db7582dd9a1151c8712f29b56c868d86 + canonicalized_ast: 6f2571e5ecbf98ddcf2a8ba463876227db7582dd9a1151c8712f29b56c868d86 + type_inferenced_ast: 8264393da586674489134d5abb9fe3af58f4f656c62aabc50f0d41c80b7a87f3 diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main_group.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main_group.leo.out index a87a815581..8f60d22321 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input/main_group.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input/main_group.leo.out @@ -14,6 +14,6 @@ outputs: output: registers: {} initial_ast: 731684bc8e22a3bbde7816d4f9ddc4db9561244b81caff4ef23e90ab5949ef60 - imports_resolved_ast: 731684bc8e22a3bbde7816d4f9ddc4db9561244b81caff4ef23e90ab5949ef60 - canonicalized_ast: d4b3e34c002f7dd2bfb3b12b5028d44a84113e9c9a2d22d7576763cd59c7521b - type_inferenced_ast: 326c07a3eae5f211848b943adcb05103121e0b241967bfd4a545ff6f6566f699 + imports_resolved_ast: 5e4688eb85c3b64cc6e652aa9bcec7914f72fe70dc6509c411de8acfb0267845 + canonicalized_ast: cb86c2b4d8c34bc237cee421b58d0781dc0775fd21605eb35aef7bdbbae02311 + type_inferenced_ast: 2a7deafa9ac7933aba1ea9d49f10f694a3f05afe349e51d2edecf82a2ca5b9f9 diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main_multi_dimension_array.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main_multi_dimension_array.leo.out index 0f10b6a61a..c3a576304f 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input/main_multi_dimension_array.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input/main_multi_dimension_array.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: f74b907c08c1bfd4d2afc9df5589bc2aed1923db5e858c5cc6046f5aed735cf2 - imports_resolved_ast: f74b907c08c1bfd4d2afc9df5589bc2aed1923db5e858c5cc6046f5aed735cf2 - canonicalized_ast: f80f2c0fd5fa415c5ca0b8295d918a884ae8590f5f9760947ca5a0513f531f73 - type_inferenced_ast: a866c7acc69cab458f8b6fe729b35cfd4fc66d578155382d130b24e2e092df8b + imports_resolved_ast: 6d70609f85ed94459de8f43f955264c3261a8078dbf4bf528ce0088305d23b3c + canonicalized_ast: 9ad6397486392caa67aba505a6404fbfb824be83d6b548eaab6a301d1fca52b5 + type_inferenced_ast: 0c8d039bf361d66861ccfd4c817408baef514b13b1542079a5d23301bdb0582a diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main_multiple.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main_multiple.leo.out index 1f690616a0..64c54834e4 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input/main_multiple.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input/main_multiple.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 094effa7fe12695679a571f560e1d3e8c299cde8de280f9309010c85f48bab95 - imports_resolved_ast: 094effa7fe12695679a571f560e1d3e8c299cde8de280f9309010c85f48bab95 - canonicalized_ast: 094effa7fe12695679a571f560e1d3e8c299cde8de280f9309010c85f48bab95 - type_inferenced_ast: ab25cb7bf7d8fe3ec64be183550ba8d6acfaf17464cf70ec45c6497fc065ac29 + imports_resolved_ast: 1d9d8399fe44bade2bd762e88a1db5805b26cb47710aea505ca5d33a60daa574 + canonicalized_ast: 1d9d8399fe44bade2bd762e88a1db5805b26cb47710aea505ca5d33a60daa574 + type_inferenced_ast: 8438f2a6c2db2f16ec11a4f12d0085039e6cd22e9106d14c25d1bbfe55c1df9e diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main_string.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main_string.leo.out index 0c516a8133..d76a778f31 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input/main_string.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input/main_string.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: a2b01e8b8d8311d8a890b0e008689dc890b104d2b6fcfc82a16e1e45975ea68b - imports_resolved_ast: a2b01e8b8d8311d8a890b0e008689dc890b104d2b6fcfc82a16e1e45975ea68b - canonicalized_ast: 8774633846aa1d61e6534c0e930777ba9452aa7368116928ba1188501d30a495 - type_inferenced_ast: be4ce222d81884b156c4fd0567755685283f7502ab192fcfaf562f0b0737a2e0 + imports_resolved_ast: feba89a1e554217b47a1409aee9ed2897fad075fd0f074af123253c3083dfdb3 + canonicalized_ast: 890d8c2d35f65dc644c1242e74b20dd3013ae60219399e279096eaad0b1515ed + type_inferenced_ast: b8bd27eae1f6ca9b9b6bfb63c1a61edd20178f9fa647857e0f9cc90826e292fc diff --git a/tests/expectations/compiler/compiler/input_files/program_input/main_tuple.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/main_tuple.leo.out index 9c084bd2f6..24d32ed7bc 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input/main_tuple.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input/main_tuple.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 01b9440246bf141fbdc27ab27f53d1b4f42415fb70a2f4d838d0a3a542fe7133 - imports_resolved_ast: 01b9440246bf141fbdc27ab27f53d1b4f42415fb70a2f4d838d0a3a542fe7133 - canonicalized_ast: 01b9440246bf141fbdc27ab27f53d1b4f42415fb70a2f4d838d0a3a542fe7133 - type_inferenced_ast: 2c84fc650ddadfb9a335688f4490156e05a5c5ea1b3ac935d8d5f2f2d3cd8c58 + imports_resolved_ast: 62d84d32d604ac223c56faac64c93fe9141465b5722ee79491668a95ebce5a58 + canonicalized_ast: 62d84d32d604ac223c56faac64c93fe9141465b5722ee79491668a95ebce5a58 + type_inferenced_ast: a8493feb42aee3e7dba9f98c95336bacacee6cf37c82336be31874fb2ac535fc diff --git a/tests/expectations/compiler/compiler/input_files/program_input_and_program_state/basic.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_and_program_state/basic.leo.out index 0b5c9be010..90bceb5ea9 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input_and_program_state/basic.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input_and_program_state/basic.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: dc7f40a1cfc4daa659784bf538f1273145b430875116ef1aad7fd778dcb5f736 - imports_resolved_ast: dc7f40a1cfc4daa659784bf538f1273145b430875116ef1aad7fd778dcb5f736 - canonicalized_ast: dc7f40a1cfc4daa659784bf538f1273145b430875116ef1aad7fd778dcb5f736 - type_inferenced_ast: f1d1997e4d2a975664689164c1113ab8ac1e0933910410324aeb204a72da3b12 + imports_resolved_ast: 93f6c95835c9f78af7f94a381d14bfbfe4a04c7e00ae0c6d93e5d101c6deeabb + canonicalized_ast: 93f6c95835c9f78af7f94a381d14bfbfe4a04c7e00ae0c6d93e5d101c6deeabb + type_inferenced_ast: 7251b2ce10126eb81d8083392091420b8c09c738c743829a1db4ef5f6d45a5c7 diff --git a/tests/expectations/compiler/compiler/input_files/program_input_and_program_state/token_withdraw.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_and_program_state/token_withdraw.leo.out index 212946e888..c446f13388 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input_and_program_state/token_withdraw.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input_and_program_state/token_withdraw.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 6b051c3f9ce82efb30d3ba89764cc9c2607a126cb0cede72ad55ecda6c9d996d - imports_resolved_ast: 6b051c3f9ce82efb30d3ba89764cc9c2607a126cb0cede72ad55ecda6c9d996d - canonicalized_ast: 6b051c3f9ce82efb30d3ba89764cc9c2607a126cb0cede72ad55ecda6c9d996d - type_inferenced_ast: 945f580a5c7a138000c0163b32e004c52e048ddf2166d0c9cfd67cd9485dc886 + imports_resolved_ast: 369ba66a04c6c34470e315edcc62c6d23c0720cbdb79e152d62f0060a54cfc07 + canonicalized_ast: 369ba66a04c6c34470e315edcc62c6d23c0720cbdb79e152d62f0060a54cfc07 + type_inferenced_ast: 10f9b1a702d99db0b38beb2f074b6e3c757affbfdcedad72b0529cd70bdb754a diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main.leo.out index 4794c19048..70e4d4329b 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 815bdfe9a6fb4bb4795686872a62882c0a953e7a5313ef7da066b11770fcb089 - imports_resolved_ast: 815bdfe9a6fb4bb4795686872a62882c0a953e7a5313ef7da066b11770fcb089 - canonicalized_ast: 815bdfe9a6fb4bb4795686872a62882c0a953e7a5313ef7da066b11770fcb089 - type_inferenced_ast: 437a14fea047eb893748b86f8a5cedb18ae7960ea92a5075b5a215125cc27863 + imports_resolved_ast: b2f8ea89cf7b96dc3575ead53f1ef5c9826d25d44fdc499922f40529cb9ccc50 + canonicalized_ast: b2f8ea89cf7b96dc3575ead53f1ef5c9826d25d44fdc499922f40529cb9ccc50 + type_inferenced_ast: 45ebc7977b92e2e861de83c6ac5d26b8ab105d1b66d889d2477c8241100816c5 diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_array.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_array.leo.out index 6f82dd1cdb..2ffcb62ec4 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_array.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_array.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 48d4334146fe85c3bf1cdd75bcf4bf5026e50bb04b624ddbe1fc9d0eb3e510a3 - imports_resolved_ast: 48d4334146fe85c3bf1cdd75bcf4bf5026e50bb04b624ddbe1fc9d0eb3e510a3 - canonicalized_ast: 48d4334146fe85c3bf1cdd75bcf4bf5026e50bb04b624ddbe1fc9d0eb3e510a3 - type_inferenced_ast: 90903b46ecc931e02742ad4caa7dce04f5efe18cad4260d1c9de5c29cf378a93 + imports_resolved_ast: 8e8b1a226d38e748817afc5485b4b62bc383eccc5139b5af1bf329e4e0638616 + canonicalized_ast: 8e8b1a226d38e748817afc5485b4b62bc383eccc5139b5af1bf329e4e0638616 + type_inferenced_ast: fa12eece824d7844e669a793d124c4e504a09f14aee45869ddf7d3ebeedc0eb4 diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_char.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_char.leo.out index 1432cad627..436acd2b17 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_char.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_char.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 54251e3a72e7c6743344cb585df6b89aef0d5b965aa13d090e89044209bf647a - imports_resolved_ast: 54251e3a72e7c6743344cb585df6b89aef0d5b965aa13d090e89044209bf647a - canonicalized_ast: 54251e3a72e7c6743344cb585df6b89aef0d5b965aa13d090e89044209bf647a - type_inferenced_ast: b3a96fc8bbfda13b19f509c3ed5bed3908ca929219581c8d7b56bb7f81590770 + imports_resolved_ast: 61fc2163c8f73820cb3414df3d645b7d49dffcbb123014675d25d1b2824dfe72 + canonicalized_ast: 61fc2163c8f73820cb3414df3d645b7d49dffcbb123014675d25d1b2824dfe72 + type_inferenced_ast: cfc2f8ad55e683b72cd4165fe627a58c9884aa5c3c923be75e97879aa0f8441a diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_field.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_field.leo.out index f47c13cea4..e353e2232d 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_field.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_field.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "false" initial_ast: 24edf3e347b161cb68d4dd19a0a56b457ee1f1668a29ad637ff22eaa0cbb384e - imports_resolved_ast: 24edf3e347b161cb68d4dd19a0a56b457ee1f1668a29ad637ff22eaa0cbb384e - canonicalized_ast: 24edf3e347b161cb68d4dd19a0a56b457ee1f1668a29ad637ff22eaa0cbb384e - type_inferenced_ast: 85af373372ad915f6633a0099e914ddc05e70f7d5fd92ad25be47c3627c68149 + imports_resolved_ast: d1ae756f0838101dd4caf5d55abdbbcbe469db9f39a55c77598e32f2c25dfad5 + canonicalized_ast: d1ae756f0838101dd4caf5d55abdbbcbe469db9f39a55c77598e32f2c25dfad5 + type_inferenced_ast: c0bf403d816bddf61225e34739faafa8c0e0be07c4d9e91f0e1db6dfed9376cc diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_group.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_group.leo.out index 21cd56b63c..6d8c5463a7 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_group.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_group.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: d6802e04fa242223923742fc9e82345b67b73138d867608c62c55999a356691d - imports_resolved_ast: d6802e04fa242223923742fc9e82345b67b73138d867608c62c55999a356691d - canonicalized_ast: d6802e04fa242223923742fc9e82345b67b73138d867608c62c55999a356691d - type_inferenced_ast: 0c53a395040f8aea133164e05ad0496f712ebd082228a635b4d181c9f4508127 + imports_resolved_ast: 394f0ce022be3c5d58903137237a234895dbaebfa6431ce30f7e0b13ff2fa3a7 + canonicalized_ast: 394f0ce022be3c5d58903137237a234895dbaebfa6431ce30f7e0b13ff2fa3a7 + type_inferenced_ast: f5dc62df544c2059469743ada31e9741b36ecc0e79ad25470a114b036f7b20d8 diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multi_dimension_array.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multi_dimension_array.leo.out index 4952ae0921..159210d7c7 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multi_dimension_array.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multi_dimension_array.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 473f66e852f694cee2d87935eee5fe7306ee404b935515ad400a06872b124e5b - imports_resolved_ast: 473f66e852f694cee2d87935eee5fe7306ee404b935515ad400a06872b124e5b - canonicalized_ast: 13943d9f8f5fb1fc9e5f9f025d3a09bc59db16494c5c225b7e4b8a7a53893c51 - type_inferenced_ast: 95eb1672ac750fbac9e1fe689a8516c00f83108e156ddda9d6cd69003d50a222 + imports_resolved_ast: 1ac27c0136c82b45125cbc3163e7925d1692f331a383727403de8b178ef75d32 + canonicalized_ast: d1dcb87af863b3e8da2a7fdf55ea77d00782e336b78a4e8235244682585fb46b + type_inferenced_ast: 048829d3b097cc2876a4936c2d85ca39533c3bc716ffc29b6c024b5b1087dfe8 diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multiple.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multiple.leo.out index 8a3f5633c2..996784ff2d 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multiple.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_multiple.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 0fe6762404e0aeb23e1adaec3a6ab638b06843ecea823306f364cf1aedd4fd07 - imports_resolved_ast: 0fe6762404e0aeb23e1adaec3a6ab638b06843ecea823306f364cf1aedd4fd07 - canonicalized_ast: 0fe6762404e0aeb23e1adaec3a6ab638b06843ecea823306f364cf1aedd4fd07 - type_inferenced_ast: 94ed42f51b4f47128964754310daf696a8bcd47e3e94e23d3e90bc2132dc9682 + imports_resolved_ast: d7e1ff60971d7a0085e76983bfddc85f412cb97f9b3b23d48325c06b5bf98bed + canonicalized_ast: d7e1ff60971d7a0085e76983bfddc85f412cb97f9b3b23d48325c06b5bf98bed + type_inferenced_ast: ec571510fa5e9f297a52f65045d197cd4a053e606eb452cfcc4f404cc8de405a diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_string.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_string.leo.out index 9b1ad3623e..74a9c8bb1f 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_string.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_string.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 4eee03b645a71b2cbe735305679051d2292f219f5db6ffc2bbb539188c6b377a - imports_resolved_ast: 4eee03b645a71b2cbe735305679051d2292f219f5db6ffc2bbb539188c6b377a - canonicalized_ast: 8f1fdffc6178e5375519646b43359d4e067a897c2ca2e360b67dbfc5523103d3 - type_inferenced_ast: d177e4046f5c7fde3ad62e66677db285279075784874f9961dec6a445d65278d + imports_resolved_ast: c7014ce34154502ddd85af44c45d4433ee14ce05aee87004964e6206633392bc + canonicalized_ast: d056363996c239396afc5df94fa34ad1497383060ff424cfb9cf06bd016897bb + type_inferenced_ast: 7ed413605d434ff375c9e71886019b32efdb1f20abb8868fe4f9e037dc5a7fd8 diff --git a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_tuple.leo.out b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_tuple.leo.out index 63b0e047a4..c952aa296d 100644 --- a/tests/expectations/compiler/compiler/input_files/program_input_constants/main_tuple.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_input_constants/main_tuple.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 2c4ba5703d0e1adf9d8ba82a2369531fe720fddce8da06eedb189c2a78f12b01 - imports_resolved_ast: 2c4ba5703d0e1adf9d8ba82a2369531fe720fddce8da06eedb189c2a78f12b01 - canonicalized_ast: 2c4ba5703d0e1adf9d8ba82a2369531fe720fddce8da06eedb189c2a78f12b01 - type_inferenced_ast: a75332a525dafba95c50a29eac05374ebf52b6ae7717966d15dec81ce1bd8623 + imports_resolved_ast: 840dc6fd62915b293ea1403612a8228b9768ae3bcfbd377baf9ec88ba5ebc777 + canonicalized_ast: 840dc6fd62915b293ea1403612a8228b9768ae3bcfbd377baf9ec88ba5ebc777 + type_inferenced_ast: db53e19aa1dd3a1241b14737c3d30068191b42baa99801a27caa4c5acda23b69 diff --git a/tests/expectations/compiler/compiler/input_files/program_registers/registers_array.leo.out b/tests/expectations/compiler/compiler/input_files/program_registers/registers_array.leo.out index b6092883b1..6935b9468c 100644 --- a/tests/expectations/compiler/compiler/input_files/program_registers/registers_array.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_registers/registers_array.leo.out @@ -17,6 +17,6 @@ outputs: type: "[[u8; 4]; 2]" value: "\"[0, 0, 0, 0][0, 0, 0, 0]\"" initial_ast: 010d0b94b6ddb74416025e35b34ce1c7feb5a768d8bf0f733c530f49b00f70c4 - imports_resolved_ast: 010d0b94b6ddb74416025e35b34ce1c7feb5a768d8bf0f733c530f49b00f70c4 - canonicalized_ast: 010d0b94b6ddb74416025e35b34ce1c7feb5a768d8bf0f733c530f49b00f70c4 - type_inferenced_ast: ab23cd03d09ac3221aa71d2bc7e5c6fe13fa3f9eb4293a3ae25cb739cb608bd9 + imports_resolved_ast: b7c76abcbcacc73930dcf9a50445d06a948233fb548bca3589f7fdbc23e8ce0d + canonicalized_ast: b7c76abcbcacc73930dcf9a50445d06a948233fb548bca3589f7fdbc23e8ce0d + type_inferenced_ast: 0e640b6211fd054d7949ef119134255314e3b0aa6d932606ee778c5d76282858 diff --git a/tests/expectations/compiler/compiler/input_files/program_registers/registers_pass.leo.out b/tests/expectations/compiler/compiler/input_files/program_registers/registers_pass.leo.out index d6fc879e40..c21e2acd69 100644 --- a/tests/expectations/compiler/compiler/input_files/program_registers/registers_pass.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_registers/registers_pass.leo.out @@ -17,6 +17,6 @@ outputs: type: u8 value: "101" initial_ast: f47238f679ee2b220452140330e99f2a6cf063be523ed8e4ce0e9d56cf806128 - imports_resolved_ast: f47238f679ee2b220452140330e99f2a6cf063be523ed8e4ce0e9d56cf806128 - canonicalized_ast: f47238f679ee2b220452140330e99f2a6cf063be523ed8e4ce0e9d56cf806128 - type_inferenced_ast: 6c62586bdcd983ee1ac3ae22b88577a5c2f0c5e5e5ed711f86c12f434917fd5f + imports_resolved_ast: 5d2413e7bdcb50ce30f02db00dd20656c3002662f7c7d969bd490b52bf22f822 + canonicalized_ast: 5d2413e7bdcb50ce30f02db00dd20656c3002662f7c7d969bd490b52bf22f822 + type_inferenced_ast: bed937859876d3565cb597c6cc59be8b007db5ac5ec4ca50acc86a265925187e diff --git a/tests/expectations/compiler/compiler/input_files/program_state/access_all.leo.out b/tests/expectations/compiler/compiler/input_files/program_state/access_all.leo.out index e5bfdaa04e..a701ad3bda 100644 --- a/tests/expectations/compiler/compiler/input_files/program_state/access_all.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_state/access_all.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 6fce132965ff40126f6175d2abe5b8598004e90cdb29c4707f7c63dbe1093474 - imports_resolved_ast: 6fce132965ff40126f6175d2abe5b8598004e90cdb29c4707f7c63dbe1093474 - canonicalized_ast: 6fce132965ff40126f6175d2abe5b8598004e90cdb29c4707f7c63dbe1093474 - type_inferenced_ast: e79e7662148ee3db46c9d52b751fb80a13213b22065e4a5008a7443ae85419e0 + imports_resolved_ast: 4d68fd3ae796ecb1dfb66c33bd1c7bb5c3b7e4606d4d345ecef4f31798f5c56a + canonicalized_ast: 4d68fd3ae796ecb1dfb66c33bd1c7bb5c3b7e4606d4d345ecef4f31798f5c56a + type_inferenced_ast: 60384ae686c13a01d936db27990e97a845b5c37d4e2279f079b2ad6f13a6c03e diff --git a/tests/expectations/compiler/compiler/input_files/program_state/access_state.leo.out b/tests/expectations/compiler/compiler/input_files/program_state/access_state.leo.out index c564c2cb73..85320750fc 100644 --- a/tests/expectations/compiler/compiler/input_files/program_state/access_state.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_state/access_state.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: a155141331da2d7bdaa11ae738d6ca2e1d62d875c872b8b8213184d989cc8baa - imports_resolved_ast: a155141331da2d7bdaa11ae738d6ca2e1d62d875c872b8b8213184d989cc8baa - canonicalized_ast: a155141331da2d7bdaa11ae738d6ca2e1d62d875c872b8b8213184d989cc8baa - type_inferenced_ast: 096e1372719be459b86ad5dea6e2e62f3afc350a204c382d4bebb835fa2dc615 + imports_resolved_ast: c8f77df94f0a73413d37ccbca4ff2e588826f3b250c8b27b26bf1ae22357105d + canonicalized_ast: c8f77df94f0a73413d37ccbca4ff2e588826f3b250c8b27b26bf1ae22357105d + type_inferenced_ast: 298cbf170111b15690cd7344caf8fda362fc395677c961d6da9bf209472af981 diff --git a/tests/expectations/compiler/compiler/input_files/program_state/basic.leo.out b/tests/expectations/compiler/compiler/input_files/program_state/basic.leo.out index 1faa7ef6dd..e6172af0a5 100644 --- a/tests/expectations/compiler/compiler/input_files/program_state/basic.leo.out +++ b/tests/expectations/compiler/compiler/input_files/program_state/basic.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 0c90e79ea8f0f5b227c498d43b8f308afb6438185fe33531617ac04b301941ce - imports_resolved_ast: 0c90e79ea8f0f5b227c498d43b8f308afb6438185fe33531617ac04b301941ce - canonicalized_ast: 0c90e79ea8f0f5b227c498d43b8f308afb6438185fe33531617ac04b301941ce - type_inferenced_ast: 8a53562f4f66ec6d9ad612558abfe45fa08c5b37943f7a46226ea7909fcf85e0 + imports_resolved_ast: 74d205699d79452d4785cb59ed9d498124b3ff1e1a0a2028dda790a31ee9749e + canonicalized_ast: 74d205699d79452d4785cb59ed9d498124b3ff1e1a0a2028dda790a31ee9749e + type_inferenced_ast: 8a15e87384e2c5a2dca133df74e97f38f3e912d7b70f354fc995b15df83e039d diff --git a/tests/expectations/compiler/compiler/integers/i128/add.leo.out b/tests/expectations/compiler/compiler/integers/i128/add.leo.out index c636d50366..80f90f9206 100644 --- a/tests/expectations/compiler/compiler/integers/i128/add.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/add.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 642f93bdca1804ff63c7d74a395836b4fae13013a8a208bd8a36647a0a51a9c4 - imports_resolved_ast: 642f93bdca1804ff63c7d74a395836b4fae13013a8a208bd8a36647a0a51a9c4 - canonicalized_ast: 642f93bdca1804ff63c7d74a395836b4fae13013a8a208bd8a36647a0a51a9c4 - type_inferenced_ast: e72578824d94283a0c95b48e47d756370f3ac29b54e82648870b8f09e592665f + imports_resolved_ast: e7cd593f35e07ac1561f96343f6a831c790097b0570f600cd9ca4e7b34bfbaef + canonicalized_ast: e7cd593f35e07ac1561f96343f6a831c790097b0570f600cd9ca4e7b34bfbaef + type_inferenced_ast: be00148f540ae49054b4ff79d6d1fe286c6360d85228ffe043c09dc8ab27a18d diff --git a/tests/expectations/compiler/compiler/integers/i128/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i128/console_assert.leo.out index 277e2de091..11899abfab 100644 --- a/tests/expectations/compiler/compiler/integers/i128/console_assert.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/console_assert.leo.out @@ -14,6 +14,6 @@ outputs: output: registers: {} initial_ast: 941047af9fff3f74b6e522fe98c16108e9e9b7ec4514cff470af18a68316f614 - imports_resolved_ast: 941047af9fff3f74b6e522fe98c16108e9e9b7ec4514cff470af18a68316f614 - canonicalized_ast: ca55154cc08f628f72fd7c45e107ebf849f38c077dfe08e80082db1feee4b4ed - type_inferenced_ast: 9396147f96ed2ce2ec5b359b65ebe55d824888fb3c778b83486a4cd3b61e0785 + imports_resolved_ast: 5c8330ba5bca4ac359eb19e59e29c68f0cadd922ecc89a7eec21dfc54bcd8cb6 + canonicalized_ast: c1abcde4a0088c689087f5cf0ae75720189e781311fbc917a8e148a0560237b5 + type_inferenced_ast: d5fb7ebc1bb307a3fcd139cee3705e9474357efdf84b2ed77cf096e617fa1de4 diff --git a/tests/expectations/compiler/compiler/integers/i128/div.leo.out b/tests/expectations/compiler/compiler/integers/i128/div.leo.out index 5ff4b0fdf7..03aeb54c46 100644 --- a/tests/expectations/compiler/compiler/integers/i128/div.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/div.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 9b5ecfc8daa3ee55e1e24a6f6e19f5a6f5c4725efabf7074bc22657f7ad89b26 - imports_resolved_ast: 9b5ecfc8daa3ee55e1e24a6f6e19f5a6f5c4725efabf7074bc22657f7ad89b26 - canonicalized_ast: 9b5ecfc8daa3ee55e1e24a6f6e19f5a6f5c4725efabf7074bc22657f7ad89b26 - type_inferenced_ast: be5f66a85fa7ae6cd81164c6da438e2e146558c9b429993d83d4177b8b5c4469 + imports_resolved_ast: e06f64add69491cac215b7a49b1cc0f1859638c1f854328ccc6f81829f047c1a + canonicalized_ast: e06f64add69491cac215b7a49b1cc0f1859638c1f854328ccc6f81829f047c1a + type_inferenced_ast: c7c736a5816a7f2f3659e97af7e3cb001bc66375c61c8e5ba0b364b817ad2058 diff --git a/tests/expectations/compiler/compiler/integers/i128/eq.leo.out b/tests/expectations/compiler/compiler/integers/i128/eq.leo.out index 3db655c771..91e7908228 100644 --- a/tests/expectations/compiler/compiler/integers/i128/eq.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/eq.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 4aab7c6dbe39e04833f6a043508421d22d62b87fa931fa8940ce8af5c876cbe1 - imports_resolved_ast: 4aab7c6dbe39e04833f6a043508421d22d62b87fa931fa8940ce8af5c876cbe1 - canonicalized_ast: 4aab7c6dbe39e04833f6a043508421d22d62b87fa931fa8940ce8af5c876cbe1 - type_inferenced_ast: b4067b1b34a4f7984160a017456f026691c60f150c59c9e4817ea740c338abb7 + imports_resolved_ast: ce5edb1c15ba1996d3ea032cfe80d5aa897f5a772e55d4c0220baee41ab155f3 + canonicalized_ast: ce5edb1c15ba1996d3ea032cfe80d5aa897f5a772e55d4c0220baee41ab155f3 + type_inferenced_ast: 1b4efc2f546a659554191c68f72ac6db6bff670e90baca0c09920a0f592dd24e diff --git a/tests/expectations/compiler/compiler/integers/i128/ge.leo.out b/tests/expectations/compiler/compiler/integers/i128/ge.leo.out index ecf7c64027..62ce33db02 100644 --- a/tests/expectations/compiler/compiler/integers/i128/ge.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/ge.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: baa6a3685d6b0fce00d68e12fae11a15f8e939d1cdb6fc2742ee57f778b7da7c - imports_resolved_ast: baa6a3685d6b0fce00d68e12fae11a15f8e939d1cdb6fc2742ee57f778b7da7c - canonicalized_ast: baa6a3685d6b0fce00d68e12fae11a15f8e939d1cdb6fc2742ee57f778b7da7c - type_inferenced_ast: 406d1f28168a11a6e8404a14d80b20bdd5067823dc00b83c60d1ccf217db17f8 + imports_resolved_ast: e472ae39cc67b3f1bb03d123aaffa2353e41c702bd44db06455d68c9b4559629 + canonicalized_ast: e472ae39cc67b3f1bb03d123aaffa2353e41c702bd44db06455d68c9b4559629 + type_inferenced_ast: b628e23cc8edf8919d5436138234564ed47876178059d12c793505ff29ca3613 diff --git a/tests/expectations/compiler/compiler/integers/i128/gt.leo.out b/tests/expectations/compiler/compiler/integers/i128/gt.leo.out index e3f4e3d9bf..afbeb6fd21 100644 --- a/tests/expectations/compiler/compiler/integers/i128/gt.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/gt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: e2b90c71500bfbdd6d581f1f66d974507922f946f48175b82768c804ca2892f5 - imports_resolved_ast: e2b90c71500bfbdd6d581f1f66d974507922f946f48175b82768c804ca2892f5 - canonicalized_ast: e2b90c71500bfbdd6d581f1f66d974507922f946f48175b82768c804ca2892f5 - type_inferenced_ast: 1752aa11aea71f4a459400f14558caf6a523bad2885bc11f8449cc25af81715c + imports_resolved_ast: 246125727421ae6adaa23cf6b9a7748bfff9f5dd2a550de204ceb9d2b1df1b4d + canonicalized_ast: 246125727421ae6adaa23cf6b9a7748bfff9f5dd2a550de204ceb9d2b1df1b4d + type_inferenced_ast: 4a2105337c32af15e4d8234c57a240bb34aefe984bb0f6ca983abb24e8ad0c2c diff --git a/tests/expectations/compiler/compiler/integers/i128/le.leo.out b/tests/expectations/compiler/compiler/integers/i128/le.leo.out index c80c011dda..8c73b09017 100644 --- a/tests/expectations/compiler/compiler/integers/i128/le.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/le.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 8753b11c3aca4b8feb1be18420840b4c9de9ddcb07d089ed2f5f4c384afc204a - imports_resolved_ast: 8753b11c3aca4b8feb1be18420840b4c9de9ddcb07d089ed2f5f4c384afc204a - canonicalized_ast: 8753b11c3aca4b8feb1be18420840b4c9de9ddcb07d089ed2f5f4c384afc204a - type_inferenced_ast: 79b296585b1e4ce4b1e9b3e29180ebfa06f7892d553d31a1f148e952f46ce768 + imports_resolved_ast: f310fce6c61a1cfb342d7a528fe1faae29b7b07f3b504c0aa227064b037b56d9 + canonicalized_ast: f310fce6c61a1cfb342d7a528fe1faae29b7b07f3b504c0aa227064b037b56d9 + type_inferenced_ast: f0fd8c73c9ad5675f603b0d0a0edd23ef6d2f2e8a6354a994c83f33e0ccdafe5 diff --git a/tests/expectations/compiler/compiler/integers/i128/lt.leo.out b/tests/expectations/compiler/compiler/integers/i128/lt.leo.out index 43e665808f..b863b90f1a 100644 --- a/tests/expectations/compiler/compiler/integers/i128/lt.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/lt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: ff20432be7beb83e5e5b022eef93d6ea0ef262fb834ce0eef5633c1db97abe03 - imports_resolved_ast: ff20432be7beb83e5e5b022eef93d6ea0ef262fb834ce0eef5633c1db97abe03 - canonicalized_ast: ff20432be7beb83e5e5b022eef93d6ea0ef262fb834ce0eef5633c1db97abe03 - type_inferenced_ast: 5a43f0e27448024f978e71e784a16071cccbe7d8bf666ce7c42653e593244249 + imports_resolved_ast: a9fcd03cf41ae30fa40c8621fd7f50408574dd0fde93e6c17ffc6a09795178cf + canonicalized_ast: a9fcd03cf41ae30fa40c8621fd7f50408574dd0fde93e6c17ffc6a09795178cf + type_inferenced_ast: b319095abb3eafdc49b0a2c1451235b543bd5cc2e1f75e215e5a502b80bef6d0 diff --git a/tests/expectations/compiler/compiler/integers/i128/max.leo.out b/tests/expectations/compiler/compiler/integers/i128/max.leo.out index c77d9b0f0c..45430f169a 100644 --- a/tests/expectations/compiler/compiler/integers/i128/max.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/max.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 48a298fe2f4f2855ad2f9e089cfbc6749ee6f8f95f81ca9a97360f331aaae1fb - imports_resolved_ast: 48a298fe2f4f2855ad2f9e089cfbc6749ee6f8f95f81ca9a97360f331aaae1fb - canonicalized_ast: 48a298fe2f4f2855ad2f9e089cfbc6749ee6f8f95f81ca9a97360f331aaae1fb - type_inferenced_ast: 5f10c4f16a11b966282e2484c7f243a794f2c1a2377be993b694080434791ff6 + imports_resolved_ast: 3f2ee9cdd7e8970dedaef855c9057457a90534a2c6bb8d38ef57bc60ae724120 + canonicalized_ast: 3f2ee9cdd7e8970dedaef855c9057457a90534a2c6bb8d38ef57bc60ae724120 + type_inferenced_ast: e79408512dfb626761d2966ca090b1cbf2285550f60a38f5856a5a6b513b707c diff --git a/tests/expectations/compiler/compiler/integers/i128/min.leo.out b/tests/expectations/compiler/compiler/integers/i128/min.leo.out index f1a1a00980..275fc7e501 100644 --- a/tests/expectations/compiler/compiler/integers/i128/min.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/min.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 7607f334bcc8676c2276fc9c0950437719631f6d7221e1f3288a4f144096fa0d - imports_resolved_ast: 7607f334bcc8676c2276fc9c0950437719631f6d7221e1f3288a4f144096fa0d - canonicalized_ast: 7607f334bcc8676c2276fc9c0950437719631f6d7221e1f3288a4f144096fa0d - type_inferenced_ast: 2d21167fca05fd5c84ab023d5fb99d8bf84f733797d01dbdf5cfb924d0aa0a26 + imports_resolved_ast: cc5b3384638986f3c27d63115fcffdba270f484a9243a4200ef19c8edb8ab3b0 + canonicalized_ast: cc5b3384638986f3c27d63115fcffdba270f484a9243a4200ef19c8edb8ab3b0 + type_inferenced_ast: 937aa3acda056610b743fc6005bff41950f20764e546eb6e11436ec443ad74a5 diff --git a/tests/expectations/compiler/compiler/integers/i128/mul.leo.out b/tests/expectations/compiler/compiler/integers/i128/mul.leo.out index 7a8b72f486..1fac843538 100644 --- a/tests/expectations/compiler/compiler/integers/i128/mul.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/mul.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 16a27b027b669640d3c23c1eca2db5ea3286bf3623baf9038cb28c4937e88c34 - imports_resolved_ast: 16a27b027b669640d3c23c1eca2db5ea3286bf3623baf9038cb28c4937e88c34 - canonicalized_ast: 16a27b027b669640d3c23c1eca2db5ea3286bf3623baf9038cb28c4937e88c34 - type_inferenced_ast: ab943eb3fb77eff83662d400ce152c5a27588bbecb72bba0c2f06146fc1e671b + imports_resolved_ast: 134dc5708313c2da653339a9bfae165482132f71120de431bd45f0809d010769 + canonicalized_ast: 134dc5708313c2da653339a9bfae165482132f71120de431bd45f0809d010769 + type_inferenced_ast: f5941eb8a2379b6ac87c8a826d145b0745dad32c3fd7dca2faa5631492539dcf diff --git a/tests/expectations/compiler/compiler/integers/i128/ne.leo.out b/tests/expectations/compiler/compiler/integers/i128/ne.leo.out index 08df752694..7d108062a7 100644 --- a/tests/expectations/compiler/compiler/integers/i128/ne.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/ne.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 6438b7751a9bfbc114ec061c946ab917fe196c321b6382a803e263fc131e94cf - imports_resolved_ast: 6438b7751a9bfbc114ec061c946ab917fe196c321b6382a803e263fc131e94cf - canonicalized_ast: 6438b7751a9bfbc114ec061c946ab917fe196c321b6382a803e263fc131e94cf - type_inferenced_ast: f956cebfdaffc93e04d75ec4017db28671a9ca95b46d7e46f0fe7c03921c8fcc + imports_resolved_ast: becbc58b95d60786c73dcca46164491edbfe3a6f7b7ce852cb533c2bb707cbbd + canonicalized_ast: becbc58b95d60786c73dcca46164491edbfe3a6f7b7ce852cb533c2bb707cbbd + type_inferenced_ast: b0e014f40c0209ed781953533c421e83078059d9e60754a123a841438870b84f diff --git a/tests/expectations/compiler/compiler/integers/i128/negate.leo.out b/tests/expectations/compiler/compiler/integers/i128/negate.leo.out index d24af05f3a..2aef30c9e2 100644 --- a/tests/expectations/compiler/compiler/integers/i128/negate.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/negate.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: f20c4c3491707834724e32b0bd9116e203db8e8e03bc77f14d958fff910ea7a8 - imports_resolved_ast: f20c4c3491707834724e32b0bd9116e203db8e8e03bc77f14d958fff910ea7a8 - canonicalized_ast: f20c4c3491707834724e32b0bd9116e203db8e8e03bc77f14d958fff910ea7a8 - type_inferenced_ast: 06e7d8be76d296f884f35880eb91b74b438316b04f1e189ac265ee76692da63f + imports_resolved_ast: 77d2a3ee655dabc54ebe3c9d5ec15a0d1d8bc97fc72ca69207b0c2d0f3ea6cb5 + canonicalized_ast: 77d2a3ee655dabc54ebe3c9d5ec15a0d1d8bc97fc72ca69207b0c2d0f3ea6cb5 + type_inferenced_ast: 4293e54cf582f285f5add9fce1952c1071c14fb65901a12ce047a0aebf67e3ae diff --git a/tests/expectations/compiler/compiler/integers/i128/negate_min.leo.out b/tests/expectations/compiler/compiler/integers/i128/negate_min.leo.out index 9e893a8160..6ac785da10 100644 --- a/tests/expectations/compiler/compiler/integers/i128/negate_min.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/negate_min.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 910fc83d7c92963a426e05d43b855610cddcd68f7ca007dc83a6dae90fc12be2 - imports_resolved_ast: 910fc83d7c92963a426e05d43b855610cddcd68f7ca007dc83a6dae90fc12be2 - canonicalized_ast: 910fc83d7c92963a426e05d43b855610cddcd68f7ca007dc83a6dae90fc12be2 - type_inferenced_ast: f27e5afe0c4bf455ca2b3cc989d8659066d2f9c817741cb0d1b7e66a756dc04f + imports_resolved_ast: bdd1bfba05e241183ee7fd5d700c4b3b6dfe1fad007037ea9ea49b36525e6c11 + canonicalized_ast: bdd1bfba05e241183ee7fd5d700c4b3b6dfe1fad007037ea9ea49b36525e6c11 + type_inferenced_ast: e1b1f673fa88da1322da105fb8a77804d7726e24f0064f654ee552d3841d8cb1 diff --git a/tests/expectations/compiler/compiler/integers/i128/negate_zero.leo.out b/tests/expectations/compiler/compiler/integers/i128/negate_zero.leo.out index 1c085131e8..5e72d4f177 100644 --- a/tests/expectations/compiler/compiler/integers/i128/negate_zero.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/negate_zero.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 68dd2506b7582cec89325afd649b76057840759d535cedca3e4cde98efeb0877 - imports_resolved_ast: 68dd2506b7582cec89325afd649b76057840759d535cedca3e4cde98efeb0877 - canonicalized_ast: 68dd2506b7582cec89325afd649b76057840759d535cedca3e4cde98efeb0877 - type_inferenced_ast: 67b08390d952e54e77e5704a13dfcedd83f4eba2f031d8d369c5c580722e02f0 + imports_resolved_ast: 87a8afc6aefc64316b83c78d0d4a153dc4f9a249cad606095cdc867309b1ed37 + canonicalized_ast: 87a8afc6aefc64316b83c78d0d4a153dc4f9a249cad606095cdc867309b1ed37 + type_inferenced_ast: 8a994186ea2cf119f597a52a1cf624b07ceae9e5f96ef0560d72692c659f5e9b diff --git a/tests/expectations/compiler/compiler/integers/i128/sub.leo.out b/tests/expectations/compiler/compiler/integers/i128/sub.leo.out index b32c214970..33b2b5fcd2 100644 --- a/tests/expectations/compiler/compiler/integers/i128/sub.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/sub.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: bc09a92a140e879b4fe0a16156a776015e48283e90b6f1af3ab2647a9ca044ce - imports_resolved_ast: bc09a92a140e879b4fe0a16156a776015e48283e90b6f1af3ab2647a9ca044ce - canonicalized_ast: bc09a92a140e879b4fe0a16156a776015e48283e90b6f1af3ab2647a9ca044ce - type_inferenced_ast: f9b47c27d64d9bd058c7341a828c51c31fcb4bc2bdb34bd8169d53a768559859 + imports_resolved_ast: df4a223a1aab7d3367bde86da49632fe8b54d0c67ad68f47302f44c204f23f0a + canonicalized_ast: df4a223a1aab7d3367bde86da49632fe8b54d0c67ad68f47302f44c204f23f0a + type_inferenced_ast: 340eac8a7910ead77232bf609debd71351eee61a6a16308496e2f91a7fc4d1b2 diff --git a/tests/expectations/compiler/compiler/integers/i128/ternary.leo.out b/tests/expectations/compiler/compiler/integers/i128/ternary.leo.out index 716a3d3807..14781739c5 100644 --- a/tests/expectations/compiler/compiler/integers/i128/ternary.leo.out +++ b/tests/expectations/compiler/compiler/integers/i128/ternary.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 59f299e993a6a2a19cfca109677cc4d5a72db425ace34b4b55d3b8b7cb54fdfe - imports_resolved_ast: 59f299e993a6a2a19cfca109677cc4d5a72db425ace34b4b55d3b8b7cb54fdfe - canonicalized_ast: 59f299e993a6a2a19cfca109677cc4d5a72db425ace34b4b55d3b8b7cb54fdfe - type_inferenced_ast: c83d950f8244fef52d7b25a588457ad771da0f73440f4d2523ac747623cf7a3a + imports_resolved_ast: cc1febf856a6c567ccbd962dd413805e8e0342e77019c59a197863e845cdf6a9 + canonicalized_ast: cc1febf856a6c567ccbd962dd413805e8e0342e77019c59a197863e845cdf6a9 + type_inferenced_ast: e6e6bb6edcfb811c4829c4ca499403c9831266950d1bc4c32341fdc5e25b813c diff --git a/tests/expectations/compiler/compiler/integers/i16/add.leo.out b/tests/expectations/compiler/compiler/integers/i16/add.leo.out index abdfe2f639..7c7da85397 100644 --- a/tests/expectations/compiler/compiler/integers/i16/add.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/add.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: a67c4ea1ac24f9da48cc18159bda3779585be4d0ff2ef7b2e36111c8e30a7095 - imports_resolved_ast: a67c4ea1ac24f9da48cc18159bda3779585be4d0ff2ef7b2e36111c8e30a7095 - canonicalized_ast: a67c4ea1ac24f9da48cc18159bda3779585be4d0ff2ef7b2e36111c8e30a7095 - type_inferenced_ast: 7d10fe70a4c3ad44ce07ae4fab3d1082d3f238757d318694f536e5b2e963c76a + imports_resolved_ast: 19220ea131f2afd4c0a6483023a34fb1cd3bedf9372957f07c0743bfd13f35c8 + canonicalized_ast: 19220ea131f2afd4c0a6483023a34fb1cd3bedf9372957f07c0743bfd13f35c8 + type_inferenced_ast: 1ef82a8bb6b6e34d4fe37c6e2772baad545001348e445ac9924e5a8b283f092d diff --git a/tests/expectations/compiler/compiler/integers/i16/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i16/console_assert.leo.out index 822c334963..6859ae40dd 100644 --- a/tests/expectations/compiler/compiler/integers/i16/console_assert.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/console_assert.leo.out @@ -14,6 +14,6 @@ outputs: output: registers: {} initial_ast: f68bd73d5f657b880c76f678c5d8b6903aebd0701415977f5dd35009b383daaf - imports_resolved_ast: f68bd73d5f657b880c76f678c5d8b6903aebd0701415977f5dd35009b383daaf - canonicalized_ast: a1a4fada7b1c3d4e82ac1065a720c6b11fdffd4a1cf270128432e04cee150cbb - type_inferenced_ast: 18633259cef0bf8b6f58b4fdddeff2e0f212f4bfd9a3a9d2e7c8b328117ee679 + imports_resolved_ast: 4ca32be2007aff3250d7c59d2d5dc56d569ebcd9bea1b98369a53d14edb77a4f + canonicalized_ast: 8d24c5829cdab6488d2d21ed4006c5af401facdcefc3c7c414a5e9367102ce41 + type_inferenced_ast: f21bc49ab1f8c3aefaddb429bd1f3e695f411fe5d7ac140dfb45edeff47c2704 diff --git a/tests/expectations/compiler/compiler/integers/i16/div.leo.out b/tests/expectations/compiler/compiler/integers/i16/div.leo.out index 66143f881a..7e938aa224 100644 --- a/tests/expectations/compiler/compiler/integers/i16/div.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/div.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: a0694975f2bd295505d998da6b165707f8231c8df9f046fccde58cc8f42da438 - imports_resolved_ast: a0694975f2bd295505d998da6b165707f8231c8df9f046fccde58cc8f42da438 - canonicalized_ast: a0694975f2bd295505d998da6b165707f8231c8df9f046fccde58cc8f42da438 - type_inferenced_ast: 66bbe4a003338adcacbf310ee8b26cb128175b0125523981d2378088760a321d + imports_resolved_ast: 435e7479c036d228102577b1612e6ebea6526974bfecf5682d3d8b52de97b6eb + canonicalized_ast: 435e7479c036d228102577b1612e6ebea6526974bfecf5682d3d8b52de97b6eb + type_inferenced_ast: 664ca6306e13f2115a748b64e6ccc11da2f4965b014902c3702e8fdda81f9009 diff --git a/tests/expectations/compiler/compiler/integers/i16/eq.leo.out b/tests/expectations/compiler/compiler/integers/i16/eq.leo.out index 109d08d761..fadcc904b2 100644 --- a/tests/expectations/compiler/compiler/integers/i16/eq.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/eq.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: b961658930719fa317e5762c0f759cccf808d0c25e4036efdc24efd3dd917145 - imports_resolved_ast: b961658930719fa317e5762c0f759cccf808d0c25e4036efdc24efd3dd917145 - canonicalized_ast: b961658930719fa317e5762c0f759cccf808d0c25e4036efdc24efd3dd917145 - type_inferenced_ast: 6e404e9ce612711f1170f49704f440a1698f61a5d830eeea3460025bd9883f29 + imports_resolved_ast: e656812559c8015c79a3c57fc216247614e2212d0d8f1a5a7bf804abb5e3e08f + canonicalized_ast: e656812559c8015c79a3c57fc216247614e2212d0d8f1a5a7bf804abb5e3e08f + type_inferenced_ast: 314cfeeed90043ce4dec97bcb56eef3b38dd55180bc04b89933b8b63b9a4db4a diff --git a/tests/expectations/compiler/compiler/integers/i16/ge.leo.out b/tests/expectations/compiler/compiler/integers/i16/ge.leo.out index 35249b2b08..2710770c44 100644 --- a/tests/expectations/compiler/compiler/integers/i16/ge.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/ge.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: af26d10d2f2a9d2c506829aec8c88fb34ae2ef681ffc4d3b8ec4b284bfdf3d9c - imports_resolved_ast: af26d10d2f2a9d2c506829aec8c88fb34ae2ef681ffc4d3b8ec4b284bfdf3d9c - canonicalized_ast: af26d10d2f2a9d2c506829aec8c88fb34ae2ef681ffc4d3b8ec4b284bfdf3d9c - type_inferenced_ast: 54cb6e5e03539e745b67bcfcd2d8175571e58747a26184d61991fd243e026efe + imports_resolved_ast: 13a2253dd2820681d4a31f5aec2302e04ad4e9fc6b4242a567509325e5c0e1cd + canonicalized_ast: 13a2253dd2820681d4a31f5aec2302e04ad4e9fc6b4242a567509325e5c0e1cd + type_inferenced_ast: 9e82be78fd2826dfb033670797c6ad087c1e960d8f7dd988ba7874a66b18d802 diff --git a/tests/expectations/compiler/compiler/integers/i16/gt.leo.out b/tests/expectations/compiler/compiler/integers/i16/gt.leo.out index 7a4d515135..46f31312ed 100644 --- a/tests/expectations/compiler/compiler/integers/i16/gt.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/gt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 062d3eb6035e1677c45329522cbd26b8a9b5bc6d501510db6d48a47e262253e6 - imports_resolved_ast: 062d3eb6035e1677c45329522cbd26b8a9b5bc6d501510db6d48a47e262253e6 - canonicalized_ast: 062d3eb6035e1677c45329522cbd26b8a9b5bc6d501510db6d48a47e262253e6 - type_inferenced_ast: 2f160dd1d274d6efc5359b8643d33846d32e78ab5c541ed5f5c58fb42c9ea245 + imports_resolved_ast: 35bd881d7b5adf5be926683665ef0d081778d5a1564ce7c6508929d6974f0afa + canonicalized_ast: 35bd881d7b5adf5be926683665ef0d081778d5a1564ce7c6508929d6974f0afa + type_inferenced_ast: 90cb8670e31e91c6a9c218c37432210f412840eb965d982f6493d3071876769d diff --git a/tests/expectations/compiler/compiler/integers/i16/le.leo.out b/tests/expectations/compiler/compiler/integers/i16/le.leo.out index bee4bdc77f..90e34ce597 100644 --- a/tests/expectations/compiler/compiler/integers/i16/le.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/le.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 6680714854c32707931c35b568b4ca58e6fb30fb6d6af7dd88752712a5932295 - imports_resolved_ast: 6680714854c32707931c35b568b4ca58e6fb30fb6d6af7dd88752712a5932295 - canonicalized_ast: 6680714854c32707931c35b568b4ca58e6fb30fb6d6af7dd88752712a5932295 - type_inferenced_ast: 9933127e345e202a0e2876dd14a3443a3a104f9faae4a6428e10268f7793b66d + imports_resolved_ast: 407653bff0805b248ea45e69afa61d86323acdfebbd41122102b8d03b9c85260 + canonicalized_ast: 407653bff0805b248ea45e69afa61d86323acdfebbd41122102b8d03b9c85260 + type_inferenced_ast: 7ebf4a3a8270ccfab95f9b1ab8c9fc6b0b5da6f473d0b997e6239e89e8c0c9f5 diff --git a/tests/expectations/compiler/compiler/integers/i16/lt.leo.out b/tests/expectations/compiler/compiler/integers/i16/lt.leo.out index bdbcfa8b12..69fc069e9e 100644 --- a/tests/expectations/compiler/compiler/integers/i16/lt.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/lt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 763c352848bf7747e761659811842656e84bb2e5e8b31cea06ded7f6b6b79f90 - imports_resolved_ast: 763c352848bf7747e761659811842656e84bb2e5e8b31cea06ded7f6b6b79f90 - canonicalized_ast: 763c352848bf7747e761659811842656e84bb2e5e8b31cea06ded7f6b6b79f90 - type_inferenced_ast: e4f72776d8aea450005835d7e69ef1f46e0b13c18673b97709546d49216064af + imports_resolved_ast: 1c1b8568cd3eaed2e8078b6ea93cffc81486843762beccaaeba4f7cdee5af336 + canonicalized_ast: 1c1b8568cd3eaed2e8078b6ea93cffc81486843762beccaaeba4f7cdee5af336 + type_inferenced_ast: 2dd4f2a6b9fd492e447f61dcca0dae958bdbe2d65ad522a75a1c20e9efed1fd9 diff --git a/tests/expectations/compiler/compiler/integers/i16/max.leo.out b/tests/expectations/compiler/compiler/integers/i16/max.leo.out index b8375ba80f..4fd8fba960 100644 --- a/tests/expectations/compiler/compiler/integers/i16/max.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/max.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 3683f5647eb1ba2d1999c80f2eb629a3ed5a7114e888b0282066556a2df7877b - imports_resolved_ast: 3683f5647eb1ba2d1999c80f2eb629a3ed5a7114e888b0282066556a2df7877b - canonicalized_ast: 3683f5647eb1ba2d1999c80f2eb629a3ed5a7114e888b0282066556a2df7877b - type_inferenced_ast: 0d239b14f356b7fc5b65558b1a74ac63af72e7f599d2af7d9f78bfca7d0dec06 + imports_resolved_ast: 4869ed591b54ea6c10c8986b3bb3b8eeb97a877d39a4494e421f9587a33bdadc + canonicalized_ast: 4869ed591b54ea6c10c8986b3bb3b8eeb97a877d39a4494e421f9587a33bdadc + type_inferenced_ast: dd61dace33e70965b1fd33eefead5defcbde4c14e7df98be07b980a9ca43566a diff --git a/tests/expectations/compiler/compiler/integers/i16/min.leo.out b/tests/expectations/compiler/compiler/integers/i16/min.leo.out index 6fe7c31078..b171ce168d 100644 --- a/tests/expectations/compiler/compiler/integers/i16/min.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/min.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: ff4a8d9a961ad3cb815e5c7fd71f32c2071b802fcec05e4768fced1f66c52d35 - imports_resolved_ast: ff4a8d9a961ad3cb815e5c7fd71f32c2071b802fcec05e4768fced1f66c52d35 - canonicalized_ast: ff4a8d9a961ad3cb815e5c7fd71f32c2071b802fcec05e4768fced1f66c52d35 - type_inferenced_ast: 27745e526e1e647526bd04fac6cf28e6c190a4d6aca2e0f235d7eff8ec1d00c3 + imports_resolved_ast: 28c60f5f6d196fcb876a98c4a0fba12d1e4e53cf25c6ec52b9d1ef46761749f2 + canonicalized_ast: 28c60f5f6d196fcb876a98c4a0fba12d1e4e53cf25c6ec52b9d1ef46761749f2 + type_inferenced_ast: 13f53a21e88b4290381c4432006dbc067836caaad1c48c32629b999cb4e3ba9e diff --git a/tests/expectations/compiler/compiler/integers/i16/mul.leo.out b/tests/expectations/compiler/compiler/integers/i16/mul.leo.out index e02846dff2..bde995f083 100644 --- a/tests/expectations/compiler/compiler/integers/i16/mul.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/mul.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: e2ea9bad702ec0c03da96d6de6e49e19600c7c59a984b1f6293456a6422a44ee - imports_resolved_ast: e2ea9bad702ec0c03da96d6de6e49e19600c7c59a984b1f6293456a6422a44ee - canonicalized_ast: e2ea9bad702ec0c03da96d6de6e49e19600c7c59a984b1f6293456a6422a44ee - type_inferenced_ast: 529c3f87ac0b87c521d21958a8fa03f1bd4a77a047ed0815935c33a35780dcb2 + imports_resolved_ast: 4bb861914a1b2804e3462f10fe635b56e6245190f87d54aff31df20e1c9921f9 + canonicalized_ast: 4bb861914a1b2804e3462f10fe635b56e6245190f87d54aff31df20e1c9921f9 + type_inferenced_ast: ca2485fb98f6f56c81e9e118bea39239347e2b7daedccdce357f541b43e9b4de diff --git a/tests/expectations/compiler/compiler/integers/i16/ne.leo.out b/tests/expectations/compiler/compiler/integers/i16/ne.leo.out index 8239a63289..3195cf7236 100644 --- a/tests/expectations/compiler/compiler/integers/i16/ne.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/ne.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: c7ab4b48ebe504d361335859297d54229144960db82dde7a6d7124821dc5bdaf - imports_resolved_ast: c7ab4b48ebe504d361335859297d54229144960db82dde7a6d7124821dc5bdaf - canonicalized_ast: c7ab4b48ebe504d361335859297d54229144960db82dde7a6d7124821dc5bdaf - type_inferenced_ast: fba12a2f71c2ae3dba292b834566ba9d3495f888e21fb07109b15be597f2b6bf + imports_resolved_ast: bd718d3f0683e3990dfffa5d5134caab687bc62377e90daab03380ef394101f9 + canonicalized_ast: bd718d3f0683e3990dfffa5d5134caab687bc62377e90daab03380ef394101f9 + type_inferenced_ast: 1faeefa47a346dd2f4526e83562ecb2bcf182ab399793ebe97c55c61c37bcc9c diff --git a/tests/expectations/compiler/compiler/integers/i16/negate.leo.out b/tests/expectations/compiler/compiler/integers/i16/negate.leo.out index d0ec10d082..ad54d0372a 100644 --- a/tests/expectations/compiler/compiler/integers/i16/negate.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/negate.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: ecbc2a7d13b6a8d1bf35f53a9d80c4aab380495ec93663410c390e5d6d4f602e - imports_resolved_ast: ecbc2a7d13b6a8d1bf35f53a9d80c4aab380495ec93663410c390e5d6d4f602e - canonicalized_ast: ecbc2a7d13b6a8d1bf35f53a9d80c4aab380495ec93663410c390e5d6d4f602e - type_inferenced_ast: 106f4bc60cc6c007d1418e2571c3183f4372988be97c319574e965d2a08d9f3d + imports_resolved_ast: 60fad5dbf8bb2e165144aa4f7147847cc69cc7df13038796fa7ced2ef64ded5c + canonicalized_ast: 60fad5dbf8bb2e165144aa4f7147847cc69cc7df13038796fa7ced2ef64ded5c + type_inferenced_ast: 6edd46cbd3492565060c0da80b018c804c6e6209a70586c0fe0d21658bf1a778 diff --git a/tests/expectations/compiler/compiler/integers/i16/negate_min.leo.out b/tests/expectations/compiler/compiler/integers/i16/negate_min.leo.out index cb03f28c62..61e414b91c 100644 --- a/tests/expectations/compiler/compiler/integers/i16/negate_min.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/negate_min.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: a8449e15a25ff4327992829605e38edc70f958d0e3af40e3244b687b6a7a524f - imports_resolved_ast: a8449e15a25ff4327992829605e38edc70f958d0e3af40e3244b687b6a7a524f - canonicalized_ast: a8449e15a25ff4327992829605e38edc70f958d0e3af40e3244b687b6a7a524f - type_inferenced_ast: 90abf0bc2284b1bee472bcc256040c4dafd0e98c8938b9912778ed9c31d3f8ec + imports_resolved_ast: b2dfa76680097aa1085ba322375119f607011523382aee152a1326d3d6ec834b + canonicalized_ast: b2dfa76680097aa1085ba322375119f607011523382aee152a1326d3d6ec834b + type_inferenced_ast: ed4874a9bc3b47a566289249e0c1a643198ac3c0607442e44443a2cba2855edd diff --git a/tests/expectations/compiler/compiler/integers/i16/negate_zero.leo.out b/tests/expectations/compiler/compiler/integers/i16/negate_zero.leo.out index bc9c8258fe..54b47438f5 100644 --- a/tests/expectations/compiler/compiler/integers/i16/negate_zero.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/negate_zero.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: d0091da13c0406b347d3c276e90831cdd65da70e601ff244bd9c861c2c30af31 - imports_resolved_ast: d0091da13c0406b347d3c276e90831cdd65da70e601ff244bd9c861c2c30af31 - canonicalized_ast: d0091da13c0406b347d3c276e90831cdd65da70e601ff244bd9c861c2c30af31 - type_inferenced_ast: bf3619f3735b49c2daa579800f40de768515f8367c7b934567ae1e79eb8d9228 + imports_resolved_ast: c25478533fa56d7ac5e12d3398e73a507a1f8feaeaf9285d62ee87bb1e673ddd + canonicalized_ast: c25478533fa56d7ac5e12d3398e73a507a1f8feaeaf9285d62ee87bb1e673ddd + type_inferenced_ast: c90d271e8a662d40cbf787213d7a70079667a0e5978a78d519dafe628453032a diff --git a/tests/expectations/compiler/compiler/integers/i16/sub.leo.out b/tests/expectations/compiler/compiler/integers/i16/sub.leo.out index 468b2421a7..08250ec797 100644 --- a/tests/expectations/compiler/compiler/integers/i16/sub.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/sub.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 29b5330610e95c16d51f5296a10729b570a50e19862685ad5d3209e458e42c79 - imports_resolved_ast: 29b5330610e95c16d51f5296a10729b570a50e19862685ad5d3209e458e42c79 - canonicalized_ast: 29b5330610e95c16d51f5296a10729b570a50e19862685ad5d3209e458e42c79 - type_inferenced_ast: b50322c970ad5e34639834c22770e359a2a3fe6434064ef3687e03889af3f02b + imports_resolved_ast: 97555fee49ba96474e2ec0eaf66b98928a228d87ed971ed2599a39719fb163ab + canonicalized_ast: 97555fee49ba96474e2ec0eaf66b98928a228d87ed971ed2599a39719fb163ab + type_inferenced_ast: 3f40764e6841c20e92d9cdaa615c7960417b245c9cd95b084307fa30f9b76816 diff --git a/tests/expectations/compiler/compiler/integers/i16/ternary.leo.out b/tests/expectations/compiler/compiler/integers/i16/ternary.leo.out index 9781a6c474..77896684f8 100644 --- a/tests/expectations/compiler/compiler/integers/i16/ternary.leo.out +++ b/tests/expectations/compiler/compiler/integers/i16/ternary.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 331af238c9ee45bd3b604155405f8ab4061ff16416387249364f83432f7f8b5a - imports_resolved_ast: 331af238c9ee45bd3b604155405f8ab4061ff16416387249364f83432f7f8b5a - canonicalized_ast: 331af238c9ee45bd3b604155405f8ab4061ff16416387249364f83432f7f8b5a - type_inferenced_ast: 50a018ce4b160bd86e9fbdfe9db17bcfd055e4800f06c55551eed3100d3f64e6 + imports_resolved_ast: eb08fb50a1c2adda5bc96314bab3613f39eb6bdbac8ae7ee7289e8b2db19c46e + canonicalized_ast: eb08fb50a1c2adda5bc96314bab3613f39eb6bdbac8ae7ee7289e8b2db19c46e + type_inferenced_ast: decc16e828351287eda05aac1068017d09c5235f369e16028a5f5a4d9860858c diff --git a/tests/expectations/compiler/compiler/integers/i32/add.leo.out b/tests/expectations/compiler/compiler/integers/i32/add.leo.out index 68fc4a45f6..f0c0faae60 100644 --- a/tests/expectations/compiler/compiler/integers/i32/add.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/add.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 39635af165ae775232853b12ac07b0a21f39382ae3e146001e1a05b7c60849c3 - imports_resolved_ast: 39635af165ae775232853b12ac07b0a21f39382ae3e146001e1a05b7c60849c3 - canonicalized_ast: 39635af165ae775232853b12ac07b0a21f39382ae3e146001e1a05b7c60849c3 - type_inferenced_ast: 8da17349b8496481730002123096f5c09debd25133db8045665aa2ae405efe1a + imports_resolved_ast: 7bfd034e31cb06d572e88b16781cc4a93d68567351a7545b7f5105e6f2263627 + canonicalized_ast: 7bfd034e31cb06d572e88b16781cc4a93d68567351a7545b7f5105e6f2263627 + type_inferenced_ast: 22ce033af5a65ddd1e4551b1325f65addc70a691b35149aa7d19b7c7be49afb5 diff --git a/tests/expectations/compiler/compiler/integers/i32/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i32/console_assert.leo.out index 4f1f835132..81485a9dca 100644 --- a/tests/expectations/compiler/compiler/integers/i32/console_assert.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/console_assert.leo.out @@ -14,6 +14,6 @@ outputs: output: registers: {} initial_ast: 6ba5c49aaa9ed5abf49a7f538392cb18905e6805b7d3780e5d6391adb7df6631 - imports_resolved_ast: 6ba5c49aaa9ed5abf49a7f538392cb18905e6805b7d3780e5d6391adb7df6631 - canonicalized_ast: 35877250663e7d44c5e01e64cd99d5e1b8fa84da4d00667bade1fd9a517f3803 - type_inferenced_ast: 2c72c8cf340cc122fb5a081c8dd6eaa22ac2c79511e98fd5f23f4b8b1dac3526 + imports_resolved_ast: d61859a0c6e76f6a89bec704a8b4e7bb5bd21e8efe9238180a208ef086a9a407 + canonicalized_ast: 1dba3c45ddd327661e17cdf2f5896eb19854487f3406342d1c0c9314fce782d9 + type_inferenced_ast: 291cd09d139f6e44970bb8dac001c7182ddb1e0368bc90af0f72051bb756f004 diff --git a/tests/expectations/compiler/compiler/integers/i32/div.leo.out b/tests/expectations/compiler/compiler/integers/i32/div.leo.out index 40804c7cb0..4e6029e2e7 100644 --- a/tests/expectations/compiler/compiler/integers/i32/div.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/div.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 3917fa03634f3abb0d497bfae7ba98c15dd93f867e3e1bf724bab8fc724ce8cf - imports_resolved_ast: 3917fa03634f3abb0d497bfae7ba98c15dd93f867e3e1bf724bab8fc724ce8cf - canonicalized_ast: 3917fa03634f3abb0d497bfae7ba98c15dd93f867e3e1bf724bab8fc724ce8cf - type_inferenced_ast: 1f460bec4ed9e4478b7ef9df14773eb92ad310d790cae429a0caadbc7f750d2e + imports_resolved_ast: fa0a4bcccb9e6d92e5578a7bbc1bcaf36df27cb72fb120a0337f0ea14f6def98 + canonicalized_ast: fa0a4bcccb9e6d92e5578a7bbc1bcaf36df27cb72fb120a0337f0ea14f6def98 + type_inferenced_ast: 376462ce31486ea565b0705cf292ac6fcb25f699eadef61b07177749ca2776a0 diff --git a/tests/expectations/compiler/compiler/integers/i32/eq.leo.out b/tests/expectations/compiler/compiler/integers/i32/eq.leo.out index 690a556f61..10620e364d 100644 --- a/tests/expectations/compiler/compiler/integers/i32/eq.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/eq.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 180d1048dd64c67ea367750630057b9c5302a89a81144d0148ea1dfafada8b4c - imports_resolved_ast: 180d1048dd64c67ea367750630057b9c5302a89a81144d0148ea1dfafada8b4c - canonicalized_ast: 180d1048dd64c67ea367750630057b9c5302a89a81144d0148ea1dfafada8b4c - type_inferenced_ast: f2f2254b22bc172f1859835e478e9456b3fdbc497f5a48483fc87969d6bf6144 + imports_resolved_ast: 19346fa582f7db4874c077834002fc2933720900757073d2e9d0bbc84ad5e3b5 + canonicalized_ast: 19346fa582f7db4874c077834002fc2933720900757073d2e9d0bbc84ad5e3b5 + type_inferenced_ast: 70c9a337f888e218b76bcea0d4cd6af43042174022cf32b38cfd7fa4f38d938c diff --git a/tests/expectations/compiler/compiler/integers/i32/ge.leo.out b/tests/expectations/compiler/compiler/integers/i32/ge.leo.out index f55b8e9939..11eb5dd805 100644 --- a/tests/expectations/compiler/compiler/integers/i32/ge.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/ge.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 6401f6c0567fe73628faf73dc3cd71635bbba9b997c918d182f6fdf2dda68b82 - imports_resolved_ast: 6401f6c0567fe73628faf73dc3cd71635bbba9b997c918d182f6fdf2dda68b82 - canonicalized_ast: 6401f6c0567fe73628faf73dc3cd71635bbba9b997c918d182f6fdf2dda68b82 - type_inferenced_ast: 9e105f38de69dddfd99b143f279f063950e305321a343dea0bf10924af6f7c2b + imports_resolved_ast: 73f9a868e136820b84253b203e326a8079d8a79ebabd5f7afd14d22fd5a56dac + canonicalized_ast: 73f9a868e136820b84253b203e326a8079d8a79ebabd5f7afd14d22fd5a56dac + type_inferenced_ast: abe4f1b90365c0ca0cfc24a1b377fc6b514dbed524f55cb8b712093e1e71e32f diff --git a/tests/expectations/compiler/compiler/integers/i32/gt.leo.out b/tests/expectations/compiler/compiler/integers/i32/gt.leo.out index 4ec0e63ed9..a97be13079 100644 --- a/tests/expectations/compiler/compiler/integers/i32/gt.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/gt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: f82734600ac57a9a5bd1ef4c2439cc5bbea882cd2ed81646ce6abd7915abc344 - imports_resolved_ast: f82734600ac57a9a5bd1ef4c2439cc5bbea882cd2ed81646ce6abd7915abc344 - canonicalized_ast: f82734600ac57a9a5bd1ef4c2439cc5bbea882cd2ed81646ce6abd7915abc344 - type_inferenced_ast: 67d4dfb5c34b3e9aa457c7897d28cf85a2366bf987279f50eb44ad5cfe617ffa + imports_resolved_ast: 1e126f5435a23f7d7c84f83905a47aa05400a94d34cbb9ef97da513d74854bc0 + canonicalized_ast: 1e126f5435a23f7d7c84f83905a47aa05400a94d34cbb9ef97da513d74854bc0 + type_inferenced_ast: 9291310f4bf2aca1c8e9700f4a440d09699885edceb0a158d43224e1aa818358 diff --git a/tests/expectations/compiler/compiler/integers/i32/le.leo.out b/tests/expectations/compiler/compiler/integers/i32/le.leo.out index c420c4c1f0..832fdad756 100644 --- a/tests/expectations/compiler/compiler/integers/i32/le.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/le.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 51baf4d7be19032fb911d8f5e7fb250ccf3e9e272644c013699be201cf44d00a - imports_resolved_ast: 51baf4d7be19032fb911d8f5e7fb250ccf3e9e272644c013699be201cf44d00a - canonicalized_ast: 51baf4d7be19032fb911d8f5e7fb250ccf3e9e272644c013699be201cf44d00a - type_inferenced_ast: 0427991a5b5ca595f7a0d5fb0d842ecc18433533366ae437fcbdaff134150481 + imports_resolved_ast: ca280c9c2f64c878d28291bc1b8b763b53c00cc9c58c021021ac9ab5da0181fb + canonicalized_ast: ca280c9c2f64c878d28291bc1b8b763b53c00cc9c58c021021ac9ab5da0181fb + type_inferenced_ast: 33309ea620e3294c97fd17b7778a8fc169584bb299b036f9ef67ebbbdd09b567 diff --git a/tests/expectations/compiler/compiler/integers/i32/lt.leo.out b/tests/expectations/compiler/compiler/integers/i32/lt.leo.out index c656ee7282..5f655fb0f1 100644 --- a/tests/expectations/compiler/compiler/integers/i32/lt.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/lt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: e464cb5a70dcb5bf51ab5ccffa10b54ea29f0e68775593f05bb0d585144487a8 - imports_resolved_ast: e464cb5a70dcb5bf51ab5ccffa10b54ea29f0e68775593f05bb0d585144487a8 - canonicalized_ast: e464cb5a70dcb5bf51ab5ccffa10b54ea29f0e68775593f05bb0d585144487a8 - type_inferenced_ast: 486d0d877dbc748210bc6a82d40a132709d83a44d5e4de255e9c40dd3bf6cedd + imports_resolved_ast: f7fe6f8000c53f47187180982d1b509d0ce6034d2f5766ea9087140ae25c4981 + canonicalized_ast: f7fe6f8000c53f47187180982d1b509d0ce6034d2f5766ea9087140ae25c4981 + type_inferenced_ast: 16d09f63481d65e8be68e4b84fd1cdc06810780aedbb662e937cf7a169d06bef diff --git a/tests/expectations/compiler/compiler/integers/i32/max.leo.out b/tests/expectations/compiler/compiler/integers/i32/max.leo.out index 48b7243612..32add0beab 100644 --- a/tests/expectations/compiler/compiler/integers/i32/max.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/max.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 2596ba582e34d7147902c469c3544d438d8ba64aeecd103938a1eb8e3536f360 - imports_resolved_ast: 2596ba582e34d7147902c469c3544d438d8ba64aeecd103938a1eb8e3536f360 - canonicalized_ast: 2596ba582e34d7147902c469c3544d438d8ba64aeecd103938a1eb8e3536f360 - type_inferenced_ast: aa0a685388d2f3aed81db5c35ead63975e8ad4df5803390f1976795ad544430f + imports_resolved_ast: 844275e0c042b71298cca9dc4bafb161be1ba8f829eda681e1b1d5962052729c + canonicalized_ast: 844275e0c042b71298cca9dc4bafb161be1ba8f829eda681e1b1d5962052729c + type_inferenced_ast: b385c02fb8bcaa5293ae27bc1e3c1e414184837e2949cc4a81fab804eb59a9bb diff --git a/tests/expectations/compiler/compiler/integers/i32/min.leo.out b/tests/expectations/compiler/compiler/integers/i32/min.leo.out index 0f8d4cf6b8..0e88130943 100644 --- a/tests/expectations/compiler/compiler/integers/i32/min.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/min.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: e08bac68e7d8ebb03c3fc1538c525de5e2caeaed750b548f4756abf12d6d38a5 - imports_resolved_ast: e08bac68e7d8ebb03c3fc1538c525de5e2caeaed750b548f4756abf12d6d38a5 - canonicalized_ast: e08bac68e7d8ebb03c3fc1538c525de5e2caeaed750b548f4756abf12d6d38a5 - type_inferenced_ast: f529d963cc870de92960d5c2eb5ec8ceeae22256f0164399867b996a14be14aa + imports_resolved_ast: c871122e9283fae426beb367ff6d71be3b8a946bd7e906c7ead14f6381c22507 + canonicalized_ast: c871122e9283fae426beb367ff6d71be3b8a946bd7e906c7ead14f6381c22507 + type_inferenced_ast: 34a4717ca862cb9125959671b51a290d361bb0e5aa29336cc2c623bab10ad420 diff --git a/tests/expectations/compiler/compiler/integers/i32/mul.leo.out b/tests/expectations/compiler/compiler/integers/i32/mul.leo.out index 4c3c4bc942..83aefdfd57 100644 --- a/tests/expectations/compiler/compiler/integers/i32/mul.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/mul.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 3fc63e8ecf481c6f4224c0206b16af942eb407b151f1fc21d8774cbf84ccc5d6 - imports_resolved_ast: 3fc63e8ecf481c6f4224c0206b16af942eb407b151f1fc21d8774cbf84ccc5d6 - canonicalized_ast: 3fc63e8ecf481c6f4224c0206b16af942eb407b151f1fc21d8774cbf84ccc5d6 - type_inferenced_ast: 89f3c749fb559365b2ea0d804cb9146d923993a6c2c2dd9a3942057d7ff343d4 + imports_resolved_ast: f804e698d9fc3534afe91a0e94d5c9a83e82f7b13a3a7fdc49616e84e7001b39 + canonicalized_ast: f804e698d9fc3534afe91a0e94d5c9a83e82f7b13a3a7fdc49616e84e7001b39 + type_inferenced_ast: c91c9bb488bf865e76eaf16d5680071797a84bae9d97f7831812b29930270030 diff --git a/tests/expectations/compiler/compiler/integers/i32/ne.leo.out b/tests/expectations/compiler/compiler/integers/i32/ne.leo.out index db5011ded1..b07510d1cc 100644 --- a/tests/expectations/compiler/compiler/integers/i32/ne.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/ne.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 79492afcb10499d002f2b1f6c60bd7e656817f7c638068ad4bb7b3f5087537c7 - imports_resolved_ast: 79492afcb10499d002f2b1f6c60bd7e656817f7c638068ad4bb7b3f5087537c7 - canonicalized_ast: 79492afcb10499d002f2b1f6c60bd7e656817f7c638068ad4bb7b3f5087537c7 - type_inferenced_ast: 2f324fbbfefac3d5fd095be4ca42fd83c711ae407e9631b0814f543331662dcf + imports_resolved_ast: 982b47a5002049eec6e42b00c7f08434daec57c99ab9afc654950e31d0a6367c + canonicalized_ast: 982b47a5002049eec6e42b00c7f08434daec57c99ab9afc654950e31d0a6367c + type_inferenced_ast: d01069bdcc2e3869b15fbf1b68dbcc737704bb0d3f957c5ea6a43fcb1ed0e436 diff --git a/tests/expectations/compiler/compiler/integers/i32/negate.leo.out b/tests/expectations/compiler/compiler/integers/i32/negate.leo.out index 51672f6983..e49d599320 100644 --- a/tests/expectations/compiler/compiler/integers/i32/negate.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/negate.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: c895e4172b4155a740dfe2aebfc4ded6f694b017d0eb1b7700b42e4498ecf151 - imports_resolved_ast: c895e4172b4155a740dfe2aebfc4ded6f694b017d0eb1b7700b42e4498ecf151 - canonicalized_ast: c895e4172b4155a740dfe2aebfc4ded6f694b017d0eb1b7700b42e4498ecf151 - type_inferenced_ast: 47858526755f4292e5e423544d3ed6b4c664b08566f1a3f066433a8e21f4480a + imports_resolved_ast: 78d656f6cb951d282e6c99b95eeda65b27b25b95088fd5ccf7d84fcbd5487eac + canonicalized_ast: 78d656f6cb951d282e6c99b95eeda65b27b25b95088fd5ccf7d84fcbd5487eac + type_inferenced_ast: 75424293b787227f46e5361ef0964857d9d2dfd2913a7fa2c639a059fa487f3b diff --git a/tests/expectations/compiler/compiler/integers/i32/negate_min.leo.out b/tests/expectations/compiler/compiler/integers/i32/negate_min.leo.out index 0ac80cea4c..c1b06d30b1 100644 --- a/tests/expectations/compiler/compiler/integers/i32/negate_min.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/negate_min.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: bcbd4fdb79ebffa456407355e6d4f71d039014dd03cee2466850f90c1c1c17e2 - imports_resolved_ast: bcbd4fdb79ebffa456407355e6d4f71d039014dd03cee2466850f90c1c1c17e2 - canonicalized_ast: bcbd4fdb79ebffa456407355e6d4f71d039014dd03cee2466850f90c1c1c17e2 - type_inferenced_ast: d2bc0ba76d451989365a4f3c40cffde6abc17865a43b2816d89bd884e8b0bdff + imports_resolved_ast: a3323e2d96c25dfd774c951bc6f488d02c31883a85365d435d77de27e05e43f4 + canonicalized_ast: a3323e2d96c25dfd774c951bc6f488d02c31883a85365d435d77de27e05e43f4 + type_inferenced_ast: f913f6e96d581f7dce76009d5e4aaf90adbff2cc8632cb4ad3fe689e9f42e938 diff --git a/tests/expectations/compiler/compiler/integers/i32/negate_zero.leo.out b/tests/expectations/compiler/compiler/integers/i32/negate_zero.leo.out index f37306e8cb..9c9eb6d0eb 100644 --- a/tests/expectations/compiler/compiler/integers/i32/negate_zero.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/negate_zero.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: b1ec676bc801b40fa773668c988ce9da33fec783743e214269a777ad122cda49 - imports_resolved_ast: b1ec676bc801b40fa773668c988ce9da33fec783743e214269a777ad122cda49 - canonicalized_ast: b1ec676bc801b40fa773668c988ce9da33fec783743e214269a777ad122cda49 - type_inferenced_ast: 97b5d8261ddffbfff0316e3bf97df502a9b1c75e79b2e94d0b8f8f8c565699de + imports_resolved_ast: fa953bd23069f5d30e245afd85d08d6025a30d505065263fdc60c7971bbe5515 + canonicalized_ast: fa953bd23069f5d30e245afd85d08d6025a30d505065263fdc60c7971bbe5515 + type_inferenced_ast: 48f0dc7d5b20eb2949ec27b93d1376512c0dcc1f5a0d1428c6c1e22d6d83878d diff --git a/tests/expectations/compiler/compiler/integers/i32/sub.leo.out b/tests/expectations/compiler/compiler/integers/i32/sub.leo.out index 113536fbea..3f00b7cc7d 100644 --- a/tests/expectations/compiler/compiler/integers/i32/sub.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/sub.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: d3776192bdb897e3ffdfe76557ba210babd9fd36945d47133552271858ff5c35 - imports_resolved_ast: d3776192bdb897e3ffdfe76557ba210babd9fd36945d47133552271858ff5c35 - canonicalized_ast: d3776192bdb897e3ffdfe76557ba210babd9fd36945d47133552271858ff5c35 - type_inferenced_ast: 36e7d5a21e55cd5d61ea6644e8d5c84a0640972921fbdcfd6e27886caf6b5216 + imports_resolved_ast: 108ac1c2363357cd06fb146c4bf4949b7cae26bd32d1281563b70c2b6cd6800e + canonicalized_ast: 108ac1c2363357cd06fb146c4bf4949b7cae26bd32d1281563b70c2b6cd6800e + type_inferenced_ast: 3a5005205d7f3955afc5a72a22ae4eca53fcd2ffeaa95bfe7d7ebda55da76188 diff --git a/tests/expectations/compiler/compiler/integers/i32/ternary.leo.out b/tests/expectations/compiler/compiler/integers/i32/ternary.leo.out index 4960310094..6b2ab2ec07 100644 --- a/tests/expectations/compiler/compiler/integers/i32/ternary.leo.out +++ b/tests/expectations/compiler/compiler/integers/i32/ternary.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 04e630cdddd76554c0049b08a3ed7a6a2c824a7dc929796e3fc713c6d11f70be - imports_resolved_ast: 04e630cdddd76554c0049b08a3ed7a6a2c824a7dc929796e3fc713c6d11f70be - canonicalized_ast: 04e630cdddd76554c0049b08a3ed7a6a2c824a7dc929796e3fc713c6d11f70be - type_inferenced_ast: 0655b17c3f9cc5c7500c8c7edfef4effa43668f096da5338b2c44ae316b0a5e1 + imports_resolved_ast: defb776ec56338efb30e1612e7b328cab14b39510f8bb81c10665d56775e510f + canonicalized_ast: defb776ec56338efb30e1612e7b328cab14b39510f8bb81c10665d56775e510f + type_inferenced_ast: bd27bf7bec866f162350f513cc3913819f2c0e95dca1415fcea6fa559bd2d8d7 diff --git a/tests/expectations/compiler/compiler/integers/i64/add.leo.out b/tests/expectations/compiler/compiler/integers/i64/add.leo.out index c7c89b8c83..a3017dbf95 100644 --- a/tests/expectations/compiler/compiler/integers/i64/add.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/add.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 8e59e1adb08d85f3d13a4e0501c7299d8258d13dd979c0a971d5f2ce75f631a6 - imports_resolved_ast: 8e59e1adb08d85f3d13a4e0501c7299d8258d13dd979c0a971d5f2ce75f631a6 - canonicalized_ast: 8e59e1adb08d85f3d13a4e0501c7299d8258d13dd979c0a971d5f2ce75f631a6 - type_inferenced_ast: 3a117cd702a7f13a7cbafd2c05c301d87562a0c6a971486c0cb07391f732c02d + imports_resolved_ast: 87ff1c18ed260de083cc4a6adcc098558cc9d5dd397a8915863a4a8beab85e1d + canonicalized_ast: 87ff1c18ed260de083cc4a6adcc098558cc9d5dd397a8915863a4a8beab85e1d + type_inferenced_ast: 1c509e14220513ef8d4258050ae0db482ac0b980a7f4221d6f51cf9d1ff2ee8d diff --git a/tests/expectations/compiler/compiler/integers/i64/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i64/console_assert.leo.out index 325e819d35..99786fa390 100644 --- a/tests/expectations/compiler/compiler/integers/i64/console_assert.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/console_assert.leo.out @@ -14,6 +14,6 @@ outputs: output: registers: {} initial_ast: 9389a270a24424ceb480768d8d0811101f2f92c7fc7447efe29686fd30d075e8 - imports_resolved_ast: 9389a270a24424ceb480768d8d0811101f2f92c7fc7447efe29686fd30d075e8 - canonicalized_ast: f44f1275eb6295af14fcc1773894b0694bb8657cb7b472b16cc1e5d846ca6a6c - type_inferenced_ast: 546c1d880e97e95d1b91a1e6b73fc9cf240c734921ebe534e2a7af6cb224f477 + imports_resolved_ast: b7b9651dc94535455bbad7de05271860de402c7aedc35b383007579335083b98 + canonicalized_ast: d0d25a6891395509a31049cb41445f975748bc342aaf639bec67c9f87656e674 + type_inferenced_ast: 4c324a1987b447fbeae0c7d1c15ed16585f605c293e293e41065ce170be163d2 diff --git a/tests/expectations/compiler/compiler/integers/i64/div.leo.out b/tests/expectations/compiler/compiler/integers/i64/div.leo.out index 90ff4e41f0..e64cf7524f 100644 --- a/tests/expectations/compiler/compiler/integers/i64/div.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/div.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 6fee781a23a251aafaea1000be3025d52bdeceb3b95aa746cdcc9560834227e3 - imports_resolved_ast: 6fee781a23a251aafaea1000be3025d52bdeceb3b95aa746cdcc9560834227e3 - canonicalized_ast: 6fee781a23a251aafaea1000be3025d52bdeceb3b95aa746cdcc9560834227e3 - type_inferenced_ast: 4e93f3e08a4f65b47fe98c337cc6b1b3cf1be2cef22ab55d3bfd7491e8776a17 + imports_resolved_ast: 5b0619487a8b3952643a3fea0333eda1874074c2bfc234a92cb5bb8069fb5ee6 + canonicalized_ast: 5b0619487a8b3952643a3fea0333eda1874074c2bfc234a92cb5bb8069fb5ee6 + type_inferenced_ast: b50d77f8d4c0de3f75d922e9e57b4dc88f4c111bb2ed96f3bce476cbbd1473c1 diff --git a/tests/expectations/compiler/compiler/integers/i64/eq.leo.out b/tests/expectations/compiler/compiler/integers/i64/eq.leo.out index 0a6b595adc..91473356bd 100644 --- a/tests/expectations/compiler/compiler/integers/i64/eq.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/eq.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: bdde37443fd01021b4b7928e9d28c94146ff2f6804200387638b5912729c6acb - imports_resolved_ast: bdde37443fd01021b4b7928e9d28c94146ff2f6804200387638b5912729c6acb - canonicalized_ast: bdde37443fd01021b4b7928e9d28c94146ff2f6804200387638b5912729c6acb - type_inferenced_ast: 20102db693d9c531d240a5926a64f5720c0e30bb5e15ba8ec55a9ccb5dc5a7e1 + imports_resolved_ast: 67f58ae710a6a989a859c907058206298fe789226d1830ff2c7de97339206f2d + canonicalized_ast: 67f58ae710a6a989a859c907058206298fe789226d1830ff2c7de97339206f2d + type_inferenced_ast: da269a08824ff04875e5bd0a33e6bf73ef7af31865bc0cc8538bb57aef04f50d diff --git a/tests/expectations/compiler/compiler/integers/i64/ge.leo.out b/tests/expectations/compiler/compiler/integers/i64/ge.leo.out index 171923e14a..41abeb25b7 100644 --- a/tests/expectations/compiler/compiler/integers/i64/ge.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/ge.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 5c1016b42105d692df8c5a799884607097e1f0e4e971f54f12f722a8b6767b85 - imports_resolved_ast: 5c1016b42105d692df8c5a799884607097e1f0e4e971f54f12f722a8b6767b85 - canonicalized_ast: 5c1016b42105d692df8c5a799884607097e1f0e4e971f54f12f722a8b6767b85 - type_inferenced_ast: 93f78d3f8250f873ffd7c7e677b4821bb727ec7018dc371c1ad383ba7496a830 + imports_resolved_ast: 3c9c891ac05f50563e42053bfe191262c3f65e025cc8c315e0b76b8835d5b408 + canonicalized_ast: 3c9c891ac05f50563e42053bfe191262c3f65e025cc8c315e0b76b8835d5b408 + type_inferenced_ast: 8170fc1e401e30fce6b647acfd3b00657348ec6596544ef94fe8d406a8590dc2 diff --git a/tests/expectations/compiler/compiler/integers/i64/gt.leo.out b/tests/expectations/compiler/compiler/integers/i64/gt.leo.out index 24f40ebe9b..77cc0c266f 100644 --- a/tests/expectations/compiler/compiler/integers/i64/gt.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/gt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: a0404ddcc589b6006a5186d8ed29c981c7b0be8e8ff56c40eb9affee5fe2f2b0 - imports_resolved_ast: a0404ddcc589b6006a5186d8ed29c981c7b0be8e8ff56c40eb9affee5fe2f2b0 - canonicalized_ast: a0404ddcc589b6006a5186d8ed29c981c7b0be8e8ff56c40eb9affee5fe2f2b0 - type_inferenced_ast: 42efeba3e4bb618fcd85360650196171a2e786149c92c5fc9bc5ee3559af3e62 + imports_resolved_ast: 8481ac39b5e108d089928b882391201f7ed5acdcd11fbd2436ce43d92117c478 + canonicalized_ast: 8481ac39b5e108d089928b882391201f7ed5acdcd11fbd2436ce43d92117c478 + type_inferenced_ast: db0cea473b9f30aef4708500b35fc08c1b6ec65aadba35fe32ca56a1196d305d diff --git a/tests/expectations/compiler/compiler/integers/i64/le.leo.out b/tests/expectations/compiler/compiler/integers/i64/le.leo.out index f5635d7292..1789adaf2f 100644 --- a/tests/expectations/compiler/compiler/integers/i64/le.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/le.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 78dbfbb72aaf373d3503564f96a35cd03525c6e39a756c17be39ff732ffd5cf9 - imports_resolved_ast: 78dbfbb72aaf373d3503564f96a35cd03525c6e39a756c17be39ff732ffd5cf9 - canonicalized_ast: 78dbfbb72aaf373d3503564f96a35cd03525c6e39a756c17be39ff732ffd5cf9 - type_inferenced_ast: dd127a982da4220d309a73347d52abb8175d73c45156384aae81e32c99451511 + imports_resolved_ast: 3bb0e33f2365912e155cc3f7ba0fa736695d1dd28430bce3cb87f75ca75b53d6 + canonicalized_ast: 3bb0e33f2365912e155cc3f7ba0fa736695d1dd28430bce3cb87f75ca75b53d6 + type_inferenced_ast: 75830f51a34ad7f3c0852e1f2f61d0fcf2273251c6a599bc78da86a51fc5b972 diff --git a/tests/expectations/compiler/compiler/integers/i64/lt.leo.out b/tests/expectations/compiler/compiler/integers/i64/lt.leo.out index 780f8e3d13..e270637a1c 100644 --- a/tests/expectations/compiler/compiler/integers/i64/lt.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/lt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: db923fdd10ce89e66c72f1db5f8e95e3016dd8513ee687250b21b7aa5ce4daec - imports_resolved_ast: db923fdd10ce89e66c72f1db5f8e95e3016dd8513ee687250b21b7aa5ce4daec - canonicalized_ast: db923fdd10ce89e66c72f1db5f8e95e3016dd8513ee687250b21b7aa5ce4daec - type_inferenced_ast: eaa70c92e2390a74eec47bee46b954cdcc2fca0f441545902759a13b81d3cfe0 + imports_resolved_ast: 9e3a01cb23861ba03cc9d256582ef2386f10fc6c5285ddec060a167136d2d6b6 + canonicalized_ast: 9e3a01cb23861ba03cc9d256582ef2386f10fc6c5285ddec060a167136d2d6b6 + type_inferenced_ast: ff10109f45ba2677875c70d38727a52b5999fc77c1acb0250c5931bb36b05d85 diff --git a/tests/expectations/compiler/compiler/integers/i64/max.leo.out b/tests/expectations/compiler/compiler/integers/i64/max.leo.out index 2302a3b102..db46aad8b1 100644 --- a/tests/expectations/compiler/compiler/integers/i64/max.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/max.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 0703335d2e00880f1443d9c5b5e7b5f5a81ef393a45e6cdfdd4880f090895c52 - imports_resolved_ast: 0703335d2e00880f1443d9c5b5e7b5f5a81ef393a45e6cdfdd4880f090895c52 - canonicalized_ast: 0703335d2e00880f1443d9c5b5e7b5f5a81ef393a45e6cdfdd4880f090895c52 - type_inferenced_ast: b5afbedc3b27ae8576a74efae219f1fe5381f93ef957934e31821f26c950d36f + imports_resolved_ast: 4b17ec0ea3264a7657eaac1dda34974118b0f08d3fe67540251daa83c3884b6e + canonicalized_ast: 4b17ec0ea3264a7657eaac1dda34974118b0f08d3fe67540251daa83c3884b6e + type_inferenced_ast: 9f15bf5b0fabcefbecc9f156d5b6aa4ae078df3f9864c3642766739414f16c1d diff --git a/tests/expectations/compiler/compiler/integers/i64/min.leo.out b/tests/expectations/compiler/compiler/integers/i64/min.leo.out index 4b13c2c9e7..52db6b55f0 100644 --- a/tests/expectations/compiler/compiler/integers/i64/min.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/min.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 5724b0d2d9d2977ddc189b58e5cba10201d51f3c38cc57e77f0d5c53c98656cb - imports_resolved_ast: 5724b0d2d9d2977ddc189b58e5cba10201d51f3c38cc57e77f0d5c53c98656cb - canonicalized_ast: 5724b0d2d9d2977ddc189b58e5cba10201d51f3c38cc57e77f0d5c53c98656cb - type_inferenced_ast: 2495a438e9e13500365e60ebc5dae138a9ac1608e0ccef13a65bbbeb411646c1 + imports_resolved_ast: 3699a6160a58a6c7bd8cbaf18fefa9b1239579439906f24c7da3c89eb3ebec60 + canonicalized_ast: 3699a6160a58a6c7bd8cbaf18fefa9b1239579439906f24c7da3c89eb3ebec60 + type_inferenced_ast: 6e2b904b920af6467f83ca1645476a37514bd35d3a2624f999c4366bf5f61caf diff --git a/tests/expectations/compiler/compiler/integers/i64/mul.leo.out b/tests/expectations/compiler/compiler/integers/i64/mul.leo.out index ee4b5ef6ce..e4e30a663d 100644 --- a/tests/expectations/compiler/compiler/integers/i64/mul.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/mul.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 7d81fb85fdaf9767a4248d83f81f48e91be6e2ce749a4a02f9fe85494154eda8 - imports_resolved_ast: 7d81fb85fdaf9767a4248d83f81f48e91be6e2ce749a4a02f9fe85494154eda8 - canonicalized_ast: 7d81fb85fdaf9767a4248d83f81f48e91be6e2ce749a4a02f9fe85494154eda8 - type_inferenced_ast: 54a87debd3d8471ba6f1afef722be088ac023304fb2c27a2ef39699bf16fe81d + imports_resolved_ast: a024e1f65dae1cfab7b73076d49ac0c2711850448ff3f0fc3277163a4303c799 + canonicalized_ast: a024e1f65dae1cfab7b73076d49ac0c2711850448ff3f0fc3277163a4303c799 + type_inferenced_ast: 7ffa47e6e36b165940bf7c97d4be16cce36e5d5d5489e4c5885ed2780744b5f9 diff --git a/tests/expectations/compiler/compiler/integers/i64/ne.leo.out b/tests/expectations/compiler/compiler/integers/i64/ne.leo.out index 43899bcc08..cc40614908 100644 --- a/tests/expectations/compiler/compiler/integers/i64/ne.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/ne.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: cb56faba44a5f54ab7fc9021e0903b7cdd70d56bbcf97fcfdaf355475a4a2011 - imports_resolved_ast: cb56faba44a5f54ab7fc9021e0903b7cdd70d56bbcf97fcfdaf355475a4a2011 - canonicalized_ast: cb56faba44a5f54ab7fc9021e0903b7cdd70d56bbcf97fcfdaf355475a4a2011 - type_inferenced_ast: ef1112d9d7f63b6addabad7a4cfbb672ef167272ea603b11a92b8b39e468fbb9 + imports_resolved_ast: 80ea29e99c9c3b77a990409b1fc208e83bf0edbb56c5208d57974f524e6fb0a1 + canonicalized_ast: 80ea29e99c9c3b77a990409b1fc208e83bf0edbb56c5208d57974f524e6fb0a1 + type_inferenced_ast: d728febd4c19803b3f698777e86f7ebac7f45749257bf2f396f4916ba4c90e29 diff --git a/tests/expectations/compiler/compiler/integers/i64/negate.leo.out b/tests/expectations/compiler/compiler/integers/i64/negate.leo.out index b36a02f1d4..cc4c0df462 100644 --- a/tests/expectations/compiler/compiler/integers/i64/negate.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/negate.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 4ace760ee44ede5868a0ea11f96f47c596da9772ab3b821be5879782747bb64d - imports_resolved_ast: 4ace760ee44ede5868a0ea11f96f47c596da9772ab3b821be5879782747bb64d - canonicalized_ast: 4ace760ee44ede5868a0ea11f96f47c596da9772ab3b821be5879782747bb64d - type_inferenced_ast: eb5b6e6f6f1c91ef1489e0d686e0ea142762777b4991ee12f235ff73a91742eb + imports_resolved_ast: f811d9b3ab0770758ba1d4ca11cecf57e681a4783dbbc6552493abfe4e959f0c + canonicalized_ast: f811d9b3ab0770758ba1d4ca11cecf57e681a4783dbbc6552493abfe4e959f0c + type_inferenced_ast: 72f5b7fad3ea4e4f630f4279cbf37f8a979fa5ed12e2809ed2174f5e2e1b37fd diff --git a/tests/expectations/compiler/compiler/integers/i64/negate_min.leo.out b/tests/expectations/compiler/compiler/integers/i64/negate_min.leo.out index a9ef61f2b6..723ded142c 100644 --- a/tests/expectations/compiler/compiler/integers/i64/negate_min.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/negate_min.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 96d8371bf9102e40d6c297ad0e042d91b9bab58212d3ace9fa0811d3be54eec5 - imports_resolved_ast: 96d8371bf9102e40d6c297ad0e042d91b9bab58212d3ace9fa0811d3be54eec5 - canonicalized_ast: 96d8371bf9102e40d6c297ad0e042d91b9bab58212d3ace9fa0811d3be54eec5 - type_inferenced_ast: 1b6005dedf0bdb85dc9d50b0435bdfa1b9d34d75f516a2383890882ad3bf3b08 + imports_resolved_ast: 95e39c1445b2399599454a0b736aa544f48780cd3ed1a494cfdc67da5e6ae3be + canonicalized_ast: 95e39c1445b2399599454a0b736aa544f48780cd3ed1a494cfdc67da5e6ae3be + type_inferenced_ast: 452020beee994b043880a79db5676144f16125ccf91047777fbde083c15deeb2 diff --git a/tests/expectations/compiler/compiler/integers/i64/negate_zero.leo.out b/tests/expectations/compiler/compiler/integers/i64/negate_zero.leo.out index 680da0f38f..bfb61308ae 100644 --- a/tests/expectations/compiler/compiler/integers/i64/negate_zero.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/negate_zero.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: d5df39c563c640844bfd7a3fd95b53c107f66a8ce0adb7154084aad9cc42a623 - imports_resolved_ast: d5df39c563c640844bfd7a3fd95b53c107f66a8ce0adb7154084aad9cc42a623 - canonicalized_ast: d5df39c563c640844bfd7a3fd95b53c107f66a8ce0adb7154084aad9cc42a623 - type_inferenced_ast: 928fe3ff4063f147fe708ef5301279b7434b5f1708f1f59a9d14f28001aaad7d + imports_resolved_ast: d66e34ad082c6355010fe99c06423c0a330dde030e48f82444272791cd97b19a + canonicalized_ast: d66e34ad082c6355010fe99c06423c0a330dde030e48f82444272791cd97b19a + type_inferenced_ast: 70381492571ec9206da029a9ca9623ff77d30c9721867143017d7f16f1a3f8f7 diff --git a/tests/expectations/compiler/compiler/integers/i64/sub.leo.out b/tests/expectations/compiler/compiler/integers/i64/sub.leo.out index f5f50da10e..8717570add 100644 --- a/tests/expectations/compiler/compiler/integers/i64/sub.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/sub.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 0918267d4d883608bdb8b1c178450077f0931539dc573d3829e37f24176a88f5 - imports_resolved_ast: 0918267d4d883608bdb8b1c178450077f0931539dc573d3829e37f24176a88f5 - canonicalized_ast: 0918267d4d883608bdb8b1c178450077f0931539dc573d3829e37f24176a88f5 - type_inferenced_ast: f2d7b1656ffb683dbb9ec39f37938cc188186aa708fef560b75523f0863886b8 + imports_resolved_ast: 79551858f58ceb2bac2dd42be9cb3eee0efb208bbf2d3a03e70e17c578bbb294 + canonicalized_ast: 79551858f58ceb2bac2dd42be9cb3eee0efb208bbf2d3a03e70e17c578bbb294 + type_inferenced_ast: 32a0fc32f44cb2df214e32577b61fa7e7d014a6a4176135bc8dcc050e1c39738 diff --git a/tests/expectations/compiler/compiler/integers/i64/ternary.leo.out b/tests/expectations/compiler/compiler/integers/i64/ternary.leo.out index 837cc91d60..5e3e119be2 100644 --- a/tests/expectations/compiler/compiler/integers/i64/ternary.leo.out +++ b/tests/expectations/compiler/compiler/integers/i64/ternary.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: f60c769d564a5a76451d1b347c300f1ff5c0030b412ba5d84559fdd67fe6bb79 - imports_resolved_ast: f60c769d564a5a76451d1b347c300f1ff5c0030b412ba5d84559fdd67fe6bb79 - canonicalized_ast: f60c769d564a5a76451d1b347c300f1ff5c0030b412ba5d84559fdd67fe6bb79 - type_inferenced_ast: d28a4ada3a3c80b09dc1f8be54035ad7a162b5c2cf8f1b7c2eba78f02387d879 + imports_resolved_ast: 0b9603435b90bee4e25b9d6117f7b0545a5730ccbe98b47d78eda34da39c3dd6 + canonicalized_ast: 0b9603435b90bee4e25b9d6117f7b0545a5730ccbe98b47d78eda34da39c3dd6 + type_inferenced_ast: 8f6c76786365fb43dbbe9082ef962e4bc27ef1f49b0b5a67d24cad46bf484537 diff --git a/tests/expectations/compiler/compiler/integers/i8/add.leo.out b/tests/expectations/compiler/compiler/integers/i8/add.leo.out index bb7943cee0..7e339fd61d 100644 --- a/tests/expectations/compiler/compiler/integers/i8/add.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/add.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 7507e4dd7081d148a851507da3d728d435ef2919517e01732a06014e32769efd - imports_resolved_ast: 7507e4dd7081d148a851507da3d728d435ef2919517e01732a06014e32769efd - canonicalized_ast: 7507e4dd7081d148a851507da3d728d435ef2919517e01732a06014e32769efd - type_inferenced_ast: ce071846a448bd392dbcb7a285c65f235daf29f9b398a8445948e6a261aa8b13 + imports_resolved_ast: 113b10c223e2ff7b2a9c38276485d283eedc7d918cc04b9282f639ad8ce2e548 + canonicalized_ast: 113b10c223e2ff7b2a9c38276485d283eedc7d918cc04b9282f639ad8ce2e548 + type_inferenced_ast: 3bd280a957f719027a0d6b171ce802ff6c75cb5865df27c7fcc4dbc70b458680 diff --git a/tests/expectations/compiler/compiler/integers/i8/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/i8/console_assert.leo.out index f273dc87f6..c1a349bed1 100644 --- a/tests/expectations/compiler/compiler/integers/i8/console_assert.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/console_assert.leo.out @@ -14,6 +14,6 @@ outputs: output: registers: {} initial_ast: 17b1eb126e8cb1e246f071e8ad20a25eee7a8abd80e3681e525439292221632c - imports_resolved_ast: 17b1eb126e8cb1e246f071e8ad20a25eee7a8abd80e3681e525439292221632c - canonicalized_ast: 6db2d0a6b45f27e9e9b8c840e91d602b11922ab7781c5d98634c80ebad314766 - type_inferenced_ast: b2c9bddf865c2f5682da9a10df552b6d6170ca2dcf45839470a745a1fce2ecda + imports_resolved_ast: bfcafd2c41e07efda1719e88c8ed24f0e0c690adecf205380eb8ac804fd7a8c5 + canonicalized_ast: 9416b55880089e8ca46f09154f306e138362340b52dddb8b93f4bd23a6eac906 + type_inferenced_ast: d9c163f4e000f3c96ace5e9147d693b6d843d9aa18f63a35177c7745e9549bd2 diff --git a/tests/expectations/compiler/compiler/integers/i8/div.leo.out b/tests/expectations/compiler/compiler/integers/i8/div.leo.out index 50f03674fa..d167a32466 100644 --- a/tests/expectations/compiler/compiler/integers/i8/div.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/div.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 832849cc580efd35a4f63217783eb380f94620f893f13a64769a01a30f4c1434 - imports_resolved_ast: 832849cc580efd35a4f63217783eb380f94620f893f13a64769a01a30f4c1434 - canonicalized_ast: 832849cc580efd35a4f63217783eb380f94620f893f13a64769a01a30f4c1434 - type_inferenced_ast: a0af076a419008b086212d675a91408ce30ffe05ff21ab32c1968f20b04f29d7 + imports_resolved_ast: 034c1d99818ae4bac33ab69be08f3d1c9fa9de40902ac1f159527915f9285a4c + canonicalized_ast: 034c1d99818ae4bac33ab69be08f3d1c9fa9de40902ac1f159527915f9285a4c + type_inferenced_ast: 3dc85c38ba8f750c1fad69720ff7506de95315ce7c12f5a1e6fbf6dda2008c5e diff --git a/tests/expectations/compiler/compiler/integers/i8/eq.leo.out b/tests/expectations/compiler/compiler/integers/i8/eq.leo.out index 9161c8b17a..49795c05fb 100644 --- a/tests/expectations/compiler/compiler/integers/i8/eq.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/eq.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 00e6ec9c3cffe65504b49e598aee8b7c8c59823f9c1c8954d659c00704f6e12e - imports_resolved_ast: 00e6ec9c3cffe65504b49e598aee8b7c8c59823f9c1c8954d659c00704f6e12e - canonicalized_ast: 00e6ec9c3cffe65504b49e598aee8b7c8c59823f9c1c8954d659c00704f6e12e - type_inferenced_ast: 8d64e2540f69eb74fe27f35f221c854a71b5fdfcc1364a54c45ce742bbec9a20 + imports_resolved_ast: 8b2be7a396ba9b718ac3684238353b0789dd99520dad0c8b0fc190eeb1ce726a + canonicalized_ast: 8b2be7a396ba9b718ac3684238353b0789dd99520dad0c8b0fc190eeb1ce726a + type_inferenced_ast: d97cc460e3e1c2b0d1f17cec944b0a62e1b0721965493383c20c21753ee6abd7 diff --git a/tests/expectations/compiler/compiler/integers/i8/ge.leo.out b/tests/expectations/compiler/compiler/integers/i8/ge.leo.out index 1d340dcd00..e1f2fe96a6 100644 --- a/tests/expectations/compiler/compiler/integers/i8/ge.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/ge.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 1e21bb732ec541ff7a980ab309747c26b105354577ff211f1dd7712f059232f5 - imports_resolved_ast: 1e21bb732ec541ff7a980ab309747c26b105354577ff211f1dd7712f059232f5 - canonicalized_ast: 1e21bb732ec541ff7a980ab309747c26b105354577ff211f1dd7712f059232f5 - type_inferenced_ast: 9cd5f4bc30be5e47771f86af4a03f7731a408abca3451e8edbd1791f20c7b54e + imports_resolved_ast: e1ef79f70d8a879ec1a82ed1f802e843123addccc285cbf95920a05abd185480 + canonicalized_ast: e1ef79f70d8a879ec1a82ed1f802e843123addccc285cbf95920a05abd185480 + type_inferenced_ast: a3aa4d8ebb1a05a1ff1e739028c3e3874009f8fdb3feb83e0619feeb446ec454 diff --git a/tests/expectations/compiler/compiler/integers/i8/gt.leo.out b/tests/expectations/compiler/compiler/integers/i8/gt.leo.out index b18fcf2599..483043fe33 100644 --- a/tests/expectations/compiler/compiler/integers/i8/gt.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/gt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 7108a8fe50fbe2b7386ef743b0627f75a4c282821f10e76713672f94830d2cbb - imports_resolved_ast: 7108a8fe50fbe2b7386ef743b0627f75a4c282821f10e76713672f94830d2cbb - canonicalized_ast: 7108a8fe50fbe2b7386ef743b0627f75a4c282821f10e76713672f94830d2cbb - type_inferenced_ast: 7a23bf5cda0089bdb57387dd291bf63a93f77f83748f0d8f90ebf6c32e458c95 + imports_resolved_ast: 33819cc0cd1e81648c11aa85771c59f3f304915470b36f707672966b55258db5 + canonicalized_ast: 33819cc0cd1e81648c11aa85771c59f3f304915470b36f707672966b55258db5 + type_inferenced_ast: 9ea4f6d4a8416079b0a9c9b45e5e46bddf7d0101706c93095b34ba2beb927311 diff --git a/tests/expectations/compiler/compiler/integers/i8/le.leo.out b/tests/expectations/compiler/compiler/integers/i8/le.leo.out index 966c759f5d..9666bbff30 100644 --- a/tests/expectations/compiler/compiler/integers/i8/le.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/le.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 40f8e855fce1d652c99ceb24edaacbe328ae159382b1ce13170c63669f4301e3 - imports_resolved_ast: 40f8e855fce1d652c99ceb24edaacbe328ae159382b1ce13170c63669f4301e3 - canonicalized_ast: 40f8e855fce1d652c99ceb24edaacbe328ae159382b1ce13170c63669f4301e3 - type_inferenced_ast: 66d57cbb8408f594263277a42765cc12fcdc97db2fbc322191df5a39ab2f7040 + imports_resolved_ast: 44e74bf8c65fa9a978929f24ca5dead1aed64bddd1e7913b26b6cf87c5b0840b + canonicalized_ast: 44e74bf8c65fa9a978929f24ca5dead1aed64bddd1e7913b26b6cf87c5b0840b + type_inferenced_ast: efaa8028aecf94706bbf27675c9bd670363e1558e808188ddcfdc854f1fdfdcc diff --git a/tests/expectations/compiler/compiler/integers/i8/lt.leo.out b/tests/expectations/compiler/compiler/integers/i8/lt.leo.out index fdd7e21c80..910caa7267 100644 --- a/tests/expectations/compiler/compiler/integers/i8/lt.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/lt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: df68f7c978cd30eff24891875fe147f6e24ce56b328d7207814ddeb5ada6bf13 - imports_resolved_ast: df68f7c978cd30eff24891875fe147f6e24ce56b328d7207814ddeb5ada6bf13 - canonicalized_ast: df68f7c978cd30eff24891875fe147f6e24ce56b328d7207814ddeb5ada6bf13 - type_inferenced_ast: 23714958eb385969480b522715c5c0c5007bdad644282aab21e07b1aab965d30 + imports_resolved_ast: 86228f42194074809ce3dbb0b32c8f5db7b32a59a3efffa755f9b30e784b026a + canonicalized_ast: 86228f42194074809ce3dbb0b32c8f5db7b32a59a3efffa755f9b30e784b026a + type_inferenced_ast: 2a5c0f7fc12f4b6403947d595071f848a96907c1104207665dc8a3ed12b66c3f diff --git a/tests/expectations/compiler/compiler/integers/i8/max.leo.out b/tests/expectations/compiler/compiler/integers/i8/max.leo.out index 901d82a33c..6415c7f46b 100644 --- a/tests/expectations/compiler/compiler/integers/i8/max.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/max.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: af42ac6f8eb44ea7890e558b2d50b67db5ab53e74022c6426aa7a63edfdf43ec - imports_resolved_ast: af42ac6f8eb44ea7890e558b2d50b67db5ab53e74022c6426aa7a63edfdf43ec - canonicalized_ast: af42ac6f8eb44ea7890e558b2d50b67db5ab53e74022c6426aa7a63edfdf43ec - type_inferenced_ast: 715450b67c109631ecef7e45c8ecaae33433daec07148953c070b97b856dbf2d + imports_resolved_ast: 1b4601ec8d1366547e782c1377d0fc332cbf191ef01a6a4ae82db191bca76518 + canonicalized_ast: 1b4601ec8d1366547e782c1377d0fc332cbf191ef01a6a4ae82db191bca76518 + type_inferenced_ast: 2ed6e54403038925953e9ec3461112a7f395a45cbcab1ae8df2ecf96f1c15e51 diff --git a/tests/expectations/compiler/compiler/integers/i8/min.leo.out b/tests/expectations/compiler/compiler/integers/i8/min.leo.out index 94ed4491b4..59d9aa7763 100644 --- a/tests/expectations/compiler/compiler/integers/i8/min.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/min.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 42725429d83957372ca63c97764550141db3f8851616a33460e68ad212df74ce - imports_resolved_ast: 42725429d83957372ca63c97764550141db3f8851616a33460e68ad212df74ce - canonicalized_ast: 42725429d83957372ca63c97764550141db3f8851616a33460e68ad212df74ce - type_inferenced_ast: 4e4799716883d22d1e491cf20f30104174d54c64176130dcc0fb6519a08b936d + imports_resolved_ast: 194a7f23ad267fd00cdd5f430f0452497186cd38edc393e9ad6d65403fbce043 + canonicalized_ast: 194a7f23ad267fd00cdd5f430f0452497186cd38edc393e9ad6d65403fbce043 + type_inferenced_ast: 108460bf99474670a3426bcb45b91067fbb765384fdd6fe7e5303fed734b6057 diff --git a/tests/expectations/compiler/compiler/integers/i8/mul.leo.out b/tests/expectations/compiler/compiler/integers/i8/mul.leo.out index 4c0d20d093..2bc51dbe07 100644 --- a/tests/expectations/compiler/compiler/integers/i8/mul.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/mul.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: c7ea692c1c4c5b5adf571bbaf8350017c123dc7de9a130d1d3c6d92065f76b30 - imports_resolved_ast: c7ea692c1c4c5b5adf571bbaf8350017c123dc7de9a130d1d3c6d92065f76b30 - canonicalized_ast: c7ea692c1c4c5b5adf571bbaf8350017c123dc7de9a130d1d3c6d92065f76b30 - type_inferenced_ast: 9324477964c91456cad1ef2d1531eeeb0a8a67d85b7cf4a0e5e59bd86beb2a86 + imports_resolved_ast: d22aa17a6b51be52827761cc1595e4874bd9b8c592a013c0806a79bf544ada6d + canonicalized_ast: d22aa17a6b51be52827761cc1595e4874bd9b8c592a013c0806a79bf544ada6d + type_inferenced_ast: 0149bd56c5b4bc1930e8e86a3895fd6e22a28e51afc90db13e3a55780c8ede32 diff --git a/tests/expectations/compiler/compiler/integers/i8/ne.leo.out b/tests/expectations/compiler/compiler/integers/i8/ne.leo.out index ca9eafb5c2..6822cff88e 100644 --- a/tests/expectations/compiler/compiler/integers/i8/ne.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/ne.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 727d71a97c85ff472274e9c77d09017023aa4a01ae55f5ef4cd1f34d493e10f0 - imports_resolved_ast: 727d71a97c85ff472274e9c77d09017023aa4a01ae55f5ef4cd1f34d493e10f0 - canonicalized_ast: 727d71a97c85ff472274e9c77d09017023aa4a01ae55f5ef4cd1f34d493e10f0 - type_inferenced_ast: a620d767d5f718c1bd7adb7acadc46b8fa4870d05d4b7f131ac717e3b4b825f6 + imports_resolved_ast: 771144872ca7de7a6f6a09f9ea315850fca31acf08841a513b1dae9840a3eb15 + canonicalized_ast: 771144872ca7de7a6f6a09f9ea315850fca31acf08841a513b1dae9840a3eb15 + type_inferenced_ast: 1f1ae7679c70a442495a16e7625f17ac4d8bf0e79d9c989efaa5889378026e76 diff --git a/tests/expectations/compiler/compiler/integers/i8/negate.leo.out b/tests/expectations/compiler/compiler/integers/i8/negate.leo.out index f8ba9ade14..b5fd61b6e6 100644 --- a/tests/expectations/compiler/compiler/integers/i8/negate.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/negate.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 048dee046e9726b86bc863821709b9b1b9a5f54afdce25a6bd46bd5fbb6307a2 - imports_resolved_ast: 048dee046e9726b86bc863821709b9b1b9a5f54afdce25a6bd46bd5fbb6307a2 - canonicalized_ast: 048dee046e9726b86bc863821709b9b1b9a5f54afdce25a6bd46bd5fbb6307a2 - type_inferenced_ast: 75838a90ef9995dc6562f4a017a4bb4fcbd455a6d1a9401db836e5844c22aea3 + imports_resolved_ast: 479caf0a90f5f4687195d469b8ae3f3366e9e775cb4c18b4c9f968ffe2fde9cb + canonicalized_ast: 479caf0a90f5f4687195d469b8ae3f3366e9e775cb4c18b4c9f968ffe2fde9cb + type_inferenced_ast: 5189b3808c5a7be409db8b79e9ba0f009ab025702e31ad84f3744f7b529ca2ab diff --git a/tests/expectations/compiler/compiler/integers/i8/negate_zero.leo.out b/tests/expectations/compiler/compiler/integers/i8/negate_zero.leo.out index c9aca1e50a..e703717e3d 100644 --- a/tests/expectations/compiler/compiler/integers/i8/negate_zero.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/negate_zero.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: f4eb2af96d56786f773843ae4a471cc27884a1d2427c4995b4303635d2341a3a - imports_resolved_ast: f4eb2af96d56786f773843ae4a471cc27884a1d2427c4995b4303635d2341a3a - canonicalized_ast: f4eb2af96d56786f773843ae4a471cc27884a1d2427c4995b4303635d2341a3a - type_inferenced_ast: 55a75c5ff5da70a4312ac3cdc1579f754ad578570160cafd05c67c1049344b3a + imports_resolved_ast: f25b796068c0559e10bde45c766198f4c635c651dfb11d327dff3d89324110b7 + canonicalized_ast: f25b796068c0559e10bde45c766198f4c635c651dfb11d327dff3d89324110b7 + type_inferenced_ast: 174eae348ece2a53b9c0086278d8b62aef72afb05e3c3d1dc23b6221fbf39162 diff --git a/tests/expectations/compiler/compiler/integers/i8/sub.leo.out b/tests/expectations/compiler/compiler/integers/i8/sub.leo.out index 44189647b2..aa052bd808 100644 --- a/tests/expectations/compiler/compiler/integers/i8/sub.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/sub.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 2c5edc8449cb6cce29bb2a02b8e3c346ab6cfd7df9cae0a00ee243999586e1a3 - imports_resolved_ast: 2c5edc8449cb6cce29bb2a02b8e3c346ab6cfd7df9cae0a00ee243999586e1a3 - canonicalized_ast: 2c5edc8449cb6cce29bb2a02b8e3c346ab6cfd7df9cae0a00ee243999586e1a3 - type_inferenced_ast: c39c0bb54e8aad9f3b59c59d2437bfcb776d26dde9c8382bae06caf1902d92ae + imports_resolved_ast: 22c606755117452cbd3714b3d39596d2d15ca81824e0940dbd27b21c6b90a907 + canonicalized_ast: 22c606755117452cbd3714b3d39596d2d15ca81824e0940dbd27b21c6b90a907 + type_inferenced_ast: ff9403de4b069eac3aac597a68b767317f8b482f0d1b3693522326a3c37d34ed diff --git a/tests/expectations/compiler/compiler/integers/i8/ternary.leo.out b/tests/expectations/compiler/compiler/integers/i8/ternary.leo.out index 41fd97e1fa..708d1e6cfe 100644 --- a/tests/expectations/compiler/compiler/integers/i8/ternary.leo.out +++ b/tests/expectations/compiler/compiler/integers/i8/ternary.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 5b3ece3765ccc07057987288af24aa37205ddf5fc38146057f6a2f042d52e2ff - imports_resolved_ast: 5b3ece3765ccc07057987288af24aa37205ddf5fc38146057f6a2f042d52e2ff - canonicalized_ast: 5b3ece3765ccc07057987288af24aa37205ddf5fc38146057f6a2f042d52e2ff - type_inferenced_ast: ed6896d5e12795fbf9705edb4ff13a68fff3d920aa01cb40b73c25b9c6e36663 + imports_resolved_ast: 786aeb5f47c8ff1ef3cd0d3aee98bddc0b9ca51d022c5879aed8a0e2bcedb7ca + canonicalized_ast: 786aeb5f47c8ff1ef3cd0d3aee98bddc0b9ca51d022c5879aed8a0e2bcedb7ca + type_inferenced_ast: 1271f1a140fda69bebb67dcae04db81d25b4b67326b64a4e24f54078831a7364 diff --git a/tests/expectations/compiler/compiler/integers/u128/add.leo.out b/tests/expectations/compiler/compiler/integers/u128/add.leo.out index 8c558529ab..a2faa76b0e 100644 --- a/tests/expectations/compiler/compiler/integers/u128/add.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/add.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: ba86672003228d42172ddb6064b6c18793cd2b10368476457a5765d72da968bb - imports_resolved_ast: ba86672003228d42172ddb6064b6c18793cd2b10368476457a5765d72da968bb - canonicalized_ast: ba86672003228d42172ddb6064b6c18793cd2b10368476457a5765d72da968bb - type_inferenced_ast: 90f8e8d95d0489fe8412b8b011c96cc3297fed62522f35dda922ffe5bc8e5eb7 + imports_resolved_ast: 946a6ef0432999154ec4fc39e85e8733c0962fbfbb8458a8e21e4ded8c8f1920 + canonicalized_ast: 946a6ef0432999154ec4fc39e85e8733c0962fbfbb8458a8e21e4ded8c8f1920 + type_inferenced_ast: 52a096d33fde918f8e4a59fdbfc6f55cee6880ba3a505be0f5945c815ed5578d diff --git a/tests/expectations/compiler/compiler/integers/u128/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u128/console_assert.leo.out index 2c938e0941..3427390bde 100644 --- a/tests/expectations/compiler/compiler/integers/u128/console_assert.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/console_assert.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: ad919602ee4b538d6500101020bef0d5eab3f0737c717eeb26a4eb223b20ec2e - imports_resolved_ast: ad919602ee4b538d6500101020bef0d5eab3f0737c717eeb26a4eb223b20ec2e - canonicalized_ast: ad919602ee4b538d6500101020bef0d5eab3f0737c717eeb26a4eb223b20ec2e - type_inferenced_ast: 7ddb15730afe53d6cfd7831572139ec4d846fa9f02bdae1955352b002c4bb2eb + imports_resolved_ast: 8416a92ceb696eed6774f6aa305a883c48ab39affb6a4cbd0a3f0c472566691f + canonicalized_ast: 8416a92ceb696eed6774f6aa305a883c48ab39affb6a4cbd0a3f0c472566691f + type_inferenced_ast: 0558e05aa6ab62880940dd58fce4917789ce6a0bb3f6267ed7fe02763b8142b8 diff --git a/tests/expectations/compiler/compiler/integers/u128/div.leo.out b/tests/expectations/compiler/compiler/integers/u128/div.leo.out index a628da7ba8..85ef547d18 100644 --- a/tests/expectations/compiler/compiler/integers/u128/div.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/div.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 2f1e3590db8fd98beb8eec3b15e51932dc50f6acccca4d89a04d9e4e45719a93 - imports_resolved_ast: 2f1e3590db8fd98beb8eec3b15e51932dc50f6acccca4d89a04d9e4e45719a93 - canonicalized_ast: 2f1e3590db8fd98beb8eec3b15e51932dc50f6acccca4d89a04d9e4e45719a93 - type_inferenced_ast: f7edc6e2efd7b862eafc38618b8d86ec92e270fbab2cf2f568b8f2e5feecc28a + imports_resolved_ast: 2e50e6eeda6db2bd075a0f4bdbf6f2a4d32cc9994d45c317adc066cddbcd5ef1 + canonicalized_ast: 2e50e6eeda6db2bd075a0f4bdbf6f2a4d32cc9994d45c317adc066cddbcd5ef1 + type_inferenced_ast: c4414eb061d334bdc476cf53e020b76f0c4c71b611cf0d1ba831374536c51900 diff --git a/tests/expectations/compiler/compiler/integers/u128/eq.leo.out b/tests/expectations/compiler/compiler/integers/u128/eq.leo.out index fb7f3e8e90..25762657e5 100644 --- a/tests/expectations/compiler/compiler/integers/u128/eq.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/eq.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: be16e6c68a47140cb65dfd6fa6ae2084799092b353a4d7bbbbe6ea3cba689c48 - imports_resolved_ast: be16e6c68a47140cb65dfd6fa6ae2084799092b353a4d7bbbbe6ea3cba689c48 - canonicalized_ast: be16e6c68a47140cb65dfd6fa6ae2084799092b353a4d7bbbbe6ea3cba689c48 - type_inferenced_ast: 70dabec56f6de97872802c0b63e48dc68b921c7bba5e526ee16f443973c1c35d + imports_resolved_ast: 3f7e36260cfd9f4986d5a8a293282298bc22b72dbbf7a2ee98194a1207e6f4ca + canonicalized_ast: 3f7e36260cfd9f4986d5a8a293282298bc22b72dbbf7a2ee98194a1207e6f4ca + type_inferenced_ast: cf0ff3c8441d6eb98ba0d681c2935bae922c1fd231de61f9c68044227ea6940c diff --git a/tests/expectations/compiler/compiler/integers/u128/ge.leo.out b/tests/expectations/compiler/compiler/integers/u128/ge.leo.out index e76870ad68..6a033327d5 100644 --- a/tests/expectations/compiler/compiler/integers/u128/ge.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/ge.leo.out @@ -29,6 +29,6 @@ outputs: type: bool value: "true" initial_ast: caca64001b0311d16373bfa5ce2f040cf054551675f664bd93f68b8a381ccc0b - imports_resolved_ast: caca64001b0311d16373bfa5ce2f040cf054551675f664bd93f68b8a381ccc0b - canonicalized_ast: caca64001b0311d16373bfa5ce2f040cf054551675f664bd93f68b8a381ccc0b - type_inferenced_ast: ad84a0f1e55ece76d7989d24b048f59e40af35918495fb0c7d9a023b810645d0 + imports_resolved_ast: 8f3427f71ec28d8779681c91a836bb98f25d1b1817d87e3323d6ff63aa812490 + canonicalized_ast: 8f3427f71ec28d8779681c91a836bb98f25d1b1817d87e3323d6ff63aa812490 + type_inferenced_ast: f08450221d582a9b387cd4b1aaa3a13bf3b224b107b785b53ff7d2f64f89ca29 diff --git a/tests/expectations/compiler/compiler/integers/u128/gt.leo.out b/tests/expectations/compiler/compiler/integers/u128/gt.leo.out index 9219d787db..a357a165ad 100644 --- a/tests/expectations/compiler/compiler/integers/u128/gt.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/gt.leo.out @@ -17,6 +17,6 @@ outputs: output: registers: {} initial_ast: 820ed988d142189cd95bfc559ded7f9de3a1327338e47844a7a2200d79af56a9 - imports_resolved_ast: 820ed988d142189cd95bfc559ded7f9de3a1327338e47844a7a2200d79af56a9 - canonicalized_ast: 3392a949832c1db83f1280df3ca8c03a4fbc0645a31325a055b63c9e44d50cdd - type_inferenced_ast: 5561d2a1ae0ff0c81d9cf1f4b9daf4ab75897efb06e87e8904492919f0d9f7f2 + imports_resolved_ast: 4d7a916897bdba849b0e3bfe03497cc99ad2c778c994203e1a70e8eab25075dd + canonicalized_ast: eeae2a030d01c1d9a381fd0149a54149179fc8ffe988bc27923f112946a1d405 + type_inferenced_ast: 1a33df8eab7752848d387f356ed22a3c5d2e9babd0d918a347e1c06a5b1fe5c8 diff --git a/tests/expectations/compiler/compiler/integers/u128/input.leo.out b/tests/expectations/compiler/compiler/integers/u128/input.leo.out index 2cf493020d..f1c6390a16 100644 --- a/tests/expectations/compiler/compiler/integers/u128/input.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/input.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 725037d892c3a0d37394849bb896f53665de6bfb21ecbf07ca498c58a50febac - imports_resolved_ast: 725037d892c3a0d37394849bb896f53665de6bfb21ecbf07ca498c58a50febac - canonicalized_ast: 725037d892c3a0d37394849bb896f53665de6bfb21ecbf07ca498c58a50febac - type_inferenced_ast: 792c1e73125395e09c23e92e715b83a86bbcc337f5bca3a6a7a4ae6719e85143 + imports_resolved_ast: e9b61f2c889c6ef2815ba214625818811eabf562bc9fab3c54758f8264716314 + canonicalized_ast: e9b61f2c889c6ef2815ba214625818811eabf562bc9fab3c54758f8264716314 + type_inferenced_ast: 55ee3c1e820b2e6d6e406dcbb4e235c188624108f22425c06f5ec7c169b9ab0f diff --git a/tests/expectations/compiler/compiler/integers/u128/le.leo.out b/tests/expectations/compiler/compiler/integers/u128/le.leo.out index 42c486ba6e..dd43621060 100644 --- a/tests/expectations/compiler/compiler/integers/u128/le.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/le.leo.out @@ -29,6 +29,6 @@ outputs: type: bool value: "false" initial_ast: a2c1fd53a31ef6621356b270a00943ccdae328cd449fafa6c9e23d59ba32be17 - imports_resolved_ast: a2c1fd53a31ef6621356b270a00943ccdae328cd449fafa6c9e23d59ba32be17 - canonicalized_ast: a2c1fd53a31ef6621356b270a00943ccdae328cd449fafa6c9e23d59ba32be17 - type_inferenced_ast: bf6dab074ed66340481a8690067e8272bd202f9d6eeb4c53102a4114051e5117 + imports_resolved_ast: ba8ae7609671c407fd6c3a2726809747e89f9b1089d8c6ae8bc28d6ead75c0be + canonicalized_ast: ba8ae7609671c407fd6c3a2726809747e89f9b1089d8c6ae8bc28d6ead75c0be + type_inferenced_ast: e5584b0a297b40afc46056dc261d9d8fd339755dd4b666d75fdb635f29f2c5b2 diff --git a/tests/expectations/compiler/compiler/integers/u128/lt.leo.out b/tests/expectations/compiler/compiler/integers/u128/lt.leo.out index f6780a1416..665e71b6a8 100644 --- a/tests/expectations/compiler/compiler/integers/u128/lt.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/lt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "false" initial_ast: 5c1e4693b718191aa0f3071ec02509a38ff2a8017ce0641ff0142f2bfa7da96a - imports_resolved_ast: 5c1e4693b718191aa0f3071ec02509a38ff2a8017ce0641ff0142f2bfa7da96a - canonicalized_ast: 5c1e4693b718191aa0f3071ec02509a38ff2a8017ce0641ff0142f2bfa7da96a - type_inferenced_ast: 6453c5fa284e2b06dbe031d7411f2d59388c75d4f3f18d2b48c4df5f91c7d870 + imports_resolved_ast: ec0c51d163a38e193ab6e8a6fbf7beb09580709a21aea23f1b329c1f4ac464db + canonicalized_ast: ec0c51d163a38e193ab6e8a6fbf7beb09580709a21aea23f1b329c1f4ac464db + type_inferenced_ast: ab70897139dc8152aef9efebf16b8b30963bad6f8fc473e6178b6f763f335bca diff --git a/tests/expectations/compiler/compiler/integers/u128/max.leo.out b/tests/expectations/compiler/compiler/integers/u128/max.leo.out index 0380abce37..545fb135fa 100644 --- a/tests/expectations/compiler/compiler/integers/u128/max.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/max.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: c0f6616cbef7676909cabcc405f75fefd1807abdacbe00d81069f7ba074372d5 - imports_resolved_ast: c0f6616cbef7676909cabcc405f75fefd1807abdacbe00d81069f7ba074372d5 - canonicalized_ast: c0f6616cbef7676909cabcc405f75fefd1807abdacbe00d81069f7ba074372d5 - type_inferenced_ast: 6d956778ffaa3453c3af36f0d8b84fc62aff73c71f5a685421b2a310fc036121 + imports_resolved_ast: fd2e9e815cff52446295f7145f2b1657da02cf2fba53cdb6aa11eb20077854f7 + canonicalized_ast: fd2e9e815cff52446295f7145f2b1657da02cf2fba53cdb6aa11eb20077854f7 + type_inferenced_ast: e07b3520fbef3d996b2e97899aca69a25dfbdba5b89e5f095a201d0eff30b100 diff --git a/tests/expectations/compiler/compiler/integers/u128/min.leo.out b/tests/expectations/compiler/compiler/integers/u128/min.leo.out index ec563dd1bb..c84f001a72 100644 --- a/tests/expectations/compiler/compiler/integers/u128/min.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/min.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 9151781352023ac8d55f9c28b1c00ebd782f0ebdc9fc0d431eacc82abdc895c1 - imports_resolved_ast: 9151781352023ac8d55f9c28b1c00ebd782f0ebdc9fc0d431eacc82abdc895c1 - canonicalized_ast: 9151781352023ac8d55f9c28b1c00ebd782f0ebdc9fc0d431eacc82abdc895c1 - type_inferenced_ast: 037701324af5adc4f453a37faef5c91eee6aabd37e3aa3c612203c41e4602b66 + imports_resolved_ast: 3eca1c21dc3444acddf9bd66e909c0c63686bf352f570523508b0e405eef9e17 + canonicalized_ast: 3eca1c21dc3444acddf9bd66e909c0c63686bf352f570523508b0e405eef9e17 + type_inferenced_ast: 8af2bb91884ae294978fdbe30080254236d35fe7abbe0a461c0485d112a129b6 diff --git a/tests/expectations/compiler/compiler/integers/u128/mul.leo.out b/tests/expectations/compiler/compiler/integers/u128/mul.leo.out index d063a3ddf7..d1ef3ab376 100644 --- a/tests/expectations/compiler/compiler/integers/u128/mul.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/mul.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "false" initial_ast: 9bacdd7f562607e16f88a6cc64a6093fd09e678f8a09d485edb6e1e9cffb90e4 - imports_resolved_ast: 9bacdd7f562607e16f88a6cc64a6093fd09e678f8a09d485edb6e1e9cffb90e4 - canonicalized_ast: 9bacdd7f562607e16f88a6cc64a6093fd09e678f8a09d485edb6e1e9cffb90e4 - type_inferenced_ast: 2fb1d8964dccf7acfc38e37cf41d859c30e19b052470ed54923b944fe8ec9b15 + imports_resolved_ast: 30258b459d72179394b1f1093a098329891b329021faf7b026cf3ed171ead67a + canonicalized_ast: 30258b459d72179394b1f1093a098329891b329021faf7b026cf3ed171ead67a + type_inferenced_ast: 25b78de4f4ffe215ce53a8ee4c82456bf9e4496d4b74d7da8a7859d02cbe3882 diff --git a/tests/expectations/compiler/compiler/integers/u128/ne.leo.out b/tests/expectations/compiler/compiler/integers/u128/ne.leo.out index 507b010140..dd8891d976 100644 --- a/tests/expectations/compiler/compiler/integers/u128/ne.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/ne.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 6796d9b74beb8daf62ccd75c5a5bcb5942d00742e35e558dcd49e4accf571458 - imports_resolved_ast: 6796d9b74beb8daf62ccd75c5a5bcb5942d00742e35e558dcd49e4accf571458 - canonicalized_ast: 6796d9b74beb8daf62ccd75c5a5bcb5942d00742e35e558dcd49e4accf571458 - type_inferenced_ast: 1a122fec3c383117b7241a98a77518aa07fc495bf5724a721439e3d2c561b770 + imports_resolved_ast: 6aa861e16a499ddf0beb36908728900faa7b0fb36e6ca5cebbc3365f83a97f09 + canonicalized_ast: 6aa861e16a499ddf0beb36908728900faa7b0fb36e6ca5cebbc3365f83a97f09 + type_inferenced_ast: da6f5de5db6fb49d72357ac1487ce0e92dd33e2dfbd54ad25c06569c4575e4b7 diff --git a/tests/expectations/compiler/compiler/integers/u128/sub.leo.out b/tests/expectations/compiler/compiler/integers/u128/sub.leo.out index e120fc8c02..a726945f0a 100644 --- a/tests/expectations/compiler/compiler/integers/u128/sub.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/sub.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 22b1398c07fa127567d547dec76a9db42d17dfbfd3c381fd9b597e6d54ebe520 - imports_resolved_ast: 22b1398c07fa127567d547dec76a9db42d17dfbfd3c381fd9b597e6d54ebe520 - canonicalized_ast: 22b1398c07fa127567d547dec76a9db42d17dfbfd3c381fd9b597e6d54ebe520 - type_inferenced_ast: 9378705614f9bb993d720e7ab3b9ad2bb6f9566c355ad8e6efdc35ed804ed1f9 + imports_resolved_ast: f4c8a2ac8b174fb61e1db065c93a86640fceb6a31c8756c4b7beb7579c10cab9 + canonicalized_ast: f4c8a2ac8b174fb61e1db065c93a86640fceb6a31c8756c4b7beb7579c10cab9 + type_inferenced_ast: d15c3f234f20c90c6c15c8c43df6e99d8dbdbd6163d9662c8c6f7aba1886cbfa diff --git a/tests/expectations/compiler/compiler/integers/u128/ternary.leo.out b/tests/expectations/compiler/compiler/integers/u128/ternary.leo.out index b82d2a83e7..dc6a303d05 100644 --- a/tests/expectations/compiler/compiler/integers/u128/ternary.leo.out +++ b/tests/expectations/compiler/compiler/integers/u128/ternary.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: d8edd41c3446a777f3d2b0b033cee9135477ebee6a559854906789ac31db6a9a - imports_resolved_ast: d8edd41c3446a777f3d2b0b033cee9135477ebee6a559854906789ac31db6a9a - canonicalized_ast: d8edd41c3446a777f3d2b0b033cee9135477ebee6a559854906789ac31db6a9a - type_inferenced_ast: 0a750c50386c174281af10df1a1ab346b11fa42554a4378fa03b4846afd960b6 + imports_resolved_ast: b78199cdcb7922fc1143b1cc3c097f495cd902e276ccfa57e83532ce589d5a41 + canonicalized_ast: b78199cdcb7922fc1143b1cc3c097f495cd902e276ccfa57e83532ce589d5a41 + type_inferenced_ast: eab68c0de7654144ad389e725eed94b502445e5132a1d004ae5212b3c20f96f4 diff --git a/tests/expectations/compiler/compiler/integers/u16/add.leo.out b/tests/expectations/compiler/compiler/integers/u16/add.leo.out index 31bc564fcf..03811134db 100644 --- a/tests/expectations/compiler/compiler/integers/u16/add.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/add.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: eb6419bbaed4c761e2c76e927f773367006508a4721ea1c70cd633fe47976545 - imports_resolved_ast: eb6419bbaed4c761e2c76e927f773367006508a4721ea1c70cd633fe47976545 - canonicalized_ast: eb6419bbaed4c761e2c76e927f773367006508a4721ea1c70cd633fe47976545 - type_inferenced_ast: 4da352adef1ef9a4d872afa8c0a563d66058c4b5f2c7ae6e1d6e76f9d0e6f828 + imports_resolved_ast: 80c5d0bf97794bcf5f1ffaa34e33ac695727a9ad7bc3a691e41c09c533c13c58 + canonicalized_ast: 80c5d0bf97794bcf5f1ffaa34e33ac695727a9ad7bc3a691e41c09c533c13c58 + type_inferenced_ast: b01641beb5cd609dc434cb3aed4fde45b53c1be10cb44450fd473da9158bc5a1 diff --git a/tests/expectations/compiler/compiler/integers/u16/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u16/console_assert.leo.out index 11f505cb32..6eae511b30 100644 --- a/tests/expectations/compiler/compiler/integers/u16/console_assert.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/console_assert.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: d530ffa650127824ba18491674144411e798de3f154c8cf6a2a7972739df7512 - imports_resolved_ast: d530ffa650127824ba18491674144411e798de3f154c8cf6a2a7972739df7512 - canonicalized_ast: d530ffa650127824ba18491674144411e798de3f154c8cf6a2a7972739df7512 - type_inferenced_ast: d5482fa8b8ade8232890a04bc9d29c9bf9f02a4dc9d49cfbe5595836a0fdabfc + imports_resolved_ast: bb6e0c9cce1f770ef2449d9bb84b92342d767eb328b20cf387dcfa4fb30b0f24 + canonicalized_ast: bb6e0c9cce1f770ef2449d9bb84b92342d767eb328b20cf387dcfa4fb30b0f24 + type_inferenced_ast: f8f027c3222f0440861550306249c0f7442f28b749588fa8c7d33b3aabae7c40 diff --git a/tests/expectations/compiler/compiler/integers/u16/div.leo.out b/tests/expectations/compiler/compiler/integers/u16/div.leo.out index 3fc719f817..adcd0b91f1 100644 --- a/tests/expectations/compiler/compiler/integers/u16/div.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/div.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 41193e8e4d4bb9d346c56a0a2630ccc9c46003d3a72a215945c74af3aede4606 - imports_resolved_ast: 41193e8e4d4bb9d346c56a0a2630ccc9c46003d3a72a215945c74af3aede4606 - canonicalized_ast: 41193e8e4d4bb9d346c56a0a2630ccc9c46003d3a72a215945c74af3aede4606 - type_inferenced_ast: 9aa867a159c530813bd8a1805fb093a208edcaf48466be37b18c311cc3590782 + imports_resolved_ast: aed91399fe283a65754f627a84788994391d8d707133bfc126dcf1de40d45190 + canonicalized_ast: aed91399fe283a65754f627a84788994391d8d707133bfc126dcf1de40d45190 + type_inferenced_ast: 22f6e58ee63388fd7cdb7d37ca5f7b428ebe303b52fd70d78cf7ccddba3157fe diff --git a/tests/expectations/compiler/compiler/integers/u16/eq.leo.out b/tests/expectations/compiler/compiler/integers/u16/eq.leo.out index 4e75571070..c99cb0bbd8 100644 --- a/tests/expectations/compiler/compiler/integers/u16/eq.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/eq.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: b45f803365a72727350696859672c162fa18a9b2b97b3c155a03cb1bf74f9e68 - imports_resolved_ast: b45f803365a72727350696859672c162fa18a9b2b97b3c155a03cb1bf74f9e68 - canonicalized_ast: b45f803365a72727350696859672c162fa18a9b2b97b3c155a03cb1bf74f9e68 - type_inferenced_ast: d34a794b0695b41198003b21773b5abd4b4aa044de22a346301158aabb005d8e + imports_resolved_ast: 32ff59bffcf37e84c3282299c6c9c6f232abe8b1c0cac4989ec7f9d3bb7ab173 + canonicalized_ast: 32ff59bffcf37e84c3282299c6c9c6f232abe8b1c0cac4989ec7f9d3bb7ab173 + type_inferenced_ast: 05313f64cd3c58bb92301a923f842bd18f4a7178f2e53a07965af81f99a2149f diff --git a/tests/expectations/compiler/compiler/integers/u16/ge.leo.out b/tests/expectations/compiler/compiler/integers/u16/ge.leo.out index a72469e83e..a8f116a2bc 100644 --- a/tests/expectations/compiler/compiler/integers/u16/ge.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/ge.leo.out @@ -29,6 +29,6 @@ outputs: type: bool value: "true" initial_ast: 05e8b0ca21ae27026fec7897079a23f522be4ecca74009c42a7d820dbf3b37dc - imports_resolved_ast: 05e8b0ca21ae27026fec7897079a23f522be4ecca74009c42a7d820dbf3b37dc - canonicalized_ast: 05e8b0ca21ae27026fec7897079a23f522be4ecca74009c42a7d820dbf3b37dc - type_inferenced_ast: f79fa9920321f18c258cdbe99fcd37b7de5ebd943bdf1a6091954c9c8501c4c0 + imports_resolved_ast: d9fd5b0db40502a53fe0ee9844d400c05bc36f6f41ea4a2187903383dfd657a9 + canonicalized_ast: d9fd5b0db40502a53fe0ee9844d400c05bc36f6f41ea4a2187903383dfd657a9 + type_inferenced_ast: 167ba888b2b25c775089f2309d2e9acb282af74148a0dd93a16c6b985d4af7a9 diff --git a/tests/expectations/compiler/compiler/integers/u16/gt.leo.out b/tests/expectations/compiler/compiler/integers/u16/gt.leo.out index 3effd84987..5d999f2209 100644 --- a/tests/expectations/compiler/compiler/integers/u16/gt.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/gt.leo.out @@ -17,6 +17,6 @@ outputs: output: registers: {} initial_ast: 07aa194712e885c67e73bd8ce425b09aa0b11a0597fd28e2b6b861c2890a7dbf - imports_resolved_ast: 07aa194712e885c67e73bd8ce425b09aa0b11a0597fd28e2b6b861c2890a7dbf - canonicalized_ast: 585b9eb84b4794b44a491f3a20919aa03b1defb10b34ff0c1ccaf16943c95498 - type_inferenced_ast: f58d2c30292c5b7066145cc1f9f103c347c69bcfd103f68a11870d436d93034c + imports_resolved_ast: 231524382ea49aaeaf23500d8a69077e9887112149376aaf109db5564be5795d + canonicalized_ast: eaf322b01507a005c104038484ae66e335c9b18c5c92048f3ea2a56eef1f25b7 + type_inferenced_ast: 783f9b1a4ef87fe2a9b6843f6b8ed749e364290779815c4a20d0c6f585e55962 diff --git a/tests/expectations/compiler/compiler/integers/u16/input.leo.out b/tests/expectations/compiler/compiler/integers/u16/input.leo.out index bb56c37ebc..53bc4379a5 100644 --- a/tests/expectations/compiler/compiler/integers/u16/input.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/input.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: ce84d1a90125776ce0b144842cfdc4722338fc48bddbf027a6684704f02e71c5 - imports_resolved_ast: ce84d1a90125776ce0b144842cfdc4722338fc48bddbf027a6684704f02e71c5 - canonicalized_ast: ce84d1a90125776ce0b144842cfdc4722338fc48bddbf027a6684704f02e71c5 - type_inferenced_ast: 4f28676ebd5a0be24690d37c2625b5f5080a5ae41368bff213d41b96377d9ee0 + imports_resolved_ast: b0b83232439c16bcc77309b48ec02825eecfe47e2d925e09fb7de7c2e5110aa4 + canonicalized_ast: b0b83232439c16bcc77309b48ec02825eecfe47e2d925e09fb7de7c2e5110aa4 + type_inferenced_ast: 022dd794eb58a06772e363e12d792b8967529b26979d513a5d3704731f28a733 diff --git a/tests/expectations/compiler/compiler/integers/u16/le.leo.out b/tests/expectations/compiler/compiler/integers/u16/le.leo.out index 765ed6181f..7713c17af3 100644 --- a/tests/expectations/compiler/compiler/integers/u16/le.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/le.leo.out @@ -29,6 +29,6 @@ outputs: type: bool value: "false" initial_ast: 4cec9681367670442f9db73b42d312321bff0f30aeec0160b5c25c3e2dd33829 - imports_resolved_ast: 4cec9681367670442f9db73b42d312321bff0f30aeec0160b5c25c3e2dd33829 - canonicalized_ast: 4cec9681367670442f9db73b42d312321bff0f30aeec0160b5c25c3e2dd33829 - type_inferenced_ast: 7cd703e68f80f112a3d93757cb906045e316616c15f781773028a4d1b4793551 + imports_resolved_ast: e7b1a1fe56f64018f6820a3ac3a65bb5d7c2196a6bcabcc87ee30feb41f01918 + canonicalized_ast: e7b1a1fe56f64018f6820a3ac3a65bb5d7c2196a6bcabcc87ee30feb41f01918 + type_inferenced_ast: 859c94a23b75ca29b4f01ad52c541276b9825fd7669381732ef700159d958a73 diff --git a/tests/expectations/compiler/compiler/integers/u16/lt.leo.out b/tests/expectations/compiler/compiler/integers/u16/lt.leo.out index 851f22fa65..e163002134 100644 --- a/tests/expectations/compiler/compiler/integers/u16/lt.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/lt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "false" initial_ast: 68a12590c757f5286e98808d5a22bb707166828f74d4b89716553328b57867f3 - imports_resolved_ast: 68a12590c757f5286e98808d5a22bb707166828f74d4b89716553328b57867f3 - canonicalized_ast: 68a12590c757f5286e98808d5a22bb707166828f74d4b89716553328b57867f3 - type_inferenced_ast: d1c19b097acf638840cadcbc81cc6e51fc750c2c49b84bcf36abc467d36e51f4 + imports_resolved_ast: f7f3479de41371d2de02acda4eff9bde1789302a3a342c6f9315e29e2b7d71f0 + canonicalized_ast: f7f3479de41371d2de02acda4eff9bde1789302a3a342c6f9315e29e2b7d71f0 + type_inferenced_ast: c90bab105e8873852710b045f01c6f8d0283c56d71c1e3743adfd0e74025117e diff --git a/tests/expectations/compiler/compiler/integers/u16/max.leo.out b/tests/expectations/compiler/compiler/integers/u16/max.leo.out index f9c3c2d5b2..b4153c4507 100644 --- a/tests/expectations/compiler/compiler/integers/u16/max.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/max.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 6a13120d649e7db047df9453464a4a88965409a39257b56ad8466f397ab61217 - imports_resolved_ast: 6a13120d649e7db047df9453464a4a88965409a39257b56ad8466f397ab61217 - canonicalized_ast: 6a13120d649e7db047df9453464a4a88965409a39257b56ad8466f397ab61217 - type_inferenced_ast: a08685b22ab2a58652759e3657a8246bd65e23d18fe895a0987e3567926eddc2 + imports_resolved_ast: 145f372d29967f8ba3bdf4a2798e1961321b6ef03869ff10b920a6180ad9e66d + canonicalized_ast: 145f372d29967f8ba3bdf4a2798e1961321b6ef03869ff10b920a6180ad9e66d + type_inferenced_ast: 9482673a2500d779dd0bf1411b78b867235099085fc04f3c1fffbfc744969580 diff --git a/tests/expectations/compiler/compiler/integers/u16/min.leo.out b/tests/expectations/compiler/compiler/integers/u16/min.leo.out index a5a6aadb9d..cf12313ecd 100644 --- a/tests/expectations/compiler/compiler/integers/u16/min.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/min.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 10bca9f23d35f0a354948dafb069860d71618205c9e0efb483c465c5794ee83a - imports_resolved_ast: 10bca9f23d35f0a354948dafb069860d71618205c9e0efb483c465c5794ee83a - canonicalized_ast: 10bca9f23d35f0a354948dafb069860d71618205c9e0efb483c465c5794ee83a - type_inferenced_ast: b7673715a9b643f97ea30652defed51f23f6ba79ae9ef39c81d25fd7d3bb815e + imports_resolved_ast: 48d646cdc0a2393649893e1e673ef5b4925dc7bccd95d2d10bdc65b8d2e36e32 + canonicalized_ast: 48d646cdc0a2393649893e1e673ef5b4925dc7bccd95d2d10bdc65b8d2e36e32 + type_inferenced_ast: f64f6b651047f075f0bcae6911b4c4de64f27d4f8f6a917573c1a5e057f209d9 diff --git a/tests/expectations/compiler/compiler/integers/u16/mul.leo.out b/tests/expectations/compiler/compiler/integers/u16/mul.leo.out index b84d167f1d..8a22c94d6a 100644 --- a/tests/expectations/compiler/compiler/integers/u16/mul.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/mul.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "false" initial_ast: 9b02c262401b83f83f76f3dd22aceaa0bdb1bdd196faf68bdd71e4105bd3b143 - imports_resolved_ast: 9b02c262401b83f83f76f3dd22aceaa0bdb1bdd196faf68bdd71e4105bd3b143 - canonicalized_ast: 9b02c262401b83f83f76f3dd22aceaa0bdb1bdd196faf68bdd71e4105bd3b143 - type_inferenced_ast: b5b3e21e917355dbbb35d62ee33a1f565b592dee2c62e4a56eb7521ea168c7d7 + imports_resolved_ast: fbba6c14d268f7901bc8f71ab178a1cf2c396b3a0611653f6c9e2dc4bb77062c + canonicalized_ast: fbba6c14d268f7901bc8f71ab178a1cf2c396b3a0611653f6c9e2dc4bb77062c + type_inferenced_ast: 163d3f129c9d0c496f7cd032491329d685074a7ae6b19f3214d87b5809041a09 diff --git a/tests/expectations/compiler/compiler/integers/u16/ne.leo.out b/tests/expectations/compiler/compiler/integers/u16/ne.leo.out index 978b1e07e8..1c7bd990e1 100644 --- a/tests/expectations/compiler/compiler/integers/u16/ne.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/ne.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 30ee8bc862393f3ffec75051160d88c703e24711dc4a742369fd824485792a44 - imports_resolved_ast: 30ee8bc862393f3ffec75051160d88c703e24711dc4a742369fd824485792a44 - canonicalized_ast: 30ee8bc862393f3ffec75051160d88c703e24711dc4a742369fd824485792a44 - type_inferenced_ast: e0f90d2b1c766550e9d7fe202705709a93771f8fce9debf3c119d0f1bf2ff19e + imports_resolved_ast: df454450e9790832370fc3821dfa95587b0bbd5dc3c9324725bd231ef0ee8e54 + canonicalized_ast: df454450e9790832370fc3821dfa95587b0bbd5dc3c9324725bd231ef0ee8e54 + type_inferenced_ast: 0447c4d788e1385fbc40f3b9804e0a5c14f620b481033b05b3f4476fdcc4fca4 diff --git a/tests/expectations/compiler/compiler/integers/u16/sub.leo.out b/tests/expectations/compiler/compiler/integers/u16/sub.leo.out index c330ad2612..05c1ceeb1a 100644 --- a/tests/expectations/compiler/compiler/integers/u16/sub.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/sub.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 63558d4f64eb9c248b6391254bc279f1ae53c08602a35e86b73d8876ae5cbff7 - imports_resolved_ast: 63558d4f64eb9c248b6391254bc279f1ae53c08602a35e86b73d8876ae5cbff7 - canonicalized_ast: 63558d4f64eb9c248b6391254bc279f1ae53c08602a35e86b73d8876ae5cbff7 - type_inferenced_ast: f272cb2627650262ddfa289e945abddb91525bb8899c8d4d7853d9e5a398aa56 + imports_resolved_ast: 35894271a6b2f0131bb2458c80aaa72e1ef35bde02a43831f0651d6048ee4d4d + canonicalized_ast: 35894271a6b2f0131bb2458c80aaa72e1ef35bde02a43831f0651d6048ee4d4d + type_inferenced_ast: 5e0efa1870c3e46a3d069155c4343eb6b69c19ab362d4ab58fe126e46947f11b diff --git a/tests/expectations/compiler/compiler/integers/u16/ternary.leo.out b/tests/expectations/compiler/compiler/integers/u16/ternary.leo.out index 31197445ef..ec9a968697 100644 --- a/tests/expectations/compiler/compiler/integers/u16/ternary.leo.out +++ b/tests/expectations/compiler/compiler/integers/u16/ternary.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: a5453842c01ff883e970a8acbc0c0164e21ab8ee9667e7d198fd02b44e4cdf56 - imports_resolved_ast: a5453842c01ff883e970a8acbc0c0164e21ab8ee9667e7d198fd02b44e4cdf56 - canonicalized_ast: a5453842c01ff883e970a8acbc0c0164e21ab8ee9667e7d198fd02b44e4cdf56 - type_inferenced_ast: 486a1e2a5f9e3eb3704f6ea039a832bfdad7a436464140933e978cee5dd42466 + imports_resolved_ast: fcf0718ddca8c05d480683801360bd6547c79b507f3690c30db82553d0834b41 + canonicalized_ast: fcf0718ddca8c05d480683801360bd6547c79b507f3690c30db82553d0834b41 + type_inferenced_ast: a3748be05f02375157d3085cbb0bbf7abafc1d01752fd611ebabf954d9fe8078 diff --git a/tests/expectations/compiler/compiler/integers/u32/add.leo.out b/tests/expectations/compiler/compiler/integers/u32/add.leo.out index e4810ab1e5..db86ee7046 100644 --- a/tests/expectations/compiler/compiler/integers/u32/add.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/add.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 3ca20068a4f2cc3ce017686240c82a7320f94700e9068448d7bbcaa6c8d11afd - imports_resolved_ast: 3ca20068a4f2cc3ce017686240c82a7320f94700e9068448d7bbcaa6c8d11afd - canonicalized_ast: 3ca20068a4f2cc3ce017686240c82a7320f94700e9068448d7bbcaa6c8d11afd - type_inferenced_ast: 6f31cebf6905062ec9c55324ee499173987eb04820414eeda3a6696a9a4df4e5 + imports_resolved_ast: c4b1f62a56deb3d1be76e79f0261394d0107ffcb5370243f7ffc2d797d0571cc + canonicalized_ast: c4b1f62a56deb3d1be76e79f0261394d0107ffcb5370243f7ffc2d797d0571cc + type_inferenced_ast: 06e4de5dd68cd7468b9f10a5cb01cc44c0bc012fa6d4d0bca21a71e308567422 diff --git a/tests/expectations/compiler/compiler/integers/u32/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u32/console_assert.leo.out index 3990b9d39e..8ff160f541 100644 --- a/tests/expectations/compiler/compiler/integers/u32/console_assert.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/console_assert.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 00f676e0063c85f5caa851dd5e1e9061cbdf79c85da857d6e5d89d42cda9651b - imports_resolved_ast: 00f676e0063c85f5caa851dd5e1e9061cbdf79c85da857d6e5d89d42cda9651b - canonicalized_ast: 00f676e0063c85f5caa851dd5e1e9061cbdf79c85da857d6e5d89d42cda9651b - type_inferenced_ast: 20a848a26a90c695b25384daf05ebc98716ec0951992087dfc4370e15920b805 + imports_resolved_ast: 51faa8d5130c20071d467c82a7fcdd821c5c43f38aec283a7b97ff15b47a8a13 + canonicalized_ast: 51faa8d5130c20071d467c82a7fcdd821c5c43f38aec283a7b97ff15b47a8a13 + type_inferenced_ast: 31ab0616252704d4a6819da1b2afe513a0c4ba015187c553a9466c5f584fb330 diff --git a/tests/expectations/compiler/compiler/integers/u32/div.leo.out b/tests/expectations/compiler/compiler/integers/u32/div.leo.out index ec1450b695..4c32a183bb 100644 --- a/tests/expectations/compiler/compiler/integers/u32/div.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/div.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 3edfc10e7ea7c05f9f42f2f22b673431820a526c5c6bd0729d98c48ba3c8e8aa - imports_resolved_ast: 3edfc10e7ea7c05f9f42f2f22b673431820a526c5c6bd0729d98c48ba3c8e8aa - canonicalized_ast: 3edfc10e7ea7c05f9f42f2f22b673431820a526c5c6bd0729d98c48ba3c8e8aa - type_inferenced_ast: 90e585dbd2a3e0d8d2d9bec6aeb443d2d3276826e18f3ce39e7cc0b4b9edad8a + imports_resolved_ast: 6837eecf5a580e3b18826c4100c016cb97263a2bca88366761098526b757e930 + canonicalized_ast: 6837eecf5a580e3b18826c4100c016cb97263a2bca88366761098526b757e930 + type_inferenced_ast: 88db4bf05f614ac6451ff6f60d16f4f6681870d30290115b1577529bc162193b diff --git a/tests/expectations/compiler/compiler/integers/u32/eq.leo.out b/tests/expectations/compiler/compiler/integers/u32/eq.leo.out index 34082bd47f..fac5b41eca 100644 --- a/tests/expectations/compiler/compiler/integers/u32/eq.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/eq.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 0064b1991c2086b76844f10afc932e912382ca46ce87a491fa698112c647da7b - imports_resolved_ast: 0064b1991c2086b76844f10afc932e912382ca46ce87a491fa698112c647da7b - canonicalized_ast: 0064b1991c2086b76844f10afc932e912382ca46ce87a491fa698112c647da7b - type_inferenced_ast: e3aa9184fea93463cfc41a487e3cc59a9dd21846d201926424bf94eb0bd1ec04 + imports_resolved_ast: 85980b8020a8bc5ab31b151926d4902a92f35f494ba3c34b753d0bf3940e313a + canonicalized_ast: 85980b8020a8bc5ab31b151926d4902a92f35f494ba3c34b753d0bf3940e313a + type_inferenced_ast: 2cbb907d3580cfddc2f45d52652cc4b2e20bbea7d3ea81b2f02d774318f985fa diff --git a/tests/expectations/compiler/compiler/integers/u32/ge.leo.out b/tests/expectations/compiler/compiler/integers/u32/ge.leo.out index 6a162f8cfe..d0293884e4 100644 --- a/tests/expectations/compiler/compiler/integers/u32/ge.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/ge.leo.out @@ -29,6 +29,6 @@ outputs: type: bool value: "true" initial_ast: 5cf54eb75aca0534ecdcebdfcd29487598ac2bfbff4ccd94e1f8372cc66647f2 - imports_resolved_ast: 5cf54eb75aca0534ecdcebdfcd29487598ac2bfbff4ccd94e1f8372cc66647f2 - canonicalized_ast: 5cf54eb75aca0534ecdcebdfcd29487598ac2bfbff4ccd94e1f8372cc66647f2 - type_inferenced_ast: fb2ff53ccf82f2b41a3c9db523623d42b49beca8a2cf2ed50743bd17c748a75c + imports_resolved_ast: 5b4fd0084f1efae6887dfe83479bcd9ab84fd9c73f1efb911213f0d0690929ce + canonicalized_ast: 5b4fd0084f1efae6887dfe83479bcd9ab84fd9c73f1efb911213f0d0690929ce + type_inferenced_ast: b75784f579e9cd480841d8d89d83767515131c3690d0b26be79bd34ea90b585c diff --git a/tests/expectations/compiler/compiler/integers/u32/gt.leo.out b/tests/expectations/compiler/compiler/integers/u32/gt.leo.out index 5c1b7b51ca..a72c2061fc 100644 --- a/tests/expectations/compiler/compiler/integers/u32/gt.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/gt.leo.out @@ -17,6 +17,6 @@ outputs: output: registers: {} initial_ast: ce24730aad7178331b88c496a8acbb95da355169193369d49801fc9eac092371 - imports_resolved_ast: ce24730aad7178331b88c496a8acbb95da355169193369d49801fc9eac092371 - canonicalized_ast: 21cd67ad1094e56f7cbcc6bc839d9b20c25e8d15e2017d64c4672da2233385e4 - type_inferenced_ast: 532bef95e9c6d5432f89a08f207e25e30b61b862f7a1fd225603cb89f0b203b5 + imports_resolved_ast: 913244c5c27e5f4c9396372e32494804ddec51ff2e275b0796a0e946a06d900f + canonicalized_ast: 36b952bdc320a561c964b36e289ff53196ce4275b5074eed292e395b0f03cf4a + type_inferenced_ast: 07e721e8f19c97c03b7ec06e03dac3853859793ef790a2f9ad32c3088b9f7933 diff --git a/tests/expectations/compiler/compiler/integers/u32/input.leo.out b/tests/expectations/compiler/compiler/integers/u32/input.leo.out index f2190b9b36..d672025ae2 100644 --- a/tests/expectations/compiler/compiler/integers/u32/input.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/input.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: b6d84a8bb303dcb914251907999a4c4747f2f1ba76547f9b6bf42cf964b8c173 - imports_resolved_ast: b6d84a8bb303dcb914251907999a4c4747f2f1ba76547f9b6bf42cf964b8c173 - canonicalized_ast: b6d84a8bb303dcb914251907999a4c4747f2f1ba76547f9b6bf42cf964b8c173 - type_inferenced_ast: 20de2c6d503d1dd20412d2f689fc34a0965994743221604b2e83dfb62ea1b76c + imports_resolved_ast: 018611e813467a905e40f5612d525c3d68cdb1840fa8e4380e93d207474be856 + canonicalized_ast: 018611e813467a905e40f5612d525c3d68cdb1840fa8e4380e93d207474be856 + type_inferenced_ast: 3c52dbe6d602db5102c0aa6ff929eead4ac843b35d4e2aeab81095cce55a0f7d diff --git a/tests/expectations/compiler/compiler/integers/u32/le.leo.out b/tests/expectations/compiler/compiler/integers/u32/le.leo.out index d54beb1abb..620e31fe6e 100644 --- a/tests/expectations/compiler/compiler/integers/u32/le.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/le.leo.out @@ -29,6 +29,6 @@ outputs: type: bool value: "false" initial_ast: 609c549354bf45d203924554785e66eaa4506fc72cab880da747d87be55fb687 - imports_resolved_ast: 609c549354bf45d203924554785e66eaa4506fc72cab880da747d87be55fb687 - canonicalized_ast: 609c549354bf45d203924554785e66eaa4506fc72cab880da747d87be55fb687 - type_inferenced_ast: deba08692c955e042da5d13a1209eb8fc84398362e51d95c8866b18332034706 + imports_resolved_ast: 9839f82b1bc7252dbf627f6ac661a773eb97a368205038f7c0b7ad8a88008e44 + canonicalized_ast: 9839f82b1bc7252dbf627f6ac661a773eb97a368205038f7c0b7ad8a88008e44 + type_inferenced_ast: 1d51b13ead1787e327d2b1b9194e3df761c86f3db122bbe67f4322549d43e714 diff --git a/tests/expectations/compiler/compiler/integers/u32/lt.leo.out b/tests/expectations/compiler/compiler/integers/u32/lt.leo.out index 14201458e4..81ff031046 100644 --- a/tests/expectations/compiler/compiler/integers/u32/lt.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/lt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "false" initial_ast: 62a00f0678c643a199718696e42d0acb438f78f1cf5c6dbcd4ecb45b7a8a7100 - imports_resolved_ast: 62a00f0678c643a199718696e42d0acb438f78f1cf5c6dbcd4ecb45b7a8a7100 - canonicalized_ast: 62a00f0678c643a199718696e42d0acb438f78f1cf5c6dbcd4ecb45b7a8a7100 - type_inferenced_ast: eb21e43b5fb6fd7fe7b7fe35af69df697aa5fc8ca94325a0b6f957c55828b46e + imports_resolved_ast: f5f1cb94ee66d416b40275d14ba7b1424725d7f98b3ac2165d30ff96a81d0571 + canonicalized_ast: f5f1cb94ee66d416b40275d14ba7b1424725d7f98b3ac2165d30ff96a81d0571 + type_inferenced_ast: 029904bd5c69e633c1484fe3a2169db5b9397203c9e93f9907848ec00d52d38b diff --git a/tests/expectations/compiler/compiler/integers/u32/max.leo.out b/tests/expectations/compiler/compiler/integers/u32/max.leo.out index 6894c507e7..c6973cedb8 100644 --- a/tests/expectations/compiler/compiler/integers/u32/max.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/max.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: e39345598cb3fb70a83082c7996f36d8c30ba9414fe7f6b9cc982bba85ec0a6a - imports_resolved_ast: e39345598cb3fb70a83082c7996f36d8c30ba9414fe7f6b9cc982bba85ec0a6a - canonicalized_ast: e39345598cb3fb70a83082c7996f36d8c30ba9414fe7f6b9cc982bba85ec0a6a - type_inferenced_ast: bca1eb2f17887930dfabe774271b8455b15536e4f835deb9961e1668ad405c3c + imports_resolved_ast: 803a54f589a31020f3da1606b713bf486d9ce6463aa6551cc7b1b937b1d4be47 + canonicalized_ast: 803a54f589a31020f3da1606b713bf486d9ce6463aa6551cc7b1b937b1d4be47 + type_inferenced_ast: ee5fcd372b734566b98ef9663488947b761ec5d9418202cf833482d2c8ecb9c2 diff --git a/tests/expectations/compiler/compiler/integers/u32/min.leo.out b/tests/expectations/compiler/compiler/integers/u32/min.leo.out index ced1a702ef..6a7c7dd58c 100644 --- a/tests/expectations/compiler/compiler/integers/u32/min.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/min.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 9ca4ca8404f1fc0d16a652b741f3e57d3483d8cdb05304a58f6b1ee3580886c1 - imports_resolved_ast: 9ca4ca8404f1fc0d16a652b741f3e57d3483d8cdb05304a58f6b1ee3580886c1 - canonicalized_ast: 9ca4ca8404f1fc0d16a652b741f3e57d3483d8cdb05304a58f6b1ee3580886c1 - type_inferenced_ast: 156bc2c711d9666d42cff2bb99582ff06ad6a13a49ee529a59242e729d71f7dc + imports_resolved_ast: bb8a3ddeb9f0017a7414ca3b4dba0856345b8edc8ab5890610ab28885b4546b8 + canonicalized_ast: bb8a3ddeb9f0017a7414ca3b4dba0856345b8edc8ab5890610ab28885b4546b8 + type_inferenced_ast: 180ff8d56e6a27667e1689219d608c51b1323708cd82cd1cb7f58747a1fa82bf diff --git a/tests/expectations/compiler/compiler/integers/u32/mul.leo.out b/tests/expectations/compiler/compiler/integers/u32/mul.leo.out index cf8fdc3da5..78a73bfa05 100644 --- a/tests/expectations/compiler/compiler/integers/u32/mul.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/mul.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "false" initial_ast: 64377d0d7fdebe1312a8b11a1e0e45b2664cbf51042de5ffddfd56a1b2c49c35 - imports_resolved_ast: 64377d0d7fdebe1312a8b11a1e0e45b2664cbf51042de5ffddfd56a1b2c49c35 - canonicalized_ast: 64377d0d7fdebe1312a8b11a1e0e45b2664cbf51042de5ffddfd56a1b2c49c35 - type_inferenced_ast: 4e218b33b3b57390e30f068e49f5ed008626b4ebb22615fdd29929bf36ec2ed0 + imports_resolved_ast: 221323ce758c52be8d7c1ccfc29c31b02c0df414025b260f0bbdb42ae9076909 + canonicalized_ast: 221323ce758c52be8d7c1ccfc29c31b02c0df414025b260f0bbdb42ae9076909 + type_inferenced_ast: 68e2a4efc5333132aeecc03f6afb27b8fef0fbba3ec31721bce3d228a4f14959 diff --git a/tests/expectations/compiler/compiler/integers/u32/ne.leo.out b/tests/expectations/compiler/compiler/integers/u32/ne.leo.out index 730c529f30..0fdf9ce01c 100644 --- a/tests/expectations/compiler/compiler/integers/u32/ne.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/ne.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 0857646d1f6fdb13fc94c7fea7f0d91fcb1fdccb4841661a170b00c3091f5691 - imports_resolved_ast: 0857646d1f6fdb13fc94c7fea7f0d91fcb1fdccb4841661a170b00c3091f5691 - canonicalized_ast: 0857646d1f6fdb13fc94c7fea7f0d91fcb1fdccb4841661a170b00c3091f5691 - type_inferenced_ast: 85905a294e0eea013e6f7c4fe93858e935258f5001d1bb6aa082325ec90df1fe + imports_resolved_ast: e022c4dfb03022d9c7856aeb730b357ec24c40410e707e9765c6857342a4dc5c + canonicalized_ast: e022c4dfb03022d9c7856aeb730b357ec24c40410e707e9765c6857342a4dc5c + type_inferenced_ast: efebfa7711b0a67b8ddd5df5b643e56e2e6357c85db514a84623ece5c2658e11 diff --git a/tests/expectations/compiler/compiler/integers/u32/sub.leo.out b/tests/expectations/compiler/compiler/integers/u32/sub.leo.out index 9a4a91c185..72e139fb57 100644 --- a/tests/expectations/compiler/compiler/integers/u32/sub.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/sub.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 5ad8be6dc638e835e2f7b4e9dd26f9ae282dbe59d9853db13ce09f38d3e43b1f - imports_resolved_ast: 5ad8be6dc638e835e2f7b4e9dd26f9ae282dbe59d9853db13ce09f38d3e43b1f - canonicalized_ast: 5ad8be6dc638e835e2f7b4e9dd26f9ae282dbe59d9853db13ce09f38d3e43b1f - type_inferenced_ast: e7b074bd40b37ada9a90999b35fdbcd56886e2f98949a4093ba8c495661a75d1 + imports_resolved_ast: 8e00c2a5a551717794add2a0ead417374b1c1d132d50232b27c70bbb0188a2a2 + canonicalized_ast: 8e00c2a5a551717794add2a0ead417374b1c1d132d50232b27c70bbb0188a2a2 + type_inferenced_ast: e0dd9cbc4255146f6b5e2b99348a480ebcfa361ecf505a50c14c33d663772b20 diff --git a/tests/expectations/compiler/compiler/integers/u32/ternary.leo.out b/tests/expectations/compiler/compiler/integers/u32/ternary.leo.out index b22494cd5e..f23c659d47 100644 --- a/tests/expectations/compiler/compiler/integers/u32/ternary.leo.out +++ b/tests/expectations/compiler/compiler/integers/u32/ternary.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: c5b7d8bd3863f44039ab510def2034acb99362b39a5428e6fc117483353f4afe - imports_resolved_ast: c5b7d8bd3863f44039ab510def2034acb99362b39a5428e6fc117483353f4afe - canonicalized_ast: c5b7d8bd3863f44039ab510def2034acb99362b39a5428e6fc117483353f4afe - type_inferenced_ast: dc3eaf97d5cb489ebffb01f14ba974027562ca17f438301c26167aa3471ddc52 + imports_resolved_ast: 5ab49542a706e7f6089ca3da733ba05998e59092fade09c75dbbd7f4d0852e3c + canonicalized_ast: 5ab49542a706e7f6089ca3da733ba05998e59092fade09c75dbbd7f4d0852e3c + type_inferenced_ast: f0e94fb6b50dde3ef25eabcd9ee152bdf96a1959665cb675b49e613de5f97b83 diff --git a/tests/expectations/compiler/compiler/integers/u64/add.leo.out b/tests/expectations/compiler/compiler/integers/u64/add.leo.out index 788d42dcc1..4f73b948b8 100644 --- a/tests/expectations/compiler/compiler/integers/u64/add.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/add.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 0ef0459ce0ac2ba8a9c2272d6c4f67f7dd9cd7d36c557c65339d2ef8d2c5b187 - imports_resolved_ast: 0ef0459ce0ac2ba8a9c2272d6c4f67f7dd9cd7d36c557c65339d2ef8d2c5b187 - canonicalized_ast: 0ef0459ce0ac2ba8a9c2272d6c4f67f7dd9cd7d36c557c65339d2ef8d2c5b187 - type_inferenced_ast: 248f3c601e2a40da8679d72f7b7316b939d60cf137c4b51cbb45fa17f7707f6e + imports_resolved_ast: 3534faf0bdfd759a3093962c7d27c62c07390474f00007ee4c55f2945bb2ae8e + canonicalized_ast: 3534faf0bdfd759a3093962c7d27c62c07390474f00007ee4c55f2945bb2ae8e + type_inferenced_ast: 736cc1c18f5ef673dc861536160e932921282290159252e910fda1e9a3f46416 diff --git a/tests/expectations/compiler/compiler/integers/u64/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u64/console_assert.leo.out index dc696c5d5e..c7f0011bbf 100644 --- a/tests/expectations/compiler/compiler/integers/u64/console_assert.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/console_assert.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: d2f3122d85fa05ee19f871887e18aa6efabad907605cea1f15450ef959b2879a - imports_resolved_ast: d2f3122d85fa05ee19f871887e18aa6efabad907605cea1f15450ef959b2879a - canonicalized_ast: d2f3122d85fa05ee19f871887e18aa6efabad907605cea1f15450ef959b2879a - type_inferenced_ast: f815e8620acc120dd2d65879e28cb0454628ce35522a1c2ff767fa01035bdf58 + imports_resolved_ast: 15e040ac0071d535448e0018537f3bdcd7348d9bc0b45481a5c04dc4fab06532 + canonicalized_ast: 15e040ac0071d535448e0018537f3bdcd7348d9bc0b45481a5c04dc4fab06532 + type_inferenced_ast: 6a5a77e64b8fd66d31f373b01108961dac1c65e3e0284d4f6f82e82ee2721fd6 diff --git a/tests/expectations/compiler/compiler/integers/u64/div.leo.out b/tests/expectations/compiler/compiler/integers/u64/div.leo.out index 001652407f..1187efa9c7 100644 --- a/tests/expectations/compiler/compiler/integers/u64/div.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/div.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 2fdc5cbc880c5460481529ab25107dd0aca1981e62799cbc2b2493aa09118a48 - imports_resolved_ast: 2fdc5cbc880c5460481529ab25107dd0aca1981e62799cbc2b2493aa09118a48 - canonicalized_ast: 2fdc5cbc880c5460481529ab25107dd0aca1981e62799cbc2b2493aa09118a48 - type_inferenced_ast: 961438f46e01229747be641eee9975d6368894da0e8a6b34339bd6268dd8afa6 + imports_resolved_ast: fbf19ba907f84cbff685a84a9ec45377e8d34431728385a8c987a8d4d67ae6df + canonicalized_ast: fbf19ba907f84cbff685a84a9ec45377e8d34431728385a8c987a8d4d67ae6df + type_inferenced_ast: a2d45ed5eace70ee0ebccffc846c93a9afc89346f717487febfaee65edf00ef3 diff --git a/tests/expectations/compiler/compiler/integers/u64/eq.leo.out b/tests/expectations/compiler/compiler/integers/u64/eq.leo.out index 769418bc71..e6c06944f7 100644 --- a/tests/expectations/compiler/compiler/integers/u64/eq.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/eq.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: ad4f42340cbf53046e609f62504385802398d608ada37e91f60134edf598ba59 - imports_resolved_ast: ad4f42340cbf53046e609f62504385802398d608ada37e91f60134edf598ba59 - canonicalized_ast: ad4f42340cbf53046e609f62504385802398d608ada37e91f60134edf598ba59 - type_inferenced_ast: 4cf9af4071478957995abe43c2e193df18a860eaa82449a0952b732ec7be9a9c + imports_resolved_ast: dd51c09561ceef5515acf4268fb2579e35cf482d923f018736f805c98f9c63d1 + canonicalized_ast: dd51c09561ceef5515acf4268fb2579e35cf482d923f018736f805c98f9c63d1 + type_inferenced_ast: 9b4326effaa7b75aa48879fc8a2cee9a27bd68a49c7275de009870e248dd90cf diff --git a/tests/expectations/compiler/compiler/integers/u64/ge.leo.out b/tests/expectations/compiler/compiler/integers/u64/ge.leo.out index 085d10a1f8..e7e8927769 100644 --- a/tests/expectations/compiler/compiler/integers/u64/ge.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/ge.leo.out @@ -29,6 +29,6 @@ outputs: type: bool value: "true" initial_ast: 98a856a767ee58ea53ec7a6f489d6db69a9e828b76e7b8b26c0222b89b4be3d3 - imports_resolved_ast: 98a856a767ee58ea53ec7a6f489d6db69a9e828b76e7b8b26c0222b89b4be3d3 - canonicalized_ast: 98a856a767ee58ea53ec7a6f489d6db69a9e828b76e7b8b26c0222b89b4be3d3 - type_inferenced_ast: 2d3be362efd6a4a97dc1b06eff92c06facd649dab585f3ad681d5ce49e4e37cf + imports_resolved_ast: e9197c2cd22af82c3499a881f487529d034db5236d355e3c3802a397c446e66a + canonicalized_ast: e9197c2cd22af82c3499a881f487529d034db5236d355e3c3802a397c446e66a + type_inferenced_ast: d623a504288fd0addd6b71f8d89081d3ffec5b2de9b81c0a9ae28f31374b9bfd diff --git a/tests/expectations/compiler/compiler/integers/u64/gt.leo.out b/tests/expectations/compiler/compiler/integers/u64/gt.leo.out index ceb14c1bab..ac3fbe855e 100644 --- a/tests/expectations/compiler/compiler/integers/u64/gt.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/gt.leo.out @@ -17,6 +17,6 @@ outputs: output: registers: {} initial_ast: c667f170b175a4c3991b2df81c0605d3980cab1ae01ae4c66c71f3a311d711c2 - imports_resolved_ast: c667f170b175a4c3991b2df81c0605d3980cab1ae01ae4c66c71f3a311d711c2 - canonicalized_ast: 173da56c6c9a8cd27a1181d9fe1197db4168f4f25129dbd02ef474e5c77c110f - type_inferenced_ast: 4618a65899c633510140b465505d8f767d890f40bc24535513f73d04e187a884 + imports_resolved_ast: 3f746ed132f23f7c3fb5c26de4cd8d61ab2baf8eafd6fb03b1543e1f17550d0b + canonicalized_ast: b557d8d1acd0a85eaa6936ef0efe63e7e431d47361fcd224527bd7d578dc88dd + type_inferenced_ast: 82008ad6ef1b91d42720035b669caab7425eb0351cae306f84f37246ceb4511e diff --git a/tests/expectations/compiler/compiler/integers/u64/input.leo.out b/tests/expectations/compiler/compiler/integers/u64/input.leo.out index ba72baf0a0..20521f3f4f 100644 --- a/tests/expectations/compiler/compiler/integers/u64/input.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/input.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 2f1b1bd0b33a99d4962b01003146df394ef6b0ba913080a4a905ad393ae5ad44 - imports_resolved_ast: 2f1b1bd0b33a99d4962b01003146df394ef6b0ba913080a4a905ad393ae5ad44 - canonicalized_ast: 2f1b1bd0b33a99d4962b01003146df394ef6b0ba913080a4a905ad393ae5ad44 - type_inferenced_ast: 4b97d8527b94d514fa342714f89595dd6384f95d21ead2b6f52ca4141e54b2b4 + imports_resolved_ast: 3ae20e6ac92064504c0a361386457210401869ca53a317b84d489d6b0525af47 + canonicalized_ast: 3ae20e6ac92064504c0a361386457210401869ca53a317b84d489d6b0525af47 + type_inferenced_ast: 4bf4dfe3e46c0febd3556529624837a29da598db7790f70da7fd60dbe299b941 diff --git a/tests/expectations/compiler/compiler/integers/u64/le.leo.out b/tests/expectations/compiler/compiler/integers/u64/le.leo.out index 4404e32632..b6054264c2 100644 --- a/tests/expectations/compiler/compiler/integers/u64/le.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/le.leo.out @@ -29,6 +29,6 @@ outputs: type: bool value: "false" initial_ast: 254f1e1190e4badc566cf6325a2204b54c3862730fd1927f940bed7fc59661ef - imports_resolved_ast: 254f1e1190e4badc566cf6325a2204b54c3862730fd1927f940bed7fc59661ef - canonicalized_ast: 254f1e1190e4badc566cf6325a2204b54c3862730fd1927f940bed7fc59661ef - type_inferenced_ast: d0f1f32a7cfddb8fdeb6d3c8d1dc671e360e6da220cc027d96ba9af05a89c9ee + imports_resolved_ast: 9804b0a2b233fb5c808ba835db7c9c3c84e87a73c14e482eecb4f1eb101ff0db + canonicalized_ast: 9804b0a2b233fb5c808ba835db7c9c3c84e87a73c14e482eecb4f1eb101ff0db + type_inferenced_ast: 49ddaa805a18a60572a36e5271b093f12b8a187c327d9447ad7d0b36bc4b4db8 diff --git a/tests/expectations/compiler/compiler/integers/u64/lt.leo.out b/tests/expectations/compiler/compiler/integers/u64/lt.leo.out index e5858787e1..d294c90d6b 100644 --- a/tests/expectations/compiler/compiler/integers/u64/lt.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/lt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "false" initial_ast: 78e1412b1d5489da7cc5748403694f48facede592b307e53b8ff81c88706aaba - imports_resolved_ast: 78e1412b1d5489da7cc5748403694f48facede592b307e53b8ff81c88706aaba - canonicalized_ast: 78e1412b1d5489da7cc5748403694f48facede592b307e53b8ff81c88706aaba - type_inferenced_ast: de8ae920138c080d121776efa9920dc1b51108aaf7e18e75c61fcd4436bfdbdb + imports_resolved_ast: 4f05ab0f383ee91f38bd53ce2213bc0df97a767cf3439b5d1307cf44b8195abb + canonicalized_ast: 4f05ab0f383ee91f38bd53ce2213bc0df97a767cf3439b5d1307cf44b8195abb + type_inferenced_ast: c151d7c609c8d63464c29a60e815aa796a0e6e91fb2306102d6c0cbd2bec02a7 diff --git a/tests/expectations/compiler/compiler/integers/u64/max.leo.out b/tests/expectations/compiler/compiler/integers/u64/max.leo.out index 2740bb1a85..29df03bc30 100644 --- a/tests/expectations/compiler/compiler/integers/u64/max.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/max.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: b683fad49d2ee3cf8e2c08db1994d40178fd8620ed5b2a1aa84a222a2db4d466 - imports_resolved_ast: b683fad49d2ee3cf8e2c08db1994d40178fd8620ed5b2a1aa84a222a2db4d466 - canonicalized_ast: b683fad49d2ee3cf8e2c08db1994d40178fd8620ed5b2a1aa84a222a2db4d466 - type_inferenced_ast: 58e6327fa6d926a54bf437c8b3368b1bb2a62c9f86c372139b0952de56b94d78 + imports_resolved_ast: a2506a1ebf1e6d1bbf87cd1581e4e81b07c38041ce7bfa860f522ff684e40978 + canonicalized_ast: a2506a1ebf1e6d1bbf87cd1581e4e81b07c38041ce7bfa860f522ff684e40978 + type_inferenced_ast: e8b8f797b1b2ecfdd9609e7a01a3438c2a7fd391b6081180a6f6be72f34115b2 diff --git a/tests/expectations/compiler/compiler/integers/u64/min.leo.out b/tests/expectations/compiler/compiler/integers/u64/min.leo.out index 8668160ca6..7461fe1a1d 100644 --- a/tests/expectations/compiler/compiler/integers/u64/min.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/min.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 2ab7dc6aeaa06191668ce218bf971a797d818d82d57e5c5238571ac7d51b3e1a - imports_resolved_ast: 2ab7dc6aeaa06191668ce218bf971a797d818d82d57e5c5238571ac7d51b3e1a - canonicalized_ast: 2ab7dc6aeaa06191668ce218bf971a797d818d82d57e5c5238571ac7d51b3e1a - type_inferenced_ast: 9b04ce3a661bfcbc23b9066b315b48ca4cc51c10364dc3f2aa6196efd1633056 + imports_resolved_ast: 09b16d374165e2c503247834e2c1cea7e206f14597749c5deb927a839e87fcf8 + canonicalized_ast: 09b16d374165e2c503247834e2c1cea7e206f14597749c5deb927a839e87fcf8 + type_inferenced_ast: 7944108d0661542178124fd86d1430e39d770a4da9ad8861437053c831d53abc diff --git a/tests/expectations/compiler/compiler/integers/u64/mul.leo.out b/tests/expectations/compiler/compiler/integers/u64/mul.leo.out index ea52e75d85..93268f5729 100644 --- a/tests/expectations/compiler/compiler/integers/u64/mul.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/mul.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "false" initial_ast: 234cebde72559d83c7ca897456c95a46345a67de7fd6b82aa9fb3a0ce5cd9d6d - imports_resolved_ast: 234cebde72559d83c7ca897456c95a46345a67de7fd6b82aa9fb3a0ce5cd9d6d - canonicalized_ast: 234cebde72559d83c7ca897456c95a46345a67de7fd6b82aa9fb3a0ce5cd9d6d - type_inferenced_ast: 41a3dae72352f43712f3cc0cb507ab92031b48cfdb7fcb06f959b6060758d17b + imports_resolved_ast: 713c30829bbeb6953acdd332038a1ad008bf63263d928ac9ad63ebb664a9decd + canonicalized_ast: 713c30829bbeb6953acdd332038a1ad008bf63263d928ac9ad63ebb664a9decd + type_inferenced_ast: 7954b6e5c6651edd5e7c328ead234fa2f6fbbae66a0ef7b139111d50bc6fefa9 diff --git a/tests/expectations/compiler/compiler/integers/u64/ne.leo.out b/tests/expectations/compiler/compiler/integers/u64/ne.leo.out index 28e0fa8284..7303021df9 100644 --- a/tests/expectations/compiler/compiler/integers/u64/ne.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/ne.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: d4062e73e7e24af37d9e4d1770d18e008d47f5df0dbc2de56a1089496e53ea1b - imports_resolved_ast: d4062e73e7e24af37d9e4d1770d18e008d47f5df0dbc2de56a1089496e53ea1b - canonicalized_ast: d4062e73e7e24af37d9e4d1770d18e008d47f5df0dbc2de56a1089496e53ea1b - type_inferenced_ast: 0b9394287626c1cbe2240d34740fc8cd3202690de88d4dae3b1062ed519415e9 + imports_resolved_ast: 980a251b15a84c14fe82f60aa155f8e37d221f249744c6a106ea2de8793238d8 + canonicalized_ast: 980a251b15a84c14fe82f60aa155f8e37d221f249744c6a106ea2de8793238d8 + type_inferenced_ast: 1db43073f0dd3c822e9d2d552d3a14d92c7ab87ab8864c71ac03bd5dd13a5ae7 diff --git a/tests/expectations/compiler/compiler/integers/u64/sub.leo.out b/tests/expectations/compiler/compiler/integers/u64/sub.leo.out index 2d4c78d409..9740ff3539 100644 --- a/tests/expectations/compiler/compiler/integers/u64/sub.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/sub.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 9776d9311c67fd4c0a402d7b62623d78090a7c548e25841d2629d503bfe185ff - imports_resolved_ast: 9776d9311c67fd4c0a402d7b62623d78090a7c548e25841d2629d503bfe185ff - canonicalized_ast: 9776d9311c67fd4c0a402d7b62623d78090a7c548e25841d2629d503bfe185ff - type_inferenced_ast: 0ca6841975de33f74979b293de56ac993cdaa92fedfe1932bec2ffaf847d43fc + imports_resolved_ast: 66f9a33cf63d5a4786003782325fd2385ca0057d6c1ed97d02df06ffee93f392 + canonicalized_ast: 66f9a33cf63d5a4786003782325fd2385ca0057d6c1ed97d02df06ffee93f392 + type_inferenced_ast: f25086e5c7e00b9cd4c25e437f30610cbb4bdb0fc9e8c758e7dd2b5c9b5780be diff --git a/tests/expectations/compiler/compiler/integers/u64/ternary.leo.out b/tests/expectations/compiler/compiler/integers/u64/ternary.leo.out index 41f8fede4f..370997aae6 100644 --- a/tests/expectations/compiler/compiler/integers/u64/ternary.leo.out +++ b/tests/expectations/compiler/compiler/integers/u64/ternary.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 3295b9a5f343261562befdfbf3a7ee33326d6316a1101c00c909cc79747f5bb4 - imports_resolved_ast: 3295b9a5f343261562befdfbf3a7ee33326d6316a1101c00c909cc79747f5bb4 - canonicalized_ast: 3295b9a5f343261562befdfbf3a7ee33326d6316a1101c00c909cc79747f5bb4 - type_inferenced_ast: a17c197c6672681826a04859b8fbe7e007401aa62fa8feed14ebefc81f958793 + imports_resolved_ast: a309c1fc6dd1532f9a5e430c54c6f36864a4da4fb2b59695f9c92e17e6458332 + canonicalized_ast: a309c1fc6dd1532f9a5e430c54c6f36864a4da4fb2b59695f9c92e17e6458332 + type_inferenced_ast: d2d030b8ca2a849aa1043b1f009cb74ccab405ae909fe7b2869928ba6d511888 diff --git a/tests/expectations/compiler/compiler/integers/u8/add.leo.out b/tests/expectations/compiler/compiler/integers/u8/add.leo.out index 6ca74c3a29..917b8aafee 100644 --- a/tests/expectations/compiler/compiler/integers/u8/add.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/add.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 9dea438cfe465dadf7fdeed3bbddd7e382f583f3f6ba99e9402fede4ba47a442 - imports_resolved_ast: 9dea438cfe465dadf7fdeed3bbddd7e382f583f3f6ba99e9402fede4ba47a442 - canonicalized_ast: 9dea438cfe465dadf7fdeed3bbddd7e382f583f3f6ba99e9402fede4ba47a442 - type_inferenced_ast: 6a607b10a9897d5b69b303c7f1640af33ddaae750077e18a29e0c6c24dfb581d + imports_resolved_ast: 56c28910540e5e3ad4380a3722ba0c6bc48eca2664fec7ec8925081c17b7c1b9 + canonicalized_ast: 56c28910540e5e3ad4380a3722ba0c6bc48eca2664fec7ec8925081c17b7c1b9 + type_inferenced_ast: 562bdd7d90f80b9e6b3813f99e4b03feb3b1f184095dabc65cf705bfecfdaefa diff --git a/tests/expectations/compiler/compiler/integers/u8/console_assert.leo.out b/tests/expectations/compiler/compiler/integers/u8/console_assert.leo.out index e40fc7da91..f3c1c23abd 100644 --- a/tests/expectations/compiler/compiler/integers/u8/console_assert.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/console_assert.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 836bd0b470cd210052613fd9b13c5e420cc52b5da5f05a1dbbbdabbda9e35d5e - imports_resolved_ast: 836bd0b470cd210052613fd9b13c5e420cc52b5da5f05a1dbbbdabbda9e35d5e - canonicalized_ast: 836bd0b470cd210052613fd9b13c5e420cc52b5da5f05a1dbbbdabbda9e35d5e - type_inferenced_ast: 65e7b6fd34672f4f4d0f09df9e2d1d3a3d6c2c632128eb8f8a2c6f0c95d28a3b + imports_resolved_ast: a478a63d06e684d409682c5b81baad641a8b48dd716c6aad94bf3ab3f8e21c27 + canonicalized_ast: a478a63d06e684d409682c5b81baad641a8b48dd716c6aad94bf3ab3f8e21c27 + type_inferenced_ast: 4c787b241512b53950f7d7aab95d65c0c393f3bd931082821ad507557845ce03 diff --git a/tests/expectations/compiler/compiler/integers/u8/div.leo.out b/tests/expectations/compiler/compiler/integers/u8/div.leo.out index 07d963bfdf..8c1f03478c 100644 --- a/tests/expectations/compiler/compiler/integers/u8/div.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/div.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 5e159a778450deb8e7a193f93700d4f70f356b414c4acf927d31117d6f4c6246 - imports_resolved_ast: 5e159a778450deb8e7a193f93700d4f70f356b414c4acf927d31117d6f4c6246 - canonicalized_ast: 5e159a778450deb8e7a193f93700d4f70f356b414c4acf927d31117d6f4c6246 - type_inferenced_ast: 1b9a06f4b0a525f5e8a678fed6eedfd9227fa5d416c578711a4b61b37ebefbc5 + imports_resolved_ast: e73b0e3522769f74cb47b65a7627d3a986071de7cd42e6ca0c9c76f6b03a9de4 + canonicalized_ast: e73b0e3522769f74cb47b65a7627d3a986071de7cd42e6ca0c9c76f6b03a9de4 + type_inferenced_ast: 62e136c22e87891c9ac9603d4a3a9ee8483af24998520a704361f55cd848f2ae diff --git a/tests/expectations/compiler/compiler/integers/u8/eq.leo.out b/tests/expectations/compiler/compiler/integers/u8/eq.leo.out index 60854938a0..f4e3bcada1 100644 --- a/tests/expectations/compiler/compiler/integers/u8/eq.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/eq.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: e3e4dc868de4fdf770bb339ab8e7dfb54e4d0786c58f892d1bca34a28403ed1f - imports_resolved_ast: e3e4dc868de4fdf770bb339ab8e7dfb54e4d0786c58f892d1bca34a28403ed1f - canonicalized_ast: e3e4dc868de4fdf770bb339ab8e7dfb54e4d0786c58f892d1bca34a28403ed1f - type_inferenced_ast: 3e57ddf8d981040924b7eb460f3627fe35eee8dfe7a54c7cbf4a48f609e408cb + imports_resolved_ast: 7a8ffc34ac47553f963e008c85719b034ff477c6ce7d40d413e10e75b0f0349a + canonicalized_ast: 7a8ffc34ac47553f963e008c85719b034ff477c6ce7d40d413e10e75b0f0349a + type_inferenced_ast: afd1fb8c87d058060023369a22378903ac007f6ffecb4fcca8ae5e5d0e15e4a5 diff --git a/tests/expectations/compiler/compiler/integers/u8/ge.leo.out b/tests/expectations/compiler/compiler/integers/u8/ge.leo.out index b65b35b985..2eb5357adf 100644 --- a/tests/expectations/compiler/compiler/integers/u8/ge.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/ge.leo.out @@ -29,6 +29,6 @@ outputs: type: bool value: "true" initial_ast: 6695ac31b2462e549a79a622e8cb11eae73c20503e727b9f50fbab4c572c785d - imports_resolved_ast: 6695ac31b2462e549a79a622e8cb11eae73c20503e727b9f50fbab4c572c785d - canonicalized_ast: 6695ac31b2462e549a79a622e8cb11eae73c20503e727b9f50fbab4c572c785d - type_inferenced_ast: 5f6c660c11b7fc64e7947923a77f30cddb93ab223f59cb322a29876b04f7c9a8 + imports_resolved_ast: d7e41ad23527080c340341aef8b15c7a2c0355d2d8e7621181f97a48924403ee + canonicalized_ast: d7e41ad23527080c340341aef8b15c7a2c0355d2d8e7621181f97a48924403ee + type_inferenced_ast: 53f33aa479e31c699ba7daba11d68b97349548bf1071d422a361a864905f340e diff --git a/tests/expectations/compiler/compiler/integers/u8/gt.leo.out b/tests/expectations/compiler/compiler/integers/u8/gt.leo.out index fac5211983..47b8766ee8 100644 --- a/tests/expectations/compiler/compiler/integers/u8/gt.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/gt.leo.out @@ -17,6 +17,6 @@ outputs: output: registers: {} initial_ast: 4a99a7af4e976c85ed87114d8a267a1d047b17f60fda4030e793fd5f66cf2c53 - imports_resolved_ast: 4a99a7af4e976c85ed87114d8a267a1d047b17f60fda4030e793fd5f66cf2c53 - canonicalized_ast: 5df377575d61a53ae6c1cd898ef1ab739660a9716eaeebee9c8a767c8d05ec60 - type_inferenced_ast: e69731b76d3e389f51f854eac84befd1d7e1c61180ca46a150f07b2aa768f2d8 + imports_resolved_ast: 849ae761c64e49d5c097ca2cc1968ffc3f25f611e7614dc649d046e1b8c9905e + canonicalized_ast: 6b07828b045055fb9e3bd4335eca3b88c0316c0c867e01750ed0ea6e2bb60d9d + type_inferenced_ast: 94927046174620d5384fe3c0bb2176ed78943a7bc18c2ecc73f8e330f3ac702a diff --git a/tests/expectations/compiler/compiler/integers/u8/input.leo.out b/tests/expectations/compiler/compiler/integers/u8/input.leo.out index 0747f5d164..6a6aa8e5e8 100644 --- a/tests/expectations/compiler/compiler/integers/u8/input.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/input.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 35b67dd962ab49f7cda88997fbd0028a30d591229b5a7e9ad8d062b1b31d4565 - imports_resolved_ast: 35b67dd962ab49f7cda88997fbd0028a30d591229b5a7e9ad8d062b1b31d4565 - canonicalized_ast: 35b67dd962ab49f7cda88997fbd0028a30d591229b5a7e9ad8d062b1b31d4565 - type_inferenced_ast: e8966ad1d14fd288b6dbda6b1de78f01048e73d231122e997f11c08b5b6c404d + imports_resolved_ast: de558dd85ba63b9ef6656a8ab969b82e06cb5c6aaf10974e2c1a58f7bc0cbfa0 + canonicalized_ast: de558dd85ba63b9ef6656a8ab969b82e06cb5c6aaf10974e2c1a58f7bc0cbfa0 + type_inferenced_ast: 94b474be1c55280b7ee9ac1dbff85b1c52f9dba08204d4d01734886bedbd1a66 diff --git a/tests/expectations/compiler/compiler/integers/u8/le.leo.out b/tests/expectations/compiler/compiler/integers/u8/le.leo.out index e93f6fb6dd..2d0f0c019a 100644 --- a/tests/expectations/compiler/compiler/integers/u8/le.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/le.leo.out @@ -29,6 +29,6 @@ outputs: type: bool value: "false" initial_ast: 72590f8b2a5ac7c0a4e663ce39009c0032ee66011f7fa1d5d61b34bd313e0e86 - imports_resolved_ast: 72590f8b2a5ac7c0a4e663ce39009c0032ee66011f7fa1d5d61b34bd313e0e86 - canonicalized_ast: 72590f8b2a5ac7c0a4e663ce39009c0032ee66011f7fa1d5d61b34bd313e0e86 - type_inferenced_ast: eda186febeb1927b5f0427f36ecaf1f6fc6c5201d8d0ddbf7399a31b0a181c0b + imports_resolved_ast: 3ea71a501ec12f0b3836f6eee5e12211f66306235ac16baf6d870c008606f2f5 + canonicalized_ast: 3ea71a501ec12f0b3836f6eee5e12211f66306235ac16baf6d870c008606f2f5 + type_inferenced_ast: 5e111f47d479eb34d5b21364da41edf3f60174b556e73ece458f20de6e8e943a diff --git a/tests/expectations/compiler/compiler/integers/u8/lt.leo.out b/tests/expectations/compiler/compiler/integers/u8/lt.leo.out index 82ef830edf..aa6f42fd1f 100644 --- a/tests/expectations/compiler/compiler/integers/u8/lt.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/lt.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "false" initial_ast: 57691c69dc440d8028e25c3e4487c52a89c5b23ff2976faa8dac057b29170945 - imports_resolved_ast: 57691c69dc440d8028e25c3e4487c52a89c5b23ff2976faa8dac057b29170945 - canonicalized_ast: 57691c69dc440d8028e25c3e4487c52a89c5b23ff2976faa8dac057b29170945 - type_inferenced_ast: eced084868377db05c2cde7dc441f0d657610891ceec6df4445debef18ee1804 + imports_resolved_ast: 46a664f390cfc95a0a6965e79a482817101cfbc1270bd0c2ac820681b154131d + canonicalized_ast: 46a664f390cfc95a0a6965e79a482817101cfbc1270bd0c2ac820681b154131d + type_inferenced_ast: 05b15ac61f963750578465522489e5b4a9b7160d7cf82c6d423927ee04d72d1c diff --git a/tests/expectations/compiler/compiler/integers/u8/max.leo.out b/tests/expectations/compiler/compiler/integers/u8/max.leo.out index 5265fe397a..ca93b8beff 100644 --- a/tests/expectations/compiler/compiler/integers/u8/max.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/max.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 1e5b1da2899876d937c9ecdf22665be02e309b6ec9fd6fa7473ffebb48a9e19b - imports_resolved_ast: 1e5b1da2899876d937c9ecdf22665be02e309b6ec9fd6fa7473ffebb48a9e19b - canonicalized_ast: 1e5b1da2899876d937c9ecdf22665be02e309b6ec9fd6fa7473ffebb48a9e19b - type_inferenced_ast: 042f053591ca529430101b4412ca9de1d0ea595d332b5ee73ea9aae0774fff7e + imports_resolved_ast: 8cd83a6ed2365baf1c2ad0a8260f91c93e9707b07805ea8541b4854c14ee193c + canonicalized_ast: 8cd83a6ed2365baf1c2ad0a8260f91c93e9707b07805ea8541b4854c14ee193c + type_inferenced_ast: db229a83a59ddce8a3d89e6224061c2575a5a038e4939f1050df1efbdd3a4635 diff --git a/tests/expectations/compiler/compiler/integers/u8/min.leo.out b/tests/expectations/compiler/compiler/integers/u8/min.leo.out index 850285bf40..ce578e4dc0 100644 --- a/tests/expectations/compiler/compiler/integers/u8/min.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/min.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 0ad4671e3a0aaf948a2ccafb0030bd29f77ebe358d8bc309e24a76691adbc15d - imports_resolved_ast: 0ad4671e3a0aaf948a2ccafb0030bd29f77ebe358d8bc309e24a76691adbc15d - canonicalized_ast: 0ad4671e3a0aaf948a2ccafb0030bd29f77ebe358d8bc309e24a76691adbc15d - type_inferenced_ast: dcf3b29842bb4b58aec3edc927f4df1373b82497624fd480af3b2c995f973a1e + imports_resolved_ast: 91f7dab2515efeadedc1b62fde2d903fa1f0631cb1f54ce0c2b7264318cfda67 + canonicalized_ast: 91f7dab2515efeadedc1b62fde2d903fa1f0631cb1f54ce0c2b7264318cfda67 + type_inferenced_ast: a823e28130686ea355a390a958dc0677b5930d955af9137cd983adfe18c38e1e diff --git a/tests/expectations/compiler/compiler/integers/u8/mul.leo.out b/tests/expectations/compiler/compiler/integers/u8/mul.leo.out index 96ad005f3f..8849b5cb3b 100644 --- a/tests/expectations/compiler/compiler/integers/u8/mul.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/mul.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "false" initial_ast: 8db1872b44d014eca2e66c5de1be6ae902623a1548ca53b6146de18dced3d409 - imports_resolved_ast: 8db1872b44d014eca2e66c5de1be6ae902623a1548ca53b6146de18dced3d409 - canonicalized_ast: 8db1872b44d014eca2e66c5de1be6ae902623a1548ca53b6146de18dced3d409 - type_inferenced_ast: c838cd4e5527762edc4fc43355c05b68085c39fd5a338f68caafc0160c68a574 + imports_resolved_ast: 0f86ba297c36318e73a9381050676709a2f01aa141fea01ae1b107f103995ebd + canonicalized_ast: 0f86ba297c36318e73a9381050676709a2f01aa141fea01ae1b107f103995ebd + type_inferenced_ast: 1cd6bad748938742eb70aeff3e3047c683b29d7847a172b2d0461e7886e773bb diff --git a/tests/expectations/compiler/compiler/integers/u8/ne.leo.out b/tests/expectations/compiler/compiler/integers/u8/ne.leo.out index cda424ec4f..3495d59d4a 100644 --- a/tests/expectations/compiler/compiler/integers/u8/ne.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/ne.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: f74da59a77c90926a1d926b1c35fd5a18e44de0f8cb6aba39fa176d431f4f965 - imports_resolved_ast: f74da59a77c90926a1d926b1c35fd5a18e44de0f8cb6aba39fa176d431f4f965 - canonicalized_ast: f74da59a77c90926a1d926b1c35fd5a18e44de0f8cb6aba39fa176d431f4f965 - type_inferenced_ast: 474128f7bfe69e7ea64a76c57e729dc85520425fc36ef88c123aebdc670176a3 + imports_resolved_ast: f1dc067bf0e11b9963a1b96650121420ddf9feb9bd9df2bd8adbc279f75e4f26 + canonicalized_ast: f1dc067bf0e11b9963a1b96650121420ddf9feb9bd9df2bd8adbc279f75e4f26 + type_inferenced_ast: 79f7ff945e73cf4856508bfb6947ea659eefade74a277709504c40cc06c69f62 diff --git a/tests/expectations/compiler/compiler/integers/u8/sub.leo.out b/tests/expectations/compiler/compiler/integers/u8/sub.leo.out index 65468f7374..39e34e0e96 100644 --- a/tests/expectations/compiler/compiler/integers/u8/sub.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/sub.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 4ad8780e5c0a3128317266059864223beac927b6d00745353114baaf5261fbca - imports_resolved_ast: 4ad8780e5c0a3128317266059864223beac927b6d00745353114baaf5261fbca - canonicalized_ast: 4ad8780e5c0a3128317266059864223beac927b6d00745353114baaf5261fbca - type_inferenced_ast: c26b34ca605ac96edbd443f0f4015493d509054c3e7b749fc9ee31ef1800d6c8 + imports_resolved_ast: 57efbe04cd53d4f16df4eaed2f334bee66d2af1011296d9a884fdd467a5c88f8 + canonicalized_ast: 57efbe04cd53d4f16df4eaed2f334bee66d2af1011296d9a884fdd467a5c88f8 + type_inferenced_ast: 8cc7f3cd340da20f54f1ff9563aea77c3a79e9ef672e4316e40bce810b328fb3 diff --git a/tests/expectations/compiler/compiler/integers/u8/ternary.leo.out b/tests/expectations/compiler/compiler/integers/u8/ternary.leo.out index 99d682ebbc..a293f08db7 100644 --- a/tests/expectations/compiler/compiler/integers/u8/ternary.leo.out +++ b/tests/expectations/compiler/compiler/integers/u8/ternary.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 74e87cd14415c4e1c4d2d89bbe56ee8ca5fc988df4cc894381b4a087fa409095 - imports_resolved_ast: 74e87cd14415c4e1c4d2d89bbe56ee8ca5fc988df4cc894381b4a087fa409095 - canonicalized_ast: 74e87cd14415c4e1c4d2d89bbe56ee8ca5fc988df4cc894381b4a087fa409095 - type_inferenced_ast: f5ae3a29090e07ccd418d3ab78fd24161fe26cc6a365ff71861f4d6ad5e8a0b4 + imports_resolved_ast: 1053cc0938a288e698fbbcd5e62f8a6472303e3230452a99ebb7b2385a987b40 + canonicalized_ast: 1053cc0938a288e698fbbcd5e62f8a6472303e3230452a99ebb7b2385a987b40 + type_inferenced_ast: 5003313707fcca85529aca7f24a0aa4de4c6770f169330f054c20ccecafe3ac5 diff --git a/tests/expectations/compiler/compiler/mutability/array_dyn_mut.leo.out b/tests/expectations/compiler/compiler/mutability/array_dyn_mut.leo.out index 01784c8694..48275db016 100644 --- a/tests/expectations/compiler/compiler/mutability/array_dyn_mut.leo.out +++ b/tests/expectations/compiler/compiler/mutability/array_dyn_mut.leo.out @@ -23,6 +23,6 @@ outputs: type: "[u32; 3]" value: "\"150\"" initial_ast: b56c67d410c98a75c5f742d382e223355d214484d198ccaefe65296421c6854b - imports_resolved_ast: b56c67d410c98a75c5f742d382e223355d214484d198ccaefe65296421c6854b - canonicalized_ast: 7217fa688744caee18ab779ab9c43deac2d70a8d0b989873fe720d3f46a5e366 - type_inferenced_ast: 6d673f91cd5c98cd1ae69777a317cf2b2ee50fd291996c8ae70d036705e76062 + imports_resolved_ast: 7c717e59cfad63ac115eefe966fb30fe1ccca975f4fe750bd30c5c5269a0bda3 + canonicalized_ast: 8da38536d104b2ee21b417f648d1806bfad8ceea07a402ec8941d5aaf2263c69 + type_inferenced_ast: 61a9bff6910e2a508bcd2abacce2635b4074cf8d4866aa4b126e268a699c500a diff --git a/tests/expectations/compiler/compiler/mutability/array_dyn_mut_indirect.leo.out b/tests/expectations/compiler/compiler/mutability/array_dyn_mut_indirect.leo.out index 79439395c7..d503569c7d 100644 --- a/tests/expectations/compiler/compiler/mutability/array_dyn_mut_indirect.leo.out +++ b/tests/expectations/compiler/compiler/mutability/array_dyn_mut_indirect.leo.out @@ -23,6 +23,6 @@ outputs: type: "[(u32, u32); 3]" value: "\"(1, 1)(2, 2)(0, 1)\"" initial_ast: 7ca87cb79f11b6342bc6db56d6b051c68bcedb798ba9eb88992dcfe0873ce139 - imports_resolved_ast: 7ca87cb79f11b6342bc6db56d6b051c68bcedb798ba9eb88992dcfe0873ce139 - canonicalized_ast: 7ca87cb79f11b6342bc6db56d6b051c68bcedb798ba9eb88992dcfe0873ce139 - type_inferenced_ast: 26f6c295a4ab2515eadf95855c66e3fa29d158a43765baa87895fea42bb379d1 + imports_resolved_ast: be6617cf106d0228192d1e321a6444ffdbf4c0d0a77a617d1ea8f7aea52456b2 + canonicalized_ast: be6617cf106d0228192d1e321a6444ffdbf4c0d0a77a617d1ea8f7aea52456b2 + type_inferenced_ast: 27167759a3eb4f915968b45d63f25685a5d3e9f1e08bf09d0bc2481af51c8619 diff --git a/tests/expectations/compiler/compiler/mutability/array_mut.leo.out b/tests/expectations/compiler/compiler/mutability/array_mut.leo.out index 4f64a7778a..793cf1b659 100644 --- a/tests/expectations/compiler/compiler/mutability/array_mut.leo.out +++ b/tests/expectations/compiler/compiler/mutability/array_mut.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 3ba284ff6893de7ffb6f90092f7c39cefd51c61022e827842fc7d4be7ed72dcd - imports_resolved_ast: 3ba284ff6893de7ffb6f90092f7c39cefd51c61022e827842fc7d4be7ed72dcd - canonicalized_ast: 3ba284ff6893de7ffb6f90092f7c39cefd51c61022e827842fc7d4be7ed72dcd - type_inferenced_ast: 75acbd9ccfb46be0f54046274dc1c200ad7b244bc8e98789d5d7e80fd2d15518 + imports_resolved_ast: 14a7cef24a2e364705a53949f6b289a21fe080df6c5f4929526d66416d890ba0 + canonicalized_ast: 14a7cef24a2e364705a53949f6b289a21fe080df6c5f4929526d66416d890ba0 + type_inferenced_ast: 75e7aeda9fc0e14e5ad3ab24f5dd5a97016ef7df630e9a94950f45653a336fda diff --git a/tests/expectations/compiler/compiler/mutability/array_splice_mut.leo.out b/tests/expectations/compiler/compiler/mutability/array_splice_mut.leo.out index b876f414f1..5f81e52fc1 100644 --- a/tests/expectations/compiler/compiler/mutability/array_splice_mut.leo.out +++ b/tests/expectations/compiler/compiler/mutability/array_splice_mut.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 7d636b2e99784c858ee66e66497caaf184f7a9fa9340d0dd1d6618e6e4b6592e - imports_resolved_ast: 7d636b2e99784c858ee66e66497caaf184f7a9fa9340d0dd1d6618e6e4b6592e - canonicalized_ast: 7d636b2e99784c858ee66e66497caaf184f7a9fa9340d0dd1d6618e6e4b6592e - type_inferenced_ast: 796ceba3c23358c37039eb3484c761a7a5d605ad09877ba006090928be814458 + imports_resolved_ast: 4da9957a4d736bd4bd54b7a4c9e1b2a1d47b45ccc54da4dd67c771e780bd328c + canonicalized_ast: 4da9957a4d736bd4bd54b7a4c9e1b2a1d47b45ccc54da4dd67c771e780bd328c + type_inferenced_ast: 23aebb7b4b7960031778b0a88006179be6151aa622c38be76946191c947c0301 diff --git a/tests/expectations/compiler/compiler/mutability/array_tuple_mut.leo.out b/tests/expectations/compiler/compiler/mutability/array_tuple_mut.leo.out index 82e3d7f297..5130b9cd0d 100644 --- a/tests/expectations/compiler/compiler/mutability/array_tuple_mut.leo.out +++ b/tests/expectations/compiler/compiler/mutability/array_tuple_mut.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 2a6e7d5838f323e53cb753dc3bae3a6e379ef0deeb0172c1c7df231cd700a5b6 - imports_resolved_ast: 2a6e7d5838f323e53cb753dc3bae3a6e379ef0deeb0172c1c7df231cd700a5b6 - canonicalized_ast: 2a6e7d5838f323e53cb753dc3bae3a6e379ef0deeb0172c1c7df231cd700a5b6 - type_inferenced_ast: d5eafbcdb2a34278a296ff9b217aa63f8baab298450533f42ace506d0df031d6 + imports_resolved_ast: 6041ac3a139680aa557e31a224b17059fda4e2d487fd19cf2d73776629f54955 + canonicalized_ast: 6041ac3a139680aa557e31a224b17059fda4e2d487fd19cf2d73776629f54955 + type_inferenced_ast: 340463e5aed430ed4f581ff5d7cc719520ef6e529f8d6fa619f36a6c980fe4b1 diff --git a/tests/expectations/compiler/compiler/mutability/circuit_function_mut.leo.out b/tests/expectations/compiler/compiler/mutability/circuit_function_mut.leo.out index 3ad11e8018..cced8345cb 100644 --- a/tests/expectations/compiler/compiler/mutability/circuit_function_mut.leo.out +++ b/tests/expectations/compiler/compiler/mutability/circuit_function_mut.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 71448f3f5387cd67a8d8c0b974fa93cf81cdfb72ae0d8f9499c9c5e478a0d15b - imports_resolved_ast: 71448f3f5387cd67a8d8c0b974fa93cf81cdfb72ae0d8f9499c9c5e478a0d15b - canonicalized_ast: 16d4030e454d8c83d2073afaaa7e8fa1eb40d36026909144db29d311ab005f46 - type_inferenced_ast: 2d0489a411d4336c01958f074b96957f3f8ae682b0046ffadf9cbddf66f7f168 + imports_resolved_ast: f1c8aad0cdbe4943440bf8d1852d88140746c77f5aad027f246ed8485a5b1ba8 + canonicalized_ast: 47b1e62f4192b3b142e0326351e57a9a769e0d6c2885e46128c7ec886d236396 + type_inferenced_ast: f8e0898b13bbce25d599f5238f6d051b31fbed4921c00fa939156f92ba474821 diff --git a/tests/expectations/compiler/compiler/mutability/circuit_variable_mut.leo.out b/tests/expectations/compiler/compiler/mutability/circuit_variable_mut.leo.out index 488666e39f..1fbc7520ff 100644 --- a/tests/expectations/compiler/compiler/mutability/circuit_variable_mut.leo.out +++ b/tests/expectations/compiler/compiler/mutability/circuit_variable_mut.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 83da7a1bf2887678937835ac77b33a0e21dd3b04d5739146f16a559b8dc3c6ab - imports_resolved_ast: 83da7a1bf2887678937835ac77b33a0e21dd3b04d5739146f16a559b8dc3c6ab - canonicalized_ast: 83da7a1bf2887678937835ac77b33a0e21dd3b04d5739146f16a559b8dc3c6ab - type_inferenced_ast: b0d9f15a133962134f094c0aa682d7f2f77085b9cad845b8af05cf48e9b7b9ca + imports_resolved_ast: e4b5474a47143a23cf94743086f6becccab1d625dc784910540a0f4cd3299072 + canonicalized_ast: e4b5474a47143a23cf94743086f6becccab1d625dc784910540a0f4cd3299072 + type_inferenced_ast: 3066d3c5667013d4d49d32a003e7d3d06e544792a7a003d06688b4c679588ef7 diff --git a/tests/expectations/compiler/compiler/mutability/cond_mut.leo.out b/tests/expectations/compiler/compiler/mutability/cond_mut.leo.out index f3092ce949..5e769e0288 100644 --- a/tests/expectations/compiler/compiler/mutability/cond_mut.leo.out +++ b/tests/expectations/compiler/compiler/mutability/cond_mut.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 384eb00d7e551705537f37e10e28eb35f88175f77351c6add02de4b896630ca6 - imports_resolved_ast: 384eb00d7e551705537f37e10e28eb35f88175f77351c6add02de4b896630ca6 - canonicalized_ast: 40b13bb543186c6f032ca6fca8144acbfa5cfcc4e691ed1f79c5120be2db8809 - type_inferenced_ast: 49d93167578fd99537e1895963545e6e95f2c55162f42f2bb9ee8b4d014152ee + imports_resolved_ast: aced49f5ca0912c246257d5e39d442f7586df1d431847e230c11bf94f804d41f + canonicalized_ast: 810d6a84a244fd43aa61f8fe71084b6ab434e09b53c11e8378f40bd840e8aab1 + type_inferenced_ast: fd4e5b91d402cda60a8aa9d1a11a1fdfb5533153cad97debe12edbd1627443d2 diff --git a/tests/expectations/compiler/compiler/mutability/function_input_mut.leo.out b/tests/expectations/compiler/compiler/mutability/function_input_mut.leo.out index 6ffeaf479f..65efb0adc3 100644 --- a/tests/expectations/compiler/compiler/mutability/function_input_mut.leo.out +++ b/tests/expectations/compiler/compiler/mutability/function_input_mut.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 77803f27d711c6b4c7f51dd846bb82dee64dadc3627e9cedcc0c125a734c5b7c - imports_resolved_ast: 77803f27d711c6b4c7f51dd846bb82dee64dadc3627e9cedcc0c125a734c5b7c - canonicalized_ast: 77803f27d711c6b4c7f51dd846bb82dee64dadc3627e9cedcc0c125a734c5b7c - type_inferenced_ast: 9cc5c0db46856226084812857f8982677ed5688259a4deb0d189c9b92eba1756 + imports_resolved_ast: 8c63983bf5c219db8e7e12cabebb25f52def9caf554e9fcc7f8c74a2787ae399 + canonicalized_ast: 8c63983bf5c219db8e7e12cabebb25f52def9caf554e9fcc7f8c74a2787ae399 + type_inferenced_ast: 725b3d00ce7277b0833f290790ef57297d8d775b0cb179328821a2a7b709f3c2 diff --git a/tests/expectations/compiler/compiler/mutability/let_mut.leo.out b/tests/expectations/compiler/compiler/mutability/let_mut.leo.out index 303c236de1..3cbd8db13a 100644 --- a/tests/expectations/compiler/compiler/mutability/let_mut.leo.out +++ b/tests/expectations/compiler/compiler/mutability/let_mut.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 561fab3e5b172eb73713783c43b079b77ab5ce1ee799526bd9c3dee51c6e15d8 - imports_resolved_ast: 561fab3e5b172eb73713783c43b079b77ab5ce1ee799526bd9c3dee51c6e15d8 - canonicalized_ast: 561fab3e5b172eb73713783c43b079b77ab5ce1ee799526bd9c3dee51c6e15d8 - type_inferenced_ast: 3715f38b2b0a49f93133616eb252d1067ef1abec8d0895cf9c7de588fcf9e6d8 + imports_resolved_ast: e8f74a739f54d653eb277c6010d4da647b2bbc3d4e15dcad5f8badab3b9e2c84 + canonicalized_ast: e8f74a739f54d653eb277c6010d4da647b2bbc3d4e15dcad5f8badab3b9e2c84 + type_inferenced_ast: c9cce19337fa5241ed3455f4e082f9e2a9ed3a1780a858662e308a1f4e5e11ab diff --git a/tests/expectations/compiler/compiler/mutability/let_mut_nested.leo.out b/tests/expectations/compiler/compiler/mutability/let_mut_nested.leo.out index a0711af408..b3cd1964cf 100644 --- a/tests/expectations/compiler/compiler/mutability/let_mut_nested.leo.out +++ b/tests/expectations/compiler/compiler/mutability/let_mut_nested.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 4de7e4f24434d5a611566054ce5e1cff1edf0e9a76fa77ab5b121bd412eceb91 - imports_resolved_ast: 4de7e4f24434d5a611566054ce5e1cff1edf0e9a76fa77ab5b121bd412eceb91 - canonicalized_ast: 4de7e4f24434d5a611566054ce5e1cff1edf0e9a76fa77ab5b121bd412eceb91 - type_inferenced_ast: 65d3153d31e7f29f65b4896eddab3fc8bb78ff919921e77a05d51b50180320d6 + imports_resolved_ast: 3c24be1091dab0a0a4cee9d3e6deb5f6edf68ab2b258df2c538eaa012ca03828 + canonicalized_ast: 3c24be1091dab0a0a4cee9d3e6deb5f6edf68ab2b258df2c538eaa012ca03828 + type_inferenced_ast: 7c31dbcbe665946d65066dcf08fd117138ed45b73f1baeea8df765d3771f7964 diff --git a/tests/expectations/compiler/compiler/mutability/swap.leo.out b/tests/expectations/compiler/compiler/mutability/swap.leo.out index 6a67168d5f..e54bc5caa8 100644 --- a/tests/expectations/compiler/compiler/mutability/swap.leo.out +++ b/tests/expectations/compiler/compiler/mutability/swap.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "false" initial_ast: abe0177ae796b70cfdd8c6d30fcd5a9d713e3d16fccfdf63853ea6f0a8a9df54 - imports_resolved_ast: abe0177ae796b70cfdd8c6d30fcd5a9d713e3d16fccfdf63853ea6f0a8a9df54 - canonicalized_ast: abe0177ae796b70cfdd8c6d30fcd5a9d713e3d16fccfdf63853ea6f0a8a9df54 - type_inferenced_ast: 43109986d2643a72bb5300c298952755f692cdd10e7071fb40b2b006412606d9 + imports_resolved_ast: f242a960a1f738a38490e838a07774dbff06dbfd1720a7d540d2496c896f5492 + canonicalized_ast: f242a960a1f738a38490e838a07774dbff06dbfd1720a7d540d2496c896f5492 + type_inferenced_ast: 85d4d182db4ef32e4fbf510820c9cb7689498b14d465c2a94d8c38dc6161475e diff --git a/tests/expectations/compiler/compiler/statements/all_loops.leo.out b/tests/expectations/compiler/compiler/statements/all_loops.leo.out index 9876a424fc..8d3153216e 100644 --- a/tests/expectations/compiler/compiler/statements/all_loops.leo.out +++ b/tests/expectations/compiler/compiler/statements/all_loops.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: d94b77f7891ca44d554f59cc07370505a1dec9cc1a5133674faf8797bddcfb4b - imports_resolved_ast: d94b77f7891ca44d554f59cc07370505a1dec9cc1a5133674faf8797bddcfb4b - canonicalized_ast: 10fb59963f44b2261fc0dd0aca8a57bf3c6c6252d9da82717fd13fbb57760ad3 - type_inferenced_ast: 833d4e649f0e3cebfddcaccd9abde073ea29a9262a93fa233e0a5dcada33b46a + imports_resolved_ast: a2ccff7a3e00b1b987de82024862aaa5ae9ec086fcab1e18a08e10e8314d3b17 + canonicalized_ast: a96bff216baa35e6b4784595c502e4f6d8a21b63047a974fa2136a44faff31a8 + type_inferenced_ast: c3d6682bcfa08aee1bf04a5de19c06f4e4df6f35f007efcffa8e32506974bc6f diff --git a/tests/expectations/compiler/compiler/statements/block.leo.out b/tests/expectations/compiler/compiler/statements/block.leo.out index e6d2d81ac5..28ff55e89e 100644 --- a/tests/expectations/compiler/compiler/statements/block.leo.out +++ b/tests/expectations/compiler/compiler/statements/block.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: e83bec8b595276da8d5fee23a1aae15ca08ce2f369c3a47cfb5732b90b020e1f - imports_resolved_ast: e83bec8b595276da8d5fee23a1aae15ca08ce2f369c3a47cfb5732b90b020e1f - canonicalized_ast: d84f3bd449f9a10b2bf8de7e284c1764dee5650840a82e38518906448f7f0457 - type_inferenced_ast: 10d48e474c04c96d7754f41070ec3a406a2a3ef3ee6938185953ff52eaba5c87 + imports_resolved_ast: 82cfc7a57ad293b789e844ed9e4cb901a8a4cdc7c19efea01ea65bdf8a2e5383 + canonicalized_ast: aa013af46bdc96823f9c0bfd0a8e8e5eaf2ee1058c559576d68c94259376a4df + type_inferenced_ast: 6c146d9837fd1e252ad14a3b59c099066216c7b47d2eb249fd5fb9bf9ec7e86c diff --git a/tests/expectations/compiler/compiler/statements/chain.leo.out b/tests/expectations/compiler/compiler/statements/chain.leo.out index 602b31525c..9342136db9 100644 --- a/tests/expectations/compiler/compiler/statements/chain.leo.out +++ b/tests/expectations/compiler/compiler/statements/chain.leo.out @@ -29,6 +29,6 @@ outputs: type: bool value: "false" initial_ast: 51f43c865b5082a79df9bba465629cc4d9cc9f3a472e35d0301ae1dc6ef37039 - imports_resolved_ast: 51f43c865b5082a79df9bba465629cc4d9cc9f3a472e35d0301ae1dc6ef37039 - canonicalized_ast: 51f43c865b5082a79df9bba465629cc4d9cc9f3a472e35d0301ae1dc6ef37039 - type_inferenced_ast: 6198dfeacc891f4e22635060fa58a476fcae08cb6cfa74b6e8d80c07adc6c36d + imports_resolved_ast: 57a3ff6a2da82f27b0a09ca786ac214472d6115cceeacdc019b466ea84444cdd + canonicalized_ast: 57a3ff6a2da82f27b0a09ca786ac214472d6115cceeacdc019b466ea84444cdd + type_inferenced_ast: d4b84cf2cab32d18042c116780f7e4a2a85759d479dd871dd69bed0d690289f0 diff --git a/tests/expectations/compiler/compiler/statements/compound_assignment.leo.out b/tests/expectations/compiler/compiler/statements/compound_assignment.leo.out index 6484927e26..ba506d1142 100644 --- a/tests/expectations/compiler/compiler/statements/compound_assignment.leo.out +++ b/tests/expectations/compiler/compiler/statements/compound_assignment.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 108be85422345d78a93d2e36e633c3a15a1465e7c868f65e2925a47e0b5f691a - imports_resolved_ast: 108be85422345d78a93d2e36e633c3a15a1465e7c868f65e2925a47e0b5f691a - canonicalized_ast: d986fa603a5031dbd5034507d05df038fe99f60f603f7ca4b2d2c8ac2b409e7a - type_inferenced_ast: 2f852c7591f1790075fe73a53f9b2ceb3bca69a8cc7ef1d27d70e5f53e8b144f + imports_resolved_ast: fea14681781a91a1f32b03071124e04fffaa4aee9d463a095709d8f1ed184526 + canonicalized_ast: 06b429640a8e045f97e58ad1ed527ec0c98cd37ca44bdf2998582c82dcfd2698 + type_inferenced_ast: df47838a1076aafdb0310ba012b77f7be3981b998f332073be5d44e19316cb2f diff --git a/tests/expectations/compiler/compiler/statements/for_loop.leo.out b/tests/expectations/compiler/compiler/statements/for_loop.leo.out index 57be45f90b..b41ea92701 100644 --- a/tests/expectations/compiler/compiler/statements/for_loop.leo.out +++ b/tests/expectations/compiler/compiler/statements/for_loop.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: a8e737bf2fcc5b5096dae768b52c04d56891a4eedd47640a0e1aea5fa4b5da1a - imports_resolved_ast: a8e737bf2fcc5b5096dae768b52c04d56891a4eedd47640a0e1aea5fa4b5da1a - canonicalized_ast: cb2eb0272a5a1730cebeaab7a63578ae0f366615af0687a83772fdcbab8b4a93 - type_inferenced_ast: 4d4e9f8fa02ed1c33893ee0f05737a8fc22062039bf2c6a69c8a95c09ba3c6d4 + imports_resolved_ast: 46f86cc467af2e56c7c695269d0c373fe3a0ba708ddce3025ea577fb862a6130 + canonicalized_ast: 22b0c532ccd649fec8276fe6179a5767f59391447343c39cbc1868fb24668972 + type_inferenced_ast: b6796ecb4d41011610f93a2a3a9a315a29f00e13fb7936a37badb9b881f3db1f diff --git a/tests/expectations/compiler/compiler/statements/iteration_basic.leo.out b/tests/expectations/compiler/compiler/statements/iteration_basic.leo.out index c5e803d5c2..694cc0714b 100644 --- a/tests/expectations/compiler/compiler/statements/iteration_basic.leo.out +++ b/tests/expectations/compiler/compiler/statements/iteration_basic.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 416faf733ca084378ca66e5900ab7ffdbb057312e358d6652d6260eff3670fc6 - imports_resolved_ast: 416faf733ca084378ca66e5900ab7ffdbb057312e358d6652d6260eff3670fc6 - canonicalized_ast: 2ec69f397b7c48bc222d812fe4afae7ea375048ceb798e17063f08ea9ccdd040 - type_inferenced_ast: 8062f011312fc76f0f1d73a628292f38deb179974e1edd18af52ee7084279ab2 + imports_resolved_ast: be25d44bdd75b2b0c8536d28be723e1e7aa8347aec71e065021b35c97d9bf156 + canonicalized_ast: 6900c1acd174c83e49adebff815b0f9608379690f351f32df83c755e83f0b7bb + type_inferenced_ast: 0cdf2a19040d022bdc0263dff24b42e492a1b656ab0d7fd23d35ad0a28b283c6 diff --git a/tests/expectations/compiler/compiler/statements/iteration_variable.leo.out b/tests/expectations/compiler/compiler/statements/iteration_variable.leo.out index 502d9d29f0..1e2d5478ed 100644 --- a/tests/expectations/compiler/compiler/statements/iteration_variable.leo.out +++ b/tests/expectations/compiler/compiler/statements/iteration_variable.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 038e16c427982d50e1f29bfb1ef4b9b5809592d431a167809641d2816255fe70 - imports_resolved_ast: 038e16c427982d50e1f29bfb1ef4b9b5809592d431a167809641d2816255fe70 - canonicalized_ast: 1d600ee2250660418ea73d55518937eac92695b6441fc2656de4568c4e7bed8c - type_inferenced_ast: 4f070f1df9bc5c1c7a5b4932b3348504b0a0b07df862e6ca027ee272208a5f79 + imports_resolved_ast: 3ec5e8ad7cf8339c3cf247ed5f8c841f5060f570250584297b4fa26222616734 + canonicalized_ast: 4e9820a02a20e8fce1246a201fa7e151b87a46f19582fc9de501dfda6a7e90e0 + type_inferenced_ast: 1156b595c36f6ef9b8506381298b558bca39784197eb75577c1b728051bc015f diff --git a/tests/expectations/compiler/compiler/statements/multiple_returns.leo.out b/tests/expectations/compiler/compiler/statements/multiple_returns.leo.out index aa199caf4a..3766c3cf5e 100644 --- a/tests/expectations/compiler/compiler/statements/multiple_returns.leo.out +++ b/tests/expectations/compiler/compiler/statements/multiple_returns.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "false" initial_ast: f842a0668ac2fa61ee1f4c693c5159b1395527ee355e8d1d54da9e1ed63ac3ca - imports_resolved_ast: f842a0668ac2fa61ee1f4c693c5159b1395527ee355e8d1d54da9e1ed63ac3ca - canonicalized_ast: f842a0668ac2fa61ee1f4c693c5159b1395527ee355e8d1d54da9e1ed63ac3ca - type_inferenced_ast: 5adf5966c1fdb8a72af941b5b706d7a24b732441b7f56fb3de1319035ade46ec + imports_resolved_ast: 9561b25b543c043e96b0b33af9fa9541b6050d14d0a4483d436ec700a9b00cfa + canonicalized_ast: 9561b25b543c043e96b0b33af9fa9541b6050d14d0a4483d436ec700a9b00cfa + type_inferenced_ast: a5ecac423de991e6a0be347eb798adc2c155dc97253d8590193fdec76216d89f diff --git a/tests/expectations/compiler/compiler/statements/mutate.leo.out b/tests/expectations/compiler/compiler/statements/mutate.leo.out index 88e5c52e5d..130bfcd7e7 100644 --- a/tests/expectations/compiler/compiler/statements/mutate.leo.out +++ b/tests/expectations/compiler/compiler/statements/mutate.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: 1939d0c4720ac464347a680666fee91d1db59acfd36c8e7f6ea1255b4787b39b - imports_resolved_ast: 1939d0c4720ac464347a680666fee91d1db59acfd36c8e7f6ea1255b4787b39b - canonicalized_ast: 1939d0c4720ac464347a680666fee91d1db59acfd36c8e7f6ea1255b4787b39b - type_inferenced_ast: 662b43067b1ddf0db1b7f5d71a07eb84ff79074c187398d4367b8694f066726b + imports_resolved_ast: b89178c115354eaa60c231e518bfa5b02641ee1c10a03c241e4f6f493c332bbe + canonicalized_ast: b89178c115354eaa60c231e518bfa5b02641ee1c10a03c241e4f6f493c332bbe + type_inferenced_ast: 6323ad7461f1b83e1cea4f04737798f60dc21ec7410d0f12e37c80604d273205 diff --git a/tests/expectations/compiler/compiler/statements/nested_mutate.leo.out b/tests/expectations/compiler/compiler/statements/nested_mutate.leo.out index 22e2fa0227..cd001cb28f 100644 --- a/tests/expectations/compiler/compiler/statements/nested_mutate.leo.out +++ b/tests/expectations/compiler/compiler/statements/nested_mutate.leo.out @@ -29,6 +29,6 @@ outputs: type: bool value: "false" initial_ast: ebf32d52f9b74643177b087221c52f994e439347407c948643b7261e107007ed - imports_resolved_ast: ebf32d52f9b74643177b087221c52f994e439347407c948643b7261e107007ed - canonicalized_ast: 2a2f30c10bc808923ae1f7fedc3debd765be612cfa1d100a853d0a2dfb65f58b - type_inferenced_ast: 628f6316908cc79ef0740fdd8baf179e9e969d19d82786f51e78a4d11bd6dab8 + imports_resolved_ast: 957fea00248b0c95353fb52df73d641872b4a49b2c80904107e2a291199f63c5 + canonicalized_ast: d70166c6f0d5164b75e7565a063e0a7e19d737e795d75b306ad45273e0135044 + type_inferenced_ast: 64faf1b65dfb08aca0264eebd0ecc14edad60aa03e14020452f1e7131adafa9b diff --git a/tests/expectations/compiler/compiler/statements/reverse_loops.leo.out b/tests/expectations/compiler/compiler/statements/reverse_loops.leo.out index 44d14de590..adf7739b28 100644 --- a/tests/expectations/compiler/compiler/statements/reverse_loops.leo.out +++ b/tests/expectations/compiler/compiler/statements/reverse_loops.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: f64afadac31c349e9c03da12d924241f36316181323adf5bd8d64b01198747f6 - imports_resolved_ast: f64afadac31c349e9c03da12d924241f36316181323adf5bd8d64b01198747f6 - canonicalized_ast: feee8d1b761c72c684f8b6a7cb985357fa8897cbc229e69302df68655669a77e - type_inferenced_ast: c8d365cde5e39faabbea291d537590c08423e4dd281327d67f3a6994a5492e53 + imports_resolved_ast: dc06a0c5e33a1077dcdce801cc9e6ec1638269612dffa248bfe437231eb9d6bb + canonicalized_ast: dc8630c3f8b57b7d1411eb348cf85bfa9e4eebf6a8d409702deacd459fa0e9bd + type_inferenced_ast: 2aaf8e2be3711e5513724f4149ab6c53ff8ea1813c492a273e290257edf4d144 diff --git a/tests/expectations/compiler/compiler/statements/reverse_one.leo.out b/tests/expectations/compiler/compiler/statements/reverse_one.leo.out index a95ee39d2c..8ab3130589 100644 --- a/tests/expectations/compiler/compiler/statements/reverse_one.leo.out +++ b/tests/expectations/compiler/compiler/statements/reverse_one.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: e999f088de99a6223d147bd686fac839d98f2d6ba2a9abb38b6d234f8c90231d - imports_resolved_ast: e999f088de99a6223d147bd686fac839d98f2d6ba2a9abb38b6d234f8c90231d - canonicalized_ast: bb02f855d59f2f551f3248cca61b12a53c28977f0ec41cf9bed9d1434c88b9ab - type_inferenced_ast: 1be9b8e6dc45ea9bd2bfd6888d1538563b532e57f180a8cbbf0dd6036ee2bf56 + imports_resolved_ast: 9a151c0221def4a6dcb34a0b0745f614e0b0568e261ce9ff666e717e671fec3e + canonicalized_ast: df44174c9a3bf59ab3660556cb34ce0aa892a14e87351a03f344d7723a7494ef + type_inferenced_ast: 91621e1d4e3788186218a27aa9de7bbf9e5436c4d443fdd893f577dd009e9aae diff --git a/tests/expectations/compiler/compiler/statements/ternary_explicit_and_implicit.leo.out b/tests/expectations/compiler/compiler/statements/ternary_explicit_and_implicit.leo.out index 285509211b..823173bcef 100644 --- a/tests/expectations/compiler/compiler/statements/ternary_explicit_and_implicit.leo.out +++ b/tests/expectations/compiler/compiler/statements/ternary_explicit_and_implicit.leo.out @@ -17,6 +17,6 @@ outputs: type: u8 value: "3" initial_ast: 8eb489d084203ff568db699a97d68cb7be586b99269cd3caa5ed075735a89430 - imports_resolved_ast: 8eb489d084203ff568db699a97d68cb7be586b99269cd3caa5ed075735a89430 - canonicalized_ast: 8eb489d084203ff568db699a97d68cb7be586b99269cd3caa5ed075735a89430 - type_inferenced_ast: 9599e37cdf0cbd702e3ee2e025996cd72d6df4c173ce591f713b685dc19d4d0f + imports_resolved_ast: 9ec5d13c17041970f23312a0a07242773baae388682451b583b8162d53feae86 + canonicalized_ast: 9ec5d13c17041970f23312a0a07242773baae388682451b583b8162d53feae86 + type_inferenced_ast: 3e9864fb1e4003939ec04bba653e20a42a990fe435e4280fb8629eef9b0d20f6 diff --git a/tests/expectations/compiler/compiler/stdlib/core_circuit_invalid.leo.out b/tests/expectations/compiler/compiler/stdlib/core_circuit_invalid.leo.out new file mode 100644 index 0000000000..ddf8c56ae5 --- /dev/null +++ b/tests/expectations/compiler/compiler/stdlib/core_circuit_invalid.leo.out @@ -0,0 +1,5 @@ +--- +namespace: Compile +expectation: Fail +outputs: + - "Error [EASG0373043]: failed to resolve import: 'std.unstable.blake2s'\n --> compiler-test:3:29\n |\n 3 | import std.unstable.blake2s.BadCircuit; // `BadCircuit` is not included in the blake2s package\n | ^^^^^^^^^^" diff --git a/tests/expectations/compiler/compiler/stdlib/core_circuit_star_fail.leo.out b/tests/expectations/compiler/compiler/stdlib/core_circuit_star_fail.leo.out new file mode 100644 index 0000000000..d0290df4cd --- /dev/null +++ b/tests/expectations/compiler/compiler/stdlib/core_circuit_star_fail.leo.out @@ -0,0 +1,5 @@ +--- +namespace: Compile +expectation: Fail +outputs: + - "Error [EAST0372011]: failed to resolve import: 'std'\n --> compiler-test:3:12\n |\n 3 | import std.*; // You cannot import all dependencies from core at once\n | ^" diff --git a/tests/expectations/compiler/compiler/stdlib/core_package_invalid.leo.out b/tests/expectations/compiler/compiler/stdlib/core_package_invalid.leo.out new file mode 100644 index 0000000000..810fed52f4 --- /dev/null +++ b/tests/expectations/compiler/compiler/stdlib/core_package_invalid.leo.out @@ -0,0 +1,5 @@ +--- +namespace: Compile +expectation: Fail +outputs: + - "Error [EAST0372011]: failed to resolve import: 'std'\n --> compiler-test:3:12\n |\n 3 | import std.bad_circuit; // `bad_circuit` is not a core package\n | ^^^^^^^^^^^" diff --git a/tests/expectations/compiler/compiler/stdlib/core_unstable_package_invalid.leo.out b/tests/expectations/compiler/compiler/stdlib/core_unstable_package_invalid.leo.out new file mode 100644 index 0000000000..3b43dfc3df --- /dev/null +++ b/tests/expectations/compiler/compiler/stdlib/core_unstable_package_invalid.leo.out @@ -0,0 +1,5 @@ +--- +namespace: Compile +expectation: Fail +outputs: + - "Error [EAST0372011]: failed to resolve import: 'std.unstable'\n --> compiler-test:3:21\n |\n 3 | import std.unstable.bad_circuit; // `bad_circuit` is not a core unstable package\n | ^^^^^^^^^^^" diff --git a/tests/expectations/compiler/compiler/string/circuit.leo.out b/tests/expectations/compiler/compiler/string/circuit.leo.out index db348e5a04..5294a807b2 100644 --- a/tests/expectations/compiler/compiler/string/circuit.leo.out +++ b/tests/expectations/compiler/compiler/string/circuit.leo.out @@ -17,6 +17,6 @@ outputs: type: "[char; 13]" value: "\"Hello, World!\"" initial_ast: 3aa0745060289c1a1af4e66265f8a92a89caff1731dc70d8c6a59798152f1a38 - imports_resolved_ast: 3aa0745060289c1a1af4e66265f8a92a89caff1731dc70d8c6a59798152f1a38 - canonicalized_ast: a1acfd3169b8f72975cd7cc9ef2059cd8fb1ed5ea0a7f51911d3365b52375e36 - type_inferenced_ast: f84470f86eadd14d2a9a56e4f1c2ff349610064704c30b169f15f0bd82b61959 + imports_resolved_ast: 51a077846fa46a0623fcd57e547717ebc28d1fa97bec7f5205e7d48f986ffda5 + canonicalized_ast: 559d13c93a8a8e0bef3e8db4e6f4a543aeca6dde6910ee6d136c43f9c73d1e6a + type_inferenced_ast: 67251b4a2e59336b16ebaa4c2f892a1595f426259a12a84d6cfd7da5626d82c5 diff --git a/tests/expectations/compiler/compiler/string/equality.leo.out b/tests/expectations/compiler/compiler/string/equality.leo.out index ab5b54b3ff..d0424877be 100644 --- a/tests/expectations/compiler/compiler/string/equality.leo.out +++ b/tests/expectations/compiler/compiler/string/equality.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "false" initial_ast: 18cc23be73fed22f06b3bfdb93c1b92688131d4bbeb0d68ed8dc691c97f0c415 - imports_resolved_ast: 18cc23be73fed22f06b3bfdb93c1b92688131d4bbeb0d68ed8dc691c97f0c415 - canonicalized_ast: 63331696106397640ace1c15d354979b8a05f25dd650465954cd1fd72124bae6 - type_inferenced_ast: 83e3cba193c50f19049cdf4296d75187cfd9d6d9fa5276fd328c2e3acf0936e2 + imports_resolved_ast: b688df7cfccd197ffec59397049fe7d3714c525a78674aa012a41c3326df747b + canonicalized_ast: ccc7e76d013ec888fb2f852204d6740e411aac19f586bc9cf334f77d9e69fe73 + type_inferenced_ast: d97c86044424b1f50cdb8838fa8b6f8d1de75db74bd9ede46b443eeaab4eac28 diff --git a/tests/expectations/compiler/compiler/string/replace.leo.out b/tests/expectations/compiler/compiler/string/replace.leo.out index 3fb95cb985..905fb7172b 100644 --- a/tests/expectations/compiler/compiler/string/replace.leo.out +++ b/tests/expectations/compiler/compiler/string/replace.leo.out @@ -23,6 +23,6 @@ outputs: type: bool value: "true" initial_ast: f3c204e48bcf159d84b551a7af01a54b49a9cd6b0ba35ab8c3e68d50caf215e6 - imports_resolved_ast: f3c204e48bcf159d84b551a7af01a54b49a9cd6b0ba35ab8c3e68d50caf215e6 - canonicalized_ast: 91c83cb469e2c9d1b4f6835dd2d503d330c9cfdc7ee4693490cced2835caa4e7 - type_inferenced_ast: d7f4ab6acb5c9569c42367d28c8af286c07147cb68a6ec31146b844ec257d2ac + imports_resolved_ast: 5ec122e1aa6de65e377d6432406f1ec690290a69fa6aac3bfebec545717797ae + canonicalized_ast: f5e314dcfae2ffbe59756d4ae65d8d6f0078a2d2753ede2461e2a3dd010857ca + type_inferenced_ast: f9919236e4853a4bc75b59f915410ce2e14e9b05b1f3bb4201484008acfc1d07 diff --git a/tests/expectations/compiler/compiler/string/string_transformation.leo.out b/tests/expectations/compiler/compiler/string/string_transformation.leo.out index b8352f44e2..6dfcfd3dfd 100644 --- a/tests/expectations/compiler/compiler/string/string_transformation.leo.out +++ b/tests/expectations/compiler/compiler/string/string_transformation.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: cb6caa7598139ad4bdf20a4ace3eb443f83932c91606214227c192684efa2c33 - imports_resolved_ast: cb6caa7598139ad4bdf20a4ace3eb443f83932c91606214227c192684efa2c33 - canonicalized_ast: ef8938160ef517c3856d42b1c651877de6baaa791409cd92ea0552b8c82b228a - type_inferenced_ast: 313f5120e880583f9cced569d3afcfe7b893a8b9c58f521680037df4202e6d8c + imports_resolved_ast: f4d1dcc6d4d40c15e0255abf329ae68a32637fb36b274f5d17f090757de57984 + canonicalized_ast: 941585ff9243bbd3b96d5653335d17ed20729bf2c4d9770fafdb85f6df80f20b + type_inferenced_ast: 8ee3a213e15295db78aa8bcef806341951dcc4c1aa8fa564c8eb22b134bbc2ee diff --git a/tests/expectations/compiler/compiler/tuples/access.leo.out b/tests/expectations/compiler/compiler/tuples/access.leo.out index 7611a6cff7..5881ab71aa 100644 --- a/tests/expectations/compiler/compiler/tuples/access.leo.out +++ b/tests/expectations/compiler/compiler/tuples/access.leo.out @@ -20,6 +20,6 @@ outputs: type: bool value: "false" initial_ast: 1398434e8180a7aba868bc9caa21b5d226a4c8216e0086a6f48d6c503e41c263 - imports_resolved_ast: 1398434e8180a7aba868bc9caa21b5d226a4c8216e0086a6f48d6c503e41c263 - canonicalized_ast: 1398434e8180a7aba868bc9caa21b5d226a4c8216e0086a6f48d6c503e41c263 - type_inferenced_ast: fed99174e3afb30da68a430b96242d63b45bb1ce58028d5c7352cc64dcbd98b7 + imports_resolved_ast: 1513488afdfeb2e13cbaaf3c3aff84b719777fe671f28d6c5b74cab0864ad22f + canonicalized_ast: 1513488afdfeb2e13cbaaf3c3aff84b719777fe671f28d6c5b74cab0864ad22f + type_inferenced_ast: 362543f57b44efffc4ea072a37f2923e74bb253f575527b425b018f0c1e199bc diff --git a/tests/expectations/compiler/compiler/tuples/basic.leo.out b/tests/expectations/compiler/compiler/tuples/basic.leo.out index 1a231ec76b..6ca21b0c66 100644 --- a/tests/expectations/compiler/compiler/tuples/basic.leo.out +++ b/tests/expectations/compiler/compiler/tuples/basic.leo.out @@ -20,6 +20,6 @@ outputs: type: bool value: "false" initial_ast: 10550feaa2c5235500abf424e222f1f8383225ae3b6906c1cd76835e83286817 - imports_resolved_ast: 10550feaa2c5235500abf424e222f1f8383225ae3b6906c1cd76835e83286817 - canonicalized_ast: 10550feaa2c5235500abf424e222f1f8383225ae3b6906c1cd76835e83286817 - type_inferenced_ast: db07b90097bb2605e23365d07d039b7845e9c7e7313a7ecaa01116dae93912ad + imports_resolved_ast: 9fc2987460c5e803ede8cc9f5f3e156c4863203d39ba4d7acdacfce050f9229b + canonicalized_ast: 9fc2987460c5e803ede8cc9f5f3e156c4863203d39ba4d7acdacfce050f9229b + type_inferenced_ast: 3b9f564f14bafe542c8ee1052e02dec08fb6bdcbdde76419761bbbcb7b6cf0f8 diff --git a/tests/expectations/compiler/compiler/tuples/dependent.leo.out b/tests/expectations/compiler/compiler/tuples/dependent.leo.out index 4a3cf972dd..eb5efca71e 100644 --- a/tests/expectations/compiler/compiler/tuples/dependent.leo.out +++ b/tests/expectations/compiler/compiler/tuples/dependent.leo.out @@ -20,6 +20,6 @@ outputs: type: bool value: "false" initial_ast: be3a0206397e9b0f95c696b4d7174ee81262e805fc787b3516b1b1a277892a4d - imports_resolved_ast: be3a0206397e9b0f95c696b4d7174ee81262e805fc787b3516b1b1a277892a4d - canonicalized_ast: be3a0206397e9b0f95c696b4d7174ee81262e805fc787b3516b1b1a277892a4d - type_inferenced_ast: 672df08a8f52ff75d5cdba1f4ebc070baba70a981351819d2205b3e8de76bfc7 + imports_resolved_ast: bfeccc62c9e5153cef910f5b98ecf1b58d3ca2ef21e612f7f9ebe20887206648 + canonicalized_ast: bfeccc62c9e5153cef910f5b98ecf1b58d3ca2ef21e612f7f9ebe20887206648 + type_inferenced_ast: 8abbaab7a395c9ee099837c0f1c99c22fbbadeec35887a9a01ae4d2002335cbe diff --git a/tests/expectations/compiler/compiler/tuples/destructured.leo.out b/tests/expectations/compiler/compiler/tuples/destructured.leo.out index 4c8ca35ede..34ef3beaa4 100644 --- a/tests/expectations/compiler/compiler/tuples/destructured.leo.out +++ b/tests/expectations/compiler/compiler/tuples/destructured.leo.out @@ -20,6 +20,6 @@ outputs: type: bool value: "true" initial_ast: ea7f6cc8c9fe0deda02c3fde1f33dd71c33b6938c832af0f220fb681f56f9354 - imports_resolved_ast: ea7f6cc8c9fe0deda02c3fde1f33dd71c33b6938c832af0f220fb681f56f9354 - canonicalized_ast: ea7f6cc8c9fe0deda02c3fde1f33dd71c33b6938c832af0f220fb681f56f9354 - type_inferenced_ast: 72d9dedc48ac69de544b2f35b1f0e675f4053f562fc708b30eebcfdc6ac59dc9 + imports_resolved_ast: 63cb9c8fd831d75199b70d59ccd1b8817584a5732b06ed82b13f09290f2ea4fe + canonicalized_ast: 63cb9c8fd831d75199b70d59ccd1b8817584a5732b06ed82b13f09290f2ea4fe + type_inferenced_ast: 60459364133940ab9776904236e361fcd21704c74616159a9712c51b3f280398 diff --git a/tests/expectations/compiler/compiler/tuples/nested_access.leo.out b/tests/expectations/compiler/compiler/tuples/nested_access.leo.out index f88364c476..fafd95204f 100644 --- a/tests/expectations/compiler/compiler/tuples/nested_access.leo.out +++ b/tests/expectations/compiler/compiler/tuples/nested_access.leo.out @@ -20,6 +20,6 @@ outputs: type: bool value: "false" initial_ast: fbd413171641a048b40bf3141ee1ae3218a205e4679721ce61e0e114bb2e340b - imports_resolved_ast: fbd413171641a048b40bf3141ee1ae3218a205e4679721ce61e0e114bb2e340b - canonicalized_ast: fbd413171641a048b40bf3141ee1ae3218a205e4679721ce61e0e114bb2e340b - type_inferenced_ast: 8dcc217ea727817113ac27684c71b3b8914a9f621952b8555d5fc4843a79967f + imports_resolved_ast: 61fdd2c00bc4eab3670e14a910d3b41c29c576504cf7a1f2f23c833c54979dd4 + canonicalized_ast: 61fdd2c00bc4eab3670e14a910d3b41c29c576504cf7a1f2f23c833c54979dd4 + type_inferenced_ast: 2fb45a1c5986db01fa9bec02302d50c3ad63c66f27bfe3436431da0c9beaa6d9 From 093517109be4a7a6f08c5427e23434dae22937bb Mon Sep 17 00:00:00 2001 From: damirka Date: Fri, 10 Sep 2021 16:11:55 +0300 Subject: [PATCH 05/25] renaming, now .length() --- asg/src/expression/{sizeof.rs => lengthof.rs} | 35 ++++++------------- asg/src/expression/mod.rs | 30 ++++++++-------- asg/src/reducer/monoidal_director.rs | 6 ++-- asg/src/reducer/monoidal_reducer.rs | 2 +- asg/src/reducer/reconstructing_director.rs | 2 +- asg/src/reducer/visitor.rs | 2 +- asg/src/reducer/visitor_director.rs | 6 ++-- ast/src/expression/{sizeof.rs => lengthof.rs} | 6 ++-- ast/src/expression/mod.rs | 12 +++---- ast/src/reducer/reconstructing_director.rs | 2 +- compiler/src/expression/expression.rs | 4 +-- .../operator/{sizeof.rs => lengthof.rs} | 10 +++--- compiler/src/expression/operator/mod.rs | 4 +-- errors/src/compiler/compiler_errors.rs | 7 ++++ grammar/src/main.rs | 5 +++ parser/src/parser/expression.rs | 22 +++++++++--- parser/src/tokenizer/lexer.rs | 4 ++- parser/src/tokenizer/token.rs | 9 ++--- .../array_without_size/input/dummy.in | 1 + tests/compiler/array_without_size/length.leo | 9 +++++ .../array_without_size/length_fail.leo | 9 +++++ .../array_without_size/length_function.leo | 17 +++++++++ .../array_without_size/length.leo.out | 22 ++++++++++++ .../array_without_size/length_fail.leo.out | 5 +++ .../length_function.leo.out | 22 ++++++++++++ 25 files changed, 176 insertions(+), 77 deletions(-) rename asg/src/expression/{sizeof.rs => lengthof.rs} (67%) rename ast/src/expression/{sizeof.rs => lengthof.rs} (91%) rename compiler/src/expression/operator/{sizeof.rs => lengthof.rs} (83%) create mode 100644 tests/compiler/array_without_size/length.leo create mode 100644 tests/compiler/array_without_size/length_fail.leo create mode 100644 tests/compiler/array_without_size/length_function.leo create mode 100644 tests/expectations/compiler/compiler/array_without_size/length.leo.out create mode 100644 tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out create mode 100644 tests/expectations/compiler/compiler/array_without_size/length_function.leo.out diff --git a/asg/src/expression/sizeof.rs b/asg/src/expression/lengthof.rs similarity index 67% rename from asg/src/expression/sizeof.rs rename to asg/src/expression/lengthof.rs index bc580eeae1..ee8c883ebb 100644 --- a/asg/src/expression/sizeof.rs +++ b/asg/src/expression/lengthof.rs @@ -21,19 +21,19 @@ use leo_errors::{Result, Span}; use std::cell::Cell; #[derive(Clone)] -pub struct SizeOfExpression<'a> { +pub struct LengthOfExpression<'a> { pub parent: Cell>>, pub span: Option, pub inner: Cell<&'a Expression<'a>>, } -impl<'a> Node for SizeOfExpression<'a> { +impl<'a> Node for LengthOfExpression<'a> { fn span(&self) -> Option<&Span> { self.span.as_ref() } } -impl<'a> ExpressionNode<'a> for SizeOfExpression<'a> { +impl<'a> ExpressionNode<'a> for LengthOfExpression<'a> { fn set_parent(&self, parent: &'a Expression<'a>) { self.parent.replace(Some(parent)); } @@ -47,10 +47,7 @@ impl<'a> ExpressionNode<'a> for SizeOfExpression<'a> { } fn get_type(&self) -> Option> { - // TODO: make decision on get type method - // Should it be always u32? For indexes? - // How type casts are applied to this? - Some(Type::Integer(IntegerType::U32)) + Some(Type::Integer(IntegerType::U32)) // For now we stick to U32 value type } fn is_mut_ref(&self) -> bool { @@ -58,16 +55,6 @@ impl<'a> ExpressionNode<'a> for SizeOfExpression<'a> { } fn const_value(&self) -> Option { - let _value = self.inner.get().const_value()?; - // match value { - // ConstValue::Int(int) => match &self.target_type { - // Type::Integer(target) => Some(ConstValue::Int(int.cast_to(target))), - // _ => None, - // }, - // _ => None, - // } - - // TODO: IMPLEMENT CONST VALUE None } @@ -76,15 +63,15 @@ impl<'a> ExpressionNode<'a> for SizeOfExpression<'a> { } } -impl<'a> FromAst<'a, leo_ast::SizeOfExpression> for SizeOfExpression<'a> { +impl<'a> FromAst<'a, leo_ast::LengthOfExpression> for LengthOfExpression<'a> { fn from_ast( scope: &'a Scope<'a>, - value: &leo_ast::SizeOfExpression, + value: &leo_ast::LengthOfExpression, _expected_type: Option>, - ) -> Result> { + ) -> Result> { let inner = <&Expression<'a>>::from_ast(scope, &*value.inner, None)?; - Ok(SizeOfExpression { + Ok(LengthOfExpression { parent: Cell::new(None), span: Some(value.span.clone()), inner: Cell::new(inner), @@ -92,9 +79,9 @@ impl<'a> FromAst<'a, leo_ast::SizeOfExpression> for SizeOfExpression<'a> { } } -impl<'a> Into for &SizeOfExpression<'a> { - fn into(self) -> leo_ast::SizeOfExpression { - leo_ast::SizeOfExpression { +impl<'a> Into for &LengthOfExpression<'a> { + fn into(self) -> leo_ast::LengthOfExpression { + leo_ast::LengthOfExpression { inner: Box::new(self.inner.get().into()), span: self.span.clone().unwrap_or_default(), } diff --git a/asg/src/expression/mod.rs b/asg/src/expression/mod.rs index 34c0c959bd..734b227344 100644 --- a/asg/src/expression/mod.rs +++ b/asg/src/expression/mod.rs @@ -65,8 +65,8 @@ pub use variable_ref::*; mod cast; pub use cast::*; -mod sizeof; -pub use sizeof::*; +mod lengthof; +pub use lengthof::*; use crate::{ConstValue, FromAst, Node, PartialType, Scope, Type}; use leo_errors::{Result, Span}; @@ -79,7 +79,7 @@ pub enum Expression<'a> { Unary(UnaryExpression<'a>), Ternary(TernaryExpression<'a>), Cast(CastExpression<'a>), - SizeOf(SizeOfExpression<'a>), + LengthOf(LengthOfExpression<'a>), ArrayInline(ArrayInlineExpression<'a>), ArrayInit(ArrayInitExpression<'a>), @@ -111,7 +111,7 @@ impl<'a> Node for Expression<'a> { Unary(x) => x.span(), Ternary(x) => x.span(), Cast(x) => x.span(), - SizeOf(x) => x.span(), + LengthOf(x) => x.span(), ArrayInline(x) => x.span(), ArrayInit(x) => x.span(), ArrayAccess(x) => x.span(), @@ -146,7 +146,7 @@ impl<'a> ExpressionNode<'a> for Expression<'a> { Unary(x) => x.set_parent(parent), Ternary(x) => x.set_parent(parent), Cast(x) => x.set_parent(parent), - SizeOf(x) => x.set_parent(parent), + LengthOf(x) => x.set_parent(parent), ArrayInline(x) => x.set_parent(parent), ArrayInit(x) => x.set_parent(parent), ArrayAccess(x) => x.set_parent(parent), @@ -168,7 +168,7 @@ impl<'a> ExpressionNode<'a> for Expression<'a> { Unary(x) => x.get_parent(), Ternary(x) => x.get_parent(), Cast(x) => x.get_parent(), - SizeOf(x) => x.get_parent(), + LengthOf(x) => x.get_parent(), ArrayInline(x) => x.get_parent(), ArrayInit(x) => x.get_parent(), ArrayAccess(x) => x.get_parent(), @@ -190,7 +190,7 @@ impl<'a> ExpressionNode<'a> for Expression<'a> { Unary(x) => x.enforce_parents(expr), Ternary(x) => x.enforce_parents(expr), Cast(x) => x.enforce_parents(expr), - SizeOf(x) => x.enforce_parents(expr), + LengthOf(x) => x.enforce_parents(expr), ArrayInline(x) => x.enforce_parents(expr), ArrayInit(x) => x.enforce_parents(expr), ArrayAccess(x) => x.enforce_parents(expr), @@ -212,7 +212,7 @@ impl<'a> ExpressionNode<'a> for Expression<'a> { Unary(x) => x.get_type(), Ternary(x) => x.get_type(), Cast(x) => x.get_type(), - SizeOf(x) => x.get_type(), + LengthOf(x) => x.get_type(), ArrayInline(x) => x.get_type(), ArrayInit(x) => x.get_type(), ArrayAccess(x) => x.get_type(), @@ -234,7 +234,7 @@ impl<'a> ExpressionNode<'a> for Expression<'a> { Unary(x) => x.is_mut_ref(), Ternary(x) => x.is_mut_ref(), Cast(x) => x.is_mut_ref(), - SizeOf(x) => x.is_mut_ref(), + LengthOf(x) => x.is_mut_ref(), ArrayInline(x) => x.is_mut_ref(), ArrayInit(x) => x.is_mut_ref(), ArrayAccess(x) => x.is_mut_ref(), @@ -256,7 +256,7 @@ impl<'a> ExpressionNode<'a> for Expression<'a> { Unary(x) => x.const_value(), Ternary(x) => x.const_value(), Cast(x) => x.const_value(), - SizeOf(x) => x.const_value(), + LengthOf(x) => x.const_value(), ArrayInline(x) => x.const_value(), ArrayInit(x) => x.const_value(), ArrayAccess(x) => x.const_value(), @@ -278,7 +278,7 @@ impl<'a> ExpressionNode<'a> for Expression<'a> { Unary(x) => x.is_consty(), Ternary(x) => x.is_consty(), Cast(x) => x.is_consty(), - SizeOf(x) => x.is_consty(), + LengthOf(x) => x.is_consty(), ArrayInline(x) => x.is_consty(), ArrayInit(x) => x.is_consty(), ArrayAccess(x) => x.is_consty(), @@ -317,9 +317,9 @@ impl<'a> FromAst<'a, leo_ast::Expression> for &'a Expression<'a> { .context .alloc_expression(CastExpression::from_ast(scope, cast, expected_type).map(Expression::Cast)?), - SizeOf(sizeof) => scope - .context - .alloc_expression(SizeOfExpression::from_ast(scope, sizeof, expected_type).map(Expression::SizeOf)?), + LengthOf(lengthof) => scope.context.alloc_expression( + LengthOfExpression::from_ast(scope, lengthof, expected_type).map(Expression::LengthOf)?, + ), ArrayInline(array_inline) => scope.context.alloc_expression( ArrayInlineExpression::from_ast(scope, array_inline, expected_type).map(Expression::ArrayInline)?, @@ -373,7 +373,7 @@ impl<'a> Into for &Expression<'a> { Unary(x) => leo_ast::Expression::Unary(x.into()), Ternary(x) => leo_ast::Expression::Ternary(x.into()), Cast(x) => leo_ast::Expression::Cast(x.into()), - SizeOf(x) => leo_ast::Expression::SizeOf(x.into()), + LengthOf(x) => leo_ast::Expression::LengthOf(x.into()), ArrayInline(x) => leo_ast::Expression::ArrayInline(x.into()), ArrayInit(x) => leo_ast::Expression::ArrayInit(x.into()), ArrayAccess(x) => leo_ast::Expression::ArrayAccess(x.into()), diff --git a/asg/src/reducer/monoidal_director.rs b/asg/src/reducer/monoidal_director.rs index 182f2aca05..8ce0e1e58b 100644 --- a/asg/src/reducer/monoidal_director.rs +++ b/asg/src/reducer/monoidal_director.rs @@ -48,7 +48,7 @@ impl<'a, T: Monoid, R: MonoidalReducerExpression<'a, T>> MonoidalDirector<'a, T, Expression::CircuitInit(e) => self.reduce_circuit_init(e), Expression::Ternary(e) => self.reduce_ternary_expression(e), Expression::Cast(e) => self.reduce_cast_expression(e), - Expression::SizeOf(e) => self.reduce_sizeof_expression(e), + Expression::LengthOf(e) => self.reduce_lengthof_expression(e), Expression::Constant(e) => self.reduce_constant(e), Expression::TupleAccess(e) => self.reduce_tuple_access(e), Expression::TupleInit(e) => self.reduce_tuple_init(e), @@ -139,10 +139,10 @@ impl<'a, T: Monoid, R: MonoidalReducerExpression<'a, T>> MonoidalDirector<'a, T, self.reducer.reduce_cast_expression(input, inner) } - pub fn reduce_sizeof_expression(&mut self, input: &SizeOfExpression<'a>) -> T { + pub fn reduce_lengthof_expression(&mut self, input: &LengthOfExpression<'a>) -> T { let inner = self.reduce_expression(input.inner.get()); - self.reducer.reduce_sizeof_expression(input, inner) + self.reducer.reduce_lengthof_expression(input, inner) } pub fn reduce_constant(&mut self, input: &Constant<'a>) -> T { diff --git a/asg/src/reducer/monoidal_reducer.rs b/asg/src/reducer/monoidal_reducer.rs index d6b5cac1fc..f33b311f26 100644 --- a/asg/src/reducer/monoidal_reducer.rs +++ b/asg/src/reducer/monoidal_reducer.rs @@ -68,7 +68,7 @@ pub trait MonoidalReducerExpression<'a, T: Monoid> { inner } - fn reduce_sizeof_expression(&mut self, input: &SizeOfExpression<'a>, inner: T) -> T { + fn reduce_lengthof_expression(&mut self, input: &LengthOfExpression<'a>, inner: T) -> T { inner } diff --git a/asg/src/reducer/reconstructing_director.rs b/asg/src/reducer/reconstructing_director.rs index 708c35a0fe..92029b0c43 100644 --- a/asg/src/reducer/reconstructing_director.rs +++ b/asg/src/reducer/reconstructing_director.rs @@ -48,7 +48,7 @@ impl<'a, R: ReconstructingReducerExpression<'a>> ReconstructingDirector<'a, R> { Expression::CircuitInit(e) => self.reduce_circuit_init(e), Expression::Ternary(e) => self.reduce_ternary_expression(e), Expression::Cast(e) => self.reduce_cast_expression(e), - Expression::SizeOf(e) => Expression::SizeOf(e), //self.reduce_sizeof_expression(e), // TODO: implement REDUCER + Expression::LengthOf(e) => Expression::LengthOf(e), // TODO: implement REDUCER Expression::Constant(e) => self.reduce_constant(e), Expression::TupleAccess(e) => self.reduce_tuple_access(e), Expression::TupleInit(e) => self.reduce_tuple_init(e), diff --git a/asg/src/reducer/visitor.rs b/asg/src/reducer/visitor.rs index d577e958bb..4f3b468ab5 100644 --- a/asg/src/reducer/visitor.rs +++ b/asg/src/reducer/visitor.rs @@ -76,7 +76,7 @@ pub trait ExpressionVisitor<'a> { Default::default() } - fn visit_sizeof_expression(&mut self, input: &SizeOfExpression<'a>) -> VisitResult { + fn visit_lengthof_expression(&mut self, input: &LengthOfExpression<'a>) -> VisitResult { Default::default() } diff --git a/asg/src/reducer/visitor_director.rs b/asg/src/reducer/visitor_director.rs index 5c56607b3e..5490f4b014 100644 --- a/asg/src/reducer/visitor_director.rs +++ b/asg/src/reducer/visitor_director.rs @@ -61,7 +61,7 @@ impl<'a, R: ExpressionVisitor<'a>> VisitorDirector<'a, R> { Expression::CircuitInit(e) => self.visit_circuit_init(e), Expression::Ternary(e) => self.visit_ternary_expression(e), Expression::Cast(e) => self.visit_cast_expression(e), - Expression::SizeOf(e) => self.visit_sizeof_expression(e), + Expression::LengthOf(e) => self.visit_lengthof_expression(e), Expression::Constant(e) => self.visit_constant(e), Expression::TupleAccess(e) => self.visit_tuple_access(e), Expression::TupleInit(e) => self.visit_tuple_init(e), @@ -196,8 +196,8 @@ impl<'a, R: ExpressionVisitor<'a>> VisitorDirector<'a, R> { } } - pub fn visit_sizeof_expression(&mut self, input: &SizeOfExpression<'a>) -> ConcreteVisitResult { - match self.visitor.visit_sizeof_expression(input) { + pub fn visit_lengthof_expression(&mut self, input: &LengthOfExpression<'a>) -> ConcreteVisitResult { + match self.visitor.visit_lengthof_expression(input) { VisitResult::VisitChildren => { self.visit_expression(&input.inner)?; Ok(()) diff --git a/ast/src/expression/sizeof.rs b/ast/src/expression/lengthof.rs similarity index 91% rename from ast/src/expression/sizeof.rs rename to ast/src/expression/lengthof.rs index 8b41f11f2d..e5dec13a62 100644 --- a/ast/src/expression/sizeof.rs +++ b/ast/src/expression/lengthof.rs @@ -19,18 +19,18 @@ use super::*; #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] -pub struct SizeOfExpression { +pub struct LengthOfExpression { pub inner: Box, pub span: Span, } -impl fmt::Display for SizeOfExpression { +impl fmt::Display for LengthOfExpression { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { write!(f, "sizeof {}", self.inner) } } -impl Node for SizeOfExpression { +impl Node for LengthOfExpression { fn span(&self) -> &Span { &self.span } diff --git a/ast/src/expression/mod.rs b/ast/src/expression/mod.rs index 7196ee4915..d40dcf109e 100644 --- a/ast/src/expression/mod.rs +++ b/ast/src/expression/mod.rs @@ -54,8 +54,8 @@ mod call; pub use call::*; mod cast; pub use cast::*; -mod sizeof; -pub use sizeof::*; +mod lengthof; +pub use lengthof::*; /// Expression that evaluates to a value #[derive(Debug, Clone, PartialEq, Eq, Serialize, Deserialize)] @@ -66,7 +66,7 @@ pub enum Expression { Unary(UnaryExpression), Ternary(TernaryExpression), Cast(CastExpression), - SizeOf(SizeOfExpression), + LengthOf(LengthOfExpression), ArrayInline(ArrayInlineExpression), ArrayInit(ArrayInitExpression), @@ -103,7 +103,7 @@ impl Node for Expression { CircuitStaticFunctionAccess(n) => n.span(), Call(n) => n.span(), Cast(n) => n.span(), - SizeOf(n) => n.span(), + LengthOf(n) => n.span(), } } @@ -126,7 +126,7 @@ impl Node for Expression { CircuitStaticFunctionAccess(n) => n.set_span(span), Call(n) => n.set_span(span), Cast(n) => n.set_span(span), - SizeOf(n) => n.set_span(span), + LengthOf(n) => n.set_span(span), } } } @@ -151,7 +151,7 @@ impl fmt::Display for Expression { CircuitStaticFunctionAccess(n) => n.fmt(f), Call(n) => n.fmt(f), Cast(n) => n.fmt(f), - SizeOf(n) => n.fmt(f), + LengthOf(n) => n.fmt(f), } } } diff --git a/ast/src/reducer/reconstructing_director.rs b/ast/src/reducer/reconstructing_director.rs index 384a3192ff..c74aad5dbc 100644 --- a/ast/src/reducer/reconstructing_director.rs +++ b/ast/src/reducer/reconstructing_director.rs @@ -57,7 +57,7 @@ impl ReconstructingDirector { Expression::Unary(unary) => Expression::Unary(self.reduce_unary(unary)?), Expression::Ternary(ternary) => Expression::Ternary(self.reduce_ternary(ternary)?), Expression::Cast(cast) => Expression::Cast(self.reduce_cast(cast)?), - Expression::SizeOf(sizeof) => Expression::SizeOf(sizeof.clone()), // Expression::SizeOf(self.reduce_sizeof(sizeof)?), // TODO: add reducer + Expression::LengthOf(sizeof) => Expression::LengthOf(sizeof.clone()), // Expression::LengthOf(self.reduce_sizeof(sizeof)?), // TODO: add reducer Expression::ArrayInline(array_inline) => Expression::ArrayInline(self.reduce_array_inline(array_inline)?), Expression::ArrayInit(array_init) => Expression::ArrayInit(self.reduce_array_init(array_init)?), diff --git a/compiler/src/expression/expression.rs b/compiler/src/expression/expression.rs index 0f85165252..4f9eb24711 100644 --- a/compiler/src/expression/expression.rs +++ b/compiler/src/expression/expression.rs @@ -98,8 +98,8 @@ impl<'a, F: PrimeField, G: GroupType> ConstrainedProgram<'a, F, G> { // Cast Expression::Cast(_) => unimplemented!("casts not implemented"), - // SizeOf - Expression::SizeOf(sizeof) => self.enforce_sizeof(cs, sizeof, span), + // LengthOf + Expression::LengthOf(sizeof) => self.enforce_sizeof(cs, sizeof, span), // Variables Expression::VariableRef(variable_ref) => self.evaluate_ref(variable_ref), diff --git a/compiler/src/expression/operator/sizeof.rs b/compiler/src/expression/operator/lengthof.rs similarity index 83% rename from compiler/src/expression/operator/sizeof.rs rename to compiler/src/expression/operator/lengthof.rs index 2f26634b96..440d1020d0 100644 --- a/compiler/src/expression/operator/sizeof.rs +++ b/compiler/src/expression/operator/lengthof.rs @@ -21,7 +21,7 @@ use crate::{ value::{ConstrainedValue, Integer}, GroupType, }; -use leo_asg::{ConstInt, SizeOfExpression}; +use leo_asg::{ConstInt, LengthOfExpression}; use leo_errors::{Result, Span}; use snarkvm_fields::PrimeField; @@ -32,16 +32,16 @@ impl<'a, F: PrimeField, G: GroupType> ConstrainedProgram<'a, F, G> { pub fn enforce_sizeof>( &mut self, cs: &mut CS, - sizeof: &'a SizeOfExpression<'a>, - _span: &Span, + lengthof: &'a LengthOfExpression<'a>, + span: &Span, ) -> Result> { - let value = self.enforce_expression(cs, sizeof.inner.get())?; + let value = self.enforce_expression(cs, lengthof.inner.get())?; Ok(match value { ConstrainedValue::Array(array) => { ConstrainedValue::Integer(Integer::new(&ConstInt::U32(array.len() as u32))) } - _ => unimplemented!("sizeof can only be used for arrays"), + _ => return Err(leo_errors::CompilerError::lengthof_can_only_be_used_on_arrays(span).into()), }) } } diff --git a/compiler/src/expression/operator/mod.rs b/compiler/src/expression/operator/mod.rs index 773e668d58..2d0e37ccc3 100644 --- a/compiler/src/expression/operator/mod.rs +++ b/compiler/src/expression/operator/mod.rs @@ -14,5 +14,5 @@ // You should have received a copy of the GNU General Public License // along with the Leo library. If not, see . -pub mod sizeof; -pub use self::sizeof::*; +pub mod lengthof; +pub use self::lengthof::*; diff --git a/errors/src/compiler/compiler_errors.rs b/errors/src/compiler/compiler_errors.rs index f46b4e9566..84272a3b45 100644 --- a/errors/src/compiler/compiler_errors.rs +++ b/errors/src/compiler/compiler_errors.rs @@ -834,4 +834,11 @@ create_errors!( msg: format!("no implementation found for `{}`", operation), help: None, } + + @formatted + lengthof_can_only_be_used_on_arrays { + args: (), + msg: "length() can only be called on an array value".to_string(), + help: None, + } ); diff --git a/grammar/src/main.rs b/grammar/src/main.rs index 28b9f6da74..d180ef3bb4 100644 --- a/grammar/src/main.rs +++ b/grammar/src/main.rs @@ -222,3 +222,8 @@ fn main() -> Result<()> { Ok(()) } + +#[test] +fn test_true() { + assert!(true); +} diff --git a/parser/src/parser/expression.rs b/parser/src/parser/expression.rs index 233e253f3b..eb07d5f4f0 100644 --- a/parser/src/parser/expression.rs +++ b/parser/src/parser/expression.rs @@ -402,8 +402,20 @@ impl ParserContext { /// pub fn parse_postfix_expression(&mut self) -> Result { let mut expr = self.parse_primary_expression()?; - while let Some(token) = self.eat_any(&[Token::LeftSquare, Token::Dot, Token::LeftParen, Token::DoubleColon]) { + while let Some(token) = self.eat_any(&[ + Token::LeftSquare, + Token::Dot, + Token::LeftParen, + Token::DoubleColon, + Token::LengthOf, + ]) { match token.token { + Token::LengthOf => { + expr = Expression::LengthOf(LengthOfExpression { + span: expr.span().clone(), + inner: Box::new(expr), + }) + } Token::LeftSquare => { if self.eat(Token::DotDot).is_some() { let right = if self.peek_token().as_ref() != &Token::RightSquare { @@ -727,10 +739,10 @@ impl ParserContext { }; Expression::Identifier(ident) } - Token::SizeOf => Expression::SizeOf(SizeOfExpression { - span, - inner: Box::new(self.parse_primary_expression()?), - }), + // Token::LengthOf => Expression::LengthOf(LengthOfExpression { + // span, + // inner: Box::new(self.parse_primary_expression()?), + // }), token => { return Err(ParserError::unexpected_str(token, "expression", &span).into()); } diff --git a/parser/src/tokenizer/lexer.rs b/parser/src/tokenizer/lexer.rs index 455b125028..7a7c32ed92 100644 --- a/parser/src/tokenizer/lexer.rs +++ b/parser/src/tokenizer/lexer.rs @@ -388,6 +388,9 @@ impl Token { return (len, Some(Token::DotDotDot)); } else if let Some(len) = eat(input, "..") { return (len, Some(Token::DotDot)); + } else if let Some(len) = eat(input, ".length()") { + // FIXME: remove this code once we allow method calls + return (len, Some(Token::LengthOf)); } return (1, Some(Token::Dot)); } @@ -519,7 +522,6 @@ impl Token { "string" => Token::String, "true" => Token::True, "type" => Token::Type, - "sizeof" => Token::SizeOf, "u8" => Token::U8, "u16" => Token::U16, "u32" => Token::U32, diff --git a/parser/src/tokenizer/token.rs b/parser/src/tokenizer/token.rs index 6c5f0ff981..97ac2164fd 100644 --- a/parser/src/tokenizer/token.rs +++ b/parser/src/tokenizer/token.rs @@ -140,8 +140,9 @@ pub enum Token { String, Type, - // Operators - SizeOf, + // Not yet in ABNF + // arr.length() token - hacky zone + LengthOf, // Not yet in ABNF // BitAnd, @@ -199,7 +200,7 @@ pub const KEYWORD_TOKENS: &[Token] = &[ Token::String, Token::True, Token::Type, - Token::SizeOf, + Token::LengthOf, Token::U8, Token::U16, Token::U32, @@ -312,7 +313,7 @@ impl fmt::Display for Token { Static => write!(f, "static"), String => write!(f, "string"), Type => write!(f, "type"), - SizeOf => write!(f, "sizeof"), + LengthOf => write!(f, ".length()"), // FIXME Eof => write!(f, ""), // BitAnd => write!(f, "&"), // BitAndEq => write!(f, "&="), diff --git a/tests/compiler/array_without_size/input/dummy.in b/tests/compiler/array_without_size/input/dummy.in index 6e43b49ecc..9a0231bcd8 100644 --- a/tests/compiler/array_without_size/input/dummy.in +++ b/tests/compiler/array_without_size/input/dummy.in @@ -1,6 +1,7 @@ [main] y: bool = true; n: bool = false; +a: [char; 11] = "hello world"; [registers] r0: bool = false; diff --git a/tests/compiler/array_without_size/length.leo b/tests/compiler/array_without_size/length.leo new file mode 100644 index 0000000000..234815c8fc --- /dev/null +++ b/tests/compiler/array_without_size/length.leo @@ -0,0 +1,9 @@ +/* +namespace: Compile +expectation: Pass +input_file: input/dummy.in +*/ + +function main(a: [char; 11], y: bool) -> bool { + return y == (a.length() == 11); +} diff --git a/tests/compiler/array_without_size/length_fail.leo b/tests/compiler/array_without_size/length_fail.leo new file mode 100644 index 0000000000..b9175ecdc5 --- /dev/null +++ b/tests/compiler/array_without_size/length_fail.leo @@ -0,0 +1,9 @@ +/* +namespace: Compile +expectation: Fail +input_file: input/dummy.in +*/ + +function main(y: bool) { + return 10.length() == 10u8; +} diff --git a/tests/compiler/array_without_size/length_function.leo b/tests/compiler/array_without_size/length_function.leo new file mode 100644 index 0000000000..7a1d371943 --- /dev/null +++ b/tests/compiler/array_without_size/length_function.leo @@ -0,0 +1,17 @@ +/* +namespace: Compile +expectation: Pass +input_file: input/dummy.in +*/ + +function main(y: bool) -> bool { + let x = 0u8; + for i in 0..strlen("I swear to god I had something for this") { + x += 1; + } + return (x == 39) == y; +} + +function strlen(str: [char; _]) -> u32 { + return str.length(); +} diff --git a/tests/expectations/compiler/compiler/array_without_size/length.leo.out b/tests/expectations/compiler/compiler/array_without_size/length.leo.out new file mode 100644 index 0000000000..5f40d5fcdd --- /dev/null +++ b/tests/expectations/compiler/compiler/array_without_size/length.leo.out @@ -0,0 +1,22 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - circuit: + num_public_variables: 0 + num_private_variables: 12 + num_constraints: 1 + at: 336f487fe39f24aef980deaaf7d6dddcc0dbfa8f121c3470b05546c1ac13f87e + bt: ae35381db5558456a49acb22132b4930efd53b90eb2668df06c5d9c1a6b0ab9f + ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05 + output: + - input_file: input/dummy.in + output: + registers: + r0: + type: bool + value: "true" + initial_ast: f8b64e1675dcb9624011ccf7a6ee9cd4fd7767f9fffbea3c87cbb21cbe734d67 + imports_resolved_ast: f8b64e1675dcb9624011ccf7a6ee9cd4fd7767f9fffbea3c87cbb21cbe734d67 + canonicalized_ast: f8b64e1675dcb9624011ccf7a6ee9cd4fd7767f9fffbea3c87cbb21cbe734d67 + type_inferenced_ast: 4934eaa23f00ce1dfd8e1062e7a6b3bdbc6c5cd4e5f53641a930e910fde34206 diff --git a/tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out b/tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out new file mode 100644 index 0000000000..40fa5ba7a6 --- /dev/null +++ b/tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out @@ -0,0 +1,5 @@ +--- +namespace: Compile +expectation: Fail +outputs: + - "Error [EASG0373025]: unexpected type, expected: '()', received: 'bool'\n --> compiler-test:4:12\n |\n 4 | return 10.length() == 10u8;\n | ^^^^^^^^^^^^^^^^^^^" diff --git a/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out b/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out new file mode 100644 index 0000000000..894eff2349 --- /dev/null +++ b/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out @@ -0,0 +1,22 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - circuit: + num_public_variables: 0 + num_private_variables: 1 + num_constraints: 1 + at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f + bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c + ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05 + output: + - input_file: input/dummy.in + output: + registers: + r0: + type: bool + value: "true" + initial_ast: 3cd71a0e1c6b7aea15b7822c7ad19f400886e82ded67c55d24046d179d202ab0 + imports_resolved_ast: 3cd71a0e1c6b7aea15b7822c7ad19f400886e82ded67c55d24046d179d202ab0 + canonicalized_ast: 2f670f34d1dffb2dd07782b566d6da942ea1cbb0ed5c3da1fc7e78e39fa096f7 + type_inferenced_ast: 4c616d4451798fff86c86c586729b643ad8194248c22956880f168b40a8eddba From e1f6b16ea7d79dd2854480078b8647d7dc32268e Mon Sep 17 00:00:00 2001 From: gluaxspeed Date: Fri, 10 Sep 2021 06:42:01 -0700 Subject: [PATCH 06/25] added new errors --- ast-passes/src/import_resolution/resolver.rs | 2 +- ast/src/program.rs | 4 +-- errors/src/import/import_errors.rs | 18 +++++++++++- stdlib/src/lib.rs | 29 +++++++++++-------- .../out_of_order_with_import.leo.out | 6 ++-- .../stdlib/core_circuit_star_fail.leo.out | 2 +- .../stdlib/core_package_invalid.leo.out | 2 +- .../core_unstable_package_invalid.leo.out | 2 +- 8 files changed, 43 insertions(+), 22 deletions(-) diff --git a/ast-passes/src/import_resolution/resolver.rs b/ast-passes/src/import_resolution/resolver.rs index 18beccafd2..069310168e 100644 --- a/ast-passes/src/import_resolution/resolver.rs +++ b/ast-passes/src/import_resolution/resolver.rs @@ -45,7 +45,7 @@ impl<'a, T: ImportResolver> CoreImportResolver<'a, T> { impl<'a, T: ImportResolver> ImportResolver for CoreImportResolver<'a, T> { fn resolve_package(&mut self, package_segments: &[&str], span: &Span) -> Result> { if !package_segments.is_empty() && package_segments.get(0).unwrap() == &"std" { - Ok(resolve_stdlib_module(&*package_segments[1..].join("."))?) + Ok(Some(resolve_stdlib_module(&*package_segments[1..].join("."))?)) } else { self.inner.resolve_package(package_segments, span) } diff --git a/ast/src/program.rs b/ast/src/program.rs index aee5660bd9..91377bcad0 100644 --- a/ast/src/program.rs +++ b/ast/src/program.rs @@ -88,9 +88,9 @@ impl Program { } } - pub fn set_core_mapping(&self, mapping: &str) { + pub fn set_core_mapping(&self, mapping: Option<&str>) { for (_, circuit) in self.circuits.iter() { - circuit.core_mapping.replace(Some(mapping.to_string())); + circuit.core_mapping.replace(mapping.map(str::to_string)); } } diff --git a/errors/src/import/import_errors.rs b/errors/src/import/import_errors.rs index 16250f2b63..04e127b048 100644 --- a/errors/src/import/import_errors.rs +++ b/errors/src/import/import_errors.rs @@ -90,11 +90,27 @@ create_errors!( help: None, } - /// / For when the crate failed due to an IO error. + /// For when the crate failed due to an IO error. @formatted io_error { args: (path: impl Display, error: impl ErrorArg), msg: format!("cannot read imported file '{}': {:?}", path, error), help: None, } + + /// For when the stdlib import file could not be found. + @backtraced + no_such_stdlib_file { + args: (import: impl Display), + msg: format!("failed to find the stdlib import file `{}`", import), + help: None, + } + + /// For when the stdlib import file could not be read. + @backtraced + failed_to_read_stdlib_file { + args: (import: impl Display), + msg: format!("failed to read the stdlib import file `{}`", import), + help: None, + } ); diff --git a/stdlib/src/lib.rs b/stdlib/src/lib.rs index 82b82607bf..2c777a9944 100644 --- a/stdlib/src/lib.rs +++ b/stdlib/src/lib.rs @@ -17,7 +17,7 @@ #![doc = include_str!("../README.md")] use leo_ast::Program; -use leo_errors::Result; +use leo_errors::{ImportError, Result}; #[macro_use] extern crate include_dir; @@ -27,25 +27,26 @@ use indexmap::IndexMap; static STDLIB: Dir = include_dir!("."); -fn resolve_file(file: &str, mapping: &str) -> Result> { - let resolved = if let Some(resolved) = STDLIB.get_file(&file).map(|f| f.contents_utf8()).flatten() { - resolved - } else { - return Ok(None); - }; +fn resolve_file(file: &str, mapping: Option<&str>) -> Result { + let resolved = STDLIB + .get_file(&file) + .ok_or_else(|| ImportError::no_such_stdlib_file(file))? + .contents_utf8() + .ok_or_else(|| ImportError::failed_to_read_stdlib_file(file))?; let ast = leo_parser::parse_ast(&file, resolved)?.into_repr(); ast.set_core_mapping(mapping); - Ok(Some(ast)) + Ok(ast) } pub fn resolve_prelude_modules() -> Result, Program>> { let mut preludes: IndexMap, Program> = IndexMap::new(); for module in STDLIB.find("prelude/*.leo").unwrap() { - let path = module.path().to_str().unwrap().replace("\\", "/"); - let program = resolve_file(&path, "")?.unwrap(); + // If on windows repalce \\ with / as all paths are stored in unix style. + let path = module.path().to_str().unwrap_or("").replace("\\", "/"); + let program = resolve_file(&path, None)?; let removed_extension = path.replace(".leo", ""); let mut parts: Vec = vec![String::from("std")]; @@ -61,11 +62,15 @@ pub fn resolve_prelude_modules() -> Result, Program>> { Ok(preludes) } -pub fn resolve_stdlib_module(module: &str) -> Result> { +pub fn resolve_stdlib_module(module: &str) -> Result { let mut file_path = module.replace(".", "/"); file_path.push_str(".leo"); - let mapping = if module == "unstable.blake2s" { module } else { "" }; + let mapping = if module == "unstable.blake2s" { + Some("blake2s") + } else { + None + }; resolve_file(&file_path, mapping) } diff --git a/tests/expectations/compiler/compiler/definition/out_of_order_with_import.leo.out b/tests/expectations/compiler/compiler/definition/out_of_order_with_import.leo.out index 26d4d55b20..418dc711a2 100644 --- a/tests/expectations/compiler/compiler/definition/out_of_order_with_import.leo.out +++ b/tests/expectations/compiler/compiler/definition/out_of_order_with_import.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 6f83048e6a7967f42f9d3175a81a24665e4c929bc5be93edb6a6a472b84c5f5c - imports_resolved_ast: 901b88dfdab5ee8217de9bcc65c2bca30e0144a82aeef4ebd404da6a588ded76 - canonicalized_ast: 90e5b8f3b70577c1a633ad48f9cc848f41460c029c7f8cf212adbf6a62b0df32 - type_inferenced_ast: a381c1677355a34ec0bf76451966437a99e7378b76b4aee56412827ca4742a9b + imports_resolved_ast: 11226fc2833079a624c36d62d4e798992a332c34cd8875adc1a92ee9bdd3d6f5 + canonicalized_ast: 3a7fc08a86b174d8913045fcc67408bf9befcefbdfa251586a121ef9f7ebc815 + type_inferenced_ast: 3497e091950ac65c659e0aa173a2f15e4eb8c570bffd0c9d0e111648065f69bb diff --git a/tests/expectations/compiler/compiler/stdlib/core_circuit_star_fail.leo.out b/tests/expectations/compiler/compiler/stdlib/core_circuit_star_fail.leo.out index d0290df4cd..2c819afc81 100644 --- a/tests/expectations/compiler/compiler/stdlib/core_circuit_star_fail.leo.out +++ b/tests/expectations/compiler/compiler/stdlib/core_circuit_star_fail.leo.out @@ -2,4 +2,4 @@ namespace: Compile expectation: Fail outputs: - - "Error [EAST0372011]: failed to resolve import: 'std'\n --> compiler-test:3:12\n |\n 3 | import std.*; // You cannot import all dependencies from core at once\n | ^" + - "Error [EIMP0374008]: failed to find the stdlib import file `.leo`" diff --git a/tests/expectations/compiler/compiler/stdlib/core_package_invalid.leo.out b/tests/expectations/compiler/compiler/stdlib/core_package_invalid.leo.out index 810fed52f4..2c819afc81 100644 --- a/tests/expectations/compiler/compiler/stdlib/core_package_invalid.leo.out +++ b/tests/expectations/compiler/compiler/stdlib/core_package_invalid.leo.out @@ -2,4 +2,4 @@ namespace: Compile expectation: Fail outputs: - - "Error [EAST0372011]: failed to resolve import: 'std'\n --> compiler-test:3:12\n |\n 3 | import std.bad_circuit; // `bad_circuit` is not a core package\n | ^^^^^^^^^^^" + - "Error [EIMP0374008]: failed to find the stdlib import file `.leo`" diff --git a/tests/expectations/compiler/compiler/stdlib/core_unstable_package_invalid.leo.out b/tests/expectations/compiler/compiler/stdlib/core_unstable_package_invalid.leo.out index 3b43dfc3df..5390911c0e 100644 --- a/tests/expectations/compiler/compiler/stdlib/core_unstable_package_invalid.leo.out +++ b/tests/expectations/compiler/compiler/stdlib/core_unstable_package_invalid.leo.out @@ -2,4 +2,4 @@ namespace: Compile expectation: Fail outputs: - - "Error [EAST0372011]: failed to resolve import: 'std.unstable'\n --> compiler-test:3:21\n |\n 3 | import std.unstable.bad_circuit; // `bad_circuit` is not a core unstable package\n | ^^^^^^^^^^^" + - "Error [EIMP0374008]: failed to find the stdlib import file `unstable.leo`" From 93f9f7df303483f56c8d4b149c40d7a4c4f42b07 Mon Sep 17 00:00:00 2001 From: gluaxspeed Date: Fri, 10 Sep 2021 06:50:01 -0700 Subject: [PATCH 07/25] update built-ins rfc --- docs/rfc/008-built-in-declarations.md | 16 ++++------------ 1 file changed, 4 insertions(+), 12 deletions(-) diff --git a/docs/rfc/008-built-in-declarations.md b/docs/rfc/008-built-in-declarations.md index 51a38430ee..2aca26f740 100644 --- a/docs/rfc/008-built-in-declarations.md +++ b/docs/rfc/008-built-in-declarations.md @@ -31,7 +31,7 @@ Leaving import declarations aside for the moment since they are "meta" in some s (as they bring in names of entities declared elsewhere), it may make sense for any of the four kinds of declarations above to have built-in instances, i.e., we could have some built-in functions, circuit types, global constants, and type aliases. These features are why this RFC talks of built-in declarations, more broadly than just built-in type aliases that inspired it. -The built-in status of the envisioned declarations will be done through explicitly declared core library files. Then these core library files must be explicitly imported. This way helps avoid unnecessary code bloat in the compilation, and any user asked for AST snapshots. +The built-in status of the envisioned declarations will be done through explicitly declared standard library(stdlib) files. Then these stdlib files must expressly be imported, except the files found in stdlib/prelude/*. The ones found in the prelude are features determined to be helpful enough in standard programs and are auto-imported. ## Drawbacks @@ -46,15 +46,7 @@ But it should not be much different from standard libraries/packages. Some alternative approaches are: -1. Their names could be simply available in any program, - without any explicit declaration found anywhere for them. -2. They could be declared in some core library files explicitly - and be available in any program without explicitly importing them, - like `java.lang.String` in Java or `std::Option` in Rust. +1. Having all stdlib imports auto included. +2. Require that all stdlib imports are explicitly imported. -From a user's perspective, there is not a lot of difference between cases 1 and 2 above: -in both cases, the names are available; the only difference is that in case 2, the user can see the declaration somewhere. - -Also, note that case 2 could be seen as having an implicit (i.e., built-in) import of the library/libraries in question. Again, imports are "meta" in this context, and what counts are the other kinds of declarations. - -In cases 2 and the decided upon design choice, a related but somewhat independent issue is whether those declarations have Leo definitions or not. The Leo library already includes functions like BLAKE2s that are not defined in Leo but rather "natively" in Rust/R1CS though some of this may be subject to change for native definitions(see the separate RFC on those). +The differences between the two above approaches and the chosen one are just how many imports are imported explicitly. From 158576f8f5444f60415acceedde1ca2b317a98a6 Mon Sep 17 00:00:00 2001 From: damirka Date: Fri, 10 Sep 2021 16:55:32 +0300 Subject: [PATCH 08/25] changed length() to len() --- docs/rfc/006-arrays-without-size.md | 4 ++-- errors/src/compiler/compiler_errors.rs | 2 +- parser/src/tokenizer/lexer.rs | 2 +- parser/src/tokenizer/token.rs | 4 ++-- tests/compiler/array_without_size/length.leo | 2 +- .../array_without_size/length_fail.leo | 2 +- .../array_without_size/length_function.leo | 2 +- .../aliases/shadowing_arg_fail.leo.out | 5 ----- .../aliases/shadowing_var_fail.leo.out | 5 ----- .../array_without_size/length.leo.out | 8 +++---- .../array_without_size/length_fail.leo.out | 2 +- .../length_function.leo.out | 8 +++---- .../compiler/compiler/console/debug.leo.out | 21 ------------------- .../const_different_types_fail_signed.leo.out | 5 ----- ...onst_different_types_fail_unsigned.leo.out | 5 ----- .../different_types_fail.leo.out | 5 ----- .../different_types_fail_unsigned.leo.out | 5 ----- .../compiler/statements/reverse_loop.leo.out | 21 ------------------- 18 files changed, 18 insertions(+), 90 deletions(-) delete mode 100644 tests/expectations/compiler/compiler/aliases/shadowing_arg_fail.leo.out delete mode 100644 tests/expectations/compiler/compiler/aliases/shadowing_var_fail.leo.out delete mode 100644 tests/expectations/compiler/compiler/console/debug.leo.out delete mode 100644 tests/expectations/compiler/compiler/input_files/program_input/const_different_types_fail_signed.leo.out delete mode 100644 tests/expectations/compiler/compiler/input_files/program_input/const_different_types_fail_unsigned.leo.out delete mode 100644 tests/expectations/compiler/compiler/input_files/program_input/different_types_fail.leo.out delete mode 100644 tests/expectations/compiler/compiler/input_files/program_input/different_types_fail_unsigned.leo.out delete mode 100644 tests/expectations/compiler/compiler/statements/reverse_loop.leo.out diff --git a/docs/rfc/006-arrays-without-size.md b/docs/rfc/006-arrays-without-size.md index 0fc67ac6c6..c074de7aca 100644 --- a/docs/rfc/006-arrays-without-size.md +++ b/docs/rfc/006-arrays-without-size.md @@ -118,7 +118,7 @@ In order to do something with the array, e.g. add all its elements and return th Thus, this RFC also proposed to extend Leo with such an operator. A possibility is `.length`, where `` is an expression of array type. -A variation is `.length()`, if we want it look more like a built-in method on arrays. +A variation is `.len()`, if we want it look more like a built-in method on arrays. Yet another option is `length()`, which is more like a built-in function. A shorter name could be `len`, leading to the three possibilities `.len`, `.len()`, and `len()`. @@ -155,4 +155,4 @@ None. # Alternatives -None. \ No newline at end of file +None. diff --git a/errors/src/compiler/compiler_errors.rs b/errors/src/compiler/compiler_errors.rs index 84272a3b45..c66358a068 100644 --- a/errors/src/compiler/compiler_errors.rs +++ b/errors/src/compiler/compiler_errors.rs @@ -838,7 +838,7 @@ create_errors!( @formatted lengthof_can_only_be_used_on_arrays { args: (), - msg: "length() can only be called on an array value".to_string(), + msg: "len() can only be called on an array value".to_string(), help: None, } ); diff --git a/parser/src/tokenizer/lexer.rs b/parser/src/tokenizer/lexer.rs index 7a7c32ed92..60ce77883a 100644 --- a/parser/src/tokenizer/lexer.rs +++ b/parser/src/tokenizer/lexer.rs @@ -388,7 +388,7 @@ impl Token { return (len, Some(Token::DotDotDot)); } else if let Some(len) = eat(input, "..") { return (len, Some(Token::DotDot)); - } else if let Some(len) = eat(input, ".length()") { + } else if let Some(len) = eat(input, ".len()") { // FIXME: remove this code once we allow method calls return (len, Some(Token::LengthOf)); } diff --git a/parser/src/tokenizer/token.rs b/parser/src/tokenizer/token.rs index 97ac2164fd..06c449b81b 100644 --- a/parser/src/tokenizer/token.rs +++ b/parser/src/tokenizer/token.rs @@ -141,7 +141,7 @@ pub enum Token { Type, // Not yet in ABNF - // arr.length() token - hacky zone + // arr.len() token - hacky zone LengthOf, // Not yet in ABNF @@ -313,7 +313,7 @@ impl fmt::Display for Token { Static => write!(f, "static"), String => write!(f, "string"), Type => write!(f, "type"), - LengthOf => write!(f, ".length()"), // FIXME + LengthOf => write!(f, ".len()"), // FIXME Eof => write!(f, ""), // BitAnd => write!(f, "&"), // BitAndEq => write!(f, "&="), diff --git a/tests/compiler/array_without_size/length.leo b/tests/compiler/array_without_size/length.leo index 234815c8fc..ab030aaf59 100644 --- a/tests/compiler/array_without_size/length.leo +++ b/tests/compiler/array_without_size/length.leo @@ -5,5 +5,5 @@ input_file: input/dummy.in */ function main(a: [char; 11], y: bool) -> bool { - return y == (a.length() == 11); + return y == (a.len() == 11); } diff --git a/tests/compiler/array_without_size/length_fail.leo b/tests/compiler/array_without_size/length_fail.leo index b9175ecdc5..4c87660cac 100644 --- a/tests/compiler/array_without_size/length_fail.leo +++ b/tests/compiler/array_without_size/length_fail.leo @@ -5,5 +5,5 @@ input_file: input/dummy.in */ function main(y: bool) { - return 10.length() == 10u8; + return (10u8.len() == 10u32) == y; } diff --git a/tests/compiler/array_without_size/length_function.leo b/tests/compiler/array_without_size/length_function.leo index 7a1d371943..2ec6cd7d11 100644 --- a/tests/compiler/array_without_size/length_function.leo +++ b/tests/compiler/array_without_size/length_function.leo @@ -13,5 +13,5 @@ function main(y: bool) -> bool { } function strlen(str: [char; _]) -> u32 { - return str.length(); + return str.len(); } diff --git a/tests/expectations/compiler/compiler/aliases/shadowing_arg_fail.leo.out b/tests/expectations/compiler/compiler/aliases/shadowing_arg_fail.leo.out deleted file mode 100644 index 70318ab6fb..0000000000 --- a/tests/expectations/compiler/compiler/aliases/shadowing_arg_fail.leo.out +++ /dev/null @@ -1,5 +0,0 @@ ---- -namespace: Compile -expectation: Fail -outputs: - - "Error [EASG0373047]: a function input cannot be named `x` as a alias with that name already exists in this scope\n --> compiler-test:5:15\n |\n 5 | function main(x: u32, y: bool) -> bool {\n | ^" diff --git a/tests/expectations/compiler/compiler/aliases/shadowing_var_fail.leo.out b/tests/expectations/compiler/compiler/aliases/shadowing_var_fail.leo.out deleted file mode 100644 index 9cbec43215..0000000000 --- a/tests/expectations/compiler/compiler/aliases/shadowing_var_fail.leo.out +++ /dev/null @@ -1,5 +0,0 @@ ---- -namespace: Compile -expectation: Fail -outputs: - - "Error [EASG0373047]: a function input cannot be named `int` as a alias with that name already exists in this scope\n --> compiler-test:6:9\n |\n 6 | let int: int = 1u32;\n | ^^^" diff --git a/tests/expectations/compiler/compiler/array_without_size/length.leo.out b/tests/expectations/compiler/compiler/array_without_size/length.leo.out index 5f40d5fcdd..5f7fdf36ef 100644 --- a/tests/expectations/compiler/compiler/array_without_size/length.leo.out +++ b/tests/expectations/compiler/compiler/array_without_size/length.leo.out @@ -16,7 +16,7 @@ outputs: r0: type: bool value: "true" - initial_ast: f8b64e1675dcb9624011ccf7a6ee9cd4fd7767f9fffbea3c87cbb21cbe734d67 - imports_resolved_ast: f8b64e1675dcb9624011ccf7a6ee9cd4fd7767f9fffbea3c87cbb21cbe734d67 - canonicalized_ast: f8b64e1675dcb9624011ccf7a6ee9cd4fd7767f9fffbea3c87cbb21cbe734d67 - type_inferenced_ast: 4934eaa23f00ce1dfd8e1062e7a6b3bdbc6c5cd4e5f53641a930e910fde34206 + initial_ast: d8e3de13a7f12866871e4117b7c4cf9872350154b19e82087fe8100adeba1354 + imports_resolved_ast: d8e3de13a7f12866871e4117b7c4cf9872350154b19e82087fe8100adeba1354 + canonicalized_ast: d8e3de13a7f12866871e4117b7c4cf9872350154b19e82087fe8100adeba1354 + type_inferenced_ast: 06be9e7e193c4fcdca75ba8218de79dcc8317b1eb63d9c2f33ca790c614a472b diff --git a/tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out b/tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out index 40fa5ba7a6..3806d95236 100644 --- a/tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out +++ b/tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out @@ -2,4 +2,4 @@ namespace: Compile expectation: Fail outputs: - - "Error [EASG0373025]: unexpected type, expected: '()', received: 'bool'\n --> compiler-test:4:12\n |\n 4 | return 10.length() == 10u8;\n | ^^^^^^^^^^^^^^^^^^^" + - "Error [EASG0373025]: unexpected type, expected: '()', received: 'bool'\n --> compiler-test:4:13\n |\n 4 | return (10u8.len() == 10u32) == y;\n | ^^^^^^^^^^^^^^^^^^^^^^^^^" diff --git a/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out b/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out index 894eff2349..18dc02eb4f 100644 --- a/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out +++ b/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out @@ -16,7 +16,7 @@ outputs: r0: type: bool value: "true" - initial_ast: 3cd71a0e1c6b7aea15b7822c7ad19f400886e82ded67c55d24046d179d202ab0 - imports_resolved_ast: 3cd71a0e1c6b7aea15b7822c7ad19f400886e82ded67c55d24046d179d202ab0 - canonicalized_ast: 2f670f34d1dffb2dd07782b566d6da942ea1cbb0ed5c3da1fc7e78e39fa096f7 - type_inferenced_ast: 4c616d4451798fff86c86c586729b643ad8194248c22956880f168b40a8eddba + initial_ast: 9886d4d97c894fade697bd99ac9cbe2a56973037837f34884e3dbad4dd4d5d65 + imports_resolved_ast: 9886d4d97c894fade697bd99ac9cbe2a56973037837f34884e3dbad4dd4d5d65 + canonicalized_ast: 36dbb999756e8e8bb68c69388889f0cfc217fbdbb0467f43453e19feb5c55d22 + type_inferenced_ast: 4fff72622455ea5bfc073c8e90e2266545b01e3004b73e4ee909b37b0bd75f46 diff --git a/tests/expectations/compiler/compiler/console/debug.leo.out b/tests/expectations/compiler/compiler/console/debug.leo.out deleted file mode 100644 index 9eecd263fd..0000000000 --- a/tests/expectations/compiler/compiler/console/debug.leo.out +++ /dev/null @@ -1,21 +0,0 @@ ---- -namespace: Compile -expectation: Pass -outputs: - - circuit: - num_public_variables: 0 - num_private_variables: 1 - num_constraints: 1 - at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f - bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c - ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05 - output: - - input_file: input/dummy.in - output: - registers: - r0: - type: bool - value: "true" - initial_ast: 80d3dbfdeb9d6fb6e9ba17ba028bd2bf71014b4353f34db9d69a66ee1d0914cf - canonicalized_ast: 80d3dbfdeb9d6fb6e9ba17ba028bd2bf71014b4353f34db9d69a66ee1d0914cf - type_inferenced_ast: bbad9d7593fb1aa2bcc25f2f2625ace659e18f293af35082ad39b1e3cd71e8b5 diff --git a/tests/expectations/compiler/compiler/input_files/program_input/const_different_types_fail_signed.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/const_different_types_fail_signed.leo.out deleted file mode 100644 index 995afe29e0..0000000000 --- a/tests/expectations/compiler/compiler/input_files/program_input/const_different_types_fail_signed.leo.out +++ /dev/null @@ -1,5 +0,0 @@ ---- -namespace: Compile -expectation: Fail -outputs: - - aborting due to syntax error diff --git a/tests/expectations/compiler/compiler/input_files/program_input/const_different_types_fail_unsigned.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/const_different_types_fail_unsigned.leo.out deleted file mode 100644 index 995afe29e0..0000000000 --- a/tests/expectations/compiler/compiler/input_files/program_input/const_different_types_fail_unsigned.leo.out +++ /dev/null @@ -1,5 +0,0 @@ ---- -namespace: Compile -expectation: Fail -outputs: - - aborting due to syntax error diff --git a/tests/expectations/compiler/compiler/input_files/program_input/different_types_fail.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/different_types_fail.leo.out deleted file mode 100644 index 43d9de36b7..0000000000 --- a/tests/expectations/compiler/compiler/input_files/program_input/different_types_fail.leo.out +++ /dev/null @@ -1,5 +0,0 @@ ---- -namespace: Compile -expectation: Fail -outputs: - - " --> compiler-test:3:15\n |\n 3 | function main(a: u32) {\n | ^\n |\n = expected data type `u32`, found `u8`" diff --git a/tests/expectations/compiler/compiler/input_files/program_input/different_types_fail_unsigned.leo.out b/tests/expectations/compiler/compiler/input_files/program_input/different_types_fail_unsigned.leo.out deleted file mode 100644 index 995afe29e0..0000000000 --- a/tests/expectations/compiler/compiler/input_files/program_input/different_types_fail_unsigned.leo.out +++ /dev/null @@ -1,5 +0,0 @@ ---- -namespace: Compile -expectation: Fail -outputs: - - aborting due to syntax error diff --git a/tests/expectations/compiler/compiler/statements/reverse_loop.leo.out b/tests/expectations/compiler/compiler/statements/reverse_loop.leo.out deleted file mode 100644 index bb4416faf3..0000000000 --- a/tests/expectations/compiler/compiler/statements/reverse_loop.leo.out +++ /dev/null @@ -1,21 +0,0 @@ ---- -namespace: Compile -expectation: Pass -outputs: - - circuit: - num_public_variables: 0 - num_private_variables: 1 - num_constraints: 1 - at: 042610d0fd1fe6d6ac112138f8755752f44c7d2a00f1b5960574d6da5cda393f - bt: e97756698880ab7555a959a5fb5c6b4e15bd64612aa677adbfe2d0bd91f0a83c - ct: cf1cbb66a638b4860a516671fb74850e6ccf787fe6c4c8d29e9c04efe880bd05 - output: - - input_file: inputs/dummy.in - output: - registers: - r0: - type: bool - value: "true" - initial_ast: 75fbb3ed1613fbf39ce803ff903befe209b26a953ba8db1d68e35066655d96e6 - canonicalized_ast: a96cae2c9e347245e07c63b5c94cf43497063c3f548c615627da4b1775e9a17b - type_inferenced_ast: dc663974ed1cce7b15c35eda29c9b1af5426eafddbd108b5a03cd7071ad4a6bc From 3a004b5f23f2c84b7ebf94a3c24aa5c7fef9741d Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Tue, 14 Sep 2021 17:55:54 +0300 Subject: [PATCH 09/25] Bump tracing from 0.1.26 to 0.1.27 (#1344) Bumps [tracing](https://github.com/tokio-rs/tracing) from 0.1.26 to 0.1.27. - [Release notes](https://github.com/tokio-rs/tracing/releases) - [Commits](https://github.com/tokio-rs/tracing/compare/tracing-0.1.26...tracing-0.1.27) --- updated-dependencies: - dependency-name: tracing dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- Cargo.lock | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 121a8d0ae3..775c693958 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2983,9 +2983,9 @@ checksum = "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6" [[package]] name = "tracing" -version = "0.1.26" +version = "0.1.27" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "09adeb8c97449311ccd28a427f96fb563e7fd31aabf994189879d9da2394b89d" +checksum = "c2ba9ab62b7d6497a8638dfda5e5c4fb3b2d5a7fca4118f2b96151c8ef1a437e" dependencies = [ "cfg-if 1.0.0", "pin-project-lite", @@ -2995,9 +2995,9 @@ dependencies = [ [[package]] name = "tracing-attributes" -version = "0.1.15" +version = "0.1.16" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c42e6fa53307c8a17e4ccd4dc81cf5ec38db9209f59b222210375b54ee40d1e2" +checksum = "98863d0dd09fa59a1b79c6750ad80dbda6b75f4e71c437a6a1a8cb91a8bcbd77" dependencies = [ "proc-macro2 1.0.27", "quote 1.0.9", @@ -3006,9 +3006,9 @@ dependencies = [ [[package]] name = "tracing-core" -version = "0.1.18" +version = "0.1.20" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "a9ff14f98b1a4b289c6248a023c1c2fa1491062964e9fed67ab29c4e4da4a052" +checksum = "46125608c26121c81b0c6d693eab5a420e416da7e43c426d2e8f7df8da8a3acf" dependencies = [ "lazy_static", ] From f12eafb957cbf5f28e5e36b27f9432b5f68e6b8e Mon Sep 17 00:00:00 2001 From: damirka Date: Tue, 14 Sep 2021 18:01:24 +0300 Subject: [PATCH 10/25] replace sizeof with lengthof --- ast/src/expression/lengthof.rs | 2 +- ast/src/reducer/reconstructing_director.rs | 2 +- compiler/src/expression/expression.rs | 2 +- compiler/src/expression/operator/lengthof.rs | 4 ++-- 4 files changed, 5 insertions(+), 5 deletions(-) diff --git a/ast/src/expression/lengthof.rs b/ast/src/expression/lengthof.rs index e5dec13a62..2dcc4175de 100644 --- a/ast/src/expression/lengthof.rs +++ b/ast/src/expression/lengthof.rs @@ -26,7 +26,7 @@ pub struct LengthOfExpression { impl fmt::Display for LengthOfExpression { fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { - write!(f, "sizeof {}", self.inner) + write!(f, "{}.len()", self.inner) } } diff --git a/ast/src/reducer/reconstructing_director.rs b/ast/src/reducer/reconstructing_director.rs index 41133a5359..1bd2567e90 100644 --- a/ast/src/reducer/reconstructing_director.rs +++ b/ast/src/reducer/reconstructing_director.rs @@ -57,7 +57,7 @@ impl ReconstructingDirector { Expression::Unary(unary) => Expression::Unary(self.reduce_unary(unary)?), Expression::Ternary(ternary) => Expression::Ternary(self.reduce_ternary(ternary)?), Expression::Cast(cast) => Expression::Cast(self.reduce_cast(cast)?), - Expression::LengthOf(sizeof) => Expression::LengthOf(sizeof.clone()), // Expression::LengthOf(self.reduce_sizeof(sizeof)?), // TODO: add reducer + Expression::LengthOf(lengthof) => Expression::LengthOf(lengthof.clone()), // Expression::LengthOf(self.reduce_lengthof(lengthof)?), // TODO: add reducer Expression::ArrayInline(array_inline) => Expression::ArrayInline(self.reduce_array_inline(array_inline)?), Expression::ArrayInit(array_init) => Expression::ArrayInit(self.reduce_array_init(array_init)?), diff --git a/compiler/src/expression/expression.rs b/compiler/src/expression/expression.rs index 4f9eb24711..1b52608de8 100644 --- a/compiler/src/expression/expression.rs +++ b/compiler/src/expression/expression.rs @@ -99,7 +99,7 @@ impl<'a, F: PrimeField, G: GroupType> ConstrainedProgram<'a, F, G> { Expression::Cast(_) => unimplemented!("casts not implemented"), // LengthOf - Expression::LengthOf(sizeof) => self.enforce_sizeof(cs, sizeof, span), + Expression::LengthOf(lengthof) => self.enforce_lengthof(cs, lengthof, span), // Variables Expression::VariableRef(variable_ref) => self.evaluate_ref(variable_ref), diff --git a/compiler/src/expression/operator/lengthof.rs b/compiler/src/expression/operator/lengthof.rs index 440d1020d0..8e4b8dc401 100644 --- a/compiler/src/expression/operator/lengthof.rs +++ b/compiler/src/expression/operator/lengthof.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 . -//! Enforces a sizeof operator in a compiled Leo program. +//! Enforces a lengthof operator in a compiled Leo program. use crate::{ program::ConstrainedProgram, @@ -29,7 +29,7 @@ use snarkvm_r1cs::ConstraintSystem; impl<'a, F: PrimeField, G: GroupType> ConstrainedProgram<'a, F, G> { /// Enforce array expressions - pub fn enforce_sizeof>( + pub fn enforce_lengthof>( &mut self, cs: &mut CS, lengthof: &'a LengthOfExpression<'a>, From a503dbb50bbaec15a898eb5befb8b8cc5fe8e185 Mon Sep 17 00:00:00 2001 From: gluaxspeed Date: Tue, 14 Sep 2021 21:38:07 -0700 Subject: [PATCH 11/25] add some READMES --- ast-passes/README.md | 29 +++++++++++++++++++++++++++++ stdlib/README.md | 30 +++++++++++++++++++++++++++++- 2 files changed, 58 insertions(+), 1 deletion(-) diff --git a/ast-passes/README.md b/ast-passes/README.md index c8542eb8cd..ad2dc2d4bd 100644 --- a/ast-passes/README.md +++ b/ast-passes/README.md @@ -1 +1,30 @@ # leo-ast-passes + +[![Crates.io](https://img.shields.io/crates/v/leo-ast.svg?color=neon)](https://crates.io/crates/leo-ast) +[![Authors](https://img.shields.io/badge/authors-Aleo-orange.svg)](../AUTHORS) +[![License](https://img.shields.io/badge/License-GPLv3-blue.svg)](./LICENSE.md) + +## Usage + +The code here is split into several usages. Each usage represents a different pass or modification when given an AST. + +### Canonicalization + +This pass of the code has a few changes it must complete: + +- `Self` is not allowed outside a circuit. +- `Self` in circuits must be replaced with an Identifier containing the Circuit Name. +- Any 0 size array definitions should be rejected. +- Multi-size array definitions should be expanded such that `[0u8; (2, 3)]` becomes `[[0u8; 3] 2]`. +- Compound assignments become simple assignments such that `a += 2;` becomes `a = a + 2;`. +- Missing function output types are replaced with an empty tuple. + +### Import Resolution + +This pass iterates through the import statements(nestedly), resloving all imports. Thus adding the improted file's AST to the main AST. + +In addition, it also handles forcibly importing the stdlib prelude files. + +## Structure + +Each different type of pass is located in its own directory within the src directory. diff --git a/stdlib/README.md b/stdlib/README.md index c8542eb8cd..f46d01071b 100644 --- a/stdlib/README.md +++ b/stdlib/README.md @@ -1 +1,29 @@ -# leo-ast-passes +# leo-stdlib + +[![Crates.io](https://img.shields.io/crates/v/leo-ast.svg?color=neon)](https://crates.io/crates/leo-ast) +[![Authors](https://img.shields.io/badge/authors-Aleo-orange.svg)](../AUTHORS) +[![License](https://img.shields.io/badge/License-GPLv3-blue.svg)](./LICENSE.md) + +This directory includes the standard library for Leo. + +## Usage + +The src directory is the Rust code that makes the Leo folders and files statically built into the compiler. So any added Leo folders and files under the `stdlib` directory will be automatically included at compile time. + +See the [Structure](#structure) section for more info. + +## Structure + +The structure for this repository is a bit special. + +One important thing to note is the prelude directory. Any Leo files defined in this directory will have all importable objects automatically imported to every Leo program. For example, the following program is valid without any imports: + +```typescript +function main() { + let s: string = "Hello, string type alias!"; +} +``` + +The above type alias is auto imported from `stdlib/prelude/string.leo`. + +The other directories must have explicit imports. For example, the unstable Blake2s can be imported with `import std.unstable.blake2s.Blake2s`. Which imports the `Blake2s` circuit defined in `stdlib/unstable/blake2s.leo`. From 02170e420114cb11f011a89a89552763f5063932 Mon Sep 17 00:00:00 2001 From: Pranav Gaddamadugu Date: Tue, 14 Sep 2021 12:08:13 -0700 Subject: [PATCH 12/25] Created errcov binary, lists error codes found in tests/exepectations --- Cargo.lock | 1 + test-framework/Cargo.toml | 4 ++ test-framework/src/bin/errcov.rs | 117 +++++++++++++++++++++++++++++++ 3 files changed, 122 insertions(+) create mode 100644 test-framework/src/bin/errcov.rs diff --git a/Cargo.lock b/Cargo.lock index 5b32f65ac2..e3ad834687 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1485,6 +1485,7 @@ dependencies = [ "leo-compiler", "leo-imports", "leo-parser", + "regex", "serde", "serde_json", "serde_yaml", diff --git a/test-framework/Cargo.toml b/test-framework/Cargo.toml index f32f3fe07a..169193230f 100644 --- a/test-framework/Cargo.toml +++ b/test-framework/Cargo.toml @@ -55,3 +55,7 @@ version = "1.5.2" [dependencies.structopt] version = "0.3" + +# List of dependencies for errcov +[dependencies.regex] +version = "1.5" \ No newline at end of file diff --git a/test-framework/src/bin/errcov.rs b/test-framework/src/bin/errcov.rs new file mode 100644 index 0000000000..b3a9a88cf3 --- /dev/null +++ b/test-framework/src/bin/errcov.rs @@ -0,0 +1,117 @@ +// 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 . + +use leo_asg::Asg; +use leo_ast::AstPass; +use leo_compiler::{compiler::thread_leaked_context, TypeInferencePhase}; +use leo_imports::ImportParser; +use leo_test_framework::{ + fetch::find_tests, + output::TestExpectation, + test::{extract_test_config, TestExpectationMode as Expectation}, +}; + +use regex::Regex; +use std::{collections::HashSet, error::Error, fs, path::PathBuf}; +use structopt::{clap::AppSettings, StructOpt}; + +#[derive(StructOpt)] +#[structopt(name = "error-coverage", author = "The Aleo Team ", setting = AppSettings::ColoredHelp)] +struct Opt { + #[structopt(short, long, help = "Path to the output file", parse(from_os_str))] + output: PathBuf, +} + +fn main() { + handle_error(run_with_args(Opt::from_args())); +} + +fn run_with_args(opt: Opt) -> Result<(), Box> { + // Variable that stores all the tests. + 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); + + // Store all covered error codes + let mut codes = HashSet::new(); + let re = Regex::new(r"Error \[(?P.*)\]:.*").unwrap(); + + for (path, content) in tests.into_iter() { + if let Some(config) = extract_test_config(&content) { + // Skip passing tests. + if config.expectation == Expectation::Pass { + continue; + } + + let mut expectation_path = expectation_dir.clone(); + + let path = PathBuf::from(path); + let relative_path = path.strip_prefix(&test_dir).expect("path error for test"); + + let mut relative_expectation_path = relative_path.to_str().unwrap().to_string(); + relative_expectation_path += ".out"; + + // Add expectation category + if relative_expectation_path.starts_with("compiler") { + expectation_path.push("compiler"); + } else { + expectation_path.push("parser"); + } + expectation_path.push(&relative_expectation_path); + + if expectation_path.exists() { + let raw = std::fs::read_to_string(&expectation_path).expect("failed to read expectations file"); + let expectation: TestExpectation = + serde_yaml::from_str(&raw).expect("invalid yaml in expectations file"); + + for value in expectation.outputs { + if let serde_yaml::Value::String(message) = value { + if let Some(caps) = re.captures(&message) { + if let Some(code) = caps.name("code") { + codes.insert(code.as_str().to_string()); + } + } + } + } + } + } + } + + let mut sorted: Vec<_> = codes.iter().collect(); + sorted.sort(); + + println!("Found the following error codes"); + for code in sorted { + println!("{}", code) + } + + Ok(()) +} + +fn handle_error(res: Result<(), Box>) { + match res { + Ok(_) => (), + Err(err) => { + eprintln!("Error: {}", err); + std::process::exit(1); + } + } +} From dc98e94d7f2cb29fc58223b1d4de7dcde152a433 Mon Sep 17 00:00:00 2001 From: Pranav Gaddamadugu Date: Wed, 15 Sep 2021 11:11:19 -0700 Subject: [PATCH 13/25] errcov collects all error codes for errors generated by create_errors! macro --- Cargo.lock | 1 + errors/src/common/macros.rs | 11 ++++- test-framework/Cargo.toml | 4 ++ test-framework/src/bin/errcov.rs | 74 ++++++++++++++++++++++++++++++-- 4 files changed, 85 insertions(+), 5 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index e3ad834687..55a696c665 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -1483,6 +1483,7 @@ dependencies = [ "leo-ast", "leo-ast-passes", "leo-compiler", + "leo-errors", "leo-imports", "leo-parser", "regex", diff --git a/errors/src/common/macros.rs b/errors/src/common/macros.rs index 9dfa00f67c..17cd024bdf 100644 --- a/errors/src/common/macros.rs +++ b/errors/src/common/macros.rs @@ -19,7 +19,14 @@ /// with a unique error code. #[macro_export] macro_rules! create_errors { - (@step $_code:expr,) => {}; + (@step $code:expr,) => { + + #[inline(always)] + // Returns the number of unique exit codes that this error type can take on. + pub fn num_exit_codes() -> i32 { + $code + } + }; ($(#[$error_type_docs:meta])* $error_type:ident, exit_code_mask: $exit_code_mask:expr, error_code_prefix: $error_code_prefix:expr, $($(#[$docs:meta])* @$formatted_or_backtraced_list:ident $names:ident { args: ($($arg_names:ident: $arg_types:ty$(,)?)*), msg: $messages:expr, help: $helps:expr, })*) => { #[allow(unused_imports)] // Allow unused for errors that only use formatted or backtraced errors. use crate::{BacktracedError, FormattedError, LeoErrorCode, Span}; @@ -63,6 +70,7 @@ macro_rules! create_errors { } } + // Steps over the list of functions with an initial error code of 0. impl $error_type { create_errors!(@step 0i32, $(($(#[$docs])* $formatted_or_backtraced_list, $names($($arg_names: $arg_types,)*), $messages, $helps),)*); @@ -112,5 +120,4 @@ macro_rules! create_errors { // Steps the error code value by one and calls on the rest of the functions. create_errors!(@step $code + 1i32, $(($(#[$docs])* $formatted_or_backtraced_tail, $names($($tail_arg_names: $tail_arg_types,)*), $messages, $helps),)*); }; - } diff --git a/test-framework/Cargo.toml b/test-framework/Cargo.toml index 169193230f..bea2f59c5c 100644 --- a/test-framework/Cargo.toml +++ b/test-framework/Cargo.toml @@ -57,5 +57,9 @@ version = "1.5.2" version = "0.3" # List of dependencies for errcov +[dependencies.leo-errors] +path = "../errors" +version = "1.5.3" + [dependencies.regex] version = "1.5" \ No newline at end of file diff --git a/test-framework/src/bin/errcov.rs b/test-framework/src/bin/errcov.rs index b3a9a88cf3..6209e5b73d 100644 --- a/test-framework/src/bin/errcov.rs +++ b/test-framework/src/bin/errcov.rs @@ -17,6 +17,9 @@ use leo_asg::Asg; use leo_ast::AstPass; use leo_compiler::{compiler::thread_leaked_context, TypeInferencePhase}; +use leo_errors::{ + AsgError, AstError, CliError, CompilerError, ImportError, LeoErrorCode, PackageError, ParserError, StateError, +}; use leo_imports::ImportParser; use leo_test_framework::{ fetch::find_tests, @@ -51,7 +54,7 @@ fn run_with_args(opt: Opt) -> Result<(), Box> { find_tests(&test_dir, &mut tests); // Store all covered error codes - let mut codes = HashSet::new(); + let mut found_codes = HashSet::new(); let re = Regex::new(r"Error \[(?P.*)\]:.*").unwrap(); for (path, content) in tests.into_iter() { @@ -86,7 +89,7 @@ fn run_with_args(opt: Opt) -> Result<(), Box> { if let serde_yaml::Value::String(message) = value { if let Some(caps) = re.captures(&message) { if let Some(code) = caps.name("code") { - codes.insert(code.as_str().to_string()); + found_codes.insert(code.as_str().to_string()); } } } @@ -95,7 +98,58 @@ fn run_with_args(opt: Opt) -> Result<(), Box> { } } - let mut sorted: Vec<_> = codes.iter().collect(); + // Collect all defined error codes. + let mut all_codes = HashSet::new(); + collect_error_codes( + &mut all_codes, + AsgError::error_type(), + AsgError::code_identifier(), + AsgError::num_exit_codes(), + ); + collect_error_codes( + &mut all_codes, + AstError::error_type(), + AstError::code_identifier(), + AstError::num_exit_codes(), + ); + collect_error_codes( + &mut all_codes, + CliError::error_type(), + CliError::code_identifier(), + CliError::num_exit_codes(), + ); + collect_error_codes( + &mut all_codes, + CompilerError::error_type(), + CompilerError::code_identifier(), + CompilerError::num_exit_codes(), + ); + collect_error_codes( + &mut all_codes, + ImportError::error_type(), + ImportError::code_identifier(), + ImportError::num_exit_codes(), + ); + collect_error_codes( + &mut all_codes, + PackageError::error_type(), + PackageError::code_identifier(), + PackageError::num_exit_codes(), + ); + collect_error_codes( + &mut all_codes, + ParserError::error_type(), + ParserError::code_identifier(), + ParserError::num_exit_codes(), + ); + collect_error_codes( + &mut all_codes, + StateError::error_type(), + StateError::code_identifier(), + StateError::num_exit_codes(), + ); + + let mut sorted: Vec<_> = found_codes.iter().collect(); sorted.sort(); println!("Found the following error codes"); @@ -103,9 +157,23 @@ fn run_with_args(opt: Opt) -> Result<(), Box> { println!("{}", code) } + let mut sorted: Vec<_> = all_codes.iter().collect(); + sorted.sort(); + + println!("Showing all error codes"); + for code in sorted { + println!("{}", code) + } + Ok(()) } +fn collect_error_codes(codes: &mut HashSet, error_type: String, code_identifier: i8, num_exit_codes: i32) { + for exit_code in 0..num_exit_codes { + codes.insert(format!("E{}{:0>3}{:0>4}", error_type, code_identifier, exit_code,)); + } +} + fn handle_error(res: Result<(), Box>) { match res { Ok(_) => (), From db1ddaa144d0439e328f1a61b75284e7cb4e2ed2 Mon Sep 17 00:00:00 2001 From: Pranav Gaddamadugu Date: Wed, 15 Sep 2021 14:47:12 -0700 Subject: [PATCH 14/25] errcov outputs coverage information for covered, uncovered, and unknown errors --- test-framework/src/bin/errcov.rs | 87 +++++++++++++++++++++++++------- 1 file changed, 68 insertions(+), 19 deletions(-) diff --git a/test-framework/src/bin/errcov.rs b/test-framework/src/bin/errcov.rs index 6209e5b73d..98f8e7b7a3 100644 --- a/test-framework/src/bin/errcov.rs +++ b/test-framework/src/bin/errcov.rs @@ -14,13 +14,9 @@ // You should have received a copy of the GNU General Public License // along with the Leo library. If not, see . -use leo_asg::Asg; -use leo_ast::AstPass; -use leo_compiler::{compiler::thread_leaked_context, TypeInferencePhase}; use leo_errors::{ AsgError, AstError, CliError, CompilerError, ImportError, LeoErrorCode, PackageError, ParserError, StateError, }; -use leo_imports::ImportParser; use leo_test_framework::{ fetch::find_tests, output::TestExpectation, @@ -28,7 +24,14 @@ use leo_test_framework::{ }; use regex::Regex; -use std::{collections::HashSet, error::Error, fs, path::PathBuf}; +use serde_yaml::Value; +use std::collections::{BTreeMap, HashSet}; +use std::{ + error::Error, + fs, + io::Write, + path::{Path, PathBuf}, +}; use structopt::{clap::AppSettings, StructOpt}; #[derive(StructOpt)] @@ -54,7 +57,7 @@ fn run_with_args(opt: Opt) -> Result<(), Box> { find_tests(&test_dir, &mut tests); // Store all covered error codes - let mut found_codes = HashSet::new(); + let mut found_codes = BTreeMap::new(); let re = Regex::new(r"Error \[(?P.*)\]:.*").unwrap(); for (path, content) in tests.into_iter() { @@ -89,7 +92,11 @@ fn run_with_args(opt: Opt) -> Result<(), Box> { if let serde_yaml::Value::String(message) = value { if let Some(caps) = re.captures(&message) { if let Some(code) = caps.name("code") { - found_codes.insert(code.as_str().to_string()); + let files = found_codes.entry(code.as_str().to_string()).or_insert(HashSet::new()); + let path = expectation_path + .strip_prefix(test_dir.clone()) + .expect("invalid prefix for expectation path"); + files.insert(PathBuf::from(path)); } } } @@ -104,73 +111,115 @@ fn run_with_args(opt: Opt) -> Result<(), Box> { &mut all_codes, AsgError::error_type(), AsgError::code_identifier(), + AsgError::exit_code_mask(), AsgError::num_exit_codes(), ); collect_error_codes( &mut all_codes, AstError::error_type(), AstError::code_identifier(), + AstError::exit_code_mask(), AstError::num_exit_codes(), ); collect_error_codes( &mut all_codes, CliError::error_type(), CliError::code_identifier(), + CliError::exit_code_mask(), CliError::num_exit_codes(), ); collect_error_codes( &mut all_codes, CompilerError::error_type(), CompilerError::code_identifier(), + CompilerError::exit_code_mask(), CompilerError::num_exit_codes(), ); collect_error_codes( &mut all_codes, ImportError::error_type(), ImportError::code_identifier(), + ImportError::exit_code_mask(), ImportError::num_exit_codes(), ); collect_error_codes( &mut all_codes, PackageError::error_type(), PackageError::code_identifier(), + PackageError::exit_code_mask(), PackageError::num_exit_codes(), ); collect_error_codes( &mut all_codes, ParserError::error_type(), ParserError::code_identifier(), + ParserError::exit_code_mask(), ParserError::num_exit_codes(), ); collect_error_codes( &mut all_codes, StateError::error_type(), StateError::code_identifier(), + StateError::exit_code_mask(), StateError::num_exit_codes(), ); - let mut sorted: Vec<_> = found_codes.iter().collect(); - sorted.sort(); + let mut covered_errors = serde_yaml::Mapping::new(); + let mut unknown_errors = serde_yaml::Mapping::new(); - println!("Found the following error codes"); - for code in sorted { - println!("{}", code) + for (code, paths) in found_codes.iter() { + let mut yaml_paths = Vec::new(); + for path in paths { + yaml_paths.push(path.to_str().unwrap()); + } + yaml_paths.sort(); + let yaml_paths = yaml_paths.iter().map(|s| Value::String(s.to_string())).collect(); + + if all_codes.contains(code) { + covered_errors.insert(Value::String(code.to_owned()), Value::Sequence(yaml_paths)); + all_codes.remove(code); + } else { + unknown_errors.insert(Value::String(code.to_owned()), Value::Sequence(yaml_paths)); + } } - let mut sorted: Vec<_> = all_codes.iter().collect(); - sorted.sort(); + let mut codes: Vec = all_codes.drain().collect(); + codes.sort(); - println!("Showing all error codes"); - for code in sorted { - println!("{}", code) + let mut uncovered_errors = Vec::new(); + for code in codes { + uncovered_errors.push(Value::String(code)) } + let mut results = serde_yaml::Mapping::new(); + results.insert( + Value::String(String::from("uncovered")), + Value::Sequence(uncovered_errors), + ); + results.insert(Value::String(String::from("covered")), Value::Mapping(covered_errors)); + results.insert(Value::String(String::from("unknown")), Value::Mapping(unknown_errors)); + //let results_str = serde_yaml::to_string(&results).expect("serialization failed for error coverage report"); + + let mut file = fs::File::create(opt.output)?; + serde_yaml::to_writer(file, &results).expect("serialization failed for error coverage report"); + Ok(()) } -fn collect_error_codes(codes: &mut HashSet, error_type: String, code_identifier: i8, num_exit_codes: i32) { +fn collect_error_codes( + codes: &mut HashSet, + error_type: String, + code_identifier: i8, + exit_code_mask: i32, + num_exit_codes: i32, +) { for exit_code in 0..num_exit_codes { - codes.insert(format!("E{}{:0>3}{:0>4}", error_type, code_identifier, exit_code,)); + codes.insert(format!( + "E{}{:0>3}{:0>4}", + error_type, + code_identifier, + exit_code_mask + exit_code, + )); } } From ef058cebb735d114f94e147cadc0e2e8ec4a1bbb Mon Sep 17 00:00:00 2001 From: Pranav Gaddamadugu Date: Wed, 15 Sep 2021 15:04:45 -0700 Subject: [PATCH 15/25] Added option to write errcov report to file or stdout --- test-framework/src/bin/errcov.rs | 25 ++++++++++++++----------- 1 file changed, 14 insertions(+), 11 deletions(-) diff --git a/test-framework/src/bin/errcov.rs b/test-framework/src/bin/errcov.rs index 98f8e7b7a3..3881f9a7ea 100644 --- a/test-framework/src/bin/errcov.rs +++ b/test-framework/src/bin/errcov.rs @@ -26,19 +26,19 @@ use leo_test_framework::{ use regex::Regex; use serde_yaml::Value; use std::collections::{BTreeMap, HashSet}; -use std::{ - error::Error, - fs, - io::Write, - path::{Path, PathBuf}, -}; +use std::{error::Error, fs, io, path::PathBuf}; use structopt::{clap::AppSettings, StructOpt}; #[derive(StructOpt)] #[structopt(name = "error-coverage", author = "The Aleo Team ", setting = AppSettings::ColoredHelp)] struct Opt { - #[structopt(short, long, help = "Path to the output file", parse(from_os_str))] - output: PathBuf, + #[structopt( + short, + long, + help = "Path to the output file, defaults to stdout.", + parse(from_os_str) + )] + output: Option, } fn main() { @@ -198,10 +198,13 @@ fn run_with_args(opt: Opt) -> Result<(), Box> { ); results.insert(Value::String(String::from("covered")), Value::Mapping(covered_errors)); results.insert(Value::String(String::from("unknown")), Value::Mapping(unknown_errors)); - //let results_str = serde_yaml::to_string(&results).expect("serialization failed for error coverage report"); - let mut file = fs::File::create(opt.output)?; - serde_yaml::to_writer(file, &results).expect("serialization failed for error coverage report"); + if let Some(pathbuf) = opt.output { + let file = fs::File::create(pathbuf).expect("error creating output file"); + serde_yaml::to_writer(file, &results).expect("serialization failed for error coverage report"); + } else { + serde_yaml::to_writer(io::stdout(), &results).expect("serialization failed for error coverage report"); + } Ok(()) } From 0cd77ca89cdc76898de685b63c556d4963ae2447 Mon Sep 17 00:00:00 2001 From: Pranav Gaddamadugu Date: Wed, 15 Sep 2021 16:13:30 -0700 Subject: [PATCH 16/25] Tested unknown error, cleanup, formatting, and ran clippy --- errors/src/common/macros.rs | 1 - test-framework/src/bin/errcov.rs | 46 +++++++++++++++++++++++++++----- 2 files changed, 39 insertions(+), 8 deletions(-) diff --git a/errors/src/common/macros.rs b/errors/src/common/macros.rs index 17cd024bdf..54551c9b53 100644 --- a/errors/src/common/macros.rs +++ b/errors/src/common/macros.rs @@ -20,7 +20,6 @@ #[macro_export] macro_rules! create_errors { (@step $code:expr,) => { - #[inline(always)] // Returns the number of unique exit codes that this error type can take on. pub fn num_exit_codes() -> i32 { diff --git a/test-framework/src/bin/errcov.rs b/test-framework/src/bin/errcov.rs index 3881f9a7ea..2d18415e71 100644 --- a/test-framework/src/bin/errcov.rs +++ b/test-framework/src/bin/errcov.rs @@ -92,7 +92,9 @@ fn run_with_args(opt: Opt) -> Result<(), Box> { if let serde_yaml::Value::String(message) = value { if let Some(caps) = re.captures(&message) { if let Some(code) = caps.name("code") { - let files = found_codes.entry(code.as_str().to_string()).or_insert(HashSet::new()); + let files = found_codes + .entry(code.as_str().to_string()) + .or_insert_with(HashSet::new); let path = expectation_path .strip_prefix(test_dir.clone()) .expect("invalid prefix for expectation path"); @@ -164,23 +166,24 @@ fn run_with_args(opt: Opt) -> Result<(), Box> { StateError::num_exit_codes(), ); + // Repackage data into values compatible with serde_yaml let mut covered_errors = serde_yaml::Mapping::new(); let mut unknown_errors = serde_yaml::Mapping::new(); for (code, paths) in found_codes.iter() { - let mut yaml_paths = Vec::new(); + let mut yaml_paths = Vec::with_capacity(paths.len()); for path in paths { yaml_paths.push(path.to_str().unwrap()); } - yaml_paths.sort(); + yaml_paths.sort_unstable(); let yaml_paths = yaml_paths.iter().map(|s| Value::String(s.to_string())).collect(); if all_codes.contains(code) { covered_errors.insert(Value::String(code.to_owned()), Value::Sequence(yaml_paths)); - all_codes.remove(code); } else { unknown_errors.insert(Value::String(code.to_owned()), Value::Sequence(yaml_paths)); } + all_codes.remove(code); } let mut codes: Vec = all_codes.drain().collect(); @@ -191,14 +194,43 @@ fn run_with_args(opt: Opt) -> Result<(), Box> { uncovered_errors.push(Value::String(code)) } + let mut uncovered_information = serde_yaml::Mapping::new(); + uncovered_information.insert( + Value::String(String::from("count")), + Value::Number(serde_yaml::Number::from(uncovered_errors.len())), + ); + uncovered_information.insert(Value::String(String::from("codes")), Value::Sequence(uncovered_errors)); + + let mut covered_information = serde_yaml::Mapping::new(); + covered_information.insert( + Value::String(String::from("count")), + Value::Number(serde_yaml::Number::from(covered_errors.len())), + ); + covered_information.insert(Value::String(String::from("codes")), Value::Mapping(covered_errors)); + + let mut unknown_information = serde_yaml::Mapping::new(); + unknown_information.insert( + Value::String(String::from("count")), + Value::Number(serde_yaml::Number::from(unknown_errors.len())), + ); + unknown_information.insert(Value::String(String::from("codes")), Value::Mapping(unknown_errors)); + let mut results = serde_yaml::Mapping::new(); results.insert( Value::String(String::from("uncovered")), - Value::Sequence(uncovered_errors), + Value::Mapping(uncovered_information), ); - results.insert(Value::String(String::from("covered")), Value::Mapping(covered_errors)); - results.insert(Value::String(String::from("unknown")), Value::Mapping(unknown_errors)); + results.insert( + Value::String(String::from("covered")), + Value::Mapping(covered_information), + ); + results.insert( + Value::String(String::from("unknown")), + Value::Mapping(unknown_information), + ); + + // Output error coverage results if let Some(pathbuf) = opt.output { let file = fs::File::create(pathbuf).expect("error creating output file"); serde_yaml::to_writer(file, &results).expect("serialization failed for error coverage report"); From fb4f398520550621a2fc5532795078922eca4f5e Mon Sep 17 00:00:00 2001 From: Pranav Gaddamadugu Date: Wed, 15 Sep 2021 18:28:54 -0700 Subject: [PATCH 17/25] Re-ran all tests with CLEAR_LEO_TEST_EXPECTATIONS=true; changed expectations for the two tests that failed in CI --- .../compiler/compiler/array_without_size/length.leo.out | 6 +++--- .../compiler/array_without_size/length_function.leo.out | 6 +++--- 2 files changed, 6 insertions(+), 6 deletions(-) diff --git a/tests/expectations/compiler/compiler/array_without_size/length.leo.out b/tests/expectations/compiler/compiler/array_without_size/length.leo.out index 5f7fdf36ef..d73bd94828 100644 --- a/tests/expectations/compiler/compiler/array_without_size/length.leo.out +++ b/tests/expectations/compiler/compiler/array_without_size/length.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: d8e3de13a7f12866871e4117b7c4cf9872350154b19e82087fe8100adeba1354 - imports_resolved_ast: d8e3de13a7f12866871e4117b7c4cf9872350154b19e82087fe8100adeba1354 - canonicalized_ast: d8e3de13a7f12866871e4117b7c4cf9872350154b19e82087fe8100adeba1354 - type_inferenced_ast: 06be9e7e193c4fcdca75ba8218de79dcc8317b1eb63d9c2f33ca790c614a472b + imports_resolved_ast: 37de52ab186133dccfc290bed3f417685ce9ee5de37c820e0e8e3d2a17804bcc + canonicalized_ast: 37de52ab186133dccfc290bed3f417685ce9ee5de37c820e0e8e3d2a17804bcc + type_inferenced_ast: 2f1b4e2127a33a02bea52ad28c0e9414268b401e11787bbde761820e8ac804e4 diff --git a/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out b/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out index 18dc02eb4f..ade62968e4 100644 --- a/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out +++ b/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 9886d4d97c894fade697bd99ac9cbe2a56973037837f34884e3dbad4dd4d5d65 - imports_resolved_ast: 9886d4d97c894fade697bd99ac9cbe2a56973037837f34884e3dbad4dd4d5d65 - canonicalized_ast: 36dbb999756e8e8bb68c69388889f0cfc217fbdbb0467f43453e19feb5c55d22 - type_inferenced_ast: 4fff72622455ea5bfc073c8e90e2266545b01e3004b73e4ee909b37b0bd75f46 + imports_resolved_ast: afd08cb992e4004c551f936d4a5867bbc0a0c05fbb8997bffd2a082badbf03fc + canonicalized_ast: 462f0feb8e304b2644d1bbcf90663a03a9e8c53d9e9ae42836ad57d1f0de3165 + type_inferenced_ast: 20f7f22df0d2826996233e2e513403f84be65d8db9e9a947df128c377299355c From 7f1277940b98265a80b0321eae750363bea0defb Mon Sep 17 00:00:00 2001 From: Eric McCarthy Date: Thu, 16 Sep 2021 12:35:22 -0700 Subject: [PATCH 18/25] [tgc CI] make log more readable; allow tgc type inference to run even if there is a tgc canonicalization failure --- .github/workflows/acl2.yml | 34 ++++++++++++++++++++-------------- 1 file changed, 20 insertions(+), 14 deletions(-) diff --git a/.github/workflows/acl2.yml b/.github/workflows/acl2.yml index 68a0b47624..f027739300 100644 --- a/.github/workflows/acl2.yml +++ b/.github/workflows/acl2.yml @@ -1,6 +1,6 @@ name: Leo-ACL2 on: workflow_dispatch -env: +env: RUST_BACKTRACE: 1 # This job can only be run on linux (Ubuntu) @@ -28,35 +28,37 @@ jobs: - name: Pull tgc executable run: | mkdir acl2 && cd acl2; - wget $(curl -s https://api.github.com/repos/AleoHQ/leo-acl2-bin/releases/latest \ - | grep "browser_download_url.*.tgz" \ - | cut -d : -f 2,3 \ - | tr -d \" \ - | xargs) + wget $( curl -s https://api.github.com/repos/AleoHQ/leo-acl2-bin/releases/latest \ + | jq -r '.assets[0].browser_download_url' ) + echo "Unpacking $(ls):" tar -xvzf $(ls) - - # Using the prepared ASTs and the pulled and unzipped tgc run theorem generation. + + # Run theorem generation and checking using the prepared ASTs and the pulled and unzipped leo-acl2 tarball. - name: Run tgc over ASTs run: | canonicalization_errors=(); type_inference_errors=(); + num_dirs=0; for dir in `ls tmp/tgc`; do cd tmp/tgc/$dir; # enter the directory + num_dirs=$((num_dirs + 1)); ./../../../acl2/tgc canonicalization initial_ast.json canonicalization_ast.json canonicalization-theorem.lisp > canonicalization_result.out || canonicalization_errors+=("$dir"); - # Disabling Type inference for now ./../../../acl2/tgc type-inference canonicalization_ast.json type_inferenced_ast.json type-inference-theorem.lisp > type_inference_result.out || type_inference_errors+=("$dir"); cd ../../.. done; + echo "----------------" + echo "Ran tgc in ${num_dirs} directories." + echo "----------------" if [ ${#canonicalization_errors[@]} -eq 0 ]; then echo "Canonicalization - Success!" else - echo "Canonicalization Failures:"; + echo "Canonicalization Failures (total: ${#canonicalization_errors[@]}):" for dir in ${canonicalization_errors[@]}; do - echo $dir; + echo $dir done; #echo "Attaching logs:" @@ -65,16 +67,16 @@ jobs: # cat tmp/tgc/$dir/canonicalization_result.out # cat tmp/tgc/$dir/canonicalization-theorem.lisp #done; - exit 1 fi + echo "----------------" if [ ${#type_inference_errors[@]} -eq 0 ]; then echo "Type Inference - Success!" else - echo "Type Inference Failures:"; + echo "Type Inference Failures (total: ${#type_inference_errors[@]}):" for dir in ${type_inference_errors[@]}; do - echo $dir; + echo $dir done; #echo "Attaching logs:" @@ -82,6 +84,10 @@ jobs: #do # cat tmp/tgc/$dir/type_inference_result.out #done; + fi + if [[ ${#canonicalization_errors[@]} -ne 0 || ${#type_inference_errors[@]} -ne 0 ]]; then + echo "----------------" + echo "Exiting with status 1 due to at least one tgc error." exit 1 fi From 27d9fffab7731329d81264e93b82d3fa93bf9da6 Mon Sep 17 00:00:00 2001 From: damirka Date: Fri, 17 Sep 2021 14:44:11 +0300 Subject: [PATCH 19/25] fix test expectations --- .../compiler/compiler/array_without_size/length.leo.out | 6 +++--- .../compiler/array_without_size/length_fail.leo.out | 5 ----- .../compiler/array_without_size/length_function.leo.out | 6 +++--- 3 files changed, 6 insertions(+), 11 deletions(-) delete mode 100644 tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out diff --git a/tests/expectations/compiler/compiler/array_without_size/length.leo.out b/tests/expectations/compiler/compiler/array_without_size/length.leo.out index 5f7fdf36ef..d73bd94828 100644 --- a/tests/expectations/compiler/compiler/array_without_size/length.leo.out +++ b/tests/expectations/compiler/compiler/array_without_size/length.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: d8e3de13a7f12866871e4117b7c4cf9872350154b19e82087fe8100adeba1354 - imports_resolved_ast: d8e3de13a7f12866871e4117b7c4cf9872350154b19e82087fe8100adeba1354 - canonicalized_ast: d8e3de13a7f12866871e4117b7c4cf9872350154b19e82087fe8100adeba1354 - type_inferenced_ast: 06be9e7e193c4fcdca75ba8218de79dcc8317b1eb63d9c2f33ca790c614a472b + imports_resolved_ast: 37de52ab186133dccfc290bed3f417685ce9ee5de37c820e0e8e3d2a17804bcc + canonicalized_ast: 37de52ab186133dccfc290bed3f417685ce9ee5de37c820e0e8e3d2a17804bcc + type_inferenced_ast: 2f1b4e2127a33a02bea52ad28c0e9414268b401e11787bbde761820e8ac804e4 diff --git a/tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out b/tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out deleted file mode 100644 index 3806d95236..0000000000 --- a/tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out +++ /dev/null @@ -1,5 +0,0 @@ ---- -namespace: Compile -expectation: Fail -outputs: - - "Error [EASG0373025]: unexpected type, expected: '()', received: 'bool'\n --> compiler-test:4:13\n |\n 4 | return (10u8.len() == 10u32) == y;\n | ^^^^^^^^^^^^^^^^^^^^^^^^^" diff --git a/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out b/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out index 18dc02eb4f..ade62968e4 100644 --- a/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out +++ b/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 9886d4d97c894fade697bd99ac9cbe2a56973037837f34884e3dbad4dd4d5d65 - imports_resolved_ast: 9886d4d97c894fade697bd99ac9cbe2a56973037837f34884e3dbad4dd4d5d65 - canonicalized_ast: 36dbb999756e8e8bb68c69388889f0cfc217fbdbb0467f43453e19feb5c55d22 - type_inferenced_ast: 4fff72622455ea5bfc073c8e90e2266545b01e3004b73e4ee909b37b0bd75f46 + imports_resolved_ast: afd08cb992e4004c551f936d4a5867bbc0a0c05fbb8997bffd2a082badbf03fc + canonicalized_ast: 462f0feb8e304b2644d1bbcf90663a03a9e8c53d9e9ae42836ad57d1f0de3165 + type_inferenced_ast: 20f7f22df0d2826996233e2e513403f84be65d8db9e9a947df128c377299355c From af777c085d70da947efef5ae80677154ff2ada25 Mon Sep 17 00:00:00 2001 From: damirka Date: Fri, 17 Sep 2021 17:39:28 +0300 Subject: [PATCH 20/25] adds .len() parser tests --- .../array_without_size/length.leo.out | 6 +- .../array_without_size/length_fail.leo.out | 5 - .../length_function.leo.out | 6 +- .../core/core_circuit_invalid.leo.out | 5 - .../core/core_circuit_star_fail.leo.out | 5 - .../core/core_package_invalid.leo.out | 5 - .../core_unstable_package_invalid.leo.out | 5 - .../parser/expression/array_len.leo.out | 204 ++++++++++++++++++ .../functions/param_array_unsized.leo.out | 66 ++++++ .../parser/statement/definition.leo.out | 140 ++++++++++++ tests/parser/expression/array_len.leo | 16 ++ .../parser/functions/param_array_unsized.leo | 8 + tests/parser/statement/definition.leo | 5 + 13 files changed, 445 insertions(+), 31 deletions(-) delete mode 100644 tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out delete mode 100644 tests/expectations/compiler/compiler/core/core_circuit_invalid.leo.out delete mode 100644 tests/expectations/compiler/compiler/core/core_circuit_star_fail.leo.out delete mode 100644 tests/expectations/compiler/compiler/core/core_package_invalid.leo.out delete mode 100644 tests/expectations/compiler/compiler/core/core_unstable_package_invalid.leo.out create mode 100644 tests/expectations/parser/parser/expression/array_len.leo.out create mode 100644 tests/expectations/parser/parser/functions/param_array_unsized.leo.out create mode 100644 tests/parser/expression/array_len.leo create mode 100644 tests/parser/functions/param_array_unsized.leo diff --git a/tests/expectations/compiler/compiler/array_without_size/length.leo.out b/tests/expectations/compiler/compiler/array_without_size/length.leo.out index 5f7fdf36ef..d73bd94828 100644 --- a/tests/expectations/compiler/compiler/array_without_size/length.leo.out +++ b/tests/expectations/compiler/compiler/array_without_size/length.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: d8e3de13a7f12866871e4117b7c4cf9872350154b19e82087fe8100adeba1354 - imports_resolved_ast: d8e3de13a7f12866871e4117b7c4cf9872350154b19e82087fe8100adeba1354 - canonicalized_ast: d8e3de13a7f12866871e4117b7c4cf9872350154b19e82087fe8100adeba1354 - type_inferenced_ast: 06be9e7e193c4fcdca75ba8218de79dcc8317b1eb63d9c2f33ca790c614a472b + imports_resolved_ast: 37de52ab186133dccfc290bed3f417685ce9ee5de37c820e0e8e3d2a17804bcc + canonicalized_ast: 37de52ab186133dccfc290bed3f417685ce9ee5de37c820e0e8e3d2a17804bcc + type_inferenced_ast: 2f1b4e2127a33a02bea52ad28c0e9414268b401e11787bbde761820e8ac804e4 diff --git a/tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out b/tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out deleted file mode 100644 index 3806d95236..0000000000 --- a/tests/expectations/compiler/compiler/array_without_size/length_fail.leo.out +++ /dev/null @@ -1,5 +0,0 @@ ---- -namespace: Compile -expectation: Fail -outputs: - - "Error [EASG0373025]: unexpected type, expected: '()', received: 'bool'\n --> compiler-test:4:13\n |\n 4 | return (10u8.len() == 10u32) == y;\n | ^^^^^^^^^^^^^^^^^^^^^^^^^" diff --git a/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out b/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out index 18dc02eb4f..ade62968e4 100644 --- a/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out +++ b/tests/expectations/compiler/compiler/array_without_size/length_function.leo.out @@ -17,6 +17,6 @@ outputs: type: bool value: "true" initial_ast: 9886d4d97c894fade697bd99ac9cbe2a56973037837f34884e3dbad4dd4d5d65 - imports_resolved_ast: 9886d4d97c894fade697bd99ac9cbe2a56973037837f34884e3dbad4dd4d5d65 - canonicalized_ast: 36dbb999756e8e8bb68c69388889f0cfc217fbdbb0467f43453e19feb5c55d22 - type_inferenced_ast: 4fff72622455ea5bfc073c8e90e2266545b01e3004b73e4ee909b37b0bd75f46 + imports_resolved_ast: afd08cb992e4004c551f936d4a5867bbc0a0c05fbb8997bffd2a082badbf03fc + canonicalized_ast: 462f0feb8e304b2644d1bbcf90663a03a9e8c53d9e9ae42836ad57d1f0de3165 + type_inferenced_ast: 20f7f22df0d2826996233e2e513403f84be65d8db9e9a947df128c377299355c diff --git a/tests/expectations/compiler/compiler/core/core_circuit_invalid.leo.out b/tests/expectations/compiler/compiler/core/core_circuit_invalid.leo.out deleted file mode 100644 index 6b1788bf0c..0000000000 --- a/tests/expectations/compiler/compiler/core/core_circuit_invalid.leo.out +++ /dev/null @@ -1,5 +0,0 @@ ---- -namespace: Compile -expectation: Fail -outputs: - - "Error [EASG0373043]: failed to resolve import: 'core.unstable.blake2s'\n --> compiler-test:3:30\n |\n 3 | import core.unstable.blake2s.BadCircuit; // `BadCircuit` is not included in the blake2s package\n | ^^^^^^^^^^" diff --git a/tests/expectations/compiler/compiler/core/core_circuit_star_fail.leo.out b/tests/expectations/compiler/compiler/core/core_circuit_star_fail.leo.out deleted file mode 100644 index c5cfe9c2bc..0000000000 --- a/tests/expectations/compiler/compiler/core/core_circuit_star_fail.leo.out +++ /dev/null @@ -1,5 +0,0 @@ ---- -namespace: Compile -expectation: Fail -outputs: - - "Error [EAST0372011]: failed to resolve import: 'core'\n --> compiler-test:3:13\n |\n 3 | import core.*; // You cannot import all dependencies from core at once\n | ^" diff --git a/tests/expectations/compiler/compiler/core/core_package_invalid.leo.out b/tests/expectations/compiler/compiler/core/core_package_invalid.leo.out deleted file mode 100644 index 1d348aeb97..0000000000 --- a/tests/expectations/compiler/compiler/core/core_package_invalid.leo.out +++ /dev/null @@ -1,5 +0,0 @@ ---- -namespace: Compile -expectation: Fail -outputs: - - "Error [EAST0372011]: failed to resolve import: 'core'\n --> compiler-test:3:13\n |\n 3 | import core.bad_circuit; // `bad_circuit` is not a core package\n | ^^^^^^^^^^^" diff --git a/tests/expectations/compiler/compiler/core/core_unstable_package_invalid.leo.out b/tests/expectations/compiler/compiler/core/core_unstable_package_invalid.leo.out deleted file mode 100644 index ff3bf66480..0000000000 --- a/tests/expectations/compiler/compiler/core/core_unstable_package_invalid.leo.out +++ /dev/null @@ -1,5 +0,0 @@ ---- -namespace: Compile -expectation: Fail -outputs: - - "Error [EAST0372011]: failed to resolve import: 'core.unstable'\n --> compiler-test:3:22\n |\n 3 | import core.unstable.bad_circuit; // `bad_circuit` is not a core unstable package\n | ^^^^^^^^^^^" diff --git a/tests/expectations/parser/parser/expression/array_len.leo.out b/tests/expectations/parser/parser/expression/array_len.leo.out new file mode 100644 index 0000000000..1d902d968e --- /dev/null +++ b/tests/expectations/parser/parser/expression/array_len.leo.out @@ -0,0 +1,204 @@ +--- +namespace: ParseExpression +expectation: Pass +outputs: + - LengthOf: + inner: + ArrayInit: + element: + Value: + Integer: + - U8 + - "0" + - line_start: 1 + line_stop: 1 + col_start: 2 + col_stop: 5 + path: "" + content: "[0u8; 1].len()" + dimensions: + - value: "1" + span: + line_start: 1 + line_stop: 1 + col_start: 1 + col_stop: 9 + path: "" + content: "[0u8; 1].len()" + span: + line_start: 1 + line_stop: 1 + col_start: 1 + col_stop: 9 + path: "" + content: "[0u8; 1].len()" + - LengthOf: + inner: + ArrayInit: + element: + Value: + Implicit: + - "0" + - line_start: 1 + line_stop: 1 + col_start: 2 + col_stop: 3 + path: "" + content: "[0; 1].len()" + dimensions: + - value: "1" + span: + line_start: 1 + line_stop: 1 + col_start: 1 + col_stop: 7 + path: "" + content: "[0; 1].len()" + span: + line_start: 1 + line_stop: 1 + col_start: 1 + col_stop: 7 + path: "" + content: "[0; 1].len()" + - LengthOf: + inner: + ArrayInit: + element: + Value: + Implicit: + - "0" + - line_start: 1 + line_stop: 1 + col_start: 2 + col_stop: 3 + path: "" + content: "[0; (1)].len()" + dimensions: + - value: "1" + span: + line_start: 1 + line_stop: 1 + col_start: 1 + col_stop: 9 + path: "" + content: "[0; (1)].len()" + span: + line_start: 1 + line_stop: 1 + col_start: 1 + col_stop: 9 + path: "" + content: "[0; (1)].len()" + - LengthOf: + inner: + ArrayInit: + element: + Value: + Implicit: + - "0" + - line_start: 1 + line_stop: 1 + col_start: 2 + col_stop: 3 + path: "" + content: "[0; (1, 2)].len()" + dimensions: + - value: "1" + - value: "2" + span: + line_start: 1 + line_stop: 1 + col_start: 1 + col_stop: 12 + path: "" + content: "[0; (1, 2)].len()" + span: + line_start: 1 + line_stop: 1 + col_start: 1 + col_stop: 12 + path: "" + content: "[0; (1, 2)].len()" + - LengthOf: + inner: + ArrayInit: + element: + Value: + Implicit: + - "0" + - line_start: 1 + line_stop: 1 + col_start: 2 + col_stop: 3 + path: "" + content: "[0; (1, 2, 3)].len()" + dimensions: + - value: "1" + - value: "2" + - value: "3" + span: + line_start: 1 + line_stop: 1 + col_start: 1 + col_stop: 15 + path: "" + content: "[0; (1, 2, 3)].len()" + span: + line_start: 1 + line_stop: 1 + col_start: 1 + col_stop: 15 + path: "" + content: "[0; (1, 2, 3)].len()" + - LengthOf: + inner: + ArrayInit: + element: + ArrayInit: + element: + ArrayInit: + element: + Value: + Implicit: + - "0" + - line_start: 1 + line_stop: 1 + col_start: 4 + col_stop: 5 + path: "" + content: "[[[0; 3]; 2]; 1].len()" + dimensions: + - value: "3" + span: + line_start: 1 + line_stop: 1 + col_start: 3 + col_stop: 9 + path: "" + content: "[[[0; 3]; 2]; 1].len()" + dimensions: + - value: "2" + span: + line_start: 1 + line_stop: 1 + col_start: 2 + col_stop: 13 + path: "" + content: "[[[0; 3]; 2]; 1].len()" + dimensions: + - value: "1" + span: + line_start: 1 + line_stop: 1 + col_start: 1 + col_stop: 17 + path: "" + content: "[[[0; 3]; 2]; 1].len()" + span: + line_start: 1 + line_stop: 1 + col_start: 1 + col_stop: 17 + path: "" + content: "[[[0; 3]; 2]; 1].len()" diff --git a/tests/expectations/parser/parser/functions/param_array_unsized.leo.out b/tests/expectations/parser/parser/functions/param_array_unsized.leo.out new file mode 100644 index 0000000000..e34bccbcb2 --- /dev/null +++ b/tests/expectations/parser/parser/functions/param_array_unsized.leo.out @@ -0,0 +1,66 @@ +--- +namespace: Parse +expectation: Pass +outputs: + - name: "" + expected_input: [] + import_statements: [] + imports: {} + aliases: {} + circuits: {} + global_consts: {} + functions: + "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function x(x: [u8; _]) {\\\"}\"}": + annotations: [] + identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":10,\\\"col_stop\\\":11,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function x(x: [u8; _]) {\\\"}\"}" + input: + - Variable: + identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":3,\\\"line_stop\\\":3,\\\"col_start\\\":12,\\\"col_stop\\\":13,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"function x(x: [u8; _]) {\\\"}\"}" + const_: false + mutable: true + type_: + Array: + - IntegerType: U8 + - - value: "0" + span: + line_start: 3 + line_stop: 3 + col_start: 12 + col_stop: 13 + path: "" + content: "function x(x: [u8; _]) {" + output: ~ + block: + statements: + - Return: + expression: + TupleInit: + elements: [] + span: + line_start: 4 + line_stop: 4 + col_start: 12 + col_stop: 14 + path: "" + content: " return ();" + span: + line_start: 4 + line_stop: 4 + col_start: 5 + col_stop: 14 + path: "" + content: " return ();" + span: + line_start: 3 + line_stop: 5 + col_start: 24 + col_stop: 2 + path: "" + content: "function x(x: [u8; _]) {\n ...\n}" + span: + line_start: 3 + line_stop: 5 + col_start: 1 + col_stop: 2 + path: "" + content: "function x(x: [u8; _]) {\n ...\n}" diff --git a/tests/expectations/parser/parser/statement/definition.leo.out b/tests/expectations/parser/parser/statement/definition.leo.out index 04b085addb..8ec6a4df81 100644 --- a/tests/expectations/parser/parser/statement/definition.leo.out +++ b/tests/expectations/parser/parser/statement/definition.leo.out @@ -1471,3 +1471,143 @@ outputs: col_stop: 14 path: "" content: "let (x,) = ();" + - Definition: + declaration_type: Let + variable_names: + - mutable: true + identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"let x: [char; _] = \\\\\\\"Hello, World!\\\\\\\";\\\"}\"}" + span: + line_start: 1 + line_stop: 1 + col_start: 5 + col_stop: 6 + path: "" + content: "let x: [char; _] = \"Hello, World!\";" + type_: + Array: + - Char + - - value: "0" + value: + Value: + String: + - - Scalar: 72 + - Scalar: 101 + - Scalar: 108 + - Scalar: 108 + - Scalar: 111 + - Scalar: 44 + - Scalar: 32 + - Scalar: 87 + - Scalar: 111 + - Scalar: 114 + - Scalar: 108 + - Scalar: 100 + - Scalar: 33 + - line_start: 1 + line_stop: 1 + col_start: 20 + col_stop: 35 + path: "" + content: "let x: [char; _] = \"Hello, World!\";" + span: + line_start: 1 + line_stop: 1 + col_start: 1 + col_stop: 35 + path: "" + content: "let x: [char; _] = \"Hello, World!\";" + - Definition: + declaration_type: Let + variable_names: + - mutable: true + identifier: "{\"name\":\"x\",\"span\":\"{\\\"line_start\\\":1,\\\"line_stop\\\":1,\\\"col_start\\\":5,\\\"col_stop\\\":6,\\\"path\\\":\\\"\\\",\\\"content\\\":\\\"let x: [[u8; 2]; 2] = [[0,0], [0,0]];\\\"}\"}" + span: + line_start: 1 + line_stop: 1 + col_start: 5 + col_stop: 6 + path: "" + content: "let x: [[u8; 2]; 2] = [[0,0], [0,0]];" + type_: + Array: + - Array: + - IntegerType: U8 + - - value: "2" + - - value: "2" + value: + ArrayInline: + elements: + - Expression: + ArrayInline: + elements: + - Expression: + Value: + Implicit: + - "0" + - line_start: 1 + line_stop: 1 + col_start: 25 + col_stop: 26 + path: "" + content: "let x: [[u8; 2]; 2] = [[0,0], [0,0]];" + - Expression: + Value: + Implicit: + - "0" + - line_start: 1 + line_stop: 1 + col_start: 27 + col_stop: 28 + path: "" + content: "let x: [[u8; 2]; 2] = [[0,0], [0,0]];" + span: + line_start: 1 + line_stop: 1 + col_start: 24 + col_stop: 29 + path: "" + content: "let x: [[u8; 2]; 2] = [[0,0], [0,0]];" + - Expression: + ArrayInline: + elements: + - Expression: + Value: + Implicit: + - "0" + - line_start: 1 + line_stop: 1 + col_start: 32 + col_stop: 33 + path: "" + content: "let x: [[u8; 2]; 2] = [[0,0], [0,0]];" + - Expression: + Value: + Implicit: + - "0" + - line_start: 1 + line_stop: 1 + col_start: 34 + col_stop: 35 + path: "" + content: "let x: [[u8; 2]; 2] = [[0,0], [0,0]];" + span: + line_start: 1 + line_stop: 1 + col_start: 31 + col_stop: 36 + path: "" + content: "let x: [[u8; 2]; 2] = [[0,0], [0,0]];" + span: + line_start: 1 + line_stop: 1 + col_start: 23 + col_stop: 37 + path: "" + content: "let x: [[u8; 2]; 2] = [[0,0], [0,0]];" + span: + line_start: 1 + line_stop: 1 + col_start: 1 + col_stop: 37 + path: "" + content: "let x: [[u8; 2]; 2] = [[0,0], [0,0]];" diff --git a/tests/parser/expression/array_len.leo b/tests/parser/expression/array_len.leo new file mode 100644 index 0000000000..4a67f8d2b6 --- /dev/null +++ b/tests/parser/expression/array_len.leo @@ -0,0 +1,16 @@ +/* +namespace: ParseExpression +expectation: Pass +*/ + +[0u8; 1].len() + +[0; 1].len() + +[0; (1)].len() + +[0; (1, 2)].len() + +[0; (1, 2, 3)].len() + +[[[0; 3]; 2]; 1].len() diff --git a/tests/parser/functions/param_array_unsized.leo b/tests/parser/functions/param_array_unsized.leo new file mode 100644 index 0000000000..ef657ba76d --- /dev/null +++ b/tests/parser/functions/param_array_unsized.leo @@ -0,0 +1,8 @@ +/* +namespace: Parse +expectation: Pass +*/ + +function x(x: [u8; _]) { + return (); +} diff --git a/tests/parser/statement/definition.leo b/tests/parser/statement/definition.leo index 0f1a7617bc..507dca476c 100644 --- a/tests/parser/statement/definition.leo +++ b/tests/parser/statement/definition.leo @@ -98,3 +98,8 @@ const (x, y): u32 = x(); let (x,y,) = (); let (x,) = (); + + +let x: [char; _] = "Hello, World!"; + +let x: [[u8; 2]; 2] = [[0,0], [0,0]]; From 45c1e86b598647ce010b7301bc99577ffe2ffb2c Mon Sep 17 00:00:00 2001 From: Pranav Gaddamadugu Date: Fri, 17 Sep 2021 09:32:57 -0700 Subject: [PATCH 21/25] Trigger CI From 8b95f3b779b5749c2c6a6116a5d712738d66795e Mon Sep 17 00:00:00 2001 From: Pranav Gaddamadugu Date: Fri, 17 Sep 2021 10:27:01 -0700 Subject: [PATCH 22/25] Enabled CircleCI, triggering again From 1eea668e4ade394ea6d72541d21177ba3a6ba50f Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 20 Sep 2021 14:03:34 +0300 Subject: [PATCH 23/25] Bump tracing from 0.1.27 to 0.1.28 (#1355) Bumps [tracing](https://github.com/tokio-rs/tracing) from 0.1.27 to 0.1.28. - [Release notes](https://github.com/tokio-rs/tracing/releases) - [Commits](https://github.com/tokio-rs/tracing/compare/tracing-0.1.27...tracing-0.1.28) --- updated-dependencies: - dependency-name: tracing dependency-type: direct:production update-type: version-update:semver-patch ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> --- Cargo.lock | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 5b32f65ac2..2854a3bcd6 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -3031,9 +3031,9 @@ checksum = "360dfd1d6d30e05fda32ace2c8c70e9c0a9da713275777f5a4dbb8a1893930c6" [[package]] name = "tracing" -version = "0.1.27" +version = "0.1.28" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "c2ba9ab62b7d6497a8638dfda5e5c4fb3b2d5a7fca4118f2b96151c8ef1a437e" +checksum = "84f96e095c0c82419687c20ddf5cb3eadb61f4e1405923c9dc8e53a1adacbda8" dependencies = [ "cfg-if 1.0.0", "pin-project-lite", From 85a3dddd8ce6fef485333dcd1ffabc1c46681773 Mon Sep 17 00:00:00 2001 From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com> Date: Mon, 20 Sep 2021 14:31:32 +0300 Subject: [PATCH 24/25] Bump dirs from 3.0.2 to 4.0.0 (#1347) Bumps [dirs](https://github.com/soc/dirs-rs) from 3.0.2 to 4.0.0. - [Release notes](https://github.com/soc/dirs-rs/releases) - [Commits](https://github.com/soc/dirs-rs/commits) --- updated-dependencies: - dependency-name: dirs dependency-type: direct:production update-type: version-update:semver-major ... Signed-off-by: dependabot[bot] Co-authored-by: dependabot[bot] <49699333+dependabot[bot]@users.noreply.github.com> Co-authored-by: damirka --- Cargo.lock | 4 ++-- Cargo.toml | 2 +- 2 files changed, 3 insertions(+), 3 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index 2854a3bcd6..4fe601ff45 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -590,9 +590,9 @@ dependencies = [ [[package]] name = "dirs" -version = "3.0.2" +version = "4.0.0" source = "registry+https://github.com/rust-lang/crates.io-index" -checksum = "30baa043103c9d0c2a57cf537cc2f35623889dc0d405e6c3cccfadbc81c71309" +checksum = "ca3aa72a6f96ea37bbc5aa912f6788242832f75369bdfdadcb0e38423f100059" dependencies = [ "dirs-sys", ] diff --git a/Cargo.toml b/Cargo.toml index cff7176398..bea9be41a1 100644 --- a/Cargo.toml +++ b/Cargo.toml @@ -115,7 +115,7 @@ color-backtrace = "0.5.1" version = "2.0" [dependencies.dirs] -version = "3.0.2" +version = "4.0.0" [dependencies.console] version = "0.14.0" From 3ad7d2fdb2899861aea4b46be60051a3ebf2ba0a Mon Sep 17 00:00:00 2001 From: Mazdak Farrokhzad Date: Thu, 23 Sep 2021 17:06:48 +0200 Subject: [PATCH 25/25] cleanup courtesy of clippy --- asg/src/reducer/monoid/bool_and.rs | 16 +++------------- asg/src/statement/conditional.rs | 2 +- .../src/canonicalization/canonicalizer.rs | 10 +--------- compiler/src/option.rs | 13 +------------ grammar/src/main.rs | 5 ----- leo/commands/build.rs | 17 +---------------- leo/config.rs | 10 +--------- 7 files changed, 8 insertions(+), 65 deletions(-) diff --git a/asg/src/reducer/monoid/bool_and.rs b/asg/src/reducer/monoid/bool_and.rs index fec573a3d0..a319b92c92 100644 --- a/asg/src/reducer/monoid/bool_and.rs +++ b/asg/src/reducer/monoid/bool_and.rs @@ -16,25 +16,15 @@ use super::*; +#[derive(Default)] pub struct BoolAnd(pub bool); -impl Default for BoolAnd { - fn default() -> Self { - BoolAnd(false) - } -} - impl Monoid for BoolAnd { fn append(self, other: Self) -> Self { BoolAnd(self.0 && other.0) } - fn append_all(self, others: impl Iterator) -> Self { - for item in others { - if !item.0 { - return BoolAnd(false); - } - } - BoolAnd(true) + fn append_all(self, mut others: impl Iterator) -> Self { + BoolAnd(others.all(|i| i.0)) } } diff --git a/asg/src/statement/conditional.rs b/asg/src/statement/conditional.rs index fb14b9c6eb..ad71ba442a 100644 --- a/asg/src/statement/conditional.rs +++ b/asg/src/statement/conditional.rs @@ -70,7 +70,7 @@ impl<'a> Into for &ConditionalStatement<'a> { Statement::Block(block) => block.into(), _ => unimplemented!(), }, - next: self.next.get().as_deref().map(|e| Box::new(e.into())), + next: self.next.get().map(|e| Box::new(e.into())), span: self.span.clone().unwrap_or_default(), } } diff --git a/ast-passes/src/canonicalization/canonicalizer.rs b/ast-passes/src/canonicalization/canonicalizer.rs index 704231cc66..ac05fa3db2 100644 --- a/ast-passes/src/canonicalization/canonicalizer.rs +++ b/ast-passes/src/canonicalization/canonicalizer.rs @@ -23,6 +23,7 @@ use leo_errors::{AstError, Result, Span}; /// Tuple array types and expressions error if a size of 0 is given. /// Compound operators become simple assignments. /// Functions missing output type return a empty tuple. +#[derive(Default)] pub struct Canonicalizer { // If we are in a circuit keep track of the circuit name. circuit_name: Option, @@ -37,15 +38,6 @@ impl AstPass for Canonicalizer { } } -impl Default for Canonicalizer { - fn default() -> Self { - Self { - circuit_name: None, - in_circuit: false, - } - } -} - impl Canonicalizer { pub fn canonicalize_accesses( &mut self, diff --git a/compiler/src/option.rs b/compiler/src/option.rs index 024726c456..d469ff08b4 100644 --- a/compiler/src/option.rs +++ b/compiler/src/option.rs @@ -35,21 +35,10 @@ impl Default for CompilerOptions { } } -#[derive(Clone)] +#[derive(Clone, Default)] pub struct AstSnapshotOptions { pub initial: bool, pub imports_resolved: bool, pub canonicalized: bool, pub type_inferenced: bool, } - -impl Default for AstSnapshotOptions { - fn default() -> Self { - Self { - initial: false, - imports_resolved: false, - canonicalized: false, - type_inferenced: false, - } - } -} diff --git a/grammar/src/main.rs b/grammar/src/main.rs index d180ef3bb4..28b9f6da74 100644 --- a/grammar/src/main.rs +++ b/grammar/src/main.rs @@ -222,8 +222,3 @@ fn main() -> Result<()> { Ok(()) } - -#[test] -fn test_true() { - assert!(true); -} diff --git a/leo/commands/build.rs b/leo/commands/build.rs index 7f377af9d2..a21a09ad35 100644 --- a/leo/commands/build.rs +++ b/leo/commands/build.rs @@ -35,7 +35,7 @@ use tracing::span::Span; /// Compiler Options wrapper for Build command. Also used by other commands which /// require Build command output as their input. -#[derive(StructOpt, Clone, Debug)] +#[derive(StructOpt, Clone, Debug, Default)] pub struct BuildOptions { #[structopt(long, help = "Disable constant folding compiler optimization")] pub disable_constant_folding: bool, @@ -55,21 +55,6 @@ pub struct BuildOptions { pub enable_type_inferenced_ast_snapshot: bool, } -impl Default for BuildOptions { - fn default() -> Self { - Self { - disable_constant_folding: false, - disable_code_elimination: false, - disable_all_optimizations: false, - enable_all_ast_snapshots: false, - enable_initial_ast_snapshot: false, - enable_imports_resolved_ast_snapshot: false, - enable_canonicalized_ast_snapshot: false, - enable_type_inferenced_ast_snapshot: false, - } - } -} - impl From for CompilerOptions { fn from(options: BuildOptions) -> Self { if options.disable_all_optimizations { diff --git a/leo/config.rs b/leo/config.rs index 4435c7223e..1d43d9f2aa 100644 --- a/leo/config.rs +++ b/leo/config.rs @@ -66,19 +66,11 @@ impl Default for Update { } } -#[derive(Clone, Debug, Serialize, Deserialize)] +#[derive(Clone, Debug, Serialize, Deserialize, Default)] pub struct Config { pub update: Update, } -impl Default for Config { - fn default() -> Self { - Self { - update: Update::default(), - } - } -} - impl Config { /// Read the config from the `config.toml` file pub fn read_config() -> Result {