diff --git a/compiler/ast/src/functions/function_input.rs b/compiler/ast/src/functions/input.rs similarity index 100% rename from compiler/ast/src/functions/function_input.rs rename to compiler/ast/src/functions/input.rs diff --git a/compiler/ast/src/functions/mod.rs b/compiler/ast/src/functions/mod.rs index bc1601f06a..17c73fe8c2 100644 --- a/compiler/ast/src/functions/mod.rs +++ b/compiler/ast/src/functions/mod.rs @@ -17,8 +17,8 @@ pub mod annotation; pub use annotation::*; -pub mod call_type; -pub use call_type::*; +pub mod variant; +pub use variant::*; pub mod external; pub use external::*; @@ -26,11 +26,11 @@ pub use external::*; pub mod finalize; pub use finalize::*; -pub mod function_input; -pub use function_input::*; +pub mod input; +pub use input::*; -pub mod function_output; -pub use function_output::*; +pub mod output; +pub use output::*; pub mod mode; pub use mode::*; @@ -47,7 +47,7 @@ pub struct Function { /// Annotations on the function. pub annotations: Vec, /// Is this function a transition, inlined, or a regular function?. - pub call_type: CallType, + pub variant: Variant, /// The function identifier, e.g., `foo` in `function foo(...) { ... }`. pub identifier: Identifier, /// The function's input parameters. @@ -77,7 +77,7 @@ impl Function { #[allow(clippy::too_many_arguments)] pub fn new( annotations: Vec, - call_type: CallType, + variant: Variant, identifier: Identifier, input: Vec, output: Vec, @@ -99,7 +99,7 @@ impl Function { Function { annotations, - call_type, + variant, identifier, input, output, @@ -123,10 +123,10 @@ impl Function { /// Private formatting method used for optimizing [fmt::Debug] and [fmt::Display] implementations. /// fn format(&self, f: &mut fmt::Formatter) -> fmt::Result { - match self.call_type { - CallType::Inline => write!(f, "inline ")?, - CallType::Standard => write!(f, "function ")?, - CallType::Transition => write!(f, "transition ")?, + match self.variant { + Variant::Inline => write!(f, "inline ")?, + Variant::Standard => write!(f, "function ")?, + Variant::Transition => write!(f, "transition ")?, } write!(f, "{}", self.identifier)?; diff --git a/compiler/ast/src/functions/function_output.rs b/compiler/ast/src/functions/output.rs similarity index 100% rename from compiler/ast/src/functions/function_output.rs rename to compiler/ast/src/functions/output.rs diff --git a/compiler/ast/src/functions/call_type.rs b/compiler/ast/src/functions/variant.rs similarity index 93% rename from compiler/ast/src/functions/call_type.rs rename to compiler/ast/src/functions/variant.rs index 2c9f68cede..407246de9b 100644 --- a/compiler/ast/src/functions/call_type.rs +++ b/compiler/ast/src/functions/variant.rs @@ -16,12 +16,12 @@ use serde::{Deserialize, Serialize}; -/// An enum declaring how the function is invoked. +/// Functions are always one of three variants. /// A transition function is permitted the ability to manipulate records. /// A regular function is not permitted to manipulate records. /// An inline function is directly copied at the call site. #[derive(Copy, Clone, Debug, Serialize, Deserialize, PartialEq, Eq)] -pub enum CallType { +pub enum Variant { Inline, Standard, Transition, diff --git a/compiler/ast/src/passes/reconstructor.rs b/compiler/ast/src/passes/reconstructor.rs index b0abc356cb..3a31e77613 100644 --- a/compiler/ast/src/passes/reconstructor.rs +++ b/compiler/ast/src/passes/reconstructor.rs @@ -378,7 +378,7 @@ pub trait ProgramReconstructor: StatementReconstructor { fn reconstruct_function(&mut self, input: Function) -> Function { Function { annotations: input.annotations, - call_type: input.call_type, + variant: input.variant, identifier: input.identifier, input: input.input, output: input.output, diff --git a/compiler/compiler/src/compiler.rs b/compiler/compiler/src/compiler.rs index 3fcf0f1cca..3b6676b787 100644 --- a/compiler/compiler/src/compiler.rs +++ b/compiler/compiler/src/compiler.rs @@ -192,14 +192,27 @@ impl<'a> Compiler<'a> { } /// Runs the flattening pass. - pub fn flattening_pass(&mut self, symbol_table: &SymbolTable, assigner: Assigner) -> Result<()> { - self.ast = Flattener::do_pass((std::mem::take(&mut self.ast), symbol_table, assigner))?; + pub fn flattening_pass(&mut self, symbol_table: &SymbolTable, assigner: Assigner) -> Result { + let (ast, assigner) = Flattener::do_pass((std::mem::take(&mut self.ast), symbol_table, assigner))?; + self.ast = ast; if self.output_options.flattened_ast { self.write_ast_to_json("flattened_ast.json")?; } - Ok(()) + Ok(assigner) + } + + /// Runs the function inlining pass. + pub fn function_inlining_pass(&mut self, call_graph: &CallGraph, assigner: Assigner) -> Result { + let (ast, assigner) = FunctionInliner::do_pass((std::mem::take(&mut self.ast), call_graph, assigner))?; + self.ast = ast; + + if self.output_options.inlined_ast { + self.write_ast_to_json("inlined_ast.json")?; + } + + Ok(assigner) } /// Runs the compiler stages. @@ -213,7 +226,9 @@ impl<'a> Compiler<'a> { // TODO: Make this pass optional. let assigner = self.static_single_assignment_pass(&st)?; - self.flattening_pass(&st, assigner)?; + let assigner = self.flattening_pass(&st, assigner)?; + + let _ = self.function_inlining_pass(&call_graph, assigner)?; Ok((st, struct_graph, call_graph)) } diff --git a/compiler/compiler/src/options.rs b/compiler/compiler/src/options.rs index e22e4f321a..6428ae3c72 100644 --- a/compiler/compiler/src/options.rs +++ b/compiler/compiler/src/options.rs @@ -14,6 +14,8 @@ // You should have received a copy of the GNU General Public License // along with the Leo library. If not, see . +// NOTE: If compiler passes are made optional, pass preconditions and invariants may not necessarily hold true. + #[derive(Clone, Default)] pub struct OutputOptions { /// Whether spans are enabled in the output ASTs. @@ -28,4 +30,6 @@ pub struct OutputOptions { pub ssa_ast: bool, /// If enabled writes the AST after flattening. pub flattened_ast: bool, + /// If enabled writes the AST after inlining. + pub inlined_ast: bool, } diff --git a/compiler/compiler/tests/compile.rs b/compiler/compiler/tests/compile.rs index e9d5a4cce0..3653723a95 100644 --- a/compiler/compiler/tests/compile.rs +++ b/compiler/compiler/tests/compile.rs @@ -53,6 +53,7 @@ struct CompileOutput { pub unrolled_ast: String, pub ssa_ast: String, pub flattened_ast: String, + pub inlined_ast: String, pub bytecode: String, } @@ -74,7 +75,7 @@ fn run_test(test: Test, handler: &Handler) -> Result { handler.extend_if_error(package.get_process().map_err(LeoError::Anyhow))?; // Hash the ast files. - let (initial_ast, unrolled_ast, ssa_ast, flattened_ast) = hash_asts(); + let (initial_ast, unrolled_ast, ssa_ast, flattened_ast, inlined_ast) = hash_asts(); // Clean up the output directory. if fs::read_dir("/tmp/output").is_ok() { @@ -86,6 +87,7 @@ fn run_test(test: Test, handler: &Handler) -> Result { unrolled_ast, ssa_ast, flattened_ast, + inlined_ast, bytecode: hash_content(&bytecode), }; Ok(serde_yaml::to_value(final_output).expect("serialization failed")) diff --git a/compiler/compiler/tests/execute.rs b/compiler/compiler/tests/execute.rs index 908ded21d3..bc7024dffe 100644 --- a/compiler/compiler/tests/execute.rs +++ b/compiler/compiler/tests/execute.rs @@ -58,6 +58,7 @@ struct ExecuteOutput { pub unrolled_ast: String, pub ssa_ast: String, pub flattened_ast: String, + pub inlined_ast: String, pub bytecode: String, pub results: BTreeMap>>, } @@ -145,7 +146,7 @@ fn run_test(test: Test, handler: &Handler, err_buf: &BufferEmitter) -> Result Result (String, String, String, String) { +pub fn hash_asts() -> (String, String, String, String, String) { let initial_ast = hash_file("/tmp/output/test.initial_ast.json"); let unrolled_ast = hash_file("/tmp/output/test.unrolled_ast.json"); let ssa_ast = hash_file("/tmp/output/test.ssa_ast.json"); let flattened_ast = hash_file("/tmp/output/test.flattened_ast.json"); + let inlined_ast = hash_file("/tmp/output/test.inlined_ast.json"); - (initial_ast, unrolled_ast, ssa_ast, flattened_ast) + (initial_ast, unrolled_ast, ssa_ast, flattened_ast, inlined_ast) } pub fn get_cwd_option(test: &Test) -> Option { @@ -100,6 +101,7 @@ pub fn new_compiler(handler: &Handler, main_file_path: PathBuf) -> Compiler<'_> unrolled_ast: true, ssa_ast: true, flattened_ast: true, + inlined_ast: true, }), ) } @@ -183,11 +185,16 @@ pub fn temp_dir() -> PathBuf { pub fn compile_and_process<'a>(parsed: &'a mut Compiler<'a>) -> Result { let st = parsed.symbol_table_pass()?; + let (st, struct_graph, call_graph) = parsed.type_checker_pass(st)?; + let st = parsed.loop_unrolling_pass(st)?; + let assigner = parsed.static_single_assignment_pass(&st)?; - parsed.flattening_pass(&st, assigner)?; + let assigner = parsed.flattening_pass(&st, assigner)?; + + let _ = parsed.function_inlining_pass(&call_graph, assigner)?; // Compile Leo program to bytecode. let bytecode = CodeGenerator::do_pass((&parsed.ast, &st, &struct_graph, &call_graph))?; diff --git a/compiler/parser/src/parser/file.rs b/compiler/parser/src/parser/file.rs index b4a342a2c5..adae462ebf 100644 --- a/compiler/parser/src/parser/file.rs +++ b/compiler/parser/src/parser/file.rs @@ -156,7 +156,7 @@ impl ParserContext<'_> { let (id, mapping) = self.parse_mapping()?; mappings.insert(id, mapping); } - Token::At | Token::Function | Token::Transition => { + Token::At | Token::Function | Token::Transition | Token::Inline => { let (id, function) = self.parse_function()?; functions.insert(id, function); } @@ -172,6 +172,7 @@ impl ParserContext<'_> { Token::At, Token::Function, Token::Transition, + Token::Inline, ], ) .into()) @@ -423,11 +424,12 @@ impl ParserContext<'_> { while self.look_ahead(0, |t| &t.token) == &Token::At { annotations.push(self.parse_annotation()?) } - // Parse ` IDENT`, where `` is `function` or `transition`. - let (call_type, start) = match self.token.token { - Token::Function => (CallType::Standard, self.expect(&Token::Function)?), - Token::Transition => (CallType::Transition, self.expect(&Token::Transition)?), - _ => self.unexpected("'function', 'transition'")?, + // Parse ` IDENT`, where `` is `function`, `transition`, or `inline`. + let (variant, start) = match self.token.token { + Token::Inline => (Variant::Inline, self.expect(&Token::Inline)?), + Token::Function => (Variant::Standard, self.expect(&Token::Function)?), + Token::Transition => (Variant::Transition, self.expect(&Token::Transition)?), + _ => self.unexpected("'function', 'transition', or 'inline'")?, }; let name = self.expect_identifier()?; @@ -489,7 +491,7 @@ impl ParserContext<'_> { let span = start + block.span; Ok(( name.name, - Function::new(annotations, call_type, name, inputs, output, block, finalize, span), + Function::new(annotations, variant, name, inputs, output, block, finalize, span), )) } } diff --git a/compiler/parser/src/tokenizer/lexer.rs b/compiler/parser/src/tokenizer/lexer.rs index ccfea1595f..073ffd8584 100644 --- a/compiler/parser/src/tokenizer/lexer.rs +++ b/compiler/parser/src/tokenizer/lexer.rs @@ -425,9 +425,10 @@ impl Token { "i64" => Token::I64, "i128" => Token::I128, "if" => Token::If, + "import" => Token::Import, "in" => Token::In, "increment" => Token::Increment, - "import" => Token::Import, + "inline" => Token::Inline, "let" => Token::Let, "leo" => Token::Leo, "mapping" => Token::Mapping, diff --git a/compiler/parser/src/tokenizer/mod.rs b/compiler/parser/src/tokenizer/mod.rs index 89c513935a..4667d01d79 100644 --- a/compiler/parser/src/tokenizer/mod.rs +++ b/compiler/parser/src/tokenizer/mod.rs @@ -103,6 +103,7 @@ mod tests { i8 if in + inline input let mut @@ -167,7 +168,7 @@ mod tests { assert_eq!( output, - r#""test" "test{}test" "test{}" "{}test" "test{" "test}" "test{test" "test}test" "te{{}}" test_ident 12345 address assert assert_eq assert_neq async bool const else false field finalize for function group i128 i64 i32 i16 i8 if in input let mut private program public return scalar self string struct test then transition true u128 u64 u32 u16 u8 console ! != && ( ) * ** + , - -> => _ . .. / : ; < <= = == > >= [ ] { { } } || ? @ // test + r#""test" "test{}test" "test{}" "{}test" "test{" "test}" "test{test" "test}test" "te{{}}" test_ident 12345 address assert assert_eq assert_neq async bool const else false field finalize for function group i128 i64 i32 i16 i8 if in inline input let mut private program public return scalar self string struct test then transition true u128 u64 u32 u16 u8 console ! != && ( ) * ** + , - -> => _ . .. / : ; < <= = == > >= [ ] { { } } || ? @ // test /* test */ // "# ); }); diff --git a/compiler/parser/src/tokenizer/token.rs b/compiler/parser/src/tokenizer/token.rs index 14fe06289b..fc6e648a3b 100644 --- a/compiler/parser/src/tokenizer/token.rs +++ b/compiler/parser/src/tokenizer/token.rs @@ -127,6 +127,7 @@ pub enum Token { Import, In, Increment, + Inline, Let, Mapping, Private, @@ -177,6 +178,7 @@ pub const KEYWORD_TOKENS: &[Token] = &[ Token::Import, Token::In, Token::Increment, + Token::Inline, Token::Let, Token::Mapping, Token::Private, @@ -231,9 +233,10 @@ impl Token { Token::I64 => sym::i64, Token::I128 => sym::i128, Token::If => sym::If, + Token::Import => sym::import, Token::In => sym::In, Token::Increment => sym::increment, - Token::Import => sym::import, + Token::Inline => sym::inline, Token::Let => sym::Let, Token::Leo => sym::leo, Token::Mapping => sym::mapping, @@ -361,6 +364,7 @@ impl fmt::Display for Token { Import => write!(f, "import"), In => write!(f, "in"), Increment => write!(f, "increment"), + Inline => write!(f, "inline"), Let => write!(f, "let"), Mapping => write!(f, "mapping"), Private => write!(f, "private"), diff --git a/compiler/passes/src/code_generation/visit_program.rs b/compiler/passes/src/code_generation/visit_program.rs index 19ea55a57f..511e3eee9a 100644 --- a/compiler/passes/src/code_generation/visit_program.rs +++ b/compiler/passes/src/code_generation/visit_program.rs @@ -16,7 +16,7 @@ use crate::CodeGenerator; -use leo_ast::{functions, CallType, Function, Mapping, Mode, Program, ProgramScope, Struct, Type}; +use leo_ast::{functions, Function, Mapping, Mode, Program, ProgramScope, Struct, Type, Variant}; use indexmap::IndexMap; use itertools::Itertools; @@ -94,7 +94,7 @@ impl<'a> CodeGenerator<'a> { let function = program_scope.functions.get(&function_name).unwrap(); // Set the `is_transition_function` flag. - self.is_transition_function = matches!(function.call_type, CallType::Transition); + self.is_transition_function = matches!(function.variant, Variant::Transition); let function_string = self.visit_function(function); diff --git a/compiler/passes/src/common/graph/mod.rs b/compiler/passes/src/common/graph/mod.rs index 4b985c2e4c..52ead80806 100644 --- a/compiler/passes/src/common/graph/mod.rs +++ b/compiler/passes/src/common/graph/mod.rs @@ -20,7 +20,7 @@ use indexmap::{IndexMap, IndexSet}; use std::fmt::Debug; use std::hash::Hash; -/// An struct dependency graph. +/// A struct dependency graph. pub type StructGraph = DiGraph; /// A call graph. @@ -211,4 +211,11 @@ mod test { let expected = Vec::from([1u32, 2, 4, 1]); assert_eq!(cycle, expected); } + + #[test] + fn test_unconnected_graph() { + let graph = DiGraph::::new(IndexSet::from([1, 2, 3, 4, 5])); + + check_post_order(&graph, &[1, 2, 3, 4, 5]); + } } diff --git a/compiler/passes/src/common/mod.rs b/compiler/passes/src/common/mod.rs index b831aa6f77..ea09e11c45 100644 --- a/compiler/passes/src/common/mod.rs +++ b/compiler/passes/src/common/mod.rs @@ -23,5 +23,8 @@ pub use graph::*; pub mod rename_table; pub use rename_table::*; +pub mod replacer; +pub use replacer::*; + pub mod symbol_table; pub use symbol_table::*; diff --git a/compiler/passes/src/common/replacer/mod.rs b/compiler/passes/src/common/replacer/mod.rs new file mode 100644 index 0000000000..19015aeeb8 --- /dev/null +++ b/compiler/passes/src/common/replacer/mod.rs @@ -0,0 +1,51 @@ +// Copyright (C) 2019-2023 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_ast::{Expression, ExpressionReconstructor, Identifier, ProgramReconstructor, StatementReconstructor}; + +/// A `Replacer` applies `replacer` to all `Identifier`s in an AST. +/// `Replacer`s are used to rename identifiers. +/// `Replacer`s are used to interpolate function arguments. +pub struct Replacer +where + F: Fn(&Identifier) -> Expression, +{ + replace: F, +} + +impl Replacer +where + F: Fn(&Identifier) -> Expression, +{ + pub fn new(replace: F) -> Self { + Self { replace } + } +} + +impl ExpressionReconstructor for Replacer +where + F: Fn(&Identifier) -> Expression, +{ + type AdditionalOutput = (); + + fn reconstruct_identifier(&mut self, input: Identifier) -> (Expression, Self::AdditionalOutput) { + ((self.replace)(&input), Default::default()) + } +} + +impl StatementReconstructor for Replacer where F: Fn(&Identifier) -> Expression {} + +impl ProgramReconstructor for Replacer where F: Fn(&Identifier) -> Expression {} diff --git a/compiler/passes/src/common/symbol_table/function_symbol.rs b/compiler/passes/src/common/symbol_table/function_symbol.rs index 602c9f165c..2e3482afbe 100644 --- a/compiler/passes/src/common/symbol_table/function_symbol.rs +++ b/compiler/passes/src/common/symbol_table/function_symbol.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 . -use leo_ast::{CallType, Function, Input, Type}; +use leo_ast::{Function, Input, Type, Variant}; use leo_span::Span; use crate::SymbolTable; @@ -36,7 +36,7 @@ pub struct FunctionSymbol { /// The output type of the function. pub(crate) output_type: Type, /// Is this function a transition, inlined, or a regular function?. - pub call_type: CallType, + pub variant: Variant, /// The `Span` associated with the function. pub(crate) _span: Span, /// The inputs to the function. @@ -50,7 +50,7 @@ impl SymbolTable { FunctionSymbol { id, output_type: func.output_type.clone(), - call_type: func.call_type, + variant: func.variant, _span: func.span, input: func.input.clone(), finalize: func.finalize.as_ref().map(|finalize| FinalizeData { diff --git a/compiler/passes/src/flattening/flatten_expression.rs b/compiler/passes/src/flattening/flatten_expression.rs index abd87438da..9743df6c30 100644 --- a/compiler/passes/src/flattening/flatten_expression.rs +++ b/compiler/passes/src/flattening/flatten_expression.rs @@ -201,12 +201,12 @@ impl ExpressionReconstructor for Flattener<'_> { statements.extend(stmts); // Create and accumulate an intermediate assignment statement for the ternary expression corresponding to the struct member. - let (identifier, statement) = self.unique_simple_assign_statement(expression); + let (result, statement) = self.unique_simple_assign_statement(expression); statements.push(statement); StructVariableInitializer { - identifier, - expression: Some(Expression::Identifier(identifier)), + identifier: *identifier, + expression: Some(Expression::Identifier(result)), } }) .collect(); @@ -297,12 +297,12 @@ impl ExpressionReconstructor for Flattener<'_> { statements.extend(stmts); // Create and accumulate an intermediate assignment statement for the ternary expression corresponding to the struct member. - let (identifier, statement) = self.unique_simple_assign_statement(expression); + let (result, statement) = self.unique_simple_assign_statement(expression); statements.push(statement); StructVariableInitializer { - identifier, - expression: Some(Expression::Identifier(identifier)), + identifier: *identifier, + expression: Some(Expression::Identifier(result)), } }) .collect(); diff --git a/compiler/passes/src/flattening/flatten_program.rs b/compiler/passes/src/flattening/flatten_program.rs index 863db72323..0cd28c8c0f 100644 --- a/compiler/passes/src/flattening/flatten_program.rs +++ b/compiler/passes/src/flattening/flatten_program.rs @@ -69,7 +69,7 @@ impl ProgramReconstructor for Flattener<'_> { Function { annotations: function.annotations, - call_type: function.call_type, + variant: function.variant, identifier: function.identifier, input: function.input, output: function.output, diff --git a/compiler/passes/src/flattening/flattener.rs b/compiler/passes/src/flattening/flattener.rs index 8a31df7297..9c153abe0b 100644 --- a/compiler/passes/src/flattening/flattener.rs +++ b/compiler/passes/src/flattening/flattener.rs @@ -27,7 +27,7 @@ use indexmap::IndexMap; pub struct Flattener<'a> { /// The symbol table associated with the program. pub(crate) symbol_table: &'a SymbolTable, - /// An struct used to construct (unique) assignment statements. + /// A struct used to construct (unique) assignment statements. pub(crate) assigner: Assigner, /// The set of variables that are structs. pub(crate) structs: IndexMap, diff --git a/compiler/passes/src/flattening/mod.rs b/compiler/passes/src/flattening/mod.rs index c81e47ee30..9cd00c6ee8 100644 --- a/compiler/passes/src/flattening/mod.rs +++ b/compiler/passes/src/flattening/mod.rs @@ -66,12 +66,12 @@ use leo_errors::Result; impl<'a> Pass for Flattener<'a> { type Input = (Ast, &'a SymbolTable, Assigner); - type Output = Result; + type Output = Result<(Ast, Assigner)>; fn do_pass((ast, st, assigner): Self::Input) -> Self::Output { let mut reconstructor = Flattener::new(st, assigner); let program = reconstructor.reconstruct_program(ast.into_repr()); - Ok(Ast::new(program)) + Ok((Ast::new(program), reconstructor.assigner)) } } diff --git a/compiler/passes/src/function_inlining/assignment_renamer.rs b/compiler/passes/src/function_inlining/assignment_renamer.rs new file mode 100644 index 0000000000..2ce3bcd92f --- /dev/null +++ b/compiler/passes/src/function_inlining/assignment_renamer.rs @@ -0,0 +1,149 @@ +// Copyright (C) 2019-2023 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::{Assigner, RenameTable}; +use leo_ast::{ + AssignStatement, ConditionalStatement, ConsoleStatement, DefinitionStatement, Expression, ExpressionReconstructor, + Identifier, IterationStatement, ProgramReconstructor, Statement, StatementReconstructor, StructExpression, + StructVariableInitializer, +}; +use leo_span::Symbol; + +// TODO: Generalize the functionality of this reconstructor to be used in other passes. +/// An `AssignmentRenamer` renames the left-hand side of all assignment statements in an AST node. +/// The new names are propagated to all following identifiers. +pub struct AssignmentRenamer { + pub assigner: Assigner, + pub rename_table: RenameTable, + pub is_lhs: bool, +} + +impl AssignmentRenamer { + /// Initialize a new `AssignmentRenamer`. + pub fn new(assigner: Assigner) -> Self { + Self { + assigner, + rename_table: RenameTable::new(None), + is_lhs: false, + } + } + + /// Load the internal rename table with a set of entries. + pub fn load(&mut self, entries: impl Iterator) { + for (key, value) in entries { + self.rename_table.update(key, value); + } + } + + /// Clear the internal rename table. + pub fn clear(&mut self) { + self.rename_table = RenameTable::new(None); + } +} + +impl ExpressionReconstructor for AssignmentRenamer { + type AdditionalOutput = (); + /// Rename the identifier if it is the left-hand side of an assignment, otherwise look up for a new name in the internal rename table. + fn reconstruct_identifier(&mut self, input: Identifier) -> (Expression, Self::AdditionalOutput) { + let name = match self.is_lhs { + // If consuming the left-hand side of an assignment, a new unique name is introduced. + true => { + let new_name = self.assigner.unique_symbol(input.name, "$"); + self.rename_table.update(input.name, new_name); + new_name + } + // Otherwise, we look up the previous name in the `RenameTable`. + // Note that we do not panic if the identifier is not found in the rename table. + // Variables that do not exist in the rename table are ones that have been introduced during the SSA pass. + // These variables are never re-assigned, and will never have an entry in the rename-table. + false => *self.rename_table.lookup(input.name).unwrap_or(&input.name), + }; + + ( + Expression::Identifier(Identifier { name, span: input.span }), + Default::default(), + ) + } + + /// Rename the variable initializers in the struct expression. + fn reconstruct_struct_init(&mut self, input: StructExpression) -> (Expression, Self::AdditionalOutput) { + ( + Expression::Struct(StructExpression { + name: input.name, + members: input + .members + .into_iter() + .map(|member| StructVariableInitializer { + identifier: member.identifier, + expression: match member.expression { + Some(expression) => Some(self.reconstruct_expression(expression).0), + None => unreachable!( + "SSA guarantees that all struct members are always of the form ` : `." + ), + }, + }) + .collect(), + span: input.span, + }), + Default::default(), + ) + } +} + +impl StatementReconstructor for AssignmentRenamer { + /// Rename the left-hand side of the assignment statement. + fn reconstruct_assign(&mut self, input: AssignStatement) -> (Statement, Self::AdditionalOutput) { + // First rename the right-hand-side of the assignment. + let value = self.reconstruct_expression(input.value).0; + + // Then assign a new unique name to the left-hand-side of the assignment. + // Note that this order is necessary to ensure that the right-hand-side uses the correct name when consuming a complex assignment. + self.is_lhs = true; + let place = self.reconstruct_expression(input.place).0; + self.is_lhs = false; + + ( + Statement::Assign(Box::new(AssignStatement { + place, + value, + span: input.span, + })), + Default::default(), + ) + } + + /// Flattening removes conditional statements from the program. + fn reconstruct_conditional(&mut self, _: ConditionalStatement) -> (Statement, Self::AdditionalOutput) { + unreachable!("`ConditionalStatement`s should not be in the AST at this phase of compilation.") + } + + /// Parsing guarantees that console statements are not present in the program. + fn reconstruct_console(&mut self, _: ConsoleStatement) -> (Statement, Self::AdditionalOutput) { + unreachable!("`ConsoleStatement`s should not be in the AST at this phase of compilation.") + } + + /// Static single assignment replaces definition statements with assignment statements. + fn reconstruct_definition(&mut self, _: DefinitionStatement) -> (Statement, Self::AdditionalOutput) { + unreachable!("`DefinitionStatement`s should not exist in the AST at this phase of compilation.") + } + + /// Loop unrolling unrolls and removes iteration statements from the program. + fn reconstruct_iteration(&mut self, _: IterationStatement) -> (Statement, Self::AdditionalOutput) { + unreachable!("`IterationStatement`s should not be in the AST at this phase of compilation."); + } +} + +impl ProgramReconstructor for AssignmentRenamer {} diff --git a/compiler/passes/src/function_inlining/function_inliner.rs b/compiler/passes/src/function_inlining/function_inliner.rs new file mode 100644 index 0000000000..c027f3b7a9 --- /dev/null +++ b/compiler/passes/src/function_inlining/function_inliner.rs @@ -0,0 +1,42 @@ +// Copyright (C) 2019-2023 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::{Assigner, AssignmentRenamer, CallGraph}; + +use leo_ast::Function; +use leo_span::Symbol; + +use indexmap::IndexMap; + +pub struct FunctionInliner<'a> { + /// The call graph for the program. + pub(crate) call_graph: &'a CallGraph, + /// A wrapper around an Assigner used to create unique variable assignments. + pub(crate) assignment_renamer: AssignmentRenamer, + /// A map of reconstructed functions in the current program scope. + pub(crate) reconstructed_functions: IndexMap, +} + +impl<'a> FunctionInliner<'a> { + /// Initializes a new `FunctionInliner`. + pub fn new(call_graph: &'a CallGraph, assigner: Assigner) -> Self { + Self { + call_graph, + assignment_renamer: AssignmentRenamer::new(assigner), + reconstructed_functions: Default::default(), + } + } +} diff --git a/compiler/passes/src/function_inlining/inline_expression.rs b/compiler/passes/src/function_inlining/inline_expression.rs new file mode 100644 index 0000000000..21d1c08565 --- /dev/null +++ b/compiler/passes/src/function_inlining/inline_expression.rs @@ -0,0 +1,93 @@ +// Copyright (C) 2019-2023 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::{FunctionInliner, Replacer}; + +use leo_ast::{ + CallExpression, Expression, ExpressionReconstructor, Identifier, ReturnStatement, Statement, + StatementReconstructor, UnitExpression, Variant, +}; + +use indexmap::IndexMap; +use itertools::Itertools; + +impl ExpressionReconstructor for FunctionInliner<'_> { + type AdditionalOutput = Vec; + + fn reconstruct_call(&mut self, input: CallExpression) -> (Expression, Self::AdditionalOutput) { + // Get the name of the callee function. + let function_name = match *input.function { + Expression::Identifier(identifier) => identifier.name, + _ => unreachable!("Parser guarantees that `input.function` is always an identifier."), + }; + + // Lookup the reconstructed callee function. + // Since this pass processes functions in post-order, the callee function is guaranteed to exist in `self.reconstructed_functions` + let callee = self.reconstructed_functions.get(&function_name).unwrap(); + + // Inline the callee function, if required, otherwise, return the call expression. + match callee.variant { + Variant::Transition | Variant::Standard => (Expression::Call(input), Default::default()), + Variant::Inline => { + // Construct a mapping from input variables of the callee function to arguments passed to the callee. + let parameter_to_argument = callee + .input + .iter() + .map(|input| input.identifier()) + .zip_eq(input.arguments.into_iter()) + .collect::>(); + + // Initializer `self.assignment_renamer` with the function parameters. + self.assignment_renamer.load( + callee + .input + .iter() + .map(|input| (input.identifier().name, input.identifier().name)), + ); + + // Duplicate the body of the callee and create a unique assignment statement for each assignment in the body. + // This is necessary to ensure the inlined variables do not conflict with variables in the caller. + let unique_block = self.assignment_renamer.reconstruct_block(callee.block.clone()).0; + + // Reset `self.assignment_renamer`. + self.assignment_renamer.clear(); + + // Replace each input variable with the appropriate parameter. + let replace = |identifier: &Identifier| match parameter_to_argument.get(identifier) { + Some(expression) => expression.clone(), + None => Expression::Identifier(*identifier), + }; + let mut inlined_statements = Replacer::new(replace).reconstruct_block(unique_block).0.statements; + + // If the inlined block returns a value, then use the value in place of the call expression, otherwise, use the unit expression. + let result = match inlined_statements.last() { + Some(Statement::Return(_)) => { + // Note that this unwrap is safe since we know that the last statement is a return statement. + match inlined_statements.pop().unwrap() { + Statement::Return(ReturnStatement { expression, .. }) => expression, + _ => unreachable!("This branch checks that the last statement is a return statement."), + } + } + _ => Expression::Unit(UnitExpression { + span: Default::default(), + }), + }; + + (result, inlined_statements) + } + } + } +} diff --git a/compiler/passes/src/function_inlining/inline_program.rs b/compiler/passes/src/function_inlining/inline_program.rs new file mode 100644 index 0000000000..d954327044 --- /dev/null +++ b/compiler/passes/src/function_inlining/inline_program.rs @@ -0,0 +1,50 @@ +// Copyright (C) 2019-2023 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::FunctionInliner; + +use leo_ast::{ProgramReconstructor, ProgramScope}; + +impl ProgramReconstructor for FunctionInliner<'_> { + fn reconstruct_program_scope(&mut self, mut input: ProgramScope) -> ProgramScope { + // Get the post-order ordering of the call graph. + // Note that the post-order always contains all nodes in the call graph. + // Note that the unwrap is safe since type checking guarantees that the call graph is acyclic. + let order = self.call_graph.post_order().unwrap(); + + // Reconstruct and accumulate each of the functions in post-order. + for function_name in order.into_iter() { + // Note that this unwrap is safe since type checking guarantees that all functions are declared. + let function = input.functions.remove(&function_name).unwrap(); + // Reconstruct the function. + let reconstructed_function = self.reconstruct_function(function); + // Add the reconstructed function to the mapping. + self.reconstructed_functions + .insert(function_name, reconstructed_function); + } + + // Note that this intentionally clears `self.reconstructed_functions` for the next program scope. + let functions = core::mem::take(&mut self.reconstructed_functions); + + ProgramScope { + program_id: input.program_id, + structs: input.structs, + mappings: input.mappings, + functions, + span: input.span, + } + } +} diff --git a/compiler/passes/src/function_inlining/inline_statement.rs b/compiler/passes/src/function_inlining/inline_statement.rs new file mode 100644 index 0000000000..cffd7560f4 --- /dev/null +++ b/compiler/passes/src/function_inlining/inline_statement.rs @@ -0,0 +1,114 @@ +// Copyright (C) 2019-2023 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::FunctionInliner; + +use leo_ast::{ + AssignStatement, Block, ConditionalStatement, ConsoleStatement, DefinitionStatement, Expression, + ExpressionReconstructor, ExpressionStatement, IterationStatement, Statement, StatementReconstructor, +}; + +impl StatementReconstructor for FunctionInliner<'_> { + /// Reconstruct an assignment statement by inlining any function calls. + /// This function also segments tuple assignment statements into multiple assignment statements. + fn reconstruct_assign(&mut self, input: AssignStatement) -> (Statement, Self::AdditionalOutput) { + let (value, mut statements) = self.reconstruct_expression(input.value.clone()); + match (input.place, value) { + // If the function call produces a tuple, we need to segment the tuple into multiple assignment statements. + (Expression::Tuple(left), Expression::Tuple(right)) if left.elements.len() == right.elements.len() => { + statements.extend( + left.elements + .into_iter() + .zip(right.elements.into_iter()) + .map(|(lhs, rhs)| { + Statement::Assign(Box::new(AssignStatement { + place: lhs, + value: rhs, + span: Default::default(), + })) + }), + ); + (Statement::dummy(Default::default()), statements) + } + + (place, value) => ( + Statement::Assign(Box::new(AssignStatement { + place, + value, + span: input.span, + })), + statements, + ), + } + } + + /// Reconstructs the statements inside a basic block, accumulating any statements produced by function inlining. + fn reconstruct_block(&mut self, block: Block) -> (Block, Self::AdditionalOutput) { + let mut statements = Vec::with_capacity(block.statements.len()); + + for statement in block.statements { + let (reconstructed_statement, additional_statements) = self.reconstruct_statement(statement); + statements.extend(additional_statements); + statements.push(reconstructed_statement); + } + + ( + Block { + span: block.span, + statements, + }, + Default::default(), + ) + } + + /// Flattening removes conditional statements from the program. + fn reconstruct_conditional(&mut self, _: ConditionalStatement) -> (Statement, Self::AdditionalOutput) { + unreachable!("`ConditionalStatement`s should not be in the AST at this phase of compilation.") + } + + /// Parsing guarantees that console statements are not present in the program. + fn reconstruct_console(&mut self, _: ConsoleStatement) -> (Statement, Self::AdditionalOutput) { + unreachable!("`ConsoleStatement`s should not be in the AST at this phase of compilation.") + } + + /// Static single assignment replaces definition statements with assignment statements. + fn reconstruct_definition(&mut self, _: DefinitionStatement) -> (Statement, Self::AdditionalOutput) { + unreachable!("`DefinitionStatement`s should not exist in the AST at this phase of compilation.") + } + + /// Reconstructs expression statements by inlining any function calls. + fn reconstruct_expression_statement(&mut self, input: ExpressionStatement) -> (Statement, Self::AdditionalOutput) { + // Reconstruct the expression. + // Note that type checking guarantees that the expression is a function call. + let (expression, additional_statements) = self.reconstruct_expression(input.expression); + + // If the resulting expression is a unit expression, return a dummy statement. + let statement = match expression { + Expression::Unit(_) => Statement::dummy(Default::default()), + _ => Statement::Expression(ExpressionStatement { + expression, + span: input.span, + }), + }; + + (statement, additional_statements) + } + + /// Loop unrolling unrolls and removes iteration statements from the program. + fn reconstruct_iteration(&mut self, _: IterationStatement) -> (Statement, Self::AdditionalOutput) { + unreachable!("`IterationStatement`s should not be in the AST at this phase of compilation."); + } +} diff --git a/compiler/passes/src/function_inlining/mod.rs b/compiler/passes/src/function_inlining/mod.rs new file mode 100644 index 0000000000..30ec9f8168 --- /dev/null +++ b/compiler/passes/src/function_inlining/mod.rs @@ -0,0 +1,82 @@ +// Copyright (C) 2019-2023 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 . + +//! The Function Inlining pass traverses the AST and inlines function at their call site. +//! See https://en.wikipedia.org/wiki/Inline_expansion for more information. +//! The pass also reorders `Function`s in a reconstructed `ProgramScope` so that they are in a post-order of the call graph. +//! In other words, a callee function will appear before a caller function in the order. +//! +//! Consider the following flattened Leo code. +//! ```leo +//! function main(flag: u8, value: u8) -> u8 { +//! $var$0 = flag == 0u8; +//! $var$1 = foo(value); +//! value$2 = $var$1; +//! value$3 = $var$0 ? value$2 : value; +//! return value$3; +//! } +//! +//! inline foo(x: u8) -> u8 { +//! $var$4 = x * x; +//! return $var$4; +//! } +//! ``` +//! +//! The inlining pass produces the following code. +//! ```leo +//! inline foo(x: u8) -> u8 { +//! $var$4 = x * x; +//! return $var$4; +//! } +//! +//! function main(flag: u8, value: u8) -> u8 { +//! $var$0 = flag == 0u8; +//! $var$4$5 = value * value; +//! $var$1 = $var$4$5; +//! value$2 = $var$1; +//! value$3 = $var$0 ? value$2 : value; +//! return value$3; +//! } +//! ``` + +pub mod assignment_renamer; +pub use assignment_renamer::*; + +mod inline_expression; + +mod inline_statement; + +mod inline_program; + +pub mod function_inliner; +pub use function_inliner::*; + +use crate::{Assigner, CallGraph, Pass}; + +use leo_ast::{Ast, ProgramReconstructor}; +use leo_errors::Result; + +impl<'a> Pass for FunctionInliner<'a> { + type Input = (Ast, &'a CallGraph, Assigner); + type Output = Result<(Ast, Assigner)>; + + fn do_pass((ast, call_graph, assigner): Self::Input) -> Self::Output { + let mut reconstructor = FunctionInliner::new(call_graph, assigner); + let program = reconstructor.reconstruct_program(ast.into_repr()); + + Ok((Ast::new(program), reconstructor.assignment_renamer.assigner)) + } +} diff --git a/compiler/passes/src/lib.rs b/compiler/passes/src/lib.rs index 29d7403edd..6da8f44218 100644 --- a/compiler/passes/src/lib.rs +++ b/compiler/passes/src/lib.rs @@ -26,6 +26,9 @@ pub use common::*; pub mod flattening; pub use flattening::*; +pub mod function_inlining; +pub use function_inlining::*; + pub mod loop_unrolling; pub use self::loop_unrolling::*; diff --git a/compiler/passes/src/loop_unrolling/unroll_program.rs b/compiler/passes/src/loop_unrolling/unroll_program.rs index 16fdf4e263..57905a91b2 100644 --- a/compiler/passes/src/loop_unrolling/unroll_program.rs +++ b/compiler/passes/src/loop_unrolling/unroll_program.rs @@ -58,7 +58,7 @@ impl ProgramReconstructor for Unroller<'_> { // Reconstruct the function block. let reconstructed_function = Function { annotations: function.annotations, - call_type: function.call_type, + variant: function.variant, identifier: function.identifier, input: function.input, output: function.output, diff --git a/compiler/passes/src/static_single_assignment/rename_program.rs b/compiler/passes/src/static_single_assignment/rename_program.rs index 6d49c537db..2ae451381b 100644 --- a/compiler/passes/src/static_single_assignment/rename_program.rs +++ b/compiler/passes/src/static_single_assignment/rename_program.rs @@ -110,7 +110,7 @@ impl FunctionConsumer for StaticSingleAssigner<'_> { Function { annotations: function.annotations, - call_type: function.call_type, + variant: function.variant, identifier: function.identifier, input: function.input, output: function.output, diff --git a/compiler/passes/src/static_single_assignment/rename_statement.rs b/compiler/passes/src/static_single_assignment/rename_statement.rs index 5bfce182bd..37c2eb0977 100644 --- a/compiler/passes/src/static_single_assignment/rename_statement.rs +++ b/compiler/passes/src/static_single_assignment/rename_statement.rs @@ -197,7 +197,7 @@ impl StatementConsumer for StaticSingleAssigner<'_> { statements } - /// Consumes the expressions in a `ConsoleStatement`, returning the list of simplified statements. + /// Parsing guarantees that console statements are not present in the program. fn consume_console(&mut self, _: ConsoleStatement) -> Self::Output { unreachable!("Parsing guarantees that console statements are not present in the program.") } diff --git a/compiler/passes/src/static_single_assignment/static_single_assigner.rs b/compiler/passes/src/static_single_assignment/static_single_assigner.rs index 7464aca202..b019c07236 100644 --- a/compiler/passes/src/static_single_assignment/static_single_assigner.rs +++ b/compiler/passes/src/static_single_assignment/static_single_assigner.rs @@ -23,7 +23,7 @@ pub struct StaticSingleAssigner<'a> { pub(crate) rename_table: RenameTable, /// A flag to determine whether or not the traversal is on the left-hand side of a definition or an assignment. pub(crate) is_lhs: bool, - /// An struct used to construct (unique) assignment statements. + /// A struct used to construct (unique) assignment statements. pub(crate) assigner: Assigner, } diff --git a/compiler/passes/src/type_checking/check_expressions.rs b/compiler/passes/src/type_checking/check_expressions.rs index aa12c3df1f..ab05fd8684 100644 --- a/compiler/passes/src/type_checking/check_expressions.rs +++ b/compiler/passes/src/type_checking/check_expressions.rs @@ -447,14 +447,17 @@ impl<'a> ExpressionVisitor<'a> for TypeChecker<'a> { if let Some(func) = func { // Check that the call is valid. - match self.is_transition_function { - // If the function is not a transition function, it cannot call any other functions. - false => { - self.emit_err(TypeCheckerError::cannot_invoke_call_from_standard_function(input.span)); + // Note that this unwrap is safe since we always set the variant before traversing the body of the function. + match self.variant.unwrap() { + // If the function is not a transition function, it can only call "inline" functions. + Variant::Inline | Variant::Standard => { + if !matches!(func.variant, Variant::Inline) { + self.emit_err(TypeCheckerError::can_only_call_inline_function(input.span)); + } } // If the function is a transition function, then check that the call is not to another local transition function. - true => { - if matches!(func.call_type, CallType::Transition) && input.external.is_none() { + Variant::Transition => { + if matches!(func.variant, Variant::Transition) && input.external.is_none() { self.emit_err(TypeCheckerError::cannot_invoke_call_to_local_transition_function( input.span, )); diff --git a/compiler/passes/src/type_checking/check_program.rs b/compiler/passes/src/type_checking/check_program.rs index 96eeeeda9c..13e824fae8 100644 --- a/compiler/passes/src/type_checking/check_program.rs +++ b/compiler/passes/src/type_checking/check_program.rs @@ -70,7 +70,7 @@ impl<'a> ProgramVisitor<'a> for TypeChecker<'a> { let mut transition_count = 0; for function in input.functions.values() { self.visit_function(function); - if matches!(function.call_type, CallType::Transition) { + if matches!(function.variant, Variant::Transition) { transition_count += 1; } } @@ -181,7 +181,7 @@ impl<'a> ProgramVisitor<'a> for TypeChecker<'a> { self.emit_err(TypeCheckerError::unknown_annotation(annotation, annotation.span)) } - self.is_transition_function = matches!(function.call_type, CallType::Transition); + self.variant = Some(function.variant); // Lookup function metadata in the symbol table. // Note that this unwrap is safe since function metadata is stored in a prior pass. @@ -216,13 +216,14 @@ impl<'a> ProgramVisitor<'a> for TypeChecker<'a> { self.emit_err(TypeCheckerError::function_cannot_take_tuple_as_input(input_var.span())) } - match self.is_transition_function { + // Note that this unwrap is safe since we assign to `self.variant` above. + match self.variant.unwrap() { // If the function is a transition function, then check that the parameter mode is not a constant. - true if input_var.mode() == Mode::Const => self.emit_err( + Variant::Transition if input_var.mode() == Mode::Const => self.emit_err( TypeCheckerError::transition_function_inputs_cannot_be_const(input_var.span()), ), // If the function is not a transition function, then check that the parameters do not have an associated mode. - false if input_var.mode() != Mode::None => self.emit_err( + Variant::Standard | Variant::Inline if input_var.mode() != Mode::None => self.emit_err( TypeCheckerError::regular_function_inputs_cannot_have_modes(input_var.span()), ), _ => {} // Do nothing. @@ -248,7 +249,7 @@ impl<'a> ProgramVisitor<'a> for TypeChecker<'a> { Output::External(external) => { // If the function is not a transition function, then it cannot output a record. // Note that an external output must always be a record. - if !self.is_transition_function { + if !matches!(function.variant, Variant::Transition) { self.emit_err(TypeCheckerError::function_cannot_output_record(external.span())); } // Otherwise, do not type check external record function outputs. @@ -259,7 +260,7 @@ impl<'a> ProgramVisitor<'a> for TypeChecker<'a> { self.assert_type_is_defined(&function_output.type_, function_output.span); // If the function is not a transition function, then it cannot output a record. if let Type::Identifier(identifier) = function_output.type_ { - if !self.is_transition_function + if !matches!(function.variant, Variant::Transition) && self .symbol_table .borrow() @@ -307,7 +308,7 @@ impl<'a> ProgramVisitor<'a> for TypeChecker<'a> { self.has_finalize = false; // Check that the function is a transition function. - if !self.is_transition_function { + if !matches!(function.variant, Variant::Transition) { self.emit_err(TypeCheckerError::only_transition_functions_can_have_finalize( finalize.span, )); @@ -393,7 +394,7 @@ impl<'a> ProgramVisitor<'a> for TypeChecker<'a> { // Exit the function's scope. self.exit_scope(function_index); - // Unset `is_transition_function` flag. - self.is_transition_function = false; + // Unset the `variant`. + self.variant = None; } } diff --git a/compiler/passes/src/type_checking/checker.rs b/compiler/passes/src/type_checking/checker.rs index 1e9edf5bea..0ba10fbf35 100644 --- a/compiler/passes/src/type_checking/checker.rs +++ b/compiler/passes/src/type_checking/checker.rs @@ -16,7 +16,7 @@ use crate::{CallGraph, StructGraph, SymbolTable}; -use leo_ast::{Identifier, IntegerType, Node, Type}; +use leo_ast::{Identifier, IntegerType, Node, Type, Variant}; use leo_core::*; use leo_errors::{emitter::Handler, TypeCheckerError}; use leo_span::{Span, Symbol}; @@ -35,12 +35,13 @@ pub struct TypeChecker<'a> { pub(crate) handler: &'a Handler, /// The name of the function that we are currently traversing. pub(crate) function: Option, + /// The variant of the function that we are currently traversing. + pub(crate) variant: Option, /// Whether or not the function that we are currently traversing has a return statement. pub(crate) has_return: bool, /// Whether or not the function that we are currently traversing invokes the finalize block. pub(crate) has_finalize: bool, - /// Whether or not we are currently traversing a transition function. - pub(crate) is_transition_function: bool, + /// Whether or not we are currently traversing a finalize block. pub(crate) is_finalize: bool, /// Whether or not we are currently traversing an imported program. @@ -99,15 +100,16 @@ impl<'a> TypeChecker<'a> { let function_names = symbol_table.functions.keys().cloned().collect(); + // Note that the `struct_graph` and `call_graph` are initialized with their full node sets. Self { symbol_table: RefCell::new(symbol_table), struct_graph: StructGraph::new(struct_names), call_graph: CallGraph::new(function_names), handler, function: None, + variant: None, has_return: false, has_finalize: false, - is_transition_function: false, is_finalize: false, is_imported: false, is_return: false, diff --git a/compiler/span/src/symbol.rs b/compiler/span/src/symbol.rs index 2e44138144..97c91430c6 100644 --- a/compiler/span/src/symbol.rs +++ b/compiler/span/src/symbol.rs @@ -199,6 +199,7 @@ symbols! { In: "in", import, increment, + inline, input, Let: "let", leo, diff --git a/errors/src/errors/type_checker/type_checker_error.rs b/errors/src/errors/type_checker/type_checker_error.rs index bb032bad0f..53c9c86ade 100644 --- a/errors/src/errors/type_checker/type_checker_error.rs +++ b/errors/src/errors/type_checker/type_checker_error.rs @@ -413,9 +413,9 @@ create_messages!( } @formatted - cannot_invoke_call_from_standard_function { + can_only_call_inline_function { args: (), - msg: format!("Cannot call another function from a standard function."), + msg: format!("Only `inline` can be called from a `function` or `inline`."), help: None, } diff --git a/leo/commands/build.rs b/leo/commands/build.rs index 772d040e01..539a6b0f87 100644 --- a/leo/commands/build.rs +++ b/leo/commands/build.rs @@ -58,6 +58,8 @@ pub struct BuildOptions { pub enable_ssa_ast_snapshot: bool, #[structopt(long, help = "Writes AST snapshot of the flattened AST.")] pub enable_flattened_ast_snapshot: bool, + #[structopt(long, help = "Writes AST snapshot of the inlined AST.")] + pub enable_inlined_ast_snapshot: bool, } impl From for OutputOptions { @@ -69,6 +71,7 @@ impl From for OutputOptions { unrolled_ast: options.enable_unrolled_ast_snapshot, ssa_ast: options.enable_ssa_ast_snapshot, flattened_ast: options.enable_flattened_ast_snapshot, + inlined_ast: options.enable_inlined_ast_snapshot, }; if options.enable_all_ast_snapshots { out_options.initial_input_ast = true; @@ -76,6 +79,7 @@ impl From for OutputOptions { out_options.unrolled_ast = true; out_options.ssa_ast = true; out_options.flattened_ast = true; + out_options.inlined_ast = true; } out_options diff --git a/tests/expectations/compiler/address/binary.out b/tests/expectations/compiler/address/binary.out index 4990411148..8e58f2fb54 100644 --- a/tests/expectations/compiler/address/binary.out +++ b/tests/expectations/compiler/address/binary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: da35eac4b0b82c923dc6075007bb615896efc249afffc57a197b129256f967e8 - unrolled_ast: da35eac4b0b82c923dc6075007bb615896efc249afffc57a197b129256f967e8 - ssa_ast: b257a4b1cf0e2aaa47df31a4845b9bb7d8293579c4b1ec4fd0f516d25c924dfa - flattened_ast: 1e009489c50036acad0df55be7cf779ec95bba86dcd40f3d08ff955a26424005 + - initial_ast: af4bf950a53dee2547324d1d139661bc2f881f1a7e9941fe34a85b3745c6958d + unrolled_ast: af4bf950a53dee2547324d1d139661bc2f881f1a7e9941fe34a85b3745c6958d + ssa_ast: 71af510447b440ecf9517b244604dead0fb36905201d7205e1da396acd0de0fe + flattened_ast: 5b0842e447b4e1f92f4bcd22824ed5e12c51c8db145d1541763d10ad3dc1f37a + inlined_ast: 5b0842e447b4e1f92f4bcd22824ed5e12c51c8db145d1541763d10ad3dc1f37a bytecode: eada90968195512a17847ed966d0bef43b7011c18ceee417a3cdb02a1190ca52 diff --git a/tests/expectations/compiler/address/branch.out b/tests/expectations/compiler/address/branch.out index 13e377d7b6..729d96fe49 100644 --- a/tests/expectations/compiler/address/branch.out +++ b/tests/expectations/compiler/address/branch.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ab702ef192a0fcfae6024bd86f419dc6413e2655d593a66abf2abe58c169e4cd - unrolled_ast: ab702ef192a0fcfae6024bd86f419dc6413e2655d593a66abf2abe58c169e4cd - ssa_ast: 2a47e9b9cc25ee909648953549f2cfc1cc575b1787a88af5c77bc3ab487ea6ce - flattened_ast: d4c71cde2c8e2b908ca3f868b33eb2486424ddfc7aa000d177a27c7fe768841a + - initial_ast: b45e54f18036a13051f622f2d8230240aaee77231e39a1b7cdb196615fb4829e + unrolled_ast: b45e54f18036a13051f622f2d8230240aaee77231e39a1b7cdb196615fb4829e + ssa_ast: 0d44a08f0cace01d86fec36ea409e6424ff21f9ee8834f53062569af8c35579e + flattened_ast: c1b6954bff1ce18c0bb3be1cd6392a554a15989c90939c99e375221b1003e3b7 + inlined_ast: c1b6954bff1ce18c0bb3be1cd6392a554a15989c90939c99e375221b1003e3b7 bytecode: b192f4b7f52da46a22cec3aec7e8c14b6e3fad7c40b9d0c0990255902fb596ef diff --git a/tests/expectations/compiler/address/equal.out b/tests/expectations/compiler/address/equal.out index b20ecfa359..8cbc886199 100644 --- a/tests/expectations/compiler/address/equal.out +++ b/tests/expectations/compiler/address/equal.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 2c04fdc69608512ca566b0eccf8d5e9fdd741b391a7937da4431293cfc3a046e - unrolled_ast: 2c04fdc69608512ca566b0eccf8d5e9fdd741b391a7937da4431293cfc3a046e - ssa_ast: 894efdfdb630a92cfa8a0a5101b681e15995e993b8c87d75dd738c8d7ce80d0c - flattened_ast: 139b39ec11943d222a18eaa61e504bc4aa46e7accc63c68755fafe861668f245 + - initial_ast: ba44127bf5639ba2f19baafa22979156d0887ace3471003cd5fc924294760e65 + unrolled_ast: ba44127bf5639ba2f19baafa22979156d0887ace3471003cd5fc924294760e65 + ssa_ast: 31d5323289dd39759350c6e762e3902b6841ed099a621b556f20b4e7dbbe4af8 + flattened_ast: f61d34c7740a32dfad5a2ddc2c48c502d6464258e16a79ab15c7a97f0724c0b9 + inlined_ast: f61d34c7740a32dfad5a2ddc2c48c502d6464258e16a79ab15c7a97f0724c0b9 bytecode: 4903abf35d22e4264aae4bf26b908108d11d981d069c247793cea817dd8851a7 diff --git a/tests/expectations/compiler/address/ternary.out b/tests/expectations/compiler/address/ternary.out index 7dae0c443b..e92bd7d9a5 100644 --- a/tests/expectations/compiler/address/ternary.out +++ b/tests/expectations/compiler/address/ternary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 035627cd394d2b54892daeb2a84e3eff5ce02f06f96c688356a7e66585aa61ec - unrolled_ast: 035627cd394d2b54892daeb2a84e3eff5ce02f06f96c688356a7e66585aa61ec - ssa_ast: ca06bce101b6ec51b72c064357bafb094b7f4aafeec89e07e7ff58694eb032c8 - flattened_ast: 9cf2f3f0e5391494304cedaf34d1bced7cc1f43599ee341d389fab7e050b574f + - initial_ast: 5287dfea1a34ec0beb84ab5d084e315e94ce0776495b278433c2d0d2bbdeca1d + unrolled_ast: 5287dfea1a34ec0beb84ab5d084e315e94ce0776495b278433c2d0d2bbdeca1d + ssa_ast: 3424c5f86b9123b7a6d71767e709d9e4ab979aa94f9e6be54824d3a8f002f1f6 + flattened_ast: e54c1dbb5d765841bcc11fc9767f47528201e221e047991929b45e2f1688704e + inlined_ast: e54c1dbb5d765841bcc11fc9767f47528201e221e047991929b45e2f1688704e bytecode: 5cbdf4a6a290f80540d2653153c57495eaf45432bc7ce44d52af2b5d0594951c diff --git a/tests/expectations/compiler/boolean/and.out b/tests/expectations/compiler/boolean/and.out index 659493642e..cb62b091f7 100644 --- a/tests/expectations/compiler/boolean/and.out +++ b/tests/expectations/compiler/boolean/and.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 10f6791409c21336d6b777f66a6266b9b69fe761701a8a3c4a61ab59ef158db9 - unrolled_ast: 10f6791409c21336d6b777f66a6266b9b69fe761701a8a3c4a61ab59ef158db9 - ssa_ast: 1fa53964ef7d5eb8e8e7cd5af01a73fab123e423cb0b49e88d1c6de6ebf227d1 - flattened_ast: 17e88106f92c0c25e20740e89304527e3044b636ebf31fdf0e34dacd86a0322a + - initial_ast: 800f83913bb57aac57e0574c67deda923814503eaa812fb82280a7ffd64f038f + unrolled_ast: 800f83913bb57aac57e0574c67deda923814503eaa812fb82280a7ffd64f038f + ssa_ast: e0015762d1fb228999fd2ef236fae8fcf8bd6e6bbd0ce37fad230a708ca063d2 + flattened_ast: 4e7759584ade51a19ff90284e5ee1ac91af6dad5cd966568b708ead553a8a4bd + inlined_ast: 4e7759584ade51a19ff90284e5ee1ac91af6dad5cd966568b708ead553a8a4bd bytecode: e3deaf24a91bcb77628f7af29d4ad6d0ba67215617d6cfe753168543123ce7d2 diff --git a/tests/expectations/compiler/boolean/conditional.out b/tests/expectations/compiler/boolean/conditional.out index 6e872dc285..92f713f9d1 100644 --- a/tests/expectations/compiler/boolean/conditional.out +++ b/tests/expectations/compiler/boolean/conditional.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: f5fd959d856025c2866f27b37e3711a49509b9a385a78d9186b1ea077ef5146d - unrolled_ast: f5fd959d856025c2866f27b37e3711a49509b9a385a78d9186b1ea077ef5146d - ssa_ast: a119ee86727dd82a8a82aaf459b14e13bc2fdc5177efdbced71bc0d5c3566f44 - flattened_ast: 67e55340f8f5e864f376d989201bf85de15783ff43c438039bf4b5790e5b3081 + - initial_ast: 080edd413ce668be563c96e2625ba86d935b529a25ff2d009a41c36d63e90867 + unrolled_ast: 080edd413ce668be563c96e2625ba86d935b529a25ff2d009a41c36d63e90867 + ssa_ast: 42925975f1f91dc72941e3c018d6c0595824086f50fa5e6398f21649a57c6661 + flattened_ast: de891bab08a157399fdceeeccc7c3d4fd70cc3f75d1ca694a4fcd0344fdaac20 + inlined_ast: de891bab08a157399fdceeeccc7c3d4fd70cc3f75d1ca694a4fcd0344fdaac20 bytecode: d0d3f79c32e6cb17c98afa2f1d4861d0f71d7f805a87712b3491ef0a9e1b4892 diff --git a/tests/expectations/compiler/boolean/equal.out b/tests/expectations/compiler/boolean/equal.out index e7e1d68a28..9860903daa 100644 --- a/tests/expectations/compiler/boolean/equal.out +++ b/tests/expectations/compiler/boolean/equal.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 01d0412fda7ce54eec5f6ca193e4444ec47d2aa22a1425df65c6a2038a991fbb - unrolled_ast: 01d0412fda7ce54eec5f6ca193e4444ec47d2aa22a1425df65c6a2038a991fbb - ssa_ast: 5c2e90a07d8231a03f335bf762f5f660d3197f23b8f59b34d4b5319f9dd2cecb - flattened_ast: e68c35439afdde8d5587f8ae5289a422871b6942f3aba8b633f0549a2ca93b3a + - initial_ast: ad12566d0b8f3bef282b67823b427a74e56acbcc34acaa4f939097fb451ea7d9 + unrolled_ast: ad12566d0b8f3bef282b67823b427a74e56acbcc34acaa4f939097fb451ea7d9 + ssa_ast: 453e77387be9254ded9019b6c362721f766ebf5a5b2d3604e51ae81452fac4e8 + flattened_ast: b39344c70e1a23869b236146ace198addf0801b348deedfb3e4ff1e3c4ace904 + inlined_ast: b39344c70e1a23869b236146ace198addf0801b348deedfb3e4ff1e3c4ace904 bytecode: e742ac3b95a8971f2018963aba6d915ea53205c21443d0b11ad52a42ad443b97 diff --git a/tests/expectations/compiler/boolean/not_equal.out b/tests/expectations/compiler/boolean/not_equal.out index 017b207d77..d1b50ca5d6 100644 --- a/tests/expectations/compiler/boolean/not_equal.out +++ b/tests/expectations/compiler/boolean/not_equal.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: bbfd6e25c73c1abe14cdd1dee14000551c1b4bdc5dc3e36c06870b7ac39ddc67 - unrolled_ast: bbfd6e25c73c1abe14cdd1dee14000551c1b4bdc5dc3e36c06870b7ac39ddc67 - ssa_ast: e3cf6c2a4fd04746714c7328cb24fa58ef15fb4e44c2be1c87e4116c62169ffa - flattened_ast: 633da269b8763b2eff9e443744d07cea72e592159171f02125bd6fbb504cdb71 + - initial_ast: 5c885cc9e6d5df3602e09f7b53cb49ee4bca3a57d647044d4d321de32c4cdd90 + unrolled_ast: 5c885cc9e6d5df3602e09f7b53cb49ee4bca3a57d647044d4d321de32c4cdd90 + ssa_ast: 211f4122a90e6a117dc4fe2e7ca3c3e21bdc09a4c7992b212b6c34c283e896f6 + flattened_ast: 84fd34b95b75f6d72b28164a9cb2ac80fa4149564c8c187b0ead1e14d2299a63 + inlined_ast: 84fd34b95b75f6d72b28164a9cb2ac80fa4149564c8c187b0ead1e14d2299a63 bytecode: 1db874ad15d9bb70df7372ed3250cc6d0f65992e17788cd90c656ef1e1ceb63e diff --git a/tests/expectations/compiler/boolean/operator_methods.out b/tests/expectations/compiler/boolean/operator_methods.out index 3f358eab96..2fc1f91a6a 100644 --- a/tests/expectations/compiler/boolean/operator_methods.out +++ b/tests/expectations/compiler/boolean/operator_methods.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 9a25a8b1eee1fb699e503df05bb0f46ed2ca10c9bc7fafbb7c14a75674b09811 - unrolled_ast: 9a25a8b1eee1fb699e503df05bb0f46ed2ca10c9bc7fafbb7c14a75674b09811 - ssa_ast: 0fc0e6501d2a700776813dcc44051d19c7b7453cb326d3531c172384f016db56 - flattened_ast: a59c0aacc4aff5883c09976c56621841297b435e693d4f217ef97a85c19e73c7 + - initial_ast: 3fda93baba12b9f280ffad75a662dfd16def0a7a1414de4cd29aa0e5afff85cc + unrolled_ast: 3fda93baba12b9f280ffad75a662dfd16def0a7a1414de4cd29aa0e5afff85cc + ssa_ast: 0ae9482705f95c26507f0040b972c76267a30eaa265f95764c758613d841932b + flattened_ast: 1e61c9d9ccdae7fb4aed4d7332538438839bef08a322f52fabcf46eac7bfc9c8 + inlined_ast: 1e61c9d9ccdae7fb4aed4d7332538438839bef08a322f52fabcf46eac7bfc9c8 bytecode: 1a2170c46bb214eb8bedf2e98b58393ec0fa09051aeb52c3f59734a8da6ca5dc diff --git a/tests/expectations/compiler/boolean/or.out b/tests/expectations/compiler/boolean/or.out index 04f7c67477..4f6171e87e 100644 --- a/tests/expectations/compiler/boolean/or.out +++ b/tests/expectations/compiler/boolean/or.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: d7b1adf3c0e7c05e1a58a2c76d2c0c675be0e04408adf3d30e7eab17cbc356bf - unrolled_ast: d7b1adf3c0e7c05e1a58a2c76d2c0c675be0e04408adf3d30e7eab17cbc356bf - ssa_ast: ecc229eb0204777ed540e09bc44119a400526ff9ca6ca8081fc5e2c511deda25 - flattened_ast: 0d3dae7d567bcf36fd442b6658b9b217907935fc91c93a8b10bfe14225f57b71 + - initial_ast: 3281347d18634932dba7502590f4ed0a45e15205fecdfb11846a1ac9de0a7c10 + unrolled_ast: 3281347d18634932dba7502590f4ed0a45e15205fecdfb11846a1ac9de0a7c10 + ssa_ast: f1ecffe7065e9782af5bf452b6ea547bfb5026a4c56e0c3105077c85ce196216 + flattened_ast: cf5034c292702654bd282c10c8d1abafed8ed328f8e6cd0a01b286438809afd5 + inlined_ast: cf5034c292702654bd282c10c8d1abafed8ed328f8e6cd0a01b286438809afd5 bytecode: e859520fd52dbdf69b14a3c3d9bad64bf6165084fb949912224eda3ccab9b638 diff --git a/tests/expectations/compiler/console/assert.out b/tests/expectations/compiler/console/assert.out index c914acc478..0c8338e1a0 100644 --- a/tests/expectations/compiler/console/assert.out +++ b/tests/expectations/compiler/console/assert.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b901b1b3790e751b788bc5ea0b8e006d3387dfa1924c85d32d4869b82e50ccde - unrolled_ast: b901b1b3790e751b788bc5ea0b8e006d3387dfa1924c85d32d4869b82e50ccde - ssa_ast: 496f4c109108408884fbe6b95c7f0a959fa636acae72e8ad8c792e4ec45892ed - flattened_ast: b5235d5705cd37b10f879e16db77cbc46b2b74f91285cef4a5611d4d02798c5d + - initial_ast: fd71e8fd519abdaf6d5abe40e167766800e80d7f9bb2523b13e2fa318598f9ef + unrolled_ast: fd71e8fd519abdaf6d5abe40e167766800e80d7f9bb2523b13e2fa318598f9ef + ssa_ast: d257cbd300cbeb2ad9d4246839296ce9a33751827bb7c2fddab7d07fdf077dd5 + flattened_ast: 80ffd6de6e7429119f5098f8f0d8290fcfc1b5c3aa00f86a9153cb1471547af6 + inlined_ast: 80ffd6de6e7429119f5098f8f0d8290fcfc1b5c3aa00f86a9153cb1471547af6 bytecode: fdc5659b97d4dbfea710ca848dcffa29bcd4da3a7a54739fb916e5292284a1a4 diff --git a/tests/expectations/compiler/console/conditional_assert.out b/tests/expectations/compiler/console/conditional_assert.out index c662f8b3ec..ebef5de571 100644 --- a/tests/expectations/compiler/console/conditional_assert.out +++ b/tests/expectations/compiler/console/conditional_assert.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: bcd5d9f7ba1b3d81d16310653b8531e39eeb6f6d35367dda89a77819f421d950 - unrolled_ast: bcd5d9f7ba1b3d81d16310653b8531e39eeb6f6d35367dda89a77819f421d950 - ssa_ast: d9f534bddd58e3fff333eadef39784a9c0f67f0b4a65fe7f7f4ae0fa4e808488 - flattened_ast: f6e67ced6f8462f2cd655fa9b6a64a767ee22b7e123cb00d364ba0c7fea73e92 + - initial_ast: c97efd0956a3c8d6a511b38d61f3f3bdd34d95ad2f78242d2816c723d1676997 + unrolled_ast: c97efd0956a3c8d6a511b38d61f3f3bdd34d95ad2f78242d2816c723d1676997 + ssa_ast: 0a690ca166cfd10c1b57d3df756032f10b003cc0d006bf27f41901b6af2ce95e + flattened_ast: 083a9af2e592de0c827b15230cd2307daae4b90e324e35714f474d50cbb59162 + inlined_ast: 083a9af2e592de0c827b15230cd2307daae4b90e324e35714f474d50cbb59162 bytecode: 9006475518263541b3a855db6907377b638ef28f2a44caf4e26db7991c3b58ef diff --git a/tests/expectations/compiler/core/algorithms/bhp1024_commit.out b/tests/expectations/compiler/core/algorithms/bhp1024_commit.out index 4c9fc36384..def2c8e976 100644 --- a/tests/expectations/compiler/core/algorithms/bhp1024_commit.out +++ b/tests/expectations/compiler/core/algorithms/bhp1024_commit.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 88ea51c2bf3abfa3c8810b8208c6e8428217a02543c584f890df6c1321ae2ec8 - unrolled_ast: 88ea51c2bf3abfa3c8810b8208c6e8428217a02543c584f890df6c1321ae2ec8 - ssa_ast: a4cd65095b0188f08dca7a5bee3c77cea0c038009e52bddac6a634641c447d54 - flattened_ast: 50f2528808517ccb6f238e23c83f75666c391958386a86daac4929b5b1155602 + - initial_ast: 4a8dc50cee056a918b491cba6cb3099695e1a76119b5aba7a31a820eb8a87d35 + unrolled_ast: 4a8dc50cee056a918b491cba6cb3099695e1a76119b5aba7a31a820eb8a87d35 + ssa_ast: 7237101f0bbd24e60a7b15718981024268b4db6d751b739cafb18c133b639713 + flattened_ast: 7ae62df655e7b0450817324f4e45f680ec4e19978e2629c9be2b4f93aa0bd519 + inlined_ast: 7ae62df655e7b0450817324f4e45f680ec4e19978e2629c9be2b4f93aa0bd519 bytecode: 65dcc91a4e07d98f73a0eb5b43d945f85859694417bd643b3ebba0d40494d001 diff --git a/tests/expectations/compiler/core/algorithms/bhp1024_hash.out b/tests/expectations/compiler/core/algorithms/bhp1024_hash.out index 05b2278cac..73e792336e 100644 --- a/tests/expectations/compiler/core/algorithms/bhp1024_hash.out +++ b/tests/expectations/compiler/core/algorithms/bhp1024_hash.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1970d7b7a42e3b910ab4d910d41eb3f5ae96d509099ff0983d66dbeb1b7a8e54 - unrolled_ast: 1970d7b7a42e3b910ab4d910d41eb3f5ae96d509099ff0983d66dbeb1b7a8e54 - ssa_ast: 260c86f7c85b3cbddd66756cab69d3890b86951411472470f68f3ab9dd937a49 - flattened_ast: ed477843f037999f6d1dae0c16ac75fb0c8e525ab44dee32e41fb4c1332d3b67 + - initial_ast: eda5b3638cf36c8454468ab8eef2a6d0ebc61bb1a66b1cba1ae4f8315753e204 + unrolled_ast: eda5b3638cf36c8454468ab8eef2a6d0ebc61bb1a66b1cba1ae4f8315753e204 + ssa_ast: 3cc52869ffc8473ac37b723f6d1e996b06e7aa9c659f19720d15d0624ea59bf9 + flattened_ast: c75e5f5d43494ea1c16ab46cddd1080bb0b56cc0ada1bc6b769fe2f4e5018e9e + inlined_ast: c75e5f5d43494ea1c16ab46cddd1080bb0b56cc0ada1bc6b769fe2f4e5018e9e bytecode: 629677c0e48a743b2fc341de20c6b14ccc59d74c6ae08c317bdf597e0cc2f749 diff --git a/tests/expectations/compiler/core/algorithms/bhp256_commit.out b/tests/expectations/compiler/core/algorithms/bhp256_commit.out index 474c2731b5..e40955a0f4 100644 --- a/tests/expectations/compiler/core/algorithms/bhp256_commit.out +++ b/tests/expectations/compiler/core/algorithms/bhp256_commit.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 8916dd47b049835d250b12ccdcb00ab91fe7c0272671098871b5e8c926f93312 - unrolled_ast: 8916dd47b049835d250b12ccdcb00ab91fe7c0272671098871b5e8c926f93312 - ssa_ast: 0b7a62110d7d274f974a91b61c592f89edec6831b743008dfd038c464f4ec6d1 - flattened_ast: 7b1400a9873fab71406b4330e864bcd8aecaa70eee0e4d96601ae0baad00f8a9 + - initial_ast: 26911d8bca0e30e7bffd6abdde2ceef7485781af40e0707f1fb79d4461a7b9cd + unrolled_ast: 26911d8bca0e30e7bffd6abdde2ceef7485781af40e0707f1fb79d4461a7b9cd + ssa_ast: 44075583b8ebb223476e90b1b7bff6b1d6a65978ff2caae4ee2eb76f7c9aac6c + flattened_ast: 4ed800dd53990580a2a318e46932e29df53fce35a9f228750fc8bce335e3576e + inlined_ast: 4ed800dd53990580a2a318e46932e29df53fce35a9f228750fc8bce335e3576e bytecode: a120b1e1d98948faf72473e55ec5ee1ea7ead4b7b5e4e79560053918dc1ff81b diff --git a/tests/expectations/compiler/core/algorithms/bhp256_hash.out b/tests/expectations/compiler/core/algorithms/bhp256_hash.out index c7e0a46088..66a12291c4 100644 --- a/tests/expectations/compiler/core/algorithms/bhp256_hash.out +++ b/tests/expectations/compiler/core/algorithms/bhp256_hash.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5fe729d3d383d535452bd280076f64905a8f508849c19cf72ea538e93d8c25bf - unrolled_ast: 5fe729d3d383d535452bd280076f64905a8f508849c19cf72ea538e93d8c25bf - ssa_ast: 99239a050244e0741313b53301d7581117b126dca571361c568209e00db550b1 - flattened_ast: 9fca40489b79b32cc320285c96c47f45fdbd14de1194aa7ff824508fb6e2b252 + - initial_ast: c7ff62b1364b62c4350b33ceb0525ee7007cb3f969641d2eecc393efc6e5e5e4 + unrolled_ast: c7ff62b1364b62c4350b33ceb0525ee7007cb3f969641d2eecc393efc6e5e5e4 + ssa_ast: ca140fdf0902378ff3e3cc7160c8d4e843171bcaa9ae2389c478a2c73b983345 + flattened_ast: 9be84865a93e187128e8c2fc1149abeb52f62b6704925ba25b49c02b16433418 + inlined_ast: 9be84865a93e187128e8c2fc1149abeb52f62b6704925ba25b49c02b16433418 bytecode: 0098070069139200be104771fcb1807e52b331b50bab0dc82d3a16d451e4db97 diff --git a/tests/expectations/compiler/core/algorithms/bhp512_commit.out b/tests/expectations/compiler/core/algorithms/bhp512_commit.out index 44392c3c3d..4ba934addb 100644 --- a/tests/expectations/compiler/core/algorithms/bhp512_commit.out +++ b/tests/expectations/compiler/core/algorithms/bhp512_commit.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 22635a9f3ee2333185a07a9a3fb2a2f8c428cef4d00bd2072db527c49a665b0a - unrolled_ast: 22635a9f3ee2333185a07a9a3fb2a2f8c428cef4d00bd2072db527c49a665b0a - ssa_ast: d1b72ed1203491549451aade31456e4926166c6448cc2805e55fbf706594e7c3 - flattened_ast: cc9c1479272915baf29b1de71b54341d06ff588a2a0816f310dbfeec10e96309 + - initial_ast: 8c19f3a015926d3333017cb8d3311be2550d83e09c06c3c58176bd3c21716252 + unrolled_ast: 8c19f3a015926d3333017cb8d3311be2550d83e09c06c3c58176bd3c21716252 + ssa_ast: 992bfc5526a3849095f173452bc0046a0523c965fa367d6242e982613d0b23d2 + flattened_ast: 178ad0e9092cd550d97360a8b8cef5f98e1c66c084a7df1e7ba930b12d83bb57 + inlined_ast: 178ad0e9092cd550d97360a8b8cef5f98e1c66c084a7df1e7ba930b12d83bb57 bytecode: b9875b017a81226905d6fec1324bf41bc859bb4fca832de6b5309224ca343511 diff --git a/tests/expectations/compiler/core/algorithms/bhp512_hash.out b/tests/expectations/compiler/core/algorithms/bhp512_hash.out index be90c128ca..3b3f338526 100644 --- a/tests/expectations/compiler/core/algorithms/bhp512_hash.out +++ b/tests/expectations/compiler/core/algorithms/bhp512_hash.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 65a69d890ef0691d1cfb7396f45a8a8c8181fc3b958a537f8b0559512a91e00f - unrolled_ast: 65a69d890ef0691d1cfb7396f45a8a8c8181fc3b958a537f8b0559512a91e00f - ssa_ast: 2810947b50fb6df3b805a5a20b61ddb5812be742bdaf8775e4d73030f4745f44 - flattened_ast: 53818a9ccc8a985d7990ad921ebfae74b68aed98cf016a37f01b9bd8127a186a + - initial_ast: 809cb6c8d6b69d3866a1b15c1d4caed220b0f63fdd83373b347ffd0dabbf873b + unrolled_ast: 809cb6c8d6b69d3866a1b15c1d4caed220b0f63fdd83373b347ffd0dabbf873b + ssa_ast: bceed5c819391bf5b52644c9acd3ad48485ad8c549f6e41592db3457664851c7 + flattened_ast: 556b4b4c66f55375093c41eaf4e524e2b333b423672c538db60fd18a249068ad + inlined_ast: 556b4b4c66f55375093c41eaf4e524e2b333b423672c538db60fd18a249068ad bytecode: 976c0daf1133bb687c763b552cf546d3c02ad6f2ba23def2a1aec0e56e5aff64 diff --git a/tests/expectations/compiler/core/algorithms/bhp768_commit.out b/tests/expectations/compiler/core/algorithms/bhp768_commit.out index 4d2d46b112..1f72a452a2 100644 --- a/tests/expectations/compiler/core/algorithms/bhp768_commit.out +++ b/tests/expectations/compiler/core/algorithms/bhp768_commit.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 4a1e5c2818e99b3779669345fec31621c54768b926a6e246ba5edeb1eb123f21 - unrolled_ast: 4a1e5c2818e99b3779669345fec31621c54768b926a6e246ba5edeb1eb123f21 - ssa_ast: 2c0de477e742beb8a851d2e26b18f9342b94ae65893bb55518a689b31b038572 - flattened_ast: 894437e501f829491e9e22617052c169541174a854aa2afedd5d3c912b71400d + - initial_ast: b3f5b26e60cf731201f24d6a0d24983196996478f878dadca2aa6b0bc9ec25fc + unrolled_ast: b3f5b26e60cf731201f24d6a0d24983196996478f878dadca2aa6b0bc9ec25fc + ssa_ast: 9d8bc97ef40df6abb744d278769607e6f22c86ccf03767dc36e1589fbf1c7e76 + flattened_ast: eb1efd8a8e0fa18452cbb0aa136995b9823d3b53fe8e579c49b31f721d65cf53 + inlined_ast: eb1efd8a8e0fa18452cbb0aa136995b9823d3b53fe8e579c49b31f721d65cf53 bytecode: d8c824aec550f73676651160b81bf3e546b5958ec8520629f779b9156b033032 diff --git a/tests/expectations/compiler/core/algorithms/bhp768_hash.out b/tests/expectations/compiler/core/algorithms/bhp768_hash.out index 31e795ea24..6e592e5ada 100644 --- a/tests/expectations/compiler/core/algorithms/bhp768_hash.out +++ b/tests/expectations/compiler/core/algorithms/bhp768_hash.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: fd09783877c99da74d6ba033e99e7bda8e82433c307d93e9c0a4e3914d6a109a - unrolled_ast: fd09783877c99da74d6ba033e99e7bda8e82433c307d93e9c0a4e3914d6a109a - ssa_ast: 74e79d5cbd5e7b80826ff017294a6542b55cfe9e0734e82c8d0b47c257d1f0a3 - flattened_ast: b5d3d72262fec88ea316abd2f6dfaf90e199aceb959b7eda6eaeddcc419233b2 + - initial_ast: df336b5d77ece6762c2c118cb15cc6f25a6f108b66df81d8986ff2ba69d45461 + unrolled_ast: df336b5d77ece6762c2c118cb15cc6f25a6f108b66df81d8986ff2ba69d45461 + ssa_ast: ab2119a0fea501f0cbe04cdf465230625ee6f447ee9e7fe110b64aa6fc3c6192 + flattened_ast: 97b6619ac108948a86250e9498148db33ae70756677e6ed23474e8268f9c061c + inlined_ast: 97b6619ac108948a86250e9498148db33ae70756677e6ed23474e8268f9c061c bytecode: 45f6f395a7abca14ca5a1e3d5dc3fb2ac5ea3946740553ca5aee7a5822a235ec diff --git a/tests/expectations/compiler/core/algorithms/pedersen128_commit.out b/tests/expectations/compiler/core/algorithms/pedersen128_commit.out index 4d9bb4f47e..716a546098 100644 --- a/tests/expectations/compiler/core/algorithms/pedersen128_commit.out +++ b/tests/expectations/compiler/core/algorithms/pedersen128_commit.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 557130262ded1b479b139b15c095260d83a1c3bdd038d7cb61e6ad852f760fe5 - unrolled_ast: 557130262ded1b479b139b15c095260d83a1c3bdd038d7cb61e6ad852f760fe5 - ssa_ast: f9a7a186621cb450664b053f18293aeec444b650403adc294cf1572958b6033d - flattened_ast: 44461faaa8269377891df43705df40021a18e0cdf75e5daebca3503005a71ab4 + - initial_ast: c57c36b9b59e05c91849e91969a79474d5fcb49d284be8140ffaac4746ae7191 + unrolled_ast: c57c36b9b59e05c91849e91969a79474d5fcb49d284be8140ffaac4746ae7191 + ssa_ast: 586af29b0b79edf5f19a4bd494d8428f22a87f851119d7f74eab9b535810468d + flattened_ast: f72217bcb7185ae66114addb89c1bcf61da6ff200ece88309aa50dc3f5ebefd9 + inlined_ast: f72217bcb7185ae66114addb89c1bcf61da6ff200ece88309aa50dc3f5ebefd9 bytecode: e5e0c25f5c089802ae51be9f719ccd87b53adf4676bc463ddf6e6f63d6e1f977 diff --git a/tests/expectations/compiler/core/algorithms/pedersen128_hash.out b/tests/expectations/compiler/core/algorithms/pedersen128_hash.out index 4bbd2470ea..f9402dea04 100644 --- a/tests/expectations/compiler/core/algorithms/pedersen128_hash.out +++ b/tests/expectations/compiler/core/algorithms/pedersen128_hash.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: bb21bfd7f94edff0912f41c0c530966e1ffe6d117ed3143e2ec005af8a2f4ab0 - unrolled_ast: bb21bfd7f94edff0912f41c0c530966e1ffe6d117ed3143e2ec005af8a2f4ab0 - ssa_ast: 4a5fbd468288f7c57f21d71246fe1aece51945b617ec91d217e734faa88b7571 - flattened_ast: fa3e33dae39e487a23accfa895fafbe1d9fa2e909d17b74d71135f5f3ab26340 + - initial_ast: c00a32cd00345e923e87dcd16427c9f2ec733022431e38cceefbb5ab6143b161 + unrolled_ast: c00a32cd00345e923e87dcd16427c9f2ec733022431e38cceefbb5ab6143b161 + ssa_ast: 29ecb3770403a15ee05a695260ebc6f7b8e313b4614e3a1f06de34b4d03ff147 + flattened_ast: 9711e4d72e2e9e85b24e3b4b3e73cc939a05a5846733c0eb15dab5c5b54a054a + inlined_ast: 9711e4d72e2e9e85b24e3b4b3e73cc939a05a5846733c0eb15dab5c5b54a054a bytecode: 9217044f6eb12f18c1298c2ce3217533eb27618e7c8c5ead76848d21935783d4 diff --git a/tests/expectations/compiler/core/algorithms/pedersen64_commit.out b/tests/expectations/compiler/core/algorithms/pedersen64_commit.out index d1a5ffc29a..42ffdd4edd 100644 --- a/tests/expectations/compiler/core/algorithms/pedersen64_commit.out +++ b/tests/expectations/compiler/core/algorithms/pedersen64_commit.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 7add075b516b60285bc9d29c17f5139f685fd899d332a401a4204d6067327419 - unrolled_ast: 7add075b516b60285bc9d29c17f5139f685fd899d332a401a4204d6067327419 - ssa_ast: 42f2f811d77249415e50dbaf99585f8617f8d14f934b5043798ab0c5c8f67ec8 - flattened_ast: 734d6c9e1008eab4451158ad667a9d8e34e2af6e960548d501057fa2558299bc + - initial_ast: 4eaa587c05eb4f4a65f33d94cd12a1ce47a55263726b7619578846c620735b3d + unrolled_ast: 4eaa587c05eb4f4a65f33d94cd12a1ce47a55263726b7619578846c620735b3d + ssa_ast: 3e1a3d03f465a60b2ceb2fc480551d9d498beb758a6b378ae6558117ec2955a7 + flattened_ast: 2448c3c0819a99113f4acb509371009619592a984911b836f9787a386cf1e617 + inlined_ast: 2448c3c0819a99113f4acb509371009619592a984911b836f9787a386cf1e617 bytecode: 6a07bdcfa9cc3f72be7acb20de65bed8983094471083dee01fc5a46d923e7506 diff --git a/tests/expectations/compiler/core/algorithms/pedersen64_hash.out b/tests/expectations/compiler/core/algorithms/pedersen64_hash.out index a735381718..dcc258d321 100644 --- a/tests/expectations/compiler/core/algorithms/pedersen64_hash.out +++ b/tests/expectations/compiler/core/algorithms/pedersen64_hash.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 4205da189bdc3b248ed6fb048073e333135e4f7a8af2700adcb5c65554063794 - unrolled_ast: 4205da189bdc3b248ed6fb048073e333135e4f7a8af2700adcb5c65554063794 - ssa_ast: 1af2511db5bcf2cf74638c72d6981ae8e16005436e8c3ebd216bc4788a48b6d1 - flattened_ast: 538f7c5c282048564690bb02ea04066e4e1e6a67f2b7550e87bf7cb53c4aab0c + - initial_ast: 8693aac7091d75fe65a52352decb2ce24e225dae9396cb45809575f7c3cbd8d9 + unrolled_ast: 8693aac7091d75fe65a52352decb2ce24e225dae9396cb45809575f7c3cbd8d9 + ssa_ast: 5a33864a3f91c0d4a63171ed36ef709b7e75593a3181b4ed3f11be873ce2b9a2 + flattened_ast: 8a13f93c69d995ea32ab518a4287d77dd9e37e4e1f15fd257361c58a0f853e7b + inlined_ast: 8a13f93c69d995ea32ab518a4287d77dd9e37e4e1f15fd257361c58a0f853e7b bytecode: e893a23da89b538d6d95e87e9a97340f63c798fda07cf50166d09e8c4e07932b diff --git a/tests/expectations/compiler/core/algorithms/poseidon2_hash.out b/tests/expectations/compiler/core/algorithms/poseidon2_hash.out index 9ce616f58c..bcb91df79b 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon2_hash.out +++ b/tests/expectations/compiler/core/algorithms/poseidon2_hash.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b944463bfcb82f802952036416b0e8908866974395da5e0a0c26afc1b0f19b5f - unrolled_ast: b944463bfcb82f802952036416b0e8908866974395da5e0a0c26afc1b0f19b5f - ssa_ast: e426c41fd8d87d5990e6bbb8dd934be2baa95d665850ecdaf5e3109a3675b541 - flattened_ast: 6947188abbeb502e1a4c8be8568df35f2d4739e1d7c15213757c7ef4e37205f9 + - initial_ast: 8e58cb6efd83104f693ef4a01ff24d7c9975357b2c01a3f5bf332d55738e90cf + unrolled_ast: 8e58cb6efd83104f693ef4a01ff24d7c9975357b2c01a3f5bf332d55738e90cf + ssa_ast: 44567392e4c23c50c0e6be993952ce738f3b6315ebb825f8ffe292937b3a30ba + flattened_ast: ab0f2b3350a96338d70af7d1e3e27ea74273c95b83591e365724250a3633a406 + inlined_ast: ab0f2b3350a96338d70af7d1e3e27ea74273c95b83591e365724250a3633a406 bytecode: b82322298b5a498c7a2a308c597a5e5d546becd9ff6d05d0c571247e09f1cb7d diff --git a/tests/expectations/compiler/core/algorithms/poseidon4_hash.out b/tests/expectations/compiler/core/algorithms/poseidon4_hash.out index 105fb2ab72..9cc10fa04c 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon4_hash.out +++ b/tests/expectations/compiler/core/algorithms/poseidon4_hash.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 9308c9c592608dcd11960a906c0753504372209da9f7b7669ac3f9adda28a592 - unrolled_ast: 9308c9c592608dcd11960a906c0753504372209da9f7b7669ac3f9adda28a592 - ssa_ast: c1f73a8466d54233516776dc587ff566345e879c0e358776a2774d32d0d154da - flattened_ast: 0b6a282a12ba27a9968282a45dccbc2b69754c56c6f719b30895de9d7ef1bec2 + - initial_ast: e7b840ff0656282ab0864e77d5e3f4a3053e98c131ccf0934f1815477c00214f + unrolled_ast: e7b840ff0656282ab0864e77d5e3f4a3053e98c131ccf0934f1815477c00214f + ssa_ast: c06874c153b1936f3caaa78f246738326ece3b38597f6507d11acf05f1d70375 + flattened_ast: f776dd25cd7be3d76ca22588625d64ef4df262e70aa069a3664e5045000f8bac + inlined_ast: f776dd25cd7be3d76ca22588625d64ef4df262e70aa069a3664e5045000f8bac bytecode: 849a917a861f86e0a277f0a92a018a81f6f6d69762816e29e585452dd805a1c1 diff --git a/tests/expectations/compiler/core/algorithms/poseidon8_hash.out b/tests/expectations/compiler/core/algorithms/poseidon8_hash.out index f61a1c4577..21eedd6f91 100644 --- a/tests/expectations/compiler/core/algorithms/poseidon8_hash.out +++ b/tests/expectations/compiler/core/algorithms/poseidon8_hash.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 095d15c58d65096d77a62ff54af5ab129002522930e0a8ca83dd0c6de4467bec - unrolled_ast: 095d15c58d65096d77a62ff54af5ab129002522930e0a8ca83dd0c6de4467bec - ssa_ast: 368a16973432fa980ce1b15d598fe6c27287055c3aefc05cf6b575cc2f4e7447 - flattened_ast: 0ffd6d24cffb39df46258a3a2a11c297fdf1ac650ba368378aa1906ededc7d8b + - initial_ast: fb480abe75542e3b109f037b1ffd53ea64bb92b21f2b33f8297e2d6f24dc1fc0 + unrolled_ast: fb480abe75542e3b109f037b1ffd53ea64bb92b21f2b33f8297e2d6f24dc1fc0 + ssa_ast: e213f529b4ff45bebaac280ee485c8bdc3af09463c349368ab236a26cf0a9370 + flattened_ast: bfaa00a0b6158f6798f5aa5852a07aa9f437d80a9b0e4e811a192fe111111084 + inlined_ast: bfaa00a0b6158f6798f5aa5852a07aa9f437d80a9b0e4e811a192fe111111084 bytecode: 8d921ede85807f033431e06b604875bb1f6712fb96957faa5a805fe02fe24245 diff --git a/tests/expectations/compiler/definition/out_of_order.out b/tests/expectations/compiler/definition/out_of_order.out index d3981e60c9..aed9047674 100644 --- a/tests/expectations/compiler/definition/out_of_order.out +++ b/tests/expectations/compiler/definition/out_of_order.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 7a5cb78dd349a26c2962daece4fc6a3eaa4f03fb67f31ace4a9d84a5ce658e34 - unrolled_ast: 7a5cb78dd349a26c2962daece4fc6a3eaa4f03fb67f31ace4a9d84a5ce658e34 - ssa_ast: a087b2cd64869c8d52a49d39d50aaccc710ec9153fe8f96be820de8d3dc02854 - flattened_ast: 41087f4e5ebf8e00900384acacecb9d2bc66774d31c63fef66ab5c4b5f44024e + - initial_ast: 9845d8aaec21f191c73e190b478e592e3e910b0dfd071cf86e692082f7ff9f23 + unrolled_ast: 9845d8aaec21f191c73e190b478e592e3e910b0dfd071cf86e692082f7ff9f23 + ssa_ast: a24e603330c02f87b70ed3e3f6467fc471d6d9d032f17eb023f37df005ceff85 + flattened_ast: bc4a52e6fb7998c2a8a454306e75598177546db8f32a5a79e95ead68abc72880 + inlined_ast: bc4a52e6fb7998c2a8a454306e75598177546db8f32a5a79e95ead68abc72880 bytecode: 9a1e5bb7b8d932d4afd347a856bfb38db144771f49a0d9589ef14236338e3dcf diff --git a/tests/expectations/compiler/field/add.out b/tests/expectations/compiler/field/add.out index d095ae9c94..b969f1ad1b 100644 --- a/tests/expectations/compiler/field/add.out +++ b/tests/expectations/compiler/field/add.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 0ae25e3f48a005325105c1ae4859df780f56dceaa7ece1c9f7036f804709d30f - unrolled_ast: 0ae25e3f48a005325105c1ae4859df780f56dceaa7ece1c9f7036f804709d30f - ssa_ast: 843981d448200fe4b207a10fea71a9afe5d3f8f255122efb3108644122cd85a4 - flattened_ast: df1e8e6fc3eb3558b3069137816491d8e6ccdeabf1e9934b70e18dfb3c1c6ebb + - initial_ast: 179113dfb723097a26a7181bbb64ed56e7ca3ebf57cf782077d9743b64595446 + unrolled_ast: 179113dfb723097a26a7181bbb64ed56e7ca3ebf57cf782077d9743b64595446 + ssa_ast: 499f15e97d7e5d5dcc0be12e85176e6f160cc2b65d66b0667f640a3d0e64f369 + flattened_ast: 9c98dfcdcb403983efb0b1078246ca9e3c3e8fe913f6ceabbd9a87b63f3fc3a4 + inlined_ast: 9c98dfcdcb403983efb0b1078246ca9e3c3e8fe913f6ceabbd9a87b63f3fc3a4 bytecode: 230d4f2bda3933eb4fafc4dda4ce0087e74e4cbd9c65349746da561cbb3f99da diff --git a/tests/expectations/compiler/field/div.out b/tests/expectations/compiler/field/div.out index b01eec468c..6031dd42ee 100644 --- a/tests/expectations/compiler/field/div.out +++ b/tests/expectations/compiler/field/div.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: c4bf7caa38d22e8398b21a08af4bb1c675160e8d03d4b96b392d6f0c595918c2 - unrolled_ast: c4bf7caa38d22e8398b21a08af4bb1c675160e8d03d4b96b392d6f0c595918c2 - ssa_ast: cf4f7d1a7e63e3979a8aca25d94719410856bbc8e022df52ef4811d83fec9ea6 - flattened_ast: 892e661b9c5a87b5598ae3f9c405a5d8d04a82dd70cc06980fb05b5e661b8820 + - initial_ast: 873e6714527c41b8cf2b3db3236b443e8ead62c4580b57b4088c46c378524598 + unrolled_ast: 873e6714527c41b8cf2b3db3236b443e8ead62c4580b57b4088c46c378524598 + ssa_ast: d451c529bc4b3207205083e58d6521f0ea5526d63d1f77c42b40854f917316cf + flattened_ast: 0840cf638ec3532c7702d10bbbfcf2fbfc8c8f7c54e532acb4ac46cbb7c8ed61 + inlined_ast: 0840cf638ec3532c7702d10bbbfcf2fbfc8c8f7c54e532acb4ac46cbb7c8ed61 bytecode: fa960590c979aea4bdfe07b7d37060bb593f73f745974241e2db578bd7ba2ced diff --git a/tests/expectations/compiler/field/eq.out b/tests/expectations/compiler/field/eq.out index 20247e9b76..ffeffed74e 100644 --- a/tests/expectations/compiler/field/eq.out +++ b/tests/expectations/compiler/field/eq.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 0a2a053e5bf78c3cc425dbb1600479aef43f652c58b34b8749aa36765720889e - unrolled_ast: 0a2a053e5bf78c3cc425dbb1600479aef43f652c58b34b8749aa36765720889e - ssa_ast: a51dea4bd834bde7d545b7226c1d94beb2aa67de016288c4a33d7bf6a11e5084 - flattened_ast: bf525b12a2743590934d071970c062b6383680a16de9f12e3f0a62422b4e6e61 + - initial_ast: 63d16c8101f9ede853a5be9d493bc61bbe57449e99499e42254a1e2d6448e3d2 + unrolled_ast: 63d16c8101f9ede853a5be9d493bc61bbe57449e99499e42254a1e2d6448e3d2 + ssa_ast: df4cad7af230e0feb2036b920bde4aa81ed297a9ee8269aa95ded280610bde49 + flattened_ast: f1d531bbe1b2e0bf0f30a1f7e86cce88c834fee9eb4d06548508907ad5f2dd24 + inlined_ast: f1d531bbe1b2e0bf0f30a1f7e86cce88c834fee9eb4d06548508907ad5f2dd24 bytecode: e8cc0536d26ff27b9fe9ff3ad45b575185b9f60c9d3910481ab66843af0f2171 diff --git a/tests/expectations/compiler/field/field.out b/tests/expectations/compiler/field/field.out index 3c45fae265..3cdf901b1a 100644 --- a/tests/expectations/compiler/field/field.out +++ b/tests/expectations/compiler/field/field.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 39a8a1edc287de186596bad9afa19c71d2bdf424eb5a666075d262edadb582ab - unrolled_ast: 39a8a1edc287de186596bad9afa19c71d2bdf424eb5a666075d262edadb582ab - ssa_ast: 2d88cadc3172088d6282e7ee6353af69ba372f592038028ce52cf4db1abdf8d5 - flattened_ast: 021d9f732dac254daf87cc96a1378bca92202b0ddeedb2ae9057638caadda0b1 + - initial_ast: 5b9e236e49cd157cbbcdb0c600c17901cd6d51169e8c115a293a1dae6d519d28 + unrolled_ast: 5b9e236e49cd157cbbcdb0c600c17901cd6d51169e8c115a293a1dae6d519d28 + ssa_ast: fcaf1a28f73f1c528ce87d8ad3dd3b30344e16a9deff4d2785f3f485b68f5a48 + flattened_ast: bd09931f20c9c72dce35ccb55bdf5fff1f5a4754fcf4dbff46a0a8c79ca88abc + inlined_ast: bd09931f20c9c72dce35ccb55bdf5fff1f5a4754fcf4dbff46a0a8c79ca88abc bytecode: eeb44a4faf22686de577f93db551bd83246583158dcecb35d2dc454e0693e419 diff --git a/tests/expectations/compiler/field/mul.out b/tests/expectations/compiler/field/mul.out index 3977353eba..78a097db11 100644 --- a/tests/expectations/compiler/field/mul.out +++ b/tests/expectations/compiler/field/mul.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 7fbe1dee1da36bbf500eac5fdb3c85096b160e10da9dc765e072bb3a3e6f8725 - unrolled_ast: 7fbe1dee1da36bbf500eac5fdb3c85096b160e10da9dc765e072bb3a3e6f8725 - ssa_ast: 14a61902cd2de8c44d6ad562a382c42bc63764b975f9c668f90eb2c9297258f7 - flattened_ast: f8cb858f6f41179bed737e5b47b138291dde83ec0a5d30787c7e1cd6d750e7c1 + - initial_ast: 6b2150ffe972e2a329964dd76f061f3af94a9b15ce821ad4bb1cedd6b0134483 + unrolled_ast: 6b2150ffe972e2a329964dd76f061f3af94a9b15ce821ad4bb1cedd6b0134483 + ssa_ast: 610db9a9ab1fe344961c36a0fe5170902b9ca4cf036094b0a5f6fc9d8cfa7b72 + flattened_ast: 384e746fcbe1428be942f6ee12041562e0c1ae98b398c26da1d62fdb57181343 + inlined_ast: 384e746fcbe1428be942f6ee12041562e0c1ae98b398c26da1d62fdb57181343 bytecode: 90662aea378f911f2798c1ece956f7a2566fd99d99a87d8285f1476edf468e43 diff --git a/tests/expectations/compiler/field/negate.out b/tests/expectations/compiler/field/negate.out index 2e26f8800f..e2cf9499a0 100644 --- a/tests/expectations/compiler/field/negate.out +++ b/tests/expectations/compiler/field/negate.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 66d929a26a59181cacf5631183d943ad5d90de0c011f00b5e7fd0a86fbca6aea - unrolled_ast: 66d929a26a59181cacf5631183d943ad5d90de0c011f00b5e7fd0a86fbca6aea - ssa_ast: 1e0bc0c103cf34a316892d929e5018d04157bd2b8fccf21a39d3ba34dffb3bb8 - flattened_ast: 07518cb75989513b755211d766ac61f7263d96203dcdd48af48b0fb8af64e6d4 + - initial_ast: cde2a91af921e65b79849153ed229de8c9a0af850ee62ac23363d0f8d8b82899 + unrolled_ast: cde2a91af921e65b79849153ed229de8c9a0af850ee62ac23363d0f8d8b82899 + ssa_ast: ebba08995e71307851655254c51deb67364ee12aa4320f9efa32c16668d26cf6 + flattened_ast: 7111dab311b76ad61366abb7a6e40586f44e17da7f8784eb6f8431dd0c41bd42 + inlined_ast: 7111dab311b76ad61366abb7a6e40586f44e17da7f8784eb6f8431dd0c41bd42 bytecode: 57bdcce5ea2ea7890a6a4786e4795f5c458da4b6b29f6295f86e15f11479f3e6 diff --git a/tests/expectations/compiler/field/operator_methods.out b/tests/expectations/compiler/field/operator_methods.out index ad1c609dcb..aed712652a 100644 --- a/tests/expectations/compiler/field/operator_methods.out +++ b/tests/expectations/compiler/field/operator_methods.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 730c7aae808fdd0cf9b2e008612191ad36d29f7f4fe7770c9b72371a1146b65f - unrolled_ast: 730c7aae808fdd0cf9b2e008612191ad36d29f7f4fe7770c9b72371a1146b65f - ssa_ast: 6b20fc19648d776c5321df0b9b3b403456cae4ed0aa815366373a64f7810e0cf - flattened_ast: b4ce53a9ebedbfe05b96f67e0894f31a70d0948d371574772e76dc3adbeb19b0 + - initial_ast: 6926fc7a56a99fb841bff97631e39b332f998908009c9c0f83e0f0b4d1a0b8f3 + unrolled_ast: 6926fc7a56a99fb841bff97631e39b332f998908009c9c0f83e0f0b4d1a0b8f3 + ssa_ast: 842449a3e29d8cd788deae538a1642bc89e326ed45768ee5121095e4293f553f + flattened_ast: c48dab53c83532533096307cda1460de12397de310e2b6622f644dcace4f4391 + inlined_ast: c48dab53c83532533096307cda1460de12397de310e2b6622f644dcace4f4391 bytecode: 1bfceea51d0a0df233268cc281d300a3c15c291de63528a723a763eba97e9b93 diff --git a/tests/expectations/compiler/field/pow.out b/tests/expectations/compiler/field/pow.out index 60c4c49ec3..afe6d5e891 100644 --- a/tests/expectations/compiler/field/pow.out +++ b/tests/expectations/compiler/field/pow.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ab79658672090ee72bf8485cdc370f980531343942292b54ff3f1b3ab9fce67d - unrolled_ast: ab79658672090ee72bf8485cdc370f980531343942292b54ff3f1b3ab9fce67d - ssa_ast: e2c1c59b1bb7a799df57044ab663d0c4b93f8c5e96c1927639abd8c0a9dc8488 - flattened_ast: f75ea6e363e36e8123507e5a285072730e03621238ade5f5c96e53314ba2b1fe + - initial_ast: bdaaa81417cac5a4c216d7d4255e79cf0d29b1f911f689956f376b1a1e265c44 + unrolled_ast: bdaaa81417cac5a4c216d7d4255e79cf0d29b1f911f689956f376b1a1e265c44 + ssa_ast: 0decc436c2c4d95b24b526a58adff114601ed3ac8a4cff335ab5229aed730480 + flattened_ast: 088aaeccfd897a2e6d323966090c3989859be3fdaf9ab3e19b54cdaebde926fc + inlined_ast: 088aaeccfd897a2e6d323966090c3989859be3fdaf9ab3e19b54cdaebde926fc bytecode: 7540a269502febfe91bebfc15030891bde7667f921d5d8d9d22efbcf16410543 diff --git a/tests/expectations/compiler/field/sub.out b/tests/expectations/compiler/field/sub.out index 6a456d9478..ac4d24ded9 100644 --- a/tests/expectations/compiler/field/sub.out +++ b/tests/expectations/compiler/field/sub.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: dc0f03e353714f93a4bdc39a64369a4bf6af4725dea2342523c0447e5666b63f - unrolled_ast: dc0f03e353714f93a4bdc39a64369a4bf6af4725dea2342523c0447e5666b63f - ssa_ast: ceb2eeb666f437f0adeb57cb689e501a3a0981ba14663b9e4f85bcf795aa5ecb - flattened_ast: dd5f38e0fa2531c81ad10c5aa2143388c47caca081cf7fc56a2e39cb0d07d98b + - initial_ast: 64dda97ee29caaad409d6138d57d8ed852caee9e40486539e03fcc570c7c3d1a + unrolled_ast: 64dda97ee29caaad409d6138d57d8ed852caee9e40486539e03fcc570c7c3d1a + ssa_ast: b893aa52ba3b0404bcfdcd8f9708df62cb91b70ba5e9417e1455fc7710c6ceb6 + flattened_ast: bbf216c1e754d2012edb4ef4896499255d956bf4f39c0b9852ee45f75d914a0b + inlined_ast: bbf216c1e754d2012edb4ef4896499255d956bf4f39c0b9852ee45f75d914a0b bytecode: ef0f05392652587de58875f041bb805a5a1172a153d96973638342d143798863 diff --git a/tests/expectations/compiler/field/ternary.out b/tests/expectations/compiler/field/ternary.out index 132beb0933..66cbcc5d77 100644 --- a/tests/expectations/compiler/field/ternary.out +++ b/tests/expectations/compiler/field/ternary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ce068059ab68c906175c70d259fc716165e8749596c80ec6e2be52c88d076335 - unrolled_ast: ce068059ab68c906175c70d259fc716165e8749596c80ec6e2be52c88d076335 - ssa_ast: 48b84a8784368f924f6b15526204f34921eee3224112cc0555a223c169047809 - flattened_ast: be6f3fd5174704ed384b73de24f569b4ca3744480bd454b7501a52a4dddb98f6 + - initial_ast: 1ea7ba67b3f77b976b2ec3493afe6958ea64055e10f7a15f33235ff62dd488ee + unrolled_ast: 1ea7ba67b3f77b976b2ec3493afe6958ea64055e10f7a15f33235ff62dd488ee + ssa_ast: dd0df684331375510fdd96af15bd2aadb8932f3eff2fabb9d1b8dba199728b48 + flattened_ast: 60cf4f7e83d3ffc10b362b701749b0d5afcf8307e099bc5c7908c9ccb4df3efc + inlined_ast: 60cf4f7e83d3ffc10b362b701749b0d5afcf8307e099bc5c7908c9ccb4df3efc bytecode: b65dba415908458745a14bfc52abda70a0899732f807ba22f56776ab3fcbf589 diff --git a/tests/expectations/compiler/finalize/decrement.out b/tests/expectations/compiler/finalize/decrement.out index ae92908c48..42b6e9f74c 100644 --- a/tests/expectations/compiler/finalize/decrement.out +++ b/tests/expectations/compiler/finalize/decrement.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 56080d8ee17c7eedbe41d281e986a8b09fa1d0e33bb1c7876fc93599c194f0fa - unrolled_ast: 56080d8ee17c7eedbe41d281e986a8b09fa1d0e33bb1c7876fc93599c194f0fa - ssa_ast: 56080d8ee17c7eedbe41d281e986a8b09fa1d0e33bb1c7876fc93599c194f0fa - flattened_ast: c49b193e77aad777550c12ac43fdb3fed1d33ef1a841af37294c43902fef9ee8 + - initial_ast: 6fa465e63f2b8e880d621cb1758b3d1c0edfa9ce09e6d4f0f28bbe6c2ca2b955 + unrolled_ast: 6fa465e63f2b8e880d621cb1758b3d1c0edfa9ce09e6d4f0f28bbe6c2ca2b955 + ssa_ast: 6fa465e63f2b8e880d621cb1758b3d1c0edfa9ce09e6d4f0f28bbe6c2ca2b955 + flattened_ast: 4b8969d1adf68074bc7a8458a9146e128041bf929f2f6a4e76a16ad2769b81b1 + inlined_ast: 4b8969d1adf68074bc7a8458a9146e128041bf929f2f6a4e76a16ad2769b81b1 bytecode: 39aa8516297ece27331b633a72466d2ff0122d36beca663a48bc07589e2d3e15 diff --git a/tests/expectations/compiler/finalize/finalize.out b/tests/expectations/compiler/finalize/finalize.out index f117c96fdf..92e62f3c8c 100644 --- a/tests/expectations/compiler/finalize/finalize.out +++ b/tests/expectations/compiler/finalize/finalize.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ab5dac20c924339789f9c0ac6fcd035b58ea7b9d3b2084a5151cba3c14f7939b - unrolled_ast: ab5dac20c924339789f9c0ac6fcd035b58ea7b9d3b2084a5151cba3c14f7939b - ssa_ast: 83186e2623d9152de399d213137d7813c027e1e76e607295b66b8c03dbe32a4d - flattened_ast: 26b244650007d2841b4dec172241e8eae1091483054e8c82ac61df52fd63f91f + - initial_ast: 9ffd4f34e261ee315a2ee29353e707b35c300e928aca532743142a538957c4ce + unrolled_ast: 9ffd4f34e261ee315a2ee29353e707b35c300e928aca532743142a538957c4ce + ssa_ast: 9ea8f3743b9bcf1584319472ca0a80707f117616d687d4c401b34fb10b44703a + flattened_ast: a4eca8b80af9863d59ebfb837fa5dae061fca7d52315d3a9f5778e6dc4b75716 + inlined_ast: a4eca8b80af9863d59ebfb837fa5dae061fca7d52315d3a9f5778e6dc4b75716 bytecode: 6db857dc2b80ea257d141b3980404e050024771f95c5f9b74f899145b2001432 diff --git a/tests/expectations/compiler/finalize/finalize_with_return.out b/tests/expectations/compiler/finalize/finalize_with_return.out index e50cd15e3d..e421d4b870 100644 --- a/tests/expectations/compiler/finalize/finalize_with_return.out +++ b/tests/expectations/compiler/finalize/finalize_with_return.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 521891369f880815ee6ac54d87588c147feff8ec4cb62128c44afdf792e30e76 - unrolled_ast: 521891369f880815ee6ac54d87588c147feff8ec4cb62128c44afdf792e30e76 - ssa_ast: fe601539c9d1cc61da7a956647e4712edacc7928d3cce050ade833e2fb9da0d8 - flattened_ast: 5c1a7f7f8356f0de01c7cd183adb76570fa9f9e80f3f5853c761293cb6ca355f + - initial_ast: 809ffb6b3ce9e51d58f18a841bbbe79e87bf3b5c0ac2d82d226b3cb66427f235 + unrolled_ast: 809ffb6b3ce9e51d58f18a841bbbe79e87bf3b5c0ac2d82d226b3cb66427f235 + ssa_ast: efeab621ea3b6113ae3ef1f326cbd75668ce034b81a1bb09a55c9a671f62c127 + flattened_ast: 06fea09c85a281be025d66565aa362f80f2036c88c284fbfb5f9b874a605916b + inlined_ast: 06fea09c85a281be025d66565aa362f80f2036c88c284fbfb5f9b874a605916b bytecode: 9f1144202f6b114409c379f7ecc4b480dd81daaf0f6f8b244efd20c520f7b76c diff --git a/tests/expectations/compiler/finalize/increment.out b/tests/expectations/compiler/finalize/increment.out index 0d25176f26..94daa97618 100644 --- a/tests/expectations/compiler/finalize/increment.out +++ b/tests/expectations/compiler/finalize/increment.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1fc29cb05bcd2261b761b2342516525cf7cf27f897cce03d13ea456362411b9d - unrolled_ast: 1fc29cb05bcd2261b761b2342516525cf7cf27f897cce03d13ea456362411b9d - ssa_ast: 1fc29cb05bcd2261b761b2342516525cf7cf27f897cce03d13ea456362411b9d - flattened_ast: ad48f1a8f2207a90e1707665b0a1047b313647d83a38a413f7fb5bc1751f22ef + - initial_ast: 19378936c22e4e747e16e132bbc727115598dfbd17068349cb300525cde35556 + unrolled_ast: 19378936c22e4e747e16e132bbc727115598dfbd17068349cb300525cde35556 + ssa_ast: 19378936c22e4e747e16e132bbc727115598dfbd17068349cb300525cde35556 + flattened_ast: c55a0edeb6a52dd728e5500ff5b1d387186321c8a3d68f2d0638628bbb05696e + inlined_ast: c55a0edeb6a52dd728e5500ff5b1d387186321c8a3d68f2d0638628bbb05696e bytecode: 49afa4d378578bc680308083733b31b8272f9c952fe8dbc133398676e3f0d2ba diff --git a/tests/expectations/compiler/finalize/increment_decrement_in_inline.out b/tests/expectations/compiler/finalize/increment_decrement_in_inline.out new file mode 100644 index 0000000000..4314c79e14 --- /dev/null +++ b/tests/expectations/compiler/finalize/increment_decrement_in_inline.out @@ -0,0 +1,5 @@ +--- +namespace: Compile +expectation: Fail +outputs: + - "Error [ETYC0372035]: `increment` or `decrement` statements must be inside a finalize block.\n --> compiler-test:8:9\n |\n 8 | increment(values, 0u8, 1u8);\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^\nError [ETYC0372035]: `increment` or `decrement` statements must be inside a finalize block.\n --> compiler-test:9:9\n |\n 9 | increment(account, self.caller, 1u64);\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\nError [ETYC0372035]: `increment` or `decrement` statements must be inside a finalize block.\n --> compiler-test:13:9\n |\n 13 | decrement(values, 0u8, 1u8);\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^\nError [ETYC0372035]: `increment` or `decrement` statements must be inside a finalize block.\n --> compiler-test:14:9\n |\n 14 | decrement(account, self.caller, 1u64);\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\nError [ETYC0372044]: Function must contain a `finalize` statement on all execution paths.\n --> compiler-test:12:5\n |\n 12 | inline bar() {\n 13 | decrement(values, 0u8, 1u8);\n 14 | decrement(account, self.caller, 1u64);\n 15 | }\n | ^\nError [ETYC0372031]: Only transition functions can have a `finalize` block.\n --> compiler-test:17:5\n |\n 17 | finalize finalize_no_params() {\n 18 | foo();\n 19 | bar();\n 20 | }\n | ^\n |\n = Remove the `finalize` block or use the keyword `transition` instead of `function`.\nError [ETYC0372045]: `finalize` name `bar` does not match function name `finalize_no_params`\n --> compiler-test:17:5\n |\n 17 | finalize finalize_no_params() {\n 18 | foo();\n 19 | bar();\n 20 | }\n | ^\nError [ETYC0372066]: Cyclic dependency between functions: `bar` --> `bar`\n" diff --git a/tests/expectations/compiler/finalize/increment_decrement_in_inline_fail.out b/tests/expectations/compiler/finalize/increment_decrement_in_inline_fail.out new file mode 100644 index 0000000000..4314c79e14 --- /dev/null +++ b/tests/expectations/compiler/finalize/increment_decrement_in_inline_fail.out @@ -0,0 +1,5 @@ +--- +namespace: Compile +expectation: Fail +outputs: + - "Error [ETYC0372035]: `increment` or `decrement` statements must be inside a finalize block.\n --> compiler-test:8:9\n |\n 8 | increment(values, 0u8, 1u8);\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^\nError [ETYC0372035]: `increment` or `decrement` statements must be inside a finalize block.\n --> compiler-test:9:9\n |\n 9 | increment(account, self.caller, 1u64);\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\nError [ETYC0372035]: `increment` or `decrement` statements must be inside a finalize block.\n --> compiler-test:13:9\n |\n 13 | decrement(values, 0u8, 1u8);\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^\nError [ETYC0372035]: `increment` or `decrement` statements must be inside a finalize block.\n --> compiler-test:14:9\n |\n 14 | decrement(account, self.caller, 1u64);\n | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^\nError [ETYC0372044]: Function must contain a `finalize` statement on all execution paths.\n --> compiler-test:12:5\n |\n 12 | inline bar() {\n 13 | decrement(values, 0u8, 1u8);\n 14 | decrement(account, self.caller, 1u64);\n 15 | }\n | ^\nError [ETYC0372031]: Only transition functions can have a `finalize` block.\n --> compiler-test:17:5\n |\n 17 | finalize finalize_no_params() {\n 18 | foo();\n 19 | bar();\n 20 | }\n | ^\n |\n = Remove the `finalize` block or use the keyword `transition` instead of `function`.\nError [ETYC0372045]: `finalize` name `bar` does not match function name `finalize_no_params`\n --> compiler-test:17:5\n |\n 17 | finalize finalize_no_params() {\n 18 | foo();\n 19 | bar();\n 20 | }\n | ^\nError [ETYC0372066]: Cyclic dependency between functions: `bar` --> `bar`\n" diff --git a/tests/expectations/compiler/finalize/inline_in_finalize.out b/tests/expectations/compiler/finalize/inline_in_finalize.out new file mode 100644 index 0000000000..77fc7fb976 --- /dev/null +++ b/tests/expectations/compiler/finalize/inline_in_finalize.out @@ -0,0 +1,10 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - initial_ast: 66c08e3fa6b22b7663e949d6ea72455bca2c26a573ba094f084310a086a4cf0b + unrolled_ast: 66c08e3fa6b22b7663e949d6ea72455bca2c26a573ba094f084310a086a4cf0b + ssa_ast: b86f0471ac1a09039a4ce147e87b0c41b9c3378dba0cb560b4a2fe41533781c2 + flattened_ast: 52f744a6cf805739c77995f73c2f626ad2403301c5dc6e007b9c2092869f5224 + inlined_ast: b7ef966c924c7fd055476fd974079af70e235aed43d8cbff30c7eadad8e342c7 + bytecode: 614bd1f31a52b5176e1c8a7b8a7fc17ced721ae71e50d33daa09ebc65b5fff20 diff --git a/tests/expectations/compiler/finalize/mapping.out b/tests/expectations/compiler/finalize/mapping.out index aeebaaee84..3cf6c32490 100644 --- a/tests/expectations/compiler/finalize/mapping.out +++ b/tests/expectations/compiler/finalize/mapping.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: fcd02f88db2176cd7e0befcda00311776bff3f8518b272c256c0e19de8eb7dd9 - unrolled_ast: fcd02f88db2176cd7e0befcda00311776bff3f8518b272c256c0e19de8eb7dd9 - ssa_ast: ba628027acf56c96c1047a38f2adb820e4dd16e7e82a77e210f60cbee2265f13 - flattened_ast: 6d53ef7e6768f1eb0b230e73c743a0d07ef5eca2e962ae8666c3a88677a33b03 + - initial_ast: 654954e49f42b92d7405fb08be0dcd80810abbdd366623ed6bb36ba99ddbaa58 + unrolled_ast: 654954e49f42b92d7405fb08be0dcd80810abbdd366623ed6bb36ba99ddbaa58 + ssa_ast: 45cca036e205fdb706c442f8d507038e0ec813cfa4de443b8c69c8485d5256e9 + flattened_ast: 8a8a44500158d7b38ccf354a7d14c4292c3cc302889489d0fe3761c1917befed + inlined_ast: 8a8a44500158d7b38ccf354a7d14c4292c3cc302889489d0fe3761c1917befed bytecode: 1da5a78fcb6f77bd197de7dce1e7e94e7a9d30a6ec26703a645b25ab7c65cc08 diff --git a/tests/expectations/compiler/function/complex_recursion_fail.out b/tests/expectations/compiler/function/complex_recursion_fail.out index afa95d695d..3e51af1807 100644 --- a/tests/expectations/compiler/function/complex_recursion_fail.out +++ b/tests/expectations/compiler/function/complex_recursion_fail.out @@ -2,4 +2,4 @@ namespace: Compile expectation: Fail outputs: - - "Error [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:7:16\n |\n 7 | return two(n);\n | ^^^^^^\nError [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:11:16\n |\n 11 | return three(n) + four(n);\n | ^^^^^^^^\nError [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:11:27\n |\n 11 | return three(n) + four(n);\n | ^^^^^^^\nError [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:15:16\n |\n 15 | return one(n);\n | ^^^^^^\nError [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:19:16\n |\n 19 | return one(n);\n | ^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:23:16\n |\n 23 | return six(n);\n | ^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:27:16\n |\n 27 | return seven(n) + eight(n);\n | ^^^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:27:27\n |\n 27 | return seven(n) + eight(n);\n | ^^^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:31:16\n |\n 31 | return five(n);\n | ^^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:35:16\n |\n 35 | return five(n);\n | ^^^^^^^\nError [ETYC0372066]: Cyclic dependency between functions: `one` --> `two` --> `three` --> `one`\n" + - "Error [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:7:16\n |\n 7 | return two(n);\n | ^^^^^^\nError [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:11:16\n |\n 11 | return three(n) + four(n);\n | ^^^^^^^^\nError [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:11:27\n |\n 11 | return three(n) + four(n);\n | ^^^^^^^\nError [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:15:16\n |\n 15 | return one(n);\n | ^^^^^^\nError [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:19:16\n |\n 19 | return one(n);\n | ^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:23:16\n |\n 23 | return six(n);\n | ^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:27:16\n |\n 27 | return seven(n) + eight(n);\n | ^^^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:27:27\n |\n 27 | return seven(n) + eight(n);\n | ^^^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:31:16\n |\n 31 | return five(n);\n | ^^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:35:16\n |\n 35 | return five(n);\n | ^^^^^^^\nError [ETYC0372066]: Cyclic dependency between functions: `one` --> `two` --> `three` --> `one`\n" diff --git a/tests/expectations/compiler/function/conditional_return.out b/tests/expectations/compiler/function/conditional_return.out index c81eecfa71..36faec6b99 100644 --- a/tests/expectations/compiler/function/conditional_return.out +++ b/tests/expectations/compiler/function/conditional_return.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: f54d04dcf65f240192da3a67407a1ab8c97942603bb031269a3b6e20e450c364 - unrolled_ast: f54d04dcf65f240192da3a67407a1ab8c97942603bb031269a3b6e20e450c364 - ssa_ast: f7a38580c6da1a0cb128799ff979843f913b87af368920ed5dbbd72b64a8f67e - flattened_ast: b31dbb46a29aec9009f7aff2a8f6f206cfed5fd837174aa66d450b38adc4df21 + - initial_ast: 01eca8ffd19d37c08eee234033181ccb72873bc1fff02a90e1863e24c9e2d446 + unrolled_ast: 01eca8ffd19d37c08eee234033181ccb72873bc1fff02a90e1863e24c9e2d446 + ssa_ast: 9e151de216e44ca801adec05a7b534cbe347c3a64f31d570a9f33591a90af191 + flattened_ast: 9f1b62847c7b725e934fd72fb9a6ab076a6d1c778957bb93e6d2e4c7c0910c58 + inlined_ast: 9f1b62847c7b725e934fd72fb9a6ab076a6d1c778957bb93e6d2e4c7c0910c58 bytecode: 434d585ff5cbe799cf645514abda7bc7ad069563501ded68fc716e583390fefa diff --git a/tests/expectations/compiler/function/flatten_inlined_tuples_of_structs.out b/tests/expectations/compiler/function/flatten_inlined_tuples_of_structs.out new file mode 100644 index 0000000000..855562b6af --- /dev/null +++ b/tests/expectations/compiler/function/flatten_inlined_tuples_of_structs.out @@ -0,0 +1,10 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - initial_ast: d9f4c437725505b182331f81158f4d4fe868ac4c51bc09e7adb207668875c1d3 + unrolled_ast: d9f4c437725505b182331f81158f4d4fe868ac4c51bc09e7adb207668875c1d3 + ssa_ast: 52bde71da7f559a45cb7dff0b9ec4634cbca56d1d02dad9ade11cd733590d5e1 + flattened_ast: 47f2df48295953cd15343288c0ce7de1394e82e6c34734992397df74c1b2138a + inlined_ast: 419b798e293216e127d3a3ed8775e39a5ab0c6cb2b0bfbcd69bbeffed7d0f113 + bytecode: d84ad59c8407d4d733886e7442e47de32cc3025f6e411d2cce0816ce30f0b488 diff --git a/tests/expectations/compiler/function/flatten_test.out b/tests/expectations/compiler/function/flatten_test.out index 585dda8b37..d0895778ba 100644 --- a/tests/expectations/compiler/function/flatten_test.out +++ b/tests/expectations/compiler/function/flatten_test.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: f2670ba11429088c8d6ca1498d168df09a9706ac2d20d71cd29af5dd867d35e7 - unrolled_ast: f2670ba11429088c8d6ca1498d168df09a9706ac2d20d71cd29af5dd867d35e7 - ssa_ast: 16b1a88055e17a218086950e9ff90c81c167872faf26d901814952f3a3c57091 - flattened_ast: 814492938dd116ec6cd0db1f084a22379a12127f123b7630efecd668452a33d9 + - initial_ast: ef14a0a65f3e5450826ec37f7e2369f0f2b8d3314ed00da3ec900d4a51ed4eb9 + unrolled_ast: ef14a0a65f3e5450826ec37f7e2369f0f2b8d3314ed00da3ec900d4a51ed4eb9 + ssa_ast: 608b9c426b08b8b97dcf7f6a14c7dd0ebca594a7e17f79580cd1274757c4dd3c + flattened_ast: 7df8d7e0db134613ff120ee03cffc2fef159cf8204273668222e41d2b0efd2d1 + inlined_ast: 7df8d7e0db134613ff120ee03cffc2fef159cf8204273668222e41d2b0efd2d1 bytecode: 2a939858f2f71f1bbe25bd039899cdb71254e56acc203eb6d60dbb5c191a4224 diff --git a/tests/expectations/compiler/function/flatten_tuples_of_structs.out b/tests/expectations/compiler/function/flatten_tuples_of_structs.out index 6bfcd64153..c2bdaefde0 100644 --- a/tests/expectations/compiler/function/flatten_tuples_of_structs.out +++ b/tests/expectations/compiler/function/flatten_tuples_of_structs.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: a21e39f581430c0a9a90d57dc00d6ba3baa09ec5a210d9c5021cd1b11072e91f - unrolled_ast: a21e39f581430c0a9a90d57dc00d6ba3baa09ec5a210d9c5021cd1b11072e91f - ssa_ast: 7b49247c500c5c179b892dd9fd7eff60104a1e04ffd00b9b53b5fbbc493b92af - flattened_ast: 99341a91c75455d056b346f1a35ecb55af04b18ddaecbbe4ec154d4d3512b0f0 + - initial_ast: 374f33d7c3329a997d7740cbbc7e79d2c52b4ab70f14c72e1e77e01789e4932c + unrolled_ast: 374f33d7c3329a997d7740cbbc7e79d2c52b4ab70f14c72e1e77e01789e4932c + ssa_ast: a4166d418cadd9c9994b6d882f94cabbc80d302439c3e738c19d8603e3e56af4 + flattened_ast: bf07e16742127065efb1989aef9582c08c8a6251057c5ae8e422901aaf46a3fa + inlined_ast: bf07e16742127065efb1989aef9582c08c8a6251057c5ae8e422901aaf46a3fa bytecode: 27556a268723e0d8ffc4210290babab1ad098d9c8a77ad2dc84195d98059deac diff --git a/tests/expectations/compiler/function/function_call.out b/tests/expectations/compiler/function/function_call.out index 64b3ae1172..6dcc30aa54 100644 --- a/tests/expectations/compiler/function/function_call.out +++ b/tests/expectations/compiler/function/function_call.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5db5302effae454776641d39a58e71fb54e7a0dd8f9abb33aad033eae6bfd2dc - unrolled_ast: 5db5302effae454776641d39a58e71fb54e7a0dd8f9abb33aad033eae6bfd2dc - ssa_ast: 380883028c4da15e42781a4488f67821bc0a24da459de5a96fe424ed0296b09b - flattened_ast: 0689f093ce2cc6ca0be1ea491a268329d67ecc1251025a5d398ab174288e2c9c + - initial_ast: ed7e4dbd69ff4231ff48a6527734c7837b872f12a444668b071298b5cdd15d99 + unrolled_ast: ed7e4dbd69ff4231ff48a6527734c7837b872f12a444668b071298b5cdd15d99 + ssa_ast: e5afe402b1d3eeb7f1465a197952931597c2a8147aa624a15c985cad460479ce + flattened_ast: 8583c9afe3f11178c11fd4ff9e7babd3ed3a74719484084d1af353b7844dddc8 + inlined_ast: 303725110ce5af01a45222f852d1096172a8aba363ef3b192bc026d2144fdf7c bytecode: 713ce56eafa3f358be317894fd3ddf287a03422f855a304ee64becfcbd1f8590 diff --git a/tests/expectations/compiler/function/function_call_inline.out b/tests/expectations/compiler/function/function_call_inline.out new file mode 100644 index 0000000000..6ba3a3fd0a --- /dev/null +++ b/tests/expectations/compiler/function/function_call_inline.out @@ -0,0 +1,10 @@ +--- +namespace: Compile +expectation: Pass +outputs: + - initial_ast: 42426e586a4fe69f06466e4621a8cf4547408ad38c108a85bf0beaf812859a66 + unrolled_ast: 42426e586a4fe69f06466e4621a8cf4547408ad38c108a85bf0beaf812859a66 + ssa_ast: 4b33649beef6673aafce25c35c16c034fb41ec33fdf562751b7e51d712caf309 + flattened_ast: e2ee2ee7c6e1c187de5977f44b0a39e11d946243990eb48df92b3a3e939b3906 + inlined_ast: aae0684cc29719b75d1af553fae21f9cafd04d15fd211eeb4d8cebbf913bcd6c + bytecode: da94a3a78e8ddb3883dafdc52da31472986f7e4a89348e03acaa1f7d1de5bb31 diff --git a/tests/expectations/compiler/function/function_call_out_of_order.out b/tests/expectations/compiler/function/function_call_out_of_order.out index 1ef1db5839..94074e96bc 100644 --- a/tests/expectations/compiler/function/function_call_out_of_order.out +++ b/tests/expectations/compiler/function/function_call_out_of_order.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 4d3f6c6d7473e2d981f1b66cdc0aa6c8c838b0cd5119749f88dd78173d948429 - unrolled_ast: 4d3f6c6d7473e2d981f1b66cdc0aa6c8c838b0cd5119749f88dd78173d948429 - ssa_ast: fa0c588d9ee1505dd06a0b90526b09e62f4336d4ce9f2e7be420235cd93bc9ab - flattened_ast: de929e7ddaf5ac129f46d064d2581b79cad2a4ff2d91243af77c07dd1d2d9146 + - initial_ast: 4b891db2ba8f6ee0f2299622ecd387e6565c8b97045ff75808e559d7ee34c074 + unrolled_ast: 4b891db2ba8f6ee0f2299622ecd387e6565c8b97045ff75808e559d7ee34c074 + ssa_ast: f67f11e78a102b6eba419bb394cdf10b6bf8b1f2245c2fd022aa03db7750535a + flattened_ast: eddea7cbfc19bcdd6880741cc2446dd88b2d070c334dcf7e3780e71061c803f4 + inlined_ast: 9220160485ed7aa28cd86b329b9805a7da3e1fb03d9526881ea356c9bc4f3f03 bytecode: a190851c7a73c1068c1c5819c3e064535d56273dffbc007874376c094399cd9e diff --git a/tests/expectations/compiler/function/helper_function_with_interface.out b/tests/expectations/compiler/function/helper_function_with_interface.out index 6687da2321..89abeb7368 100644 --- a/tests/expectations/compiler/function/helper_function_with_interface.out +++ b/tests/expectations/compiler/function/helper_function_with_interface.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ea45c4127e9cb23abb3761d287db4841f7d4bcde901104d33447cf5f8a40a964 - unrolled_ast: ea45c4127e9cb23abb3761d287db4841f7d4bcde901104d33447cf5f8a40a964 - ssa_ast: 3c660861f07ab818e4fc7ac137e9fcc2d8b39d5174a2fd307b0a478869bf8a83 - flattened_ast: 5d5bc19468ea4393bb7a5f3737724c999030eb04c71d25e8d53e995706e2b762 + - initial_ast: a1949ce7cd298b1eae7d1e68bd82735cb5430fbf3d98c846a742af495162c674 + unrolled_ast: a1949ce7cd298b1eae7d1e68bd82735cb5430fbf3d98c846a742af495162c674 + ssa_ast: 7af2a8837e274f8fad34cc663a822d4d901d71cda15268baf9b2b3131fad1b0e + flattened_ast: 66bc317eaff6320b4eb9eb8bdfad3dec14040cbeb81c9c73f3f7632ae699408e + inlined_ast: 66bc317eaff6320b4eb9eb8bdfad3dec14040cbeb81c9c73f3f7632ae699408e bytecode: 56875e297f05e4c60762445a3ac97b57e4a0f12d69180bb7207ef62f950b0b25 diff --git a/tests/expectations/compiler/function/mutual_recursion_fail.out b/tests/expectations/compiler/function/mutual_recursion_fail.out index 9f2ad2e058..3e481b993e 100644 --- a/tests/expectations/compiler/function/mutual_recursion_fail.out +++ b/tests/expectations/compiler/function/mutual_recursion_fail.out @@ -2,4 +2,4 @@ namespace: Compile expectation: Fail outputs: - - "Error [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:5:16\n |\n 5 | return bar(n);\n | ^^^^^^\nError [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:9:16\n |\n 9 | return foo(n);\n | ^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:13:16\n |\n 13 | return bax(n);\n | ^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:17:16\n |\n 17 | return baz(n);\n | ^^^^^^\nError [ETYC0372066]: Cyclic dependency between functions: `foo` --> `bar` --> `foo`\n" + - "Error [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:5:16\n |\n 5 | return bar(n);\n | ^^^^^^\nError [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:9:16\n |\n 9 | return foo(n);\n | ^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:13:16\n |\n 13 | return bax(n);\n | ^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:17:16\n |\n 17 | return baz(n);\n | ^^^^^^\nError [ETYC0372066]: Cyclic dependency between functions: `foo` --> `bar` --> `foo`\n" diff --git a/tests/expectations/compiler/function/private_input_output.out b/tests/expectations/compiler/function/private_input_output.out index f540fe49a6..2f1902a1ef 100644 --- a/tests/expectations/compiler/function/private_input_output.out +++ b/tests/expectations/compiler/function/private_input_output.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 3d476147549e1c400f8d99b7868d4bb55873f63a8935b64335cdb8ebb2836121 - unrolled_ast: 3d476147549e1c400f8d99b7868d4bb55873f63a8935b64335cdb8ebb2836121 - ssa_ast: f36b1fa15ab9001afe65592d2c3f5a790301ff47c68fb3ef3766c75251cdbe75 - flattened_ast: 161c5aa7b09fc1d3fba97998c52055855426cbe34ca5c05739f7831e8dcf30a5 + - initial_ast: 2d1182494129f414a987c520aeb8fcfaaa9019d688f810d8ba5589accbb11747 + unrolled_ast: 2d1182494129f414a987c520aeb8fcfaaa9019d688f810d8ba5589accbb11747 + ssa_ast: 7ae7272d7babd64cc7845463755decb6073b095b04ae52e76197c68bc081cdf6 + flattened_ast: c39c24be2f2e4792f87bf1e8dcd123064e1a9f31fec6923f8daf7800e6b9cd2a + inlined_ast: c39c24be2f2e4792f87bf1e8dcd123064e1a9f31fec6923f8daf7800e6b9cd2a bytecode: 6d5fea51d9eec1cf3a5037b123147f9d532855197e3891ff870fbe700dd08d3f diff --git a/tests/expectations/compiler/function/program_function_any_number_of_inputs_and_outputs.out b/tests/expectations/compiler/function/program_function_any_number_of_inputs_and_outputs.out index 3db65150ca..85f9d240d8 100644 --- a/tests/expectations/compiler/function/program_function_any_number_of_inputs_and_outputs.out +++ b/tests/expectations/compiler/function/program_function_any_number_of_inputs_and_outputs.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 6d33052975f037a698138d1e3d7bb06ac22669c9f92997b1ececac62a8361fe4 - unrolled_ast: 6d33052975f037a698138d1e3d7bb06ac22669c9f92997b1ececac62a8361fe4 - ssa_ast: e0f62e9ed02da031b11dbffb2e0e928ea2fbda7c2f0eb28013068abdaab521dc - flattened_ast: bf48feece0821904ba575f8a4de972d1f72631e102f2e6968c69a364fd70ea1d + - initial_ast: 5a6e8de67b7ddf2a34dd7bf302b73001f4cdf9f64517806622ed3787d35eadcc + unrolled_ast: 5a6e8de67b7ddf2a34dd7bf302b73001f4cdf9f64517806622ed3787d35eadcc + ssa_ast: 4d554be19b3abc0c13bccd5225bc75011e8a77ec764de362788b9d221bae09c4 + flattened_ast: faf9aeb6811760108ec7fd83ddf1d08314719c707e9818bebd9cf9b7e0adbff2 + inlined_ast: faf9aeb6811760108ec7fd83ddf1d08314719c707e9818bebd9cf9b7e0adbff2 bytecode: 76a90286cb4903577bb9b0d219abe140fd8e2ef8a74df48a82d986e8efc4235d diff --git a/tests/expectations/compiler/function/program_function_empty_body.out b/tests/expectations/compiler/function/program_function_empty_body.out index 88c477daaf..04d84310bb 100644 --- a/tests/expectations/compiler/function/program_function_empty_body.out +++ b/tests/expectations/compiler/function/program_function_empty_body.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: df120b5592ffccee9259d4dd27c40c0d1b960abc37c342057aeb73e0c01ca8bf - unrolled_ast: df120b5592ffccee9259d4dd27c40c0d1b960abc37c342057aeb73e0c01ca8bf - ssa_ast: df120b5592ffccee9259d4dd27c40c0d1b960abc37c342057aeb73e0c01ca8bf - flattened_ast: df120b5592ffccee9259d4dd27c40c0d1b960abc37c342057aeb73e0c01ca8bf + - initial_ast: 6a343455b83835e5e2bc4760238b988d508dbf8a73b078f95bbd92c825f931bc + unrolled_ast: 6a343455b83835e5e2bc4760238b988d508dbf8a73b078f95bbd92c825f931bc + ssa_ast: 6a343455b83835e5e2bc4760238b988d508dbf8a73b078f95bbd92c825f931bc + flattened_ast: 6a343455b83835e5e2bc4760238b988d508dbf8a73b078f95bbd92c825f931bc + inlined_ast: 6a343455b83835e5e2bc4760238b988d508dbf8a73b078f95bbd92c825f931bc bytecode: a26eca302425b77f7d017763631062a040d57f8557dd53a31bfe4d17584ab0e2 diff --git a/tests/expectations/compiler/function/program_function_unit_type.out b/tests/expectations/compiler/function/program_function_unit_type.out index edb728f989..4874ff96de 100644 --- a/tests/expectations/compiler/function/program_function_unit_type.out +++ b/tests/expectations/compiler/function/program_function_unit_type.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b7ac599b0560dd5b3282817ed32b8b22d0999026b0dfa78a8cd2b90691fad917 - unrolled_ast: b7ac599b0560dd5b3282817ed32b8b22d0999026b0dfa78a8cd2b90691fad917 - ssa_ast: b7ac599b0560dd5b3282817ed32b8b22d0999026b0dfa78a8cd2b90691fad917 - flattened_ast: b7ac599b0560dd5b3282817ed32b8b22d0999026b0dfa78a8cd2b90691fad917 + - initial_ast: 46c8f1a9f3ac3b544211d70cbf18eb2c30e659096e36309b268ecebfb8901047 + unrolled_ast: 46c8f1a9f3ac3b544211d70cbf18eb2c30e659096e36309b268ecebfb8901047 + ssa_ast: 46c8f1a9f3ac3b544211d70cbf18eb2c30e659096e36309b268ecebfb8901047 + flattened_ast: 46c8f1a9f3ac3b544211d70cbf18eb2c30e659096e36309b268ecebfb8901047 + inlined_ast: 46c8f1a9f3ac3b544211d70cbf18eb2c30e659096e36309b268ecebfb8901047 bytecode: 8f6238b1942bb3cf2eb7d0eed9745dffaf088c884c423992f0d23b989f3954ff diff --git a/tests/expectations/compiler/function/program_function_with_mode.out b/tests/expectations/compiler/function/program_function_with_mode.out index ab41fa1d05..2989b95862 100644 --- a/tests/expectations/compiler/function/program_function_with_mode.out +++ b/tests/expectations/compiler/function/program_function_with_mode.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: c4ce51e4c750829268e97fe1c5333b1cbb354bcb91a85bc6404f031a1ff2e291 - unrolled_ast: c4ce51e4c750829268e97fe1c5333b1cbb354bcb91a85bc6404f031a1ff2e291 - ssa_ast: 58066c4b25ab20dd7df4125558d9ed640860aa8a07fba43edf93e45a43966eb4 - flattened_ast: 76d51105eed165130131944cb57697e1f6328eabfc0356f780ce10af062e0d84 + - initial_ast: b240780b5255b2ceb6f095c0a4a2061bc060fb06d9ad0725f1e4aa1de1ab2500 + unrolled_ast: b240780b5255b2ceb6f095c0a4a2061bc060fb06d9ad0725f1e4aa1de1ab2500 + ssa_ast: 52bc08100046182123c83e77a8f89b24a92f6c5dedb09115361d500e08f92443 + flattened_ast: a1af6ce731eb84ce6f493bfffa4c34d682203f41f036a54613bc22b74e135d7a + inlined_ast: a1af6ce731eb84ce6f493bfffa4c34d682203f41f036a54613bc22b74e135d7a bytecode: 70d3806e31f660faa4eff783ad05a73cf249a0a1ac7c29046fd8f1b2cec656b1 diff --git a/tests/expectations/compiler/function/record_in_conditional_return.out b/tests/expectations/compiler/function/record_in_conditional_return.out index aa4b85cbb0..193a0aa7da 100644 --- a/tests/expectations/compiler/function/record_in_conditional_return.out +++ b/tests/expectations/compiler/function/record_in_conditional_return.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 73d07c274e50c7ea55284ad7d934eac48d7157d3019d9b3097ef57c641427de6 - unrolled_ast: 73d07c274e50c7ea55284ad7d934eac48d7157d3019d9b3097ef57c641427de6 - ssa_ast: d045710e1117eacb8be6d8e6c20c0b0a5782ce56f309b3f8302395f09789378f - flattened_ast: c036ab67e797fda07180962b44adbb43e16cebc88b86f9beec77c874688e6482 + - initial_ast: bde5dc5690f0be194a47c5bf9f39c11fc4ce1e2fa04d15970cdb60ead041395b + unrolled_ast: bde5dc5690f0be194a47c5bf9f39c11fc4ce1e2fa04d15970cdb60ead041395b + ssa_ast: 4a1a21498e62feefd9db31a254c1015703dc89dec4a32c39f1ab851279fb2ddc + flattened_ast: cfbbdf28d0919efc98023b650c0fa88cd90b0b17ba62fe7b7f12b20cad4c8bab + inlined_ast: cfbbdf28d0919efc98023b650c0fa88cd90b0b17ba62fe7b7f12b20cad4c8bab bytecode: f5572172f6812e0eb6e906c230138c76d1344fd15522b8b2ee98156d6c92ca0a diff --git a/tests/expectations/compiler/function/self.out b/tests/expectations/compiler/function/self.out index e8e5071329..971867230d 100644 --- a/tests/expectations/compiler/function/self.out +++ b/tests/expectations/compiler/function/self.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 0579db12bce5b6f72c0f548276347f1dbb15a3fbee9096566dac494f0d2f429c - unrolled_ast: 0579db12bce5b6f72c0f548276347f1dbb15a3fbee9096566dac494f0d2f429c - ssa_ast: b52f3c0f0b541815aa8c44a975458e05c9a29a58e882c89b95423060b67be520 - flattened_ast: 35afdc86059af5851243dcb987b586241484e1fa649cd3ba062921e1860e48eb + - initial_ast: a1273726570fc7a7cc2a27f2689258df5f6fb26964aab84c89f5a771d4841ea3 + unrolled_ast: a1273726570fc7a7cc2a27f2689258df5f6fb26964aab84c89f5a771d4841ea3 + ssa_ast: 028b589972bfceff9fb375e832f0595848ec7b7ec7a791995c7d360f0397e68a + flattened_ast: ef3ca55705d6cf89c60d2f7b62a11bb6aef71a03dc92f86ddd7ea61ff8faca72 + inlined_ast: ef3ca55705d6cf89c60d2f7b62a11bb6aef71a03dc92f86ddd7ea61ff8faca72 bytecode: e62ba6ed16c820d4f4a8c2569bf96add46e3b8ce999e5fc77fa99c1769ca2dbd diff --git a/tests/expectations/compiler/function/self_recursive_cycle_fail.out b/tests/expectations/compiler/function/self_recursive_cycle_fail.out index cc63ee3a09..3e62dc6be8 100644 --- a/tests/expectations/compiler/function/self_recursive_cycle_fail.out +++ b/tests/expectations/compiler/function/self_recursive_cycle_fail.out @@ -2,4 +2,4 @@ namespace: Compile expectation: Fail outputs: - - "Error [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:8:20\n |\n 8 | return fib(n - 1u8) + fib(n - 2u8);\n | ^^^^^^^^^^^^\nError [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:8:35\n |\n 8 | return fib(n - 1u8) + fib(n - 2u8);\n | ^^^^^^^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:16:20\n |\n 16 | return foo(n - 1u8) + foo(n - 2u8);\n | ^^^^^^^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:16:35\n |\n 16 | return foo(n - 1u8) + foo(n - 2u8);\n | ^^^^^^^^^^^^\nError [ETYC0372066]: Cyclic dependency between functions: `fib` --> `fib`\n" + - "Error [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:8:20\n |\n 8 | return fib(n - 1u8) + fib(n - 2u8);\n | ^^^^^^^^^^^^\nError [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:8:35\n |\n 8 | return fib(n - 1u8) + fib(n - 2u8);\n | ^^^^^^^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:16:20\n |\n 16 | return foo(n - 1u8) + foo(n - 2u8);\n | ^^^^^^^^^^^^\nError [ETYC0372048]: Cannot call a local transition function from a transition function.\n --> compiler-test:16:35\n |\n 16 | return foo(n - 1u8) + foo(n - 2u8);\n | ^^^^^^^^^^^^\nError [ETYC0372066]: Cyclic dependency between functions: `fib` --> `fib`\n" diff --git a/tests/expectations/compiler/function/standard_function_calls_standard_function_fail.out b/tests/expectations/compiler/function/standard_function_calls_standard_function_fail.out index ff9e488b1a..4d89eab9be 100644 --- a/tests/expectations/compiler/function/standard_function_calls_standard_function_fail.out +++ b/tests/expectations/compiler/function/standard_function_calls_standard_function_fail.out @@ -2,4 +2,4 @@ namespace: Compile expectation: Fail outputs: - - "Error [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:6:19\n |\n 6 | return adder(a, b);\n | ^^^^^^^^^^^\nError [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:8:20\n |\n 8 | return subber(a, b);\n | ^^^^^^^^^^^^\n" + - "Error [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:6:19\n |\n 6 | return adder(a, b);\n | ^^^^^^^^^^^\nError [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:8:20\n |\n 8 | return subber(a, b);\n | ^^^^^^^^^^^^\n" diff --git a/tests/expectations/compiler/function/standard_function_calls_transition_function_fail.out b/tests/expectations/compiler/function/standard_function_calls_transition_function_fail.out index ff9e488b1a..4d89eab9be 100644 --- a/tests/expectations/compiler/function/standard_function_calls_transition_function_fail.out +++ b/tests/expectations/compiler/function/standard_function_calls_transition_function_fail.out @@ -2,4 +2,4 @@ namespace: Compile expectation: Fail outputs: - - "Error [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:6:19\n |\n 6 | return adder(a, b);\n | ^^^^^^^^^^^\nError [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:8:20\n |\n 8 | return subber(a, b);\n | ^^^^^^^^^^^^\n" + - "Error [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:6:19\n |\n 6 | return adder(a, b);\n | ^^^^^^^^^^^\nError [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:8:20\n |\n 8 | return subber(a, b);\n | ^^^^^^^^^^^^\n" diff --git a/tests/expectations/compiler/group/add.out b/tests/expectations/compiler/group/add.out index ffa05eafdd..641ee5deb3 100644 --- a/tests/expectations/compiler/group/add.out +++ b/tests/expectations/compiler/group/add.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 195a02f5609697e7ba75c2057d0793b4be01e032ffdf4f86ab3cd139bd8ccb45 - unrolled_ast: 195a02f5609697e7ba75c2057d0793b4be01e032ffdf4f86ab3cd139bd8ccb45 - ssa_ast: 99d29759cb73fadd73e12d0d9cc61bb3d76de5f9a8a029327fcca11740c81911 - flattened_ast: de07b90b2461632b0ab11ca4e4a89261f3b19bf28dd1d12c4146c2308aab7d0a + - initial_ast: 8a63ddc2632d093e0c5acb7a3a51a41d588188ac05f5e0e8b309bf4ff85755e6 + unrolled_ast: 8a63ddc2632d093e0c5acb7a3a51a41d588188ac05f5e0e8b309bf4ff85755e6 + ssa_ast: 93527404a2273693c87ef75e9b4598a512e27de7d682be813baf7abe536755d8 + flattened_ast: fb8eb972c5e55fb0850d3515770b9dc207fd2ede668ef8fa4da72269a7d5a043 + inlined_ast: fb8eb972c5e55fb0850d3515770b9dc207fd2ede668ef8fa4da72269a7d5a043 bytecode: 12e9627877abc9f4f519aeb445a200162f2c962b8ec7ecf49564c35abf14caa4 diff --git a/tests/expectations/compiler/group/assert_eq.out b/tests/expectations/compiler/group/assert_eq.out index 059f60b399..638a68a6d1 100644 --- a/tests/expectations/compiler/group/assert_eq.out +++ b/tests/expectations/compiler/group/assert_eq.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 98faf200b99d4d413f3cda0b984c27b4898258040bbc8255c736d75887cbb845 - unrolled_ast: 98faf200b99d4d413f3cda0b984c27b4898258040bbc8255c736d75887cbb845 - ssa_ast: f672d9bfcaa92675a142fe1e6bd33b1d46cdf455340a7157fc5e38799ee61cf8 - flattened_ast: 5ecef425c9fa0b75f72ea912cd30700cab07c62a4b19402de638c2a50501c394 + - initial_ast: d46f9e78fe7243c6eaf708f6503761fcf1a264c79af6e709587e8c5cb40ef332 + unrolled_ast: d46f9e78fe7243c6eaf708f6503761fcf1a264c79af6e709587e8c5cb40ef332 + ssa_ast: ae9e7dbaa1df8397ba6bf8c0b76d51efcf363f75cb7e22c2fa3bea29cb0e895d + flattened_ast: 6a94a55b67bf6e0a76416d5f200029415ea0968b89d79a4f22bedc92ae54ff12 + inlined_ast: 6a94a55b67bf6e0a76416d5f200029415ea0968b89d79a4f22bedc92ae54ff12 bytecode: ec93d62ff5b281dc94a2adea7451851a6101494b2539a653869f8cf5dc8d64b7 diff --git a/tests/expectations/compiler/group/eq.out b/tests/expectations/compiler/group/eq.out index 059f60b399..638a68a6d1 100644 --- a/tests/expectations/compiler/group/eq.out +++ b/tests/expectations/compiler/group/eq.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 98faf200b99d4d413f3cda0b984c27b4898258040bbc8255c736d75887cbb845 - unrolled_ast: 98faf200b99d4d413f3cda0b984c27b4898258040bbc8255c736d75887cbb845 - ssa_ast: f672d9bfcaa92675a142fe1e6bd33b1d46cdf455340a7157fc5e38799ee61cf8 - flattened_ast: 5ecef425c9fa0b75f72ea912cd30700cab07c62a4b19402de638c2a50501c394 + - initial_ast: d46f9e78fe7243c6eaf708f6503761fcf1a264c79af6e709587e8c5cb40ef332 + unrolled_ast: d46f9e78fe7243c6eaf708f6503761fcf1a264c79af6e709587e8c5cb40ef332 + ssa_ast: ae9e7dbaa1df8397ba6bf8c0b76d51efcf363f75cb7e22c2fa3bea29cb0e895d + flattened_ast: 6a94a55b67bf6e0a76416d5f200029415ea0968b89d79a4f22bedc92ae54ff12 + inlined_ast: 6a94a55b67bf6e0a76416d5f200029415ea0968b89d79a4f22bedc92ae54ff12 bytecode: ec93d62ff5b281dc94a2adea7451851a6101494b2539a653869f8cf5dc8d64b7 diff --git a/tests/expectations/compiler/group/group_mul.out b/tests/expectations/compiler/group/group_mul.out index f6b4e0ad5d..c3fe46d369 100644 --- a/tests/expectations/compiler/group/group_mul.out +++ b/tests/expectations/compiler/group/group_mul.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1ef73786d0a40335e6d0edb2d560b20334113b48857030b87a638b6ff71a00da - unrolled_ast: 1ef73786d0a40335e6d0edb2d560b20334113b48857030b87a638b6ff71a00da - ssa_ast: abd17aba00c9af6437d78c5a05a999c14dbb19baf9a2617061d5df1092503845 - flattened_ast: d157785860e8aea337c5aeab93b9d23cf78c1fd91a958f138606e12d163176b4 + - initial_ast: 5ece34df030e2e1b8c4978490da897a4790980be8e3db6ba59a1bca995e34514 + unrolled_ast: 5ece34df030e2e1b8c4978490da897a4790980be8e3db6ba59a1bca995e34514 + ssa_ast: ea25750a75ae1aad0c436fd1c4af381f3b1ff1f389bbc07344f8d8dae74eef91 + flattened_ast: 10a306c6d15ca0748be2fa6240161fefa8e8918911ee4d19534d00eba3e71b9e + inlined_ast: 10a306c6d15ca0748be2fa6240161fefa8e8918911ee4d19534d00eba3e71b9e bytecode: 734e21460ab7e6ae2f2f66f0dbb45e31b82e8e154807c69aa36a9332c31c9b6a diff --git a/tests/expectations/compiler/group/input.out b/tests/expectations/compiler/group/input.out index 059f60b399..638a68a6d1 100644 --- a/tests/expectations/compiler/group/input.out +++ b/tests/expectations/compiler/group/input.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 98faf200b99d4d413f3cda0b984c27b4898258040bbc8255c736d75887cbb845 - unrolled_ast: 98faf200b99d4d413f3cda0b984c27b4898258040bbc8255c736d75887cbb845 - ssa_ast: f672d9bfcaa92675a142fe1e6bd33b1d46cdf455340a7157fc5e38799ee61cf8 - flattened_ast: 5ecef425c9fa0b75f72ea912cd30700cab07c62a4b19402de638c2a50501c394 + - initial_ast: d46f9e78fe7243c6eaf708f6503761fcf1a264c79af6e709587e8c5cb40ef332 + unrolled_ast: d46f9e78fe7243c6eaf708f6503761fcf1a264c79af6e709587e8c5cb40ef332 + ssa_ast: ae9e7dbaa1df8397ba6bf8c0b76d51efcf363f75cb7e22c2fa3bea29cb0e895d + flattened_ast: 6a94a55b67bf6e0a76416d5f200029415ea0968b89d79a4f22bedc92ae54ff12 + inlined_ast: 6a94a55b67bf6e0a76416d5f200029415ea0968b89d79a4f22bedc92ae54ff12 bytecode: ec93d62ff5b281dc94a2adea7451851a6101494b2539a653869f8cf5dc8d64b7 diff --git a/tests/expectations/compiler/group/mul.out b/tests/expectations/compiler/group/mul.out index af0d14f457..353f1a4460 100644 --- a/tests/expectations/compiler/group/mul.out +++ b/tests/expectations/compiler/group/mul.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 9ba40b1ed2211831c2e70bbb47dcc6f9bdbed6f3a758f0d7f8fa0e854e12b68c - unrolled_ast: 9ba40b1ed2211831c2e70bbb47dcc6f9bdbed6f3a758f0d7f8fa0e854e12b68c - ssa_ast: 6dcfde6afdaa4519781018b5f20141d1f4d4dc98fe2d6e4ab0a42bce86e414cc - flattened_ast: e28793a0f344690ea2d325882fb8aff55066ab403cc6a52f1eb881e69fab3399 + - initial_ast: 30d2a04c0577317210def067a5155151eb522249e78b6416c45ea69c1c65a10b + unrolled_ast: 30d2a04c0577317210def067a5155151eb522249e78b6416c45ea69c1c65a10b + ssa_ast: e86a8817d2bbcbf9bcf1fa4e6b3491d07691532c8371e8c06ea597c916683dce + flattened_ast: fea850a724c312c42466e22afa2b21380f9637174fd275237cbdf593b8b0c9dd + inlined_ast: fea850a724c312c42466e22afa2b21380f9637174fd275237cbdf593b8b0c9dd bytecode: 9dd44babd234f3b33af51d04ffd422308692b59caa5f1d6c3b765d0d8e795644 diff --git a/tests/expectations/compiler/group/mult_by_scalar.out b/tests/expectations/compiler/group/mult_by_scalar.out index 2ee378ab54..8a234be7b7 100644 --- a/tests/expectations/compiler/group/mult_by_scalar.out +++ b/tests/expectations/compiler/group/mult_by_scalar.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5dd447ad60022886199098602ccf066013f072ce9622dd400bd2ac57816b376d - unrolled_ast: 5dd447ad60022886199098602ccf066013f072ce9622dd400bd2ac57816b376d - ssa_ast: c85b3e962cfee75d39b3c50bf61a1eb6d023fa28d1cea2c1fa3d037eec3d03a5 - flattened_ast: 212a97dc2ef10c35a3f70b9c490fe874bacb765d8ef0b1a5f6a1c3a7aad66392 + - initial_ast: f15fa0ac6f61834601639168787aaeba57abe293e45e559a2e17456aa61a2d69 + unrolled_ast: f15fa0ac6f61834601639168787aaeba57abe293e45e559a2e17456aa61a2d69 + ssa_ast: e131305123f3f30fd02823739a124336f59950def015a2e16f6ae0d7da276214 + flattened_ast: 2369a4344b21218b00ff06f027f54e81240ee05e02297c039822ebdddc9b6282 + inlined_ast: 2369a4344b21218b00ff06f027f54e81240ee05e02297c039822ebdddc9b6282 bytecode: b3cef3c4dcd879fc92c9a2082e4820b102bf0ce47335b5e432b17a5c1b55da81 diff --git a/tests/expectations/compiler/group/negate.out b/tests/expectations/compiler/group/negate.out index 77e5b9bd4a..cce8d1ac59 100644 --- a/tests/expectations/compiler/group/negate.out +++ b/tests/expectations/compiler/group/negate.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: bbd661aa4a9ada502cbdbb2665efe6013a863a2a793df248c6098e232a80bc5e - unrolled_ast: bbd661aa4a9ada502cbdbb2665efe6013a863a2a793df248c6098e232a80bc5e - ssa_ast: 0a0b98bae2ae082aeeff6e4ec78d8c1ee2b2a5627ac8a3000d4fb00466e0821e - flattened_ast: 913ad9fa99a583ed51cfaaadb7cf990256c02d4361bcbb3b955e7458add13ca0 + - initial_ast: 1f2eb7c4e5443c57cf49ce470cfa8229fb67e162c041c6fb7fe9ecd46b5a3546 + unrolled_ast: 1f2eb7c4e5443c57cf49ce470cfa8229fb67e162c041c6fb7fe9ecd46b5a3546 + ssa_ast: 41032ad876b2160b388f01d716655ddd073b8cd7d185faa01002eeac19840597 + flattened_ast: 98d83fec655c25d2889cb6405068c46de336976f1468efb7e9bc30d434a5cb56 + inlined_ast: 98d83fec655c25d2889cb6405068c46de336976f1468efb7e9bc30d434a5cb56 bytecode: 96c9838c6cd113e26c1cb3abcb9aebb52e622fec38cab2a13ebaad1683a1c15d diff --git a/tests/expectations/compiler/group/operator_methods.out b/tests/expectations/compiler/group/operator_methods.out index 4b7946e8c5..1b46e90c51 100644 --- a/tests/expectations/compiler/group/operator_methods.out +++ b/tests/expectations/compiler/group/operator_methods.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: d2e4ad5bce1daeeebf758d000ac7751ba2ce982742338165fe5bb87d3ecd7960 - unrolled_ast: d2e4ad5bce1daeeebf758d000ac7751ba2ce982742338165fe5bb87d3ecd7960 - ssa_ast: 5f9670251173735ac6ea1aad7edbe922b940ef55ab909253a032e788d5b526ce - flattened_ast: 5d6d814439ab855a5cfd7af55c47f8005dfc082bbfe3c5aef3fea8e90f208ee4 + - initial_ast: 7840ca57eb2f32d2f6a3fdcb58a8fda5a15600ca31d8fd3a149129de61c30a13 + unrolled_ast: 7840ca57eb2f32d2f6a3fdcb58a8fda5a15600ca31d8fd3a149129de61c30a13 + ssa_ast: 084403de451d50b3941abf9a007cc223e8ec038cc04e2204bb2483d92b861fb6 + flattened_ast: ec3eec8f9dd98b80fe3621ab58494a4a0b3ff0e60edbec554ddc2a4138dd4fc9 + inlined_ast: ec3eec8f9dd98b80fe3621ab58494a4a0b3ff0e60edbec554ddc2a4138dd4fc9 bytecode: 3e00010d213e17baaa50b9dd4f0a2b77264d697e851e4c64b6f33eaa15c16ed8 diff --git a/tests/expectations/compiler/group/point_input.out b/tests/expectations/compiler/group/point_input.out index 14ee1243e1..09fa83ebc4 100644 --- a/tests/expectations/compiler/group/point_input.out +++ b/tests/expectations/compiler/group/point_input.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 579ebc703c9567acb936536395be67bd0ceba6ee723875f7a13a087faf5e1228 - unrolled_ast: 579ebc703c9567acb936536395be67bd0ceba6ee723875f7a13a087faf5e1228 - ssa_ast: a3a5204d56f2b6a7b5f7d2e7aa7beb9592831da092de01638e10a98c3e787272 - flattened_ast: 9365c2eb0ac1ef7dbd8a4124010230851dec684062fe4e3acbbb523e6df5ad2a + - initial_ast: 7da2673aada54bb5a17fd1783f3346b49389a8f5a3777c7e43c717453e627868 + unrolled_ast: 7da2673aada54bb5a17fd1783f3346b49389a8f5a3777c7e43c717453e627868 + ssa_ast: bb05e4f93c78ac321b3dc25afdcf2fac45dc1db9a4c01e139a576594deda8b2b + flattened_ast: 5230f944fffccae1af7e94f6e46f49b69b4f9ac21c32e2c0e7026a2d6e6071d2 + inlined_ast: 5230f944fffccae1af7e94f6e46f49b69b4f9ac21c32e2c0e7026a2d6e6071d2 bytecode: ab93704b9e34e4588d4b5e1ae347f661a182ce16fac8a45c1d95232b38564d23 diff --git a/tests/expectations/compiler/group/sub.out b/tests/expectations/compiler/group/sub.out index fc2b6f3506..5becc3d398 100644 --- a/tests/expectations/compiler/group/sub.out +++ b/tests/expectations/compiler/group/sub.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 2c6d2c17a9aef05c817c6435e69a63c3bcfb15176464a5e632d0a3f263c4ea61 - unrolled_ast: 2c6d2c17a9aef05c817c6435e69a63c3bcfb15176464a5e632d0a3f263c4ea61 - ssa_ast: 4c6573fe76fa1a65a8d06f0e6a388ddb398c39c21eefad762f0fa16925aefb11 - flattened_ast: dc2cf7117e9a8c87aed98a23da5ba8c58f8ec01a10c56c49fe6041ec3f9e91d3 + - initial_ast: 57a4673db7fd8ba95410ee15a34570a15b168a7734c03bfa1a915a799bc41060 + unrolled_ast: 57a4673db7fd8ba95410ee15a34570a15b168a7734c03bfa1a915a799bc41060 + ssa_ast: c7ef2a2666b54099f49f96b949ecb811c4fb87fd008cfce40c1d3cf4698b2b90 + flattened_ast: a682efda5ec163a12aa62f6a300ed5dd1d26a3195b10fb5ed9b955bee472e69a + inlined_ast: a682efda5ec163a12aa62f6a300ed5dd1d26a3195b10fb5ed9b955bee472e69a bytecode: 8389291206b5fde26edad53fd7cbfa30f4594fe5818a2cbb1a02b193a0382693 diff --git a/tests/expectations/compiler/group/ternary.out b/tests/expectations/compiler/group/ternary.out index 2258e9e6b9..778006169e 100644 --- a/tests/expectations/compiler/group/ternary.out +++ b/tests/expectations/compiler/group/ternary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 99ff057c8a5851601a3d60209dbeb87032128ca2a04a2daa54f3d6b484e7ddc3 - unrolled_ast: 99ff057c8a5851601a3d60209dbeb87032128ca2a04a2daa54f3d6b484e7ddc3 - ssa_ast: 54d5c3881def5b8279e797176be1409c032ae1f9c429009f9a4a79f5400ceb04 - flattened_ast: 686318cd6349eedddcbec1954f5305f294dc6acab1c5129c4c902d24da82cfce + - initial_ast: 47afd9d4561cac37263a954e42e2e95924ffe7254dc03579a89a6ec16314c484 + unrolled_ast: 47afd9d4561cac37263a954e42e2e95924ffe7254dc03579a89a6ec16314c484 + ssa_ast: ecf95c0af4f924d3a352258ae414f2b7b1baee27371558ad4333e983669615ea + flattened_ast: 30a77b393bc6bd937b6d8ead2171a6e5297a7bb0b538d6891f178a3c94e725f2 + inlined_ast: 30a77b393bc6bd937b6d8ead2171a6e5297a7bb0b538d6891f178a3c94e725f2 bytecode: cdbe7fcbbe006b5e22012279653209cfb5ba4db73631553c0eddd44a59e4a581 diff --git a/tests/expectations/compiler/group/x_and_y.out b/tests/expectations/compiler/group/x_and_y.out index ff904dab7b..20b8687d0d 100644 --- a/tests/expectations/compiler/group/x_and_y.out +++ b/tests/expectations/compiler/group/x_and_y.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: f9ed9bf2435a4565f8e03f5383219bb17fb0ec5f59e4b5dfec7d79563950bf8a - unrolled_ast: f9ed9bf2435a4565f8e03f5383219bb17fb0ec5f59e4b5dfec7d79563950bf8a - ssa_ast: c67405bb4c2ef247dd665eff62d93351ad79d634cae7bcdb67db6aea61de4e02 - flattened_ast: 83659f1d7ff7ef190db88405e21fdfbf4ab997cf18e6f405c3371a4f87faeda0 + - initial_ast: 8fe0d1d02e535dadd5bc65feccbd4fce90ac88a34606c9cf93bdc8678d563855 + unrolled_ast: 8fe0d1d02e535dadd5bc65feccbd4fce90ac88a34606c9cf93bdc8678d563855 + ssa_ast: b3624f2d15152428a37fae2e9bb6bb0bc72384b153bd57246379d6261ceeb9cb + flattened_ast: 02643666dc4ebb26b5d599c20472a82e10947e8ed6779e340e503b05db694198 + inlined_ast: 02643666dc4ebb26b5d599c20472a82e10947e8ed6779e340e503b05db694198 bytecode: e96081d4904a9d73c7ce8bb9cd6357c90051b37b97961e254aff910cb2d73827 diff --git a/tests/expectations/compiler/group/x_sign_high.out b/tests/expectations/compiler/group/x_sign_high.out index 8dab485856..6902a1e832 100644 --- a/tests/expectations/compiler/group/x_sign_high.out +++ b/tests/expectations/compiler/group/x_sign_high.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 4d301f9d6b17407c63148b4f8c041b8b909793ceb30eeeeb317e76dbcfcc99c9 - unrolled_ast: 4d301f9d6b17407c63148b4f8c041b8b909793ceb30eeeeb317e76dbcfcc99c9 - ssa_ast: 7202b4ad4215848a310b8225168a7c4f7603b878d74a669e096c8e8c31a89b34 - flattened_ast: aead5633b1b881f6f860a1fb3c03a8b2a8b4a297293533b005f38cde2514935c + - initial_ast: 3d30382990b5ec3eadf87cbf0a3cee8ae17e4d783e2fada3f1d790b8c599e637 + unrolled_ast: 3d30382990b5ec3eadf87cbf0a3cee8ae17e4d783e2fada3f1d790b8c599e637 + ssa_ast: f78b3c57cfa8409ba3b603ee42373705efaff4a625fcd29597abd90d63db8316 + flattened_ast: 4571065f061a5059794566a2c12ba08b726d97932b7bf756cea7a934f8e0e022 + inlined_ast: 4571065f061a5059794566a2c12ba08b726d97932b7bf756cea7a934f8e0e022 bytecode: e96081d4904a9d73c7ce8bb9cd6357c90051b37b97961e254aff910cb2d73827 diff --git a/tests/expectations/compiler/group/x_sign_inferred.out b/tests/expectations/compiler/group/x_sign_inferred.out index 3f0d974950..e386c42e80 100644 --- a/tests/expectations/compiler/group/x_sign_inferred.out +++ b/tests/expectations/compiler/group/x_sign_inferred.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 604563d4a0d52722b6c15e370f927659a499e91ad5649d58967a8a245c8c476d - unrolled_ast: 604563d4a0d52722b6c15e370f927659a499e91ad5649d58967a8a245c8c476d - ssa_ast: 7f811a402fc8219914ed3dd4b9654a81beba256f0211f987cf448de19c9bf5bb - flattened_ast: e3abc3d29b6c9b690323c128a7da46de9fccf8d4123d24fe15df65f96d169b4f + - initial_ast: df82f756e1442522f5165ec1edcff81bc4d5424c68b531c8749bd458744ac9ff + unrolled_ast: df82f756e1442522f5165ec1edcff81bc4d5424c68b531c8749bd458744ac9ff + ssa_ast: 2b8f96c04fcd1d1be970ec1c688fbc2a9c29f949cab7afac3770399940d4c6e4 + flattened_ast: 89d0593675ffaa7570e879c725925a7d581dc39a2768679872e9f861bfacc882 + inlined_ast: 89d0593675ffaa7570e879c725925a7d581dc39a2768679872e9f861bfacc882 bytecode: e96081d4904a9d73c7ce8bb9cd6357c90051b37b97961e254aff910cb2d73827 diff --git a/tests/expectations/compiler/group/x_sign_low.out b/tests/expectations/compiler/group/x_sign_low.out index e8bad2c891..b360eb2e25 100644 --- a/tests/expectations/compiler/group/x_sign_low.out +++ b/tests/expectations/compiler/group/x_sign_low.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 3e35b37fd750edd97e1a3662c4bce21b6f5fc1c88774c386ca0096e437972599 - unrolled_ast: 3e35b37fd750edd97e1a3662c4bce21b6f5fc1c88774c386ca0096e437972599 - ssa_ast: 3fdd109073c0e7110dd3379e077c05b6352ba06e8188dad3c069f2d081d919eb - flattened_ast: 5704d3db9b7f86cc5723e69f66f605ef7132e30204de430527521e55f0d33ce4 + - initial_ast: 025a397209d0b0588108a4f99e637103d60d654fbf284776073e58f209656910 + unrolled_ast: 025a397209d0b0588108a4f99e637103d60d654fbf284776073e58f209656910 + ssa_ast: e729b830c6d0231f85e8a78630c296cfcbd98133b4b6d2559719d39af7af6f14 + flattened_ast: f1333af91e0503c15ec6db132e8b8994b28cb07e06961044108563ec435b5288 + inlined_ast: f1333af91e0503c15ec6db132e8b8994b28cb07e06961044108563ec435b5288 bytecode: e96081d4904a9d73c7ce8bb9cd6357c90051b37b97961e254aff910cb2d73827 diff --git a/tests/expectations/compiler/group/zero.out b/tests/expectations/compiler/group/zero.out index 35a007a833..3cd625f896 100644 --- a/tests/expectations/compiler/group/zero.out +++ b/tests/expectations/compiler/group/zero.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 82fb5f408fbf7647e4084c267bddad855272b2f75438247aa6338945ce62db5c - unrolled_ast: 82fb5f408fbf7647e4084c267bddad855272b2f75438247aa6338945ce62db5c - ssa_ast: 37e4ce8ac228a2c2bf01fb72739fc819889d609b1ece3edc7d66db4adccd7128 - flattened_ast: cb9291cc666173917ecdda359e79083fac86addd5d5694dca5d077cfff866368 + - initial_ast: 049ebcc8aee7c4a87355659266eca71d3f480dda69a4771deb75ffcb71187d30 + unrolled_ast: 049ebcc8aee7c4a87355659266eca71d3f480dda69a4771deb75ffcb71187d30 + ssa_ast: 43ce028a30c30e2d672fb95b2694fa54803eba972b996466dbd392780b3baf74 + flattened_ast: 8e4057902e9231d5a558ee8f9d24a0019389f9d93d786ae99c7ed1aa989f29c5 + inlined_ast: 8e4057902e9231d5a558ee8f9d24a0019389f9d93d786ae99c7ed1aa989f29c5 bytecode: a94d1d8f79e69b746fcaf829916aae3f08c540aff13fd5d5a828addaded23621 diff --git a/tests/expectations/compiler/input/main.out b/tests/expectations/compiler/input/main.out index 43d710c4f8..95dc6af90c 100644 --- a/tests/expectations/compiler/input/main.out +++ b/tests/expectations/compiler/input/main.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 19d110903b06eb82c5c4874563eb500c0dd36c4919408daad9f77a327b3b1aa7 - unrolled_ast: 19d110903b06eb82c5c4874563eb500c0dd36c4919408daad9f77a327b3b1aa7 - ssa_ast: 1b9b290637908e25c9c0433fa968a0f5d69945f44a8fd7a4c85bb118edf739b8 - flattened_ast: 6d6965a5201fc59e8903d51599813a97ef1f40dac787d94aa27fefc39d0765de + - initial_ast: 281257417e814b4b023b3012dafaf43f595b9081073568ee63d4cce70fd728eb + unrolled_ast: 281257417e814b4b023b3012dafaf43f595b9081073568ee63d4cce70fd728eb + ssa_ast: 3187bd21eb4e27414cee29208aabe782444c2bc3228b372c90a852a632bae9d9 + flattened_ast: 9a1fd8fbc9feaabe3fba14d803512de5dffd9f92f96847a9295e2bdcec2b259a + inlined_ast: 9a1fd8fbc9feaabe3fba14d803512de5dffd9f92f96847a9295e2bdcec2b259a bytecode: 9a1e5bb7b8d932d4afd347a856bfb38db144771f49a0d9589ef14236338e3dcf diff --git a/tests/expectations/compiler/input/main_field.out b/tests/expectations/compiler/input/main_field.out index eaf2873e12..1f95fe97e0 100644 --- a/tests/expectations/compiler/input/main_field.out +++ b/tests/expectations/compiler/input/main_field.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e6bc55f56476fbc040c72a5ecdf5bb22d8c2312d1d2b1ddd337a126dbc2b761d - unrolled_ast: e6bc55f56476fbc040c72a5ecdf5bb22d8c2312d1d2b1ddd337a126dbc2b761d - ssa_ast: 26075e53cb215ce7f8be51dcc0ca710932d41ced058030984ea03185bf7e0e37 - flattened_ast: b137a195e489a4099fae89406755bad365c094a0982da96660d7b2b7e08746aa + - initial_ast: 9170fa221e6b6c73e935324f4ea604bc595014b4b8c0bad157b340a5dd66ad25 + unrolled_ast: 9170fa221e6b6c73e935324f4ea604bc595014b4b8c0bad157b340a5dd66ad25 + ssa_ast: 804feefc20b612249c7c44144033728c6e1354b152f196e262f135c652d2ecba + flattened_ast: a2f0d1256d3e08215e96cf625f61eea6f55c786e1f23f028d110252a40ad75c7 + inlined_ast: a2f0d1256d3e08215e96cf625f61eea6f55c786e1f23f028d110252a40ad75c7 bytecode: 33b0428205d23a2e03c265edac88f7b98fcfb7769b86ee0508128e68069b5b46 diff --git a/tests/expectations/compiler/integers/i128/add.out b/tests/expectations/compiler/integers/i128/add.out index 93ae3c778a..a48ec29d34 100644 --- a/tests/expectations/compiler/integers/i128/add.out +++ b/tests/expectations/compiler/integers/i128/add.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: d189fe8b28b7c36c871e03c2a86c8942aa2fea5e4b1c059bff5396293fd16944 - unrolled_ast: d189fe8b28b7c36c871e03c2a86c8942aa2fea5e4b1c059bff5396293fd16944 - ssa_ast: 4eb45856236a2aec21eee3587586bca6f012ef68e4885328f0ec0799988bd944 - flattened_ast: 11b3cffdbd8f6bbabc8f619e77c80e56dfd9afff9eff861f7190d9575329caaa + - initial_ast: 09800387836633ae681573ed23071c36ba768b04e4d1ace2e68dd81ff58e1f8f + unrolled_ast: 09800387836633ae681573ed23071c36ba768b04e4d1ace2e68dd81ff58e1f8f + ssa_ast: 2f02ad7d8893241fe0701045abf0417e023fc9952e3def17623d4f24df34964b + flattened_ast: 3848bb69bf1487f5d678279b17a82d7d8996b0ab03c0aff50f18619d9b31a3d8 + inlined_ast: 3848bb69bf1487f5d678279b17a82d7d8996b0ab03c0aff50f18619d9b31a3d8 bytecode: 6f3edf18242106629627faa1e59807276fabe9703a44c467ab0869035a916e59 diff --git a/tests/expectations/compiler/integers/i128/and.out b/tests/expectations/compiler/integers/i128/and.out index fe358cd0d0..04dec4faf4 100644 --- a/tests/expectations/compiler/integers/i128/and.out +++ b/tests/expectations/compiler/integers/i128/and.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e0cb5b24cd7e6dbda157f7aa0295bde5b3859367ef497673aa50fe0990f1d50e - unrolled_ast: e0cb5b24cd7e6dbda157f7aa0295bde5b3859367ef497673aa50fe0990f1d50e - ssa_ast: 4432815bfb84d4bc36106dd593c1b0779bf0d4874687b7838f45a091accf8213 - flattened_ast: ee02b0137f2b5e86e7ab98d27d1a4ab3136cb1a106eabb7e7bc49c033fe40283 + - initial_ast: b807f509b3094310b447d8eaa0605962905cfb9abbc45e214c8e307c43695515 + unrolled_ast: b807f509b3094310b447d8eaa0605962905cfb9abbc45e214c8e307c43695515 + ssa_ast: 480bc825f7733fbe9440be43fc32101d634c72cf63c22042865eeb8d54700454 + flattened_ast: 6f04dd20f5e62b04236fcf7c47eba78eb6af0555d6278afc2fc347a691790dbd + inlined_ast: 6f04dd20f5e62b04236fcf7c47eba78eb6af0555d6278afc2fc347a691790dbd bytecode: d3d6361fcc04fcc6102c91ec93ca087f2248b8868883a216282223937942b9ff diff --git a/tests/expectations/compiler/integers/i128/console_assert.out b/tests/expectations/compiler/integers/i128/console_assert.out index 17c8430a4d..92ece51527 100644 --- a/tests/expectations/compiler/integers/i128/console_assert.out +++ b/tests/expectations/compiler/integers/i128/console_assert.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 430e69cefed74391fe5a5de982090eee7ef96575bfd3fc04ff3d1a3623be65b0 - unrolled_ast: 430e69cefed74391fe5a5de982090eee7ef96575bfd3fc04ff3d1a3623be65b0 - ssa_ast: a912f5c92b89cf2a00e8a66b3e8f46569d11f97f765f9d5833a587e1d23845bc - flattened_ast: 46ec14d163ad58816884cf8aa5461f2726df0deb258d737bccae8a577b4b9c3a + - initial_ast: c240883b826b167ea2db9025caf789512a88cb52568c9f67e3c8a3b94efcbe54 + unrolled_ast: c240883b826b167ea2db9025caf789512a88cb52568c9f67e3c8a3b94efcbe54 + ssa_ast: 20e0b2fb427dcf7c1c7ed9a4e3c2f22f3980b4402fe8b8415c618baa4676aa34 + flattened_ast: d7ea40e2c1f9478f7c14c6a29d1c4cb6616aa820a00609531f29444be505c258 + inlined_ast: d7ea40e2c1f9478f7c14c6a29d1c4cb6616aa820a00609531f29444be505c258 bytecode: d865e47d55dd534c79a7f0abc2a97c569a9195a3579412a415379b6131003628 diff --git a/tests/expectations/compiler/integers/i128/div.out b/tests/expectations/compiler/integers/i128/div.out index 874ec4b14d..9a95fa49b4 100644 --- a/tests/expectations/compiler/integers/i128/div.out +++ b/tests/expectations/compiler/integers/i128/div.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: a855bb1bed2d8bf27d37ea893758dddf23a1d1f3ab7e53bf7045627769654f00 - unrolled_ast: a855bb1bed2d8bf27d37ea893758dddf23a1d1f3ab7e53bf7045627769654f00 - ssa_ast: b2f4a4cc16abdcb6a4da0d448860e132a019d2c35aa433e21288fee5ab1dbe60 - flattened_ast: 91cf630edd9ec636fdae558e655aff2523e0fa4990adeabbf5d24026313a4ec5 + - initial_ast: d3f8cbc4837ba1b9754b3855afc124ad5b80b2993588799f5418eeda0f2633fe + unrolled_ast: d3f8cbc4837ba1b9754b3855afc124ad5b80b2993588799f5418eeda0f2633fe + ssa_ast: 5d2245475f2786417fbd3f2bfb1fb8c04bbdd4f5604c1e199057c7005cd528a3 + flattened_ast: 7c6e8b9ac6e3cbfe263e20973e0bae98348b6713c4d5daf9359448412284152d + inlined_ast: 7c6e8b9ac6e3cbfe263e20973e0bae98348b6713c4d5daf9359448412284152d bytecode: 6a831f79614e36f29287d0c38c39352d1563a85cfd3d1ffcda037ce3dd6f32bd diff --git a/tests/expectations/compiler/integers/i128/eq.out b/tests/expectations/compiler/integers/i128/eq.out index 3bdc5874b3..8d9b39117c 100644 --- a/tests/expectations/compiler/integers/i128/eq.out +++ b/tests/expectations/compiler/integers/i128/eq.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 314179c813e78e89afacf2698d5f3a9509df02c9c05102404cc3ccb9838d919a - unrolled_ast: 314179c813e78e89afacf2698d5f3a9509df02c9c05102404cc3ccb9838d919a - ssa_ast: 99d92ee25742219c66ad49cf9e23d26e1d25ee1e8b6ef9c57518ecdb1aeda6cf - flattened_ast: 2c98a4d126ef3c0180aac7c29ca22d3e6f82022f52a45eded7a51d68e63e078c + - initial_ast: dda837a8180f20e72977f385e2c8a8e6a04ff68df8dc0fda6763ff7de5ce063d + unrolled_ast: dda837a8180f20e72977f385e2c8a8e6a04ff68df8dc0fda6763ff7de5ce063d + ssa_ast: bba57260a95706f4f05130a3faa698016f3d2bf3c6e9dabb2741c205d0600f5f + flattened_ast: 75ef9e42f15a6816413b79c45cde5032579254e797d83831a11dcf91926ac180 + inlined_ast: 75ef9e42f15a6816413b79c45cde5032579254e797d83831a11dcf91926ac180 bytecode: 0497ce2fbdcd7212261295b10194407589572843d8ab24596f194c486ca2ea8a diff --git a/tests/expectations/compiler/integers/i128/ge.out b/tests/expectations/compiler/integers/i128/ge.out index 016ddffb22..681f08a0ea 100644 --- a/tests/expectations/compiler/integers/i128/ge.out +++ b/tests/expectations/compiler/integers/i128/ge.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e124b477251252c4e52d4cc96cea5704ace30e2cc6f84103a528c002d109da19 - unrolled_ast: e124b477251252c4e52d4cc96cea5704ace30e2cc6f84103a528c002d109da19 - ssa_ast: 094aa869fbaae46eb578015aaf9a4501039c64672987aaa6e96e76dff9f67c84 - flattened_ast: ed17ac922a947b4ea6696d2eacef910bb0921e67fe53aa00c9670b0c1a69eea2 + - initial_ast: f726529ab42bbd445cd3c0aeed70d2cd6d1c75746bbb89ef8721c7229ea21016 + unrolled_ast: f726529ab42bbd445cd3c0aeed70d2cd6d1c75746bbb89ef8721c7229ea21016 + ssa_ast: 53e214ec2ba7534cc6379668320cb4a1034467a36d099085b5ac8f36b2827654 + flattened_ast: a6454ab1c865e41906eaabe02ad435c8ab450be97f5673fb98fb1f7c49344ffa + inlined_ast: a6454ab1c865e41906eaabe02ad435c8ab450be97f5673fb98fb1f7c49344ffa bytecode: 305c7f46ca9ad5640019699025196349bbc986ebc1532a17600e41d048df3d97 diff --git a/tests/expectations/compiler/integers/i128/gt.out b/tests/expectations/compiler/integers/i128/gt.out index f25a1e2b3e..0e61aee565 100644 --- a/tests/expectations/compiler/integers/i128/gt.out +++ b/tests/expectations/compiler/integers/i128/gt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: afc0761d407235f3f42ebd1a8bd96e6b1a6c6b551b8bbbfbb52e3c83a6786932 - unrolled_ast: afc0761d407235f3f42ebd1a8bd96e6b1a6c6b551b8bbbfbb52e3c83a6786932 - ssa_ast: 22709e954c12c74215000b8b621d171608165c43e5938bb1efdc2f47ba8a8ec3 - flattened_ast: 9b7dd9ac8d93a9bc0347bcc0d9a5719f0bd9bf935ecc46f6c1506bf4231e5b6d + - initial_ast: a999ba6783e75155ac4b78f40302f4644deede47b94296098302398581e96e74 + unrolled_ast: a999ba6783e75155ac4b78f40302f4644deede47b94296098302398581e96e74 + ssa_ast: 2325557531c7246271a84aa971309952cfaceb99a1e64b5b3ef57487faa45637 + flattened_ast: 5ee1d1befc3103cac9a91bfe8b7e165a7cc46c8cd524043768255ea9bd48936d + inlined_ast: 5ee1d1befc3103cac9a91bfe8b7e165a7cc46c8cd524043768255ea9bd48936d bytecode: 9abaadb0253d49dfeee51800854119b7464f14158804826e78f6ab145ffe63e9 diff --git a/tests/expectations/compiler/integers/i128/le.out b/tests/expectations/compiler/integers/i128/le.out index 75bb2589ec..d617bedcca 100644 --- a/tests/expectations/compiler/integers/i128/le.out +++ b/tests/expectations/compiler/integers/i128/le.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: f46e78aaae54009bac9a12e37ae17f9a6580d733ff8b5ed21cf487f291675220 - unrolled_ast: f46e78aaae54009bac9a12e37ae17f9a6580d733ff8b5ed21cf487f291675220 - ssa_ast: 860df825dfc234d8409d436d10a90a35101326c7a32a83dca5c2873a2911e341 - flattened_ast: 7e2e910843110f19826ba2fbb5397050ba029e0038b9e5aec533122aa546c8aa + - initial_ast: 29dc76537853317079fb5eecf438efeff2a20536e87705180122db5661a85433 + unrolled_ast: 29dc76537853317079fb5eecf438efeff2a20536e87705180122db5661a85433 + ssa_ast: a67527b38b38525dc2a8b252ce60795d8f1f57806981550734b236920ed69925 + flattened_ast: 9fb5a9189a34aa4e2b43d9e03522215ff65af82fa8b5ec4b4760299f482a0ba1 + inlined_ast: 9fb5a9189a34aa4e2b43d9e03522215ff65af82fa8b5ec4b4760299f482a0ba1 bytecode: 8f31c696966ee1357b25d09dbad473b72482970eafed6a581aa90d13134dfb09 diff --git a/tests/expectations/compiler/integers/i128/lt.out b/tests/expectations/compiler/integers/i128/lt.out index 6c41e0590a..742789da2d 100644 --- a/tests/expectations/compiler/integers/i128/lt.out +++ b/tests/expectations/compiler/integers/i128/lt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: f6309e8478b5a8e2c8c5f455a5b0335de448029eeda9023fba17f9d12109bfe8 - unrolled_ast: f6309e8478b5a8e2c8c5f455a5b0335de448029eeda9023fba17f9d12109bfe8 - ssa_ast: 0b898c35a71a64e1347e1c3a34e4db9b72b8fa46dfe7a363ee0a027ac8c56d42 - flattened_ast: 74f35d0a8b11e1b1e501f1c8c872b27e526b94b76ad01b0bdcc2f0f516812bb3 + - initial_ast: dba5a3bb2de91ecfd6e2943fe661f46b369279e6b60c904d8e38c7859d2a7ab4 + unrolled_ast: dba5a3bb2de91ecfd6e2943fe661f46b369279e6b60c904d8e38c7859d2a7ab4 + ssa_ast: 2d334ebb3fb5aea4f78dfcf9ef83267de38bc1d914fe990743562755767cb322 + flattened_ast: 3f1992f161804d90681b7500f183f6809881b43689b7dff4b0e0350f12a662d2 + inlined_ast: 3f1992f161804d90681b7500f183f6809881b43689b7dff4b0e0350f12a662d2 bytecode: 3b4376c236be3332bde01a7d6beabda973f64e777ee81bc17c2b082c8fb34d80 diff --git a/tests/expectations/compiler/integers/i128/max.out b/tests/expectations/compiler/integers/i128/max.out index 064fbc4b96..1246fed677 100644 --- a/tests/expectations/compiler/integers/i128/max.out +++ b/tests/expectations/compiler/integers/i128/max.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 67950aac7e791df4b5547ad01ce7322f22ba9c650ecc92012a54b6c5d2256d04 - unrolled_ast: 67950aac7e791df4b5547ad01ce7322f22ba9c650ecc92012a54b6c5d2256d04 - ssa_ast: f9046d8edf4629c2f371bd0e6dc917165f3987de68bddf0ba1a974eac6249284 - flattened_ast: f7cfdcde1a8e19702ab37edeab8b3077e4935fdf481c8dd030ff1ff64413aec3 + - initial_ast: fe3697f7d1caadc5b0be81ae4e63d63fc6d0d1a9962c92f146224436f8b0c41d + unrolled_ast: fe3697f7d1caadc5b0be81ae4e63d63fc6d0d1a9962c92f146224436f8b0c41d + ssa_ast: b91dad585db06fc37ad1deabcf694fb17ff054ebc527815c608a6b47cc647d12 + flattened_ast: c3f90dfda9068aed1550ae25cb0e4125e9bce765e4a00616c6e2f542d9921a19 + inlined_ast: c3f90dfda9068aed1550ae25cb0e4125e9bce765e4a00616c6e2f542d9921a19 bytecode: 4a17c14a9beba81a7b8177ff19eb147431b1d5769cca507dfe8cbce02a29ae1d diff --git a/tests/expectations/compiler/integers/i128/min.out b/tests/expectations/compiler/integers/i128/min.out index 1ff4f5ea3b..c50a3064d7 100644 --- a/tests/expectations/compiler/integers/i128/min.out +++ b/tests/expectations/compiler/integers/i128/min.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 655033e68000f0abae9dfde77abbbd9484ff0c95bc6c8230c8a8d335e8a6882c - unrolled_ast: 655033e68000f0abae9dfde77abbbd9484ff0c95bc6c8230c8a8d335e8a6882c - ssa_ast: 8fdbe08df76b8185f6defa52503668a41409cd6636b63029880c1bfd3dd94586 - flattened_ast: c06ea99c57dbe8e033e06582c7d64ce254bb0f79ac954fbc3684a6ee5a958cee + - initial_ast: a38e415c9dddc3301e239a2bc4e8bc4cda3832595c80c6767b0498a31e9bb2ae + unrolled_ast: a38e415c9dddc3301e239a2bc4e8bc4cda3832595c80c6767b0498a31e9bb2ae + ssa_ast: 35e014ae5d9539afb5d94a52c07dcac30796fd0346f871d8dd7475696939879b + flattened_ast: 6f947b23102ec39346fd657f2329f670a18704f2cd2caa5a35b6feebc691526b + inlined_ast: 6f947b23102ec39346fd657f2329f670a18704f2cd2caa5a35b6feebc691526b bytecode: 5dd12bea92c7275bd2ef924ed8006f84593cd73bd7a517088f3350735d320ed6 diff --git a/tests/expectations/compiler/integers/i128/min_fail.out b/tests/expectations/compiler/integers/i128/min_fail.out index 003e9c9c20..b588e43731 100644 --- a/tests/expectations/compiler/integers/i128/min_fail.out +++ b/tests/expectations/compiler/integers/i128/min_fail.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 711bcf0e920537e99779ae3725c86b9f2758e0df6129a92641c2041b0242946b - unrolled_ast: 711bcf0e920537e99779ae3725c86b9f2758e0df6129a92641c2041b0242946b - ssa_ast: 8f2d46e2c444560a5a3cfaf1bcb8fc7480b9f5881708fe5e43c49cb112319137 - flattened_ast: b6428fe05f919c3584f24eda3779191dd33f6b5a44b5835b8d58258510139d03 + - initial_ast: 5cb7f18400477e5c233d7c5a40f7b0fc1dd380d0dac1132461eb497048630e19 + unrolled_ast: 5cb7f18400477e5c233d7c5a40f7b0fc1dd380d0dac1132461eb497048630e19 + ssa_ast: 58deb613e423d7a5c680ab4efb0df87d54f4567a87337cac43b5385a341bda08 + flattened_ast: 7f7e8f021084d372d2951853e4d5912dd13be8f66995b0495f60c7559d83ec9b + inlined_ast: 7f7e8f021084d372d2951853e4d5912dd13be8f66995b0495f60c7559d83ec9b bytecode: 8514f62e239ece8b0cd2f7bc3c6b259ceeca8b9d921b0a3a167875814febe9d2 diff --git a/tests/expectations/compiler/integers/i128/mul.out b/tests/expectations/compiler/integers/i128/mul.out index e7acc8e41b..76e6db9d3f 100644 --- a/tests/expectations/compiler/integers/i128/mul.out +++ b/tests/expectations/compiler/integers/i128/mul.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b4fb5f080e02c918f3ec0079da577b7d10da85b7a27c297d9bdd76c8ac4896a4 - unrolled_ast: b4fb5f080e02c918f3ec0079da577b7d10da85b7a27c297d9bdd76c8ac4896a4 - ssa_ast: 4b148681615e0cb140b614139a7b22ee5838b9dfa059fd87dfd70368df012c6b - flattened_ast: 8d18710dbe4975b06e19edfcb58754fa477b1d7781b3b31d674ee2cd0195e3f2 + - initial_ast: 75a27a782802300b3cc172cd9d316882b1e6d9060fb4cc846ef8d2d7db26b0fe + unrolled_ast: 75a27a782802300b3cc172cd9d316882b1e6d9060fb4cc846ef8d2d7db26b0fe + ssa_ast: 724df8594df1fed020d4ad386ea25eb54359eec65040ec005f50acc7549c8d9b + flattened_ast: e15ca26e2a432dd7093e23fbaa617defdc16b63473ac6a1c719e7a9a3ddbac0f + inlined_ast: e15ca26e2a432dd7093e23fbaa617defdc16b63473ac6a1c719e7a9a3ddbac0f bytecode: cf239c5d4821dc939540cb2317a2713906d1f552cf8f31e1ba4e0f37a92b8a35 diff --git a/tests/expectations/compiler/integers/i128/ne.out b/tests/expectations/compiler/integers/i128/ne.out index b7c812f18e..b3bfb39c86 100644 --- a/tests/expectations/compiler/integers/i128/ne.out +++ b/tests/expectations/compiler/integers/i128/ne.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 6705c4af4cab75cf1df851fca1a43d4dfa154705c5f2bc2791ea2aa2a580b490 - unrolled_ast: 6705c4af4cab75cf1df851fca1a43d4dfa154705c5f2bc2791ea2aa2a580b490 - ssa_ast: e1f4434d0bb9736387f28f2212a3c7dd22dc27221ab51bd33fc6786532961b86 - flattened_ast: 6414384571c5a21f543ac4fee184d0e68f1e58b0075689674cdb02e076b7f790 + - initial_ast: e7854ad0c98fd2939313666c6c315e1671ca402941cf4a2832c02c1158a933cd + unrolled_ast: e7854ad0c98fd2939313666c6c315e1671ca402941cf4a2832c02c1158a933cd + ssa_ast: ee79e0cd84ec73b44d0ca00d306cf72095160c5d08e8e02e970c8e631b89f72c + flattened_ast: e8f1ed69f803fd1b7bb8a7fcefc489b5d6b355ea35838368ba025f972459bc88 + inlined_ast: e8f1ed69f803fd1b7bb8a7fcefc489b5d6b355ea35838368ba025f972459bc88 bytecode: 1fdfc70503d61138eccaa03367363c5e3b5c46f439fa5e9666f34f1b795e4998 diff --git a/tests/expectations/compiler/integers/i128/negate.out b/tests/expectations/compiler/integers/i128/negate.out index b919b6066f..5a2742aef4 100644 --- a/tests/expectations/compiler/integers/i128/negate.out +++ b/tests/expectations/compiler/integers/i128/negate.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: a133d7aed17a86ee23adba1d649d0aa0b2208e139eca8b2bb68c048c62b4a22d - unrolled_ast: a133d7aed17a86ee23adba1d649d0aa0b2208e139eca8b2bb68c048c62b4a22d - ssa_ast: 8c466028bd0eac80b4fb2d51175d98f91b9b7cc1b9805be0bd717742cd4dc107 - flattened_ast: 558c98ce88c995c445dd253118e17fc17dd53f1d980f4f11b492e86cd9f30f49 + - initial_ast: 6d2d9fdf337248c6f6ba13f0dba6164547855a3352467dff33d6929810f3e864 + unrolled_ast: 6d2d9fdf337248c6f6ba13f0dba6164547855a3352467dff33d6929810f3e864 + ssa_ast: 03858ad60cbdfddf5b82d406c5bf0e58f7a5261ba4b7edc474efb2ef090f969d + flattened_ast: 8478013efd02e41b60fe74a43dc9ff3233dd62da8d5f40bc0654f08f8a11878c + inlined_ast: 8478013efd02e41b60fe74a43dc9ff3233dd62da8d5f40bc0654f08f8a11878c bytecode: 7cd3cce37a87bb48f44b2f44e37be5e1821abfc3d73d7ab6a5e7e96c72f8f091 diff --git a/tests/expectations/compiler/integers/i128/negate_min_fail.out b/tests/expectations/compiler/integers/i128/negate_min_fail.out index 91c6ee9ba1..b3196fd94c 100644 --- a/tests/expectations/compiler/integers/i128/negate_min_fail.out +++ b/tests/expectations/compiler/integers/i128/negate_min_fail.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5ded4174b536a02944bc27a36fc9c6f2a4a51558da05eb6574efcb5da88ef6c7 - unrolled_ast: 5ded4174b536a02944bc27a36fc9c6f2a4a51558da05eb6574efcb5da88ef6c7 - ssa_ast: 5e6aa992e4bc756d9651507f9a1ee732cc824c2c7013708a10c284f38e26654d - flattened_ast: 0495861b8de56ee0e490bafacac0ceff52c442bdbc0821b824a775df0efff141 + - initial_ast: 9c94ddcfd6eb76da0b195471d1d1c94e3f1900a33a5379e54c940312bd46c958 + unrolled_ast: 9c94ddcfd6eb76da0b195471d1d1c94e3f1900a33a5379e54c940312bd46c958 + ssa_ast: 7f992f62357bc9183f143a71f6577ef2d83eb39e7a1c84414adee1cfddd65e89 + flattened_ast: 23a42e341e4dea017a3214189f0b64bbb360fe44025f73f54720a028ee8aadec + inlined_ast: 23a42e341e4dea017a3214189f0b64bbb360fe44025f73f54720a028ee8aadec bytecode: 494ae1254dbca57e7dedbc2d9e21e837803b3124a21a87bdba507780a7e14fd7 diff --git a/tests/expectations/compiler/integers/i128/negate_zero.out b/tests/expectations/compiler/integers/i128/negate_zero.out index f2414e13a8..803f79c719 100644 --- a/tests/expectations/compiler/integers/i128/negate_zero.out +++ b/tests/expectations/compiler/integers/i128/negate_zero.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 0a0034b90fb853ef8a3fe279a2aef9c782decf3d6d8089fd15d17c57a4175e4b - unrolled_ast: 0a0034b90fb853ef8a3fe279a2aef9c782decf3d6d8089fd15d17c57a4175e4b - ssa_ast: 1115ec764603c47cbad7ffe307b6505df3c7ab67ba7d7d26c9ec714b9c694dd2 - flattened_ast: a96b8fd2115e4390c9d2366f850c3f320c6d8cc54f9f4e5bb059832ddb8765bb + - initial_ast: 398cc3af36c1c28246afb789dd78caddd25f17601d9ca99f97e2337208ad0d73 + unrolled_ast: 398cc3af36c1c28246afb789dd78caddd25f17601d9ca99f97e2337208ad0d73 + ssa_ast: 7d0e91dca9a7c2b0874c6099c5af2a39d8a6dfa6d4bfc53649a4b04299bf93f5 + flattened_ast: 778e60326f04840d1905d3fb04090ca471bb5c90190879c0e086c1f09c7165c4 + inlined_ast: 778e60326f04840d1905d3fb04090ca471bb5c90190879c0e086c1f09c7165c4 bytecode: e6204df8c165d3c5fc23fa09299a67fc651c5ab297ce3d7ddab7766d7b360857 diff --git a/tests/expectations/compiler/integers/i128/operator_methods.out b/tests/expectations/compiler/integers/i128/operator_methods.out index 38ef3f1211..f08b0f37f5 100644 --- a/tests/expectations/compiler/integers/i128/operator_methods.out +++ b/tests/expectations/compiler/integers/i128/operator_methods.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: cf3f5321a65b327de126fef12fee797f58b8f1e67a0ff99b1caa26c71b8e3ef1 - unrolled_ast: cf3f5321a65b327de126fef12fee797f58b8f1e67a0ff99b1caa26c71b8e3ef1 - ssa_ast: dbcc3625b2bf2ca1e1186e454c2ffa74c99f7e766cdc39fa18768cf0871ea9e4 - flattened_ast: 0563d02599f8b2247d164d7bbf088fa57b32956da7dd209ad4e760828349c461 + - initial_ast: 6b89d3bab13e52897bf04b9235e31a3e5bfdab7fe60a2dcc9ab926be141abb4f + unrolled_ast: 6b89d3bab13e52897bf04b9235e31a3e5bfdab7fe60a2dcc9ab926be141abb4f + ssa_ast: 0b44d837ff2020c4a6ede3595577a20231ea57034673a0471fd73e6234ae6232 + flattened_ast: 20be84b5b3ee1bd280628f71c0d075cb74ff40ffa718d8b2efa58352ffd79fba + inlined_ast: 20be84b5b3ee1bd280628f71c0d075cb74ff40ffa718d8b2efa58352ffd79fba bytecode: 379a43829001f6d142c2f738b3849505a90c255244d02c8581ab405cc8bd8afa diff --git a/tests/expectations/compiler/integers/i128/or.out b/tests/expectations/compiler/integers/i128/or.out index f9e045398a..fef5cd00c2 100644 --- a/tests/expectations/compiler/integers/i128/or.out +++ b/tests/expectations/compiler/integers/i128/or.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 0d2139956268ba3da2b68064907148961cdf24ab0d9787be3503cbe648b965ce - unrolled_ast: 0d2139956268ba3da2b68064907148961cdf24ab0d9787be3503cbe648b965ce - ssa_ast: 570e75c1074001f1f7472499b2ec0436acf2bf2e84eb7ffbab8b05c76b17cb9d - flattened_ast: 9ce4368b29320061431c5a443be2b5d33457b3d021c02a1b50638dfbeb394a6f + - initial_ast: 1c282a2eae95ea57f270a429860443fd6a81ee9db83a94935cb7c689ed1473d5 + unrolled_ast: 1c282a2eae95ea57f270a429860443fd6a81ee9db83a94935cb7c689ed1473d5 + ssa_ast: 2a8017edf038722b73227c0308af6161a670372d2d99cd496a736d7d86494642 + flattened_ast: c9845d2324396337d84943c519c8329cf5dbbd900458789db557e9f78e6d6a31 + inlined_ast: c9845d2324396337d84943c519c8329cf5dbbd900458789db557e9f78e6d6a31 bytecode: d262f60575627f8c4757304c45cd849e4b92b9ea44f0b342b12fa14c49d717ab diff --git a/tests/expectations/compiler/integers/i128/pow.out b/tests/expectations/compiler/integers/i128/pow.out index 43572ac9a1..c093bba6ee 100644 --- a/tests/expectations/compiler/integers/i128/pow.out +++ b/tests/expectations/compiler/integers/i128/pow.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: dce7e36daed4b4f7bc9fec2930808cf5e6e09dcfc7e5efa19485cb679b2ebf55 - unrolled_ast: dce7e36daed4b4f7bc9fec2930808cf5e6e09dcfc7e5efa19485cb679b2ebf55 - ssa_ast: b0c280050c730d4dc74745727882eb0f7b1b0f70cfd0895b553d003bc5906eca - flattened_ast: c7aa06a57eaa5be0424c58d7dc1da3bc28a302ca9f568a93355b2b7cd90258cd + - initial_ast: e3b5454917a0cf6c9476a28ad4e31287c0bc902b0d0b333797e681e88fa64ad5 + unrolled_ast: e3b5454917a0cf6c9476a28ad4e31287c0bc902b0d0b333797e681e88fa64ad5 + ssa_ast: 1a98abd515be7b4f957f31fa905afaa59f4c3b855131f748f5d097b90b7d675e + flattened_ast: e45a94f688f9e5c6774951a95185f0ef6a21add5824cb49e658bf29371de1226 + inlined_ast: e45a94f688f9e5c6774951a95185f0ef6a21add5824cb49e658bf29371de1226 bytecode: dfd9659f15094e672f456a9603906d5babfca253c2b3098bc07e49aac07ca022 diff --git a/tests/expectations/compiler/integers/i128/rem.out b/tests/expectations/compiler/integers/i128/rem.out index 2928155439..8acd4b6c0f 100644 --- a/tests/expectations/compiler/integers/i128/rem.out +++ b/tests/expectations/compiler/integers/i128/rem.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 31eea787b1cdc1b5954efa413e56865f7bbb2c24de1c6fcf6b95e5d58e59e5a2 - unrolled_ast: 31eea787b1cdc1b5954efa413e56865f7bbb2c24de1c6fcf6b95e5d58e59e5a2 - ssa_ast: bf2ba7abf710e8fe2cc789cea659ba32b515f268540d583e40f0d8f3dde77d28 - flattened_ast: 9f166726d1ee8e57a56dbca1ff0b8e9140c710eacb93ec8bebd964ab6d04e40f + - initial_ast: b3fc5f1c805eb5f041af70eaae5c932f97d3c8ecbfd87cd0068c5147bab965c2 + unrolled_ast: b3fc5f1c805eb5f041af70eaae5c932f97d3c8ecbfd87cd0068c5147bab965c2 + ssa_ast: 748a5b3183f1217b43b8ef06190693a554b2fce723824bf65e8019c65c44d4e1 + flattened_ast: 282c6fc22a149fa5c6efd58f3c9b40eccb417be5ac26095ee0ec18ecc3567e42 + inlined_ast: 282c6fc22a149fa5c6efd58f3c9b40eccb417be5ac26095ee0ec18ecc3567e42 bytecode: 632f8400deb0e0e0aebadd45f557698474142e78ea2628de28c2cd4f6617d413 diff --git a/tests/expectations/compiler/integers/i128/shl.out b/tests/expectations/compiler/integers/i128/shl.out index 4c4d9309eb..03f522ddec 100644 --- a/tests/expectations/compiler/integers/i128/shl.out +++ b/tests/expectations/compiler/integers/i128/shl.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5ed13cf5124fcc5700f3e93b9e1d5027c60c9d0b7ffe4579509c54386e0adcfe - unrolled_ast: 5ed13cf5124fcc5700f3e93b9e1d5027c60c9d0b7ffe4579509c54386e0adcfe - ssa_ast: 0622ae8caec4b070d8c04fe1c63068a2ebf69d55896832cb717da8257fbfcec5 - flattened_ast: 34b68f21728ed90574b51e8729a349aa2bf6b2c0fb7a56fa553b17708af97211 + - initial_ast: 5606e097af75ef020355df5e2f34637790e8bbe96fda0c42b2ebf91062fbfba6 + unrolled_ast: 5606e097af75ef020355df5e2f34637790e8bbe96fda0c42b2ebf91062fbfba6 + ssa_ast: 61f6fef784d65e8455466cbad402d307a756d395281c6bd45480846f16f1c68e + flattened_ast: 839df4abb90146f72f9ff56b2f96c5908a03a30cfd04e6aaa846cfb8170c40d1 + inlined_ast: 839df4abb90146f72f9ff56b2f96c5908a03a30cfd04e6aaa846cfb8170c40d1 bytecode: f29d4cc186e6bc24ca0b6e70e5845295b29a2c1f1e9f46f635c90e66ef0e588d diff --git a/tests/expectations/compiler/integers/i128/shr.out b/tests/expectations/compiler/integers/i128/shr.out index 7d82bf9dd4..bde0d0080c 100644 --- a/tests/expectations/compiler/integers/i128/shr.out +++ b/tests/expectations/compiler/integers/i128/shr.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 0dd8a1bac58e34fe63a33e3fb1cd1a7b4f9543b6fe02ba6ba77744102ae3db2b - unrolled_ast: 0dd8a1bac58e34fe63a33e3fb1cd1a7b4f9543b6fe02ba6ba77744102ae3db2b - ssa_ast: 6748714f0a04106cba5c9c4e4d188ab8001e7491818c5f35e7f02bcfddcbe59b - flattened_ast: 1dfc8f3c24f2497c06c701435d1671c74497a48ffb34957a464022bc5bc0705f + - initial_ast: 078c448f122af181952bd73df7b827f019828d16480e4220caa13372f683fd31 + unrolled_ast: 078c448f122af181952bd73df7b827f019828d16480e4220caa13372f683fd31 + ssa_ast: 648f2cd65c4103b62eeb508112a2945b87282b86b7b88466da7d631598304327 + flattened_ast: 1c47bcea52c7244a19943927beb9c2036b01000ee022755e02a07b678fe089ce + inlined_ast: 1c47bcea52c7244a19943927beb9c2036b01000ee022755e02a07b678fe089ce bytecode: 6a4fa49e165ac0c731dd78a8c05ced2418d69ced736d07ddbb3a07c50bcf6b37 diff --git a/tests/expectations/compiler/integers/i128/sub.out b/tests/expectations/compiler/integers/i128/sub.out index 003633aeea..6b46bff168 100644 --- a/tests/expectations/compiler/integers/i128/sub.out +++ b/tests/expectations/compiler/integers/i128/sub.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 48f37ac6323b6f12a7ae0f7c0da535ba85fa97c7fb7f99991778b10b02dfa2f2 - unrolled_ast: 48f37ac6323b6f12a7ae0f7c0da535ba85fa97c7fb7f99991778b10b02dfa2f2 - ssa_ast: aa6f0565527199c7c74bd4b8eb1d0f126a2c30cc42227eb8ef528e8101be65e0 - flattened_ast: 86185db302ca96d3ce37c4d5a85a3258c796b4b16f9b51a41867d27b52f0aa40 + - initial_ast: 53a2d219204076fa6eed972bb3383814d159a6f40f42c0cf4296f816ac8d2916 + unrolled_ast: 53a2d219204076fa6eed972bb3383814d159a6f40f42c0cf4296f816ac8d2916 + ssa_ast: 3ac91e399deb372a4ceecbb6462941572da0d2a384b8fe6d592ea24f27a0a7d4 + flattened_ast: 29e10f37e5eb1c3d7cfafe3e5ca42ec27c5c3887d57601c18e3179233c4f151e + inlined_ast: 29e10f37e5eb1c3d7cfafe3e5ca42ec27c5c3887d57601c18e3179233c4f151e bytecode: 07685949b1e45db55522bf01298e4cd0ba6b2818a8212365c12f468ed061a731 diff --git a/tests/expectations/compiler/integers/i128/ternary.out b/tests/expectations/compiler/integers/i128/ternary.out index 86a087ec60..f9b9142134 100644 --- a/tests/expectations/compiler/integers/i128/ternary.out +++ b/tests/expectations/compiler/integers/i128/ternary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1c5f83296430b3bc6b756bc623e55be9757e1df35a47cd86aff0fee695b4f92a - unrolled_ast: 1c5f83296430b3bc6b756bc623e55be9757e1df35a47cd86aff0fee695b4f92a - ssa_ast: bf698ce134161c1c136e8102d697cd7b7f7451b9a83cf15a6e1b343e18a4fdde - flattened_ast: 156f2ebaddfc81fd9d54891855ccfda54db34c5a78c137c75da5e2a3c76cca9a + - initial_ast: ab0c99a87e7816beaa6618981c8d8d3cf0fbe4cbb1a26d15891248791a1b530d + unrolled_ast: ab0c99a87e7816beaa6618981c8d8d3cf0fbe4cbb1a26d15891248791a1b530d + ssa_ast: 1c907200062ca8354448ecdfc23e2f943d10154850a67f6e7da0eb215851a959 + flattened_ast: 361730e669b78f7a9beab3d9fa6a26bb68ec6003a859681f1146e87a08583086 + inlined_ast: 361730e669b78f7a9beab3d9fa6a26bb68ec6003a859681f1146e87a08583086 bytecode: 1b5ee12236a81275c1c8597e6956c715050077486831d3900e20d9053433ac2d diff --git a/tests/expectations/compiler/integers/i128/xor.out b/tests/expectations/compiler/integers/i128/xor.out index 581df05e0b..fb0a886446 100644 --- a/tests/expectations/compiler/integers/i128/xor.out +++ b/tests/expectations/compiler/integers/i128/xor.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5d84eb96a2712f0442bc1ced7f737531bcfeb50669309ee0646bfdfd9c5d5247 - unrolled_ast: 5d84eb96a2712f0442bc1ced7f737531bcfeb50669309ee0646bfdfd9c5d5247 - ssa_ast: d548fc3fd808fedcc3444a25cbdeb1a5a20c15a69ce4733b222efd880bb795d7 - flattened_ast: a2a81aad78f99ca60e0768e3b02a8d6b53509e2d3716b9768e556b5e00933e6c + - initial_ast: 226d5ca7f311e2eb18a4069f233f0ea2142639faf64c1f37c975c9c6ef960fcf + unrolled_ast: 226d5ca7f311e2eb18a4069f233f0ea2142639faf64c1f37c975c9c6ef960fcf + ssa_ast: 12beb8682c2ba511dafaecf4000a5ff4172e6ce70f00cbd71b68904de34411d2 + flattened_ast: 42ad29e996e2e6159bbb1504538e6109783ade2e7bde85c15f6a39393c5f8eb2 + inlined_ast: 42ad29e996e2e6159bbb1504538e6109783ade2e7bde85c15f6a39393c5f8eb2 bytecode: 6431d8554d06ea3522030d1a433ef1f39fe17ac974b4ac60f8d18afc2a5e1f71 diff --git a/tests/expectations/compiler/integers/i16/add.out b/tests/expectations/compiler/integers/i16/add.out index cadcab1a51..3f8c83d7d3 100644 --- a/tests/expectations/compiler/integers/i16/add.out +++ b/tests/expectations/compiler/integers/i16/add.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: d06de10cebc94c12fb985c144934967c3cbe72b7dfdb3d1021f46674a8b10862 - unrolled_ast: d06de10cebc94c12fb985c144934967c3cbe72b7dfdb3d1021f46674a8b10862 - ssa_ast: cce4f1ee853faee4d002764c56fbc7ca239be0254d2a66020639595c73c66417 - flattened_ast: 4c839986bb12f66adfaa45d2c1e706c589ce0896afa8d4c9219221f2165da662 + - initial_ast: a2e35f61bd0b4923c588b8cd59fcbdd26bece9be0b9ddd3c99f81b0dd56338d5 + unrolled_ast: a2e35f61bd0b4923c588b8cd59fcbdd26bece9be0b9ddd3c99f81b0dd56338d5 + ssa_ast: 83733fe8a9f0c6774a59023658db4ba6a6b64c139fe12a57854509ae73b8bf6d + flattened_ast: 6cf98da8956399be277b0899491aaf166274765f54d7faf79af993c554c8d8ec + inlined_ast: 6cf98da8956399be277b0899491aaf166274765f54d7faf79af993c554c8d8ec bytecode: a61fbd6923f8bf087a21d6e2779b62e264d63a92071f34a762adc7eaf9cbbe28 diff --git a/tests/expectations/compiler/integers/i16/and.out b/tests/expectations/compiler/integers/i16/and.out index 4d29f6792f..b4ed36cba5 100644 --- a/tests/expectations/compiler/integers/i16/and.out +++ b/tests/expectations/compiler/integers/i16/and.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 11e2d2f6a5b4ef35cbcec8d94e1a9a140a9084f9c3b0da2f613d9f0f872f0aae - unrolled_ast: 11e2d2f6a5b4ef35cbcec8d94e1a9a140a9084f9c3b0da2f613d9f0f872f0aae - ssa_ast: f91a94924bbdde0d640419533736039a10d2bf48a535a699b7468d7eaf34cc16 - flattened_ast: 04c80e3a04ad7b65f43eea77e19764149947e8c9f0928341331f5fa0c7744fdf + - initial_ast: b355dc40937fc9c274f66259f6712fdb51d01603d3b466c1dbb4f964b17e1a79 + unrolled_ast: b355dc40937fc9c274f66259f6712fdb51d01603d3b466c1dbb4f964b17e1a79 + ssa_ast: 29dce3af75d158d4d722934e72377d4811fad6d0f5544a83e215d0befebe18fa + flattened_ast: 9f31c0e8d7a641d6eb4f80ace284a894eb5b3d524ec9c332a054777226296abc + inlined_ast: 9f31c0e8d7a641d6eb4f80ace284a894eb5b3d524ec9c332a054777226296abc bytecode: 5dad432ec3e9573b92eac45865218e8dc3c93ef477d7293d2a6867528faf0826 diff --git a/tests/expectations/compiler/integers/i16/console_assert.out b/tests/expectations/compiler/integers/i16/console_assert.out index 3d3f80cedb..a7040750a1 100644 --- a/tests/expectations/compiler/integers/i16/console_assert.out +++ b/tests/expectations/compiler/integers/i16/console_assert.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 6b37ab5b4f6aaa4064b6569803fbf42a93f235ade304d706dfe2e6db678e369a - unrolled_ast: 6b37ab5b4f6aaa4064b6569803fbf42a93f235ade304d706dfe2e6db678e369a - ssa_ast: 05733ff9d1d2ded2523838c0aa637b369cc83ce5b4c1aaf077a875221ef5191a - flattened_ast: 55fdd7f4accdd13918a184ccaad51988ed62528cdd97efd4e69f24405e0a4aff + - initial_ast: e68750d37fbd7249a0a36126a496257714d1bed91c92f81eaaac96bc5a315a3d + unrolled_ast: e68750d37fbd7249a0a36126a496257714d1bed91c92f81eaaac96bc5a315a3d + ssa_ast: 7660a58caad701434628d57b8cdaa2263873e648c6a7f62043592e625c077ade + flattened_ast: 738f79592b405b5349ae190f14796978a3c0b5c38e0e0c0d22bb3e8193c5fb73 + inlined_ast: 738f79592b405b5349ae190f14796978a3c0b5c38e0e0c0d22bb3e8193c5fb73 bytecode: 9d7d64b8d70d040e6e587e10d48e14c46ff63bffe4379f954f7749deffdf593b diff --git a/tests/expectations/compiler/integers/i16/div.out b/tests/expectations/compiler/integers/i16/div.out index c772fd1e39..b146ea6289 100644 --- a/tests/expectations/compiler/integers/i16/div.out +++ b/tests/expectations/compiler/integers/i16/div.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 4c899a62daf8b1efc45511d24210c3862e7b786c74ee575edeb9a64671ed50ba - unrolled_ast: 4c899a62daf8b1efc45511d24210c3862e7b786c74ee575edeb9a64671ed50ba - ssa_ast: 1a7fa9bba580ce79730123b095f2c2b29f873145d00dcb3f40ac18481e248593 - flattened_ast: c64d3b34a55cf2a1fb5037ef0f9ba483af518a3cd04eba0d9983d6c79c5af90f + - initial_ast: c2f3bd5431b74d90ec46c36f3dabd0b8ef55360dd67e8823183f2d574399f10a + unrolled_ast: c2f3bd5431b74d90ec46c36f3dabd0b8ef55360dd67e8823183f2d574399f10a + ssa_ast: 10c1684314e40ac52692ecbaef808dde4254dcb703126a65f6edc204cb71ff79 + flattened_ast: 35af048146e13b8e29c6e8afacd73bc1bccc033b657232068415a0ed15fa74e7 + inlined_ast: 35af048146e13b8e29c6e8afacd73bc1bccc033b657232068415a0ed15fa74e7 bytecode: 2e49ec96b230329d29aafbfb7dd025dfc1d94a410f17972055b103e5a1629646 diff --git a/tests/expectations/compiler/integers/i16/eq.out b/tests/expectations/compiler/integers/i16/eq.out index 5fb3644fd4..ec5030e3c3 100644 --- a/tests/expectations/compiler/integers/i16/eq.out +++ b/tests/expectations/compiler/integers/i16/eq.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: d6294529a76aec3464ea95296d80f861c4b6f4c89a3723ba1b7174b4a465b920 - unrolled_ast: d6294529a76aec3464ea95296d80f861c4b6f4c89a3723ba1b7174b4a465b920 - ssa_ast: 835a4f549fedcc9184166b90a7e60e63e53742b06ae18df370cca6a86f529b06 - flattened_ast: 2eabb640f035c7a44c304b0028d1f0f25919a4a4e96987f53f5a8cde71a643fc + - initial_ast: 4e987bf633b7f75ffe9c26430fdf31f952690856f5f3e81e70a37ce4e6db7a9b + unrolled_ast: 4e987bf633b7f75ffe9c26430fdf31f952690856f5f3e81e70a37ce4e6db7a9b + ssa_ast: 5c70a71177bc58e06867ec661facaa14945d01a5ec9432eb0d1bf589d8d295d8 + flattened_ast: 0bd3d3f23e14c3475259c9dc71d61cd3f2fcd3e3d3cf69da32481f033dcd2044 + inlined_ast: 0bd3d3f23e14c3475259c9dc71d61cd3f2fcd3e3d3cf69da32481f033dcd2044 bytecode: ae49e3dc309ac1fae7c4285e37e5a2dca653f25dfb4fbed5cab087d203c4c94f diff --git a/tests/expectations/compiler/integers/i16/ge.out b/tests/expectations/compiler/integers/i16/ge.out index 4757892df7..9bc8de27cb 100644 --- a/tests/expectations/compiler/integers/i16/ge.out +++ b/tests/expectations/compiler/integers/i16/ge.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 95cb312ce7b435e9596c1b7909c42f6ef611e2879f06123402139b600411413f - unrolled_ast: 95cb312ce7b435e9596c1b7909c42f6ef611e2879f06123402139b600411413f - ssa_ast: 3821bbbb5435a49f1d550e7f86562bd04cb0d668d5343e459b13616dabe303c6 - flattened_ast: c5392e2fab688c58cd33204a140a24e164c6a9c6be3fde0712ffeb3b6751f4ef + - initial_ast: 42ef6e17e9ce3447c220f1aba36faec7ae1359a2f82ca73104b7dd3aeebf2fa7 + unrolled_ast: 42ef6e17e9ce3447c220f1aba36faec7ae1359a2f82ca73104b7dd3aeebf2fa7 + ssa_ast: ca342636bc6d95e433b72d65d99440689af0da3ebce4d6fdb2ffcde0c4ecdf91 + flattened_ast: 30b152a6e109f3f335c2b32a3834ae5e50a1128af27ff995362485de38ae0c85 + inlined_ast: 30b152a6e109f3f335c2b32a3834ae5e50a1128af27ff995362485de38ae0c85 bytecode: afd97c7c25711fe41717b8f2cc653082f5d81466b099a490dae43e058605e7e4 diff --git a/tests/expectations/compiler/integers/i16/gt.out b/tests/expectations/compiler/integers/i16/gt.out index 947ec68fe4..1f6f7d83a0 100644 --- a/tests/expectations/compiler/integers/i16/gt.out +++ b/tests/expectations/compiler/integers/i16/gt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1ad895f524048c1450936e2c1697579519314006a7b7a62adeafa1079eb79b0e - unrolled_ast: 1ad895f524048c1450936e2c1697579519314006a7b7a62adeafa1079eb79b0e - ssa_ast: dd4ce87aa8c9e202c91f80526a8a394e1a1dbf07258a75d7c1f7322379e6ae1b - flattened_ast: a7c402da9412f2d74c5782812bdd709d0e193f4fd7ef181f1a874a3f6c288d2a + - initial_ast: f63bd997a8fd51ae6dabfe0a1f9d642c0f28ba4a593aba6e3491016d8e90e705 + unrolled_ast: f63bd997a8fd51ae6dabfe0a1f9d642c0f28ba4a593aba6e3491016d8e90e705 + ssa_ast: d1d7fb6696426a5a4f110828891add9addcf44fa9412129e677986b6f4dfee49 + flattened_ast: 04ba36ab1a209f4011492b0af604fddc3655ece716593c0548515f82a35395cb + inlined_ast: 04ba36ab1a209f4011492b0af604fddc3655ece716593c0548515f82a35395cb bytecode: f7802d16ffb5304531ce00063506d55ff82a24dd6aa659e96c46c37b597ec3e9 diff --git a/tests/expectations/compiler/integers/i16/le.out b/tests/expectations/compiler/integers/i16/le.out index 296772aaa6..1f011f16a2 100644 --- a/tests/expectations/compiler/integers/i16/le.out +++ b/tests/expectations/compiler/integers/i16/le.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 71904d7ae60a1275148b23f0bb8eaa8f153c285d474576dc805da1a5dd256eec - unrolled_ast: 71904d7ae60a1275148b23f0bb8eaa8f153c285d474576dc805da1a5dd256eec - ssa_ast: d0b82ba3081053e10dde3d3c89d881f47fba5f273457856e64955355eb52591a - flattened_ast: e09f1ef0d423cf6495be8f8548305895b468d8f7842124f73d5974646fd771b2 + - initial_ast: 781bfce16bae43749ebefb34df714227ec93b477e31478263f32374dc2b469a9 + unrolled_ast: 781bfce16bae43749ebefb34df714227ec93b477e31478263f32374dc2b469a9 + ssa_ast: 95f843a41fdc15c1948545f7dc68e5af2953a64728382d18ca96ec588fe3d5dc + flattened_ast: e2fd5403df811e2bfb3599842bfe3a0d5ee1f926569a66da5b920609fc6bb7d4 + inlined_ast: e2fd5403df811e2bfb3599842bfe3a0d5ee1f926569a66da5b920609fc6bb7d4 bytecode: 4098055f0ddcaeedbeb57f3ba3914a9ef47ad8cd114258f04ff47dedff6d9a00 diff --git a/tests/expectations/compiler/integers/i16/lt.out b/tests/expectations/compiler/integers/i16/lt.out index 67f93094ae..1110315843 100644 --- a/tests/expectations/compiler/integers/i16/lt.out +++ b/tests/expectations/compiler/integers/i16/lt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b74fb1122140742af0db7b3989de16241a447b1a71aa15470b8fafcd2c8dfd43 - unrolled_ast: b74fb1122140742af0db7b3989de16241a447b1a71aa15470b8fafcd2c8dfd43 - ssa_ast: 0eb240c1f8de1c84e64e1d7cbdc396eefe703dccccfd7f7bfbca595a5850053d - flattened_ast: 3cc5d031c3c38166c682ec3a1f22e86f74fe7c57a68c6c4a9af6df85bd633451 + - initial_ast: 3de1faff250ff5813904e8e2b7b0c8cd7d7d0b9541208fe4aba7252adb67630a + unrolled_ast: 3de1faff250ff5813904e8e2b7b0c8cd7d7d0b9541208fe4aba7252adb67630a + ssa_ast: 90859050e09dcde8362d150eb305f4ff1351d60c63953f6b926595d613be7da8 + flattened_ast: 7872bf6de336f453809a46b974eca88602223da8006bc457e5cbb42b5229f807 + inlined_ast: 7872bf6de336f453809a46b974eca88602223da8006bc457e5cbb42b5229f807 bytecode: 5246d0c0e3bcae2402ea4d869b25ea506f69b9f2b151c0a437a80c53f6b06820 diff --git a/tests/expectations/compiler/integers/i16/max.out b/tests/expectations/compiler/integers/i16/max.out index 264a69840c..576bd50425 100644 --- a/tests/expectations/compiler/integers/i16/max.out +++ b/tests/expectations/compiler/integers/i16/max.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 0121c2f396502fc8652c947b96904acc0abae7453ffce676d1359e79a7e17e5b - unrolled_ast: 0121c2f396502fc8652c947b96904acc0abae7453ffce676d1359e79a7e17e5b - ssa_ast: efd9b5c7ef2f754c3a4fbae67dce7e2e4be2637315d0ad81a3a5e5785acc4cfb - flattened_ast: ee1d76974e1e591a97bb208e0cd1d0cb13e5ea06ec6ac662bf4dc986b69d74bd + - initial_ast: 2d56d2f748e6ac9b276e18b2168096c0ddc5f43c2202a0656d2f9300cb05e818 + unrolled_ast: 2d56d2f748e6ac9b276e18b2168096c0ddc5f43c2202a0656d2f9300cb05e818 + ssa_ast: 4ea47db3de3c1bbc84cc4620070cce3f6e5f6764e03a9b44fea2463b9a6a61be + flattened_ast: a37fa26f4af62d04e8cd9e32d1f792f4b51262479cb5e1d456b11c0d82a76b6f + inlined_ast: a37fa26f4af62d04e8cd9e32d1f792f4b51262479cb5e1d456b11c0d82a76b6f bytecode: 6958108d2957c63c3584130ff20bfffaac82cc978c77da23b73c4633a75f1b4f diff --git a/tests/expectations/compiler/integers/i16/min.out b/tests/expectations/compiler/integers/i16/min.out index d829accb8a..073fd4ea74 100644 --- a/tests/expectations/compiler/integers/i16/min.out +++ b/tests/expectations/compiler/integers/i16/min.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e00aff7ac821e33ff65913a75b520fccc909a22ca0f2b81bad8c0bbf73960de2 - unrolled_ast: e00aff7ac821e33ff65913a75b520fccc909a22ca0f2b81bad8c0bbf73960de2 - ssa_ast: 02c93268d7c06492cbfe81f8660fa9d32e2b01ff049116a7cf9e8c6aad468c7b - flattened_ast: 333922a3939dc0a0753e173708e65f1a64d39972bde737eae60a605b2a55047b + - initial_ast: 2154123c075212d946e7293a04308e053248816e3acf154646da3062ce9404a4 + unrolled_ast: 2154123c075212d946e7293a04308e053248816e3acf154646da3062ce9404a4 + ssa_ast: 0ca8a34a361e6be28153bf314b7762dd6bf8155c8390878f5918541c839d5ace + flattened_ast: 53bfa1c6c4a95e2bcd36ec6be5c9239a2ee52d358e0190683476682543e44e43 + inlined_ast: 53bfa1c6c4a95e2bcd36ec6be5c9239a2ee52d358e0190683476682543e44e43 bytecode: f2fe31979d1155f5b72ae5746b03fd87c6f2f45da939acffade988230a8e2ad4 diff --git a/tests/expectations/compiler/integers/i16/min_fail.out b/tests/expectations/compiler/integers/i16/min_fail.out index a2844711bd..2934f5a860 100644 --- a/tests/expectations/compiler/integers/i16/min_fail.out +++ b/tests/expectations/compiler/integers/i16/min_fail.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 79d6eefe0bc22de1feeff36937009998b1d7b413fbd90e3fc68777d5ffc83ca2 - unrolled_ast: 79d6eefe0bc22de1feeff36937009998b1d7b413fbd90e3fc68777d5ffc83ca2 - ssa_ast: 5661f3cf74d1c447498bea03ef64fe3183ed6195ef9f907f50912c2652994c8d - flattened_ast: 5d0188426c39c2afc8e45e3432ca14dbffd43a454f5cfe6257cb271e7ed0d06d + - initial_ast: 1819ff40b94d1e54432d40e3f8f3e2b500fff76f321c8d2798cb1623bb060de3 + unrolled_ast: 1819ff40b94d1e54432d40e3f8f3e2b500fff76f321c8d2798cb1623bb060de3 + ssa_ast: bce25bcb1376beab03517fcbb0231baf7f2b997a79e39a0c54666268aaf8a2f9 + flattened_ast: faf31d65e557e571505d53c1026252c28c46bc1dfbb007de1a86d8c1251f8d7d + inlined_ast: faf31d65e557e571505d53c1026252c28c46bc1dfbb007de1a86d8c1251f8d7d bytecode: 610f6da5a1bfe09e95c9fcc99b8905d5889d879fa9e09167fc9dfbe512faab0d diff --git a/tests/expectations/compiler/integers/i16/mul.out b/tests/expectations/compiler/integers/i16/mul.out index 3f79d7d2f0..3f67069127 100644 --- a/tests/expectations/compiler/integers/i16/mul.out +++ b/tests/expectations/compiler/integers/i16/mul.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: d1a832e392858c7bd15e5cf2ae40a32ec5c0368c0d6482cab1f77e042e35b0cf - unrolled_ast: d1a832e392858c7bd15e5cf2ae40a32ec5c0368c0d6482cab1f77e042e35b0cf - ssa_ast: 33101425a7c781f6429e3880f3e3fccb8b25b9d7c0e43c8143c67f4481013a56 - flattened_ast: ea89df496484708281bc2d67bcb2e93da033fc357dcb5b3fbe330baa5230d3f0 + - initial_ast: 0c972f5b48ba5679885f8ba8a0c823267996240bdb51a6c23b96a2309549e395 + unrolled_ast: 0c972f5b48ba5679885f8ba8a0c823267996240bdb51a6c23b96a2309549e395 + ssa_ast: ab9ab3ee550ed4ba677ec9ddf7d04719f9ff3fc3669e4caf532076670a550197 + flattened_ast: 7771f004f9eb830376745296300ee1132f37e0e0611f11e8e02fd290b377622c + inlined_ast: 7771f004f9eb830376745296300ee1132f37e0e0611f11e8e02fd290b377622c bytecode: d8edabcfee75bc808014904105c76f84c9acef35797c0e25bbf339e768d853b8 diff --git a/tests/expectations/compiler/integers/i16/ne.out b/tests/expectations/compiler/integers/i16/ne.out index 562ac87714..a03c06c2b1 100644 --- a/tests/expectations/compiler/integers/i16/ne.out +++ b/tests/expectations/compiler/integers/i16/ne.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 0d20212d390c4ef2632f93502c12a7214960dd1ea4f8fe038beaa7018f327e5e - unrolled_ast: 0d20212d390c4ef2632f93502c12a7214960dd1ea4f8fe038beaa7018f327e5e - ssa_ast: 7472b7af2569c2d0367bae47c3205f1e22b0a930f2b4127768a11cc53b424d3f - flattened_ast: 2357ff5c76e538212534d1a9dbea8f4b88f78d87c31dc95b2a8b13a0f3012500 + - initial_ast: afe493d5ccec11a491c803608ef0236d140ab4bec7b9e65b2799fa44d5390784 + unrolled_ast: afe493d5ccec11a491c803608ef0236d140ab4bec7b9e65b2799fa44d5390784 + ssa_ast: f1e715bf69409f35a85b1738975077c6fdb1f2354ea0f73e57a64f3b7ce73a8c + flattened_ast: 6a1fb0193d47926466894eb84e3cf235cb893a6bca01881c685fb86a048c9a63 + inlined_ast: 6a1fb0193d47926466894eb84e3cf235cb893a6bca01881c685fb86a048c9a63 bytecode: 7625de6e12d49943dc9afd004ecbced1ca28e58e37ee87bf8f7896de8230b61b diff --git a/tests/expectations/compiler/integers/i16/negate.out b/tests/expectations/compiler/integers/i16/negate.out index 53c13b957d..591c9a846c 100644 --- a/tests/expectations/compiler/integers/i16/negate.out +++ b/tests/expectations/compiler/integers/i16/negate.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 85e44241879552cb0936124ffd6af4363c7eac0fd8d228bd32029931608726c4 - unrolled_ast: 85e44241879552cb0936124ffd6af4363c7eac0fd8d228bd32029931608726c4 - ssa_ast: cf1c308442f6cae61e12eb1201f76a78fec25c7c01af7952baef366659632ee0 - flattened_ast: 33ed8a5963450e08fc4f049f7da5a0592874ce8d2b84c2ab4b03c82af8d74d7b + - initial_ast: b08b7012cad1e466225f9e0cdba7b907a14ed1d0c3b1e9692feba8650a74478c + unrolled_ast: b08b7012cad1e466225f9e0cdba7b907a14ed1d0c3b1e9692feba8650a74478c + ssa_ast: 04594cd2713912aebd82538d8e140d3fe8ad489fb41ecf6b0b31e515cff40c45 + flattened_ast: 0748407f0dd950b2aa9ddae84120f9401311e77ccabc2bbfdb16d64c6a662cfb + inlined_ast: 0748407f0dd950b2aa9ddae84120f9401311e77ccabc2bbfdb16d64c6a662cfb bytecode: ff7764c9bd18a9bedde5cf440934d90d38f8e75b7a882e506899e54c81de578a diff --git a/tests/expectations/compiler/integers/i16/negate_min_fail.out b/tests/expectations/compiler/integers/i16/negate_min_fail.out index 735a467989..f7c7d72937 100644 --- a/tests/expectations/compiler/integers/i16/negate_min_fail.out +++ b/tests/expectations/compiler/integers/i16/negate_min_fail.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5b904f28c79524c63414652a1af63b09990abc3fdcabe89cf2839b4e5ba4944d - unrolled_ast: 5b904f28c79524c63414652a1af63b09990abc3fdcabe89cf2839b4e5ba4944d - ssa_ast: 4c7c5d32385001660cc160a2006cf203c1b404ff577fa69cf4e169ee8d4845b5 - flattened_ast: 530a6692f51730f366463ab0259cf710a57cb6335311cc63ead6f101023d9a16 + - initial_ast: c0d1bfa4459c6a7f94c59adf491054ed67bea3aefc772e943dcaee45b4bcb3d0 + unrolled_ast: c0d1bfa4459c6a7f94c59adf491054ed67bea3aefc772e943dcaee45b4bcb3d0 + ssa_ast: ccd90f4b485926da4d3e98ed7d371614fcfb732c0008f9e2f0e124536aa52c16 + flattened_ast: 3477100ef9525d882b17e9435d8b37497b8efdeb467895b00d52f6c0719ae4ed + inlined_ast: 3477100ef9525d882b17e9435d8b37497b8efdeb467895b00d52f6c0719ae4ed bytecode: bb7257ac8246f75ff2fa570e93351842aeac6b6b1711f233bc29427df8e5105a diff --git a/tests/expectations/compiler/integers/i16/negate_zero.out b/tests/expectations/compiler/integers/i16/negate_zero.out index a0ff6ea2aa..ae32920500 100644 --- a/tests/expectations/compiler/integers/i16/negate_zero.out +++ b/tests/expectations/compiler/integers/i16/negate_zero.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5067eda944d304804107a56d720ee05e37e3f88591056353e60adcaf0e9acac0 - unrolled_ast: 5067eda944d304804107a56d720ee05e37e3f88591056353e60adcaf0e9acac0 - ssa_ast: 15518eff87e0600e14b5669fed404890778ec27930359f5ac99b6e2414f9fbf8 - flattened_ast: 121f14007adefc43108c1207422c08ccb34cf568be68b4b9bd5878c53128261f + - initial_ast: 61a70d1bbe2720abe3e6d7653cf81e2e695428abbe7ecea57e335d53b45d3d0a + unrolled_ast: 61a70d1bbe2720abe3e6d7653cf81e2e695428abbe7ecea57e335d53b45d3d0a + ssa_ast: e5f1b1f5d7fc2416a08cb7cf5952f34778b321e00605ceec1e82fb27fdc13937 + flattened_ast: afbe512b0ba6eba2c33bac7cdacb718bf1c51c346ae5d9c1ba346235acab3580 + inlined_ast: afbe512b0ba6eba2c33bac7cdacb718bf1c51c346ae5d9c1ba346235acab3580 bytecode: 82f078cb2577720b3ec0efb950478d85280f6d2cd4282c48f229ecd2286591f9 diff --git a/tests/expectations/compiler/integers/i16/operator_methods.out b/tests/expectations/compiler/integers/i16/operator_methods.out index 053bda5485..633830dcc8 100644 --- a/tests/expectations/compiler/integers/i16/operator_methods.out +++ b/tests/expectations/compiler/integers/i16/operator_methods.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: a77e4d9f2116fbc70fa97e34755401c4c22c49e890add1fa486ae3b35e69e1a3 - unrolled_ast: a77e4d9f2116fbc70fa97e34755401c4c22c49e890add1fa486ae3b35e69e1a3 - ssa_ast: a8c6a9814c128f348950bc9c92ab04dcd119a999dc1692a97baf0ad8c1c29eb0 - flattened_ast: 46a3eccef69cbe785576cc040f3f73450804c277472073dd19a24428898b9158 + - initial_ast: eecbf39e1d25a542f6eeb36a50f49a96e432d424d6bed35676e9e3fa4d97aaa0 + unrolled_ast: eecbf39e1d25a542f6eeb36a50f49a96e432d424d6bed35676e9e3fa4d97aaa0 + ssa_ast: 17432df3d1c6504ce57a8ba77f2ab699bd250b44338db7cbb2061e7567822c9b + flattened_ast: 6cc1152fb17f0197e269366aa90378cf19b2495785d70da0db0789f455242b8f + inlined_ast: 6cc1152fb17f0197e269366aa90378cf19b2495785d70da0db0789f455242b8f bytecode: ca26df3d981c76ea139e38698ccbb6ac2fe8c940f7dd424a6791d29d2d8a28f9 diff --git a/tests/expectations/compiler/integers/i16/or.out b/tests/expectations/compiler/integers/i16/or.out index 0d656683f9..16e7a7bb21 100644 --- a/tests/expectations/compiler/integers/i16/or.out +++ b/tests/expectations/compiler/integers/i16/or.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e240eae9985903b2ee4f5cef794fd7d1ea3b4d24598bbcb7c0bd6ed083c8a91a - unrolled_ast: e240eae9985903b2ee4f5cef794fd7d1ea3b4d24598bbcb7c0bd6ed083c8a91a - ssa_ast: 23d3141792239841af1abea74afe61b3e39543b2e4bf0176e8e81c8e9ee7cad3 - flattened_ast: be1cbfdc321f0c0eea4f831c6796df5e5db698908f61d9d42703f04eabcb7cbc + - initial_ast: 4140af4f462e117c1b35ae4d44bdfe87096c801e34556d3b527d2a2db707428e + unrolled_ast: 4140af4f462e117c1b35ae4d44bdfe87096c801e34556d3b527d2a2db707428e + ssa_ast: 41663bab6bec2a78b7626f690f776e09f2310b28430f47c6485f99a80e9d9508 + flattened_ast: 8e003509896e96197f8f3d1615eddf2969c064432ce3a71602b1a6f330bdaa32 + inlined_ast: 8e003509896e96197f8f3d1615eddf2969c064432ce3a71602b1a6f330bdaa32 bytecode: 24dbe991a15924dab9a19dc86f6173f85a793bcf6d3b6d33c7fe2c29a9401cc1 diff --git a/tests/expectations/compiler/integers/i16/pow.out b/tests/expectations/compiler/integers/i16/pow.out index 43dfe5067d..6b85f0e994 100644 --- a/tests/expectations/compiler/integers/i16/pow.out +++ b/tests/expectations/compiler/integers/i16/pow.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 80d57d683008e67f7c5fc5b21bf94542b076e1f94e91540c4c524a0ac81d9a3e - unrolled_ast: 80d57d683008e67f7c5fc5b21bf94542b076e1f94e91540c4c524a0ac81d9a3e - ssa_ast: eac9072a4760952f36e9bcb93672c0c6749df54ed7be860de8b2d60e9f9cb7f6 - flattened_ast: b0fc31b36074d4a36d0778ba1e28e5a72d7b2254ba149c197157088c00d6de3e + - initial_ast: 9a59ecc9ac1f1f3b8aae34cafb282cb1822b3c15468fda671b60b72adea38226 + unrolled_ast: 9a59ecc9ac1f1f3b8aae34cafb282cb1822b3c15468fda671b60b72adea38226 + ssa_ast: 3efabf105c175d8b0a9219e2736719b53e9f557e10d564d08ea20d0494d888bb + flattened_ast: 1d1399f68a015307a219bf22cd6113060d8639f6d8dfe0fbe69d5919a9732c11 + inlined_ast: 1d1399f68a015307a219bf22cd6113060d8639f6d8dfe0fbe69d5919a9732c11 bytecode: 0a5d25027b5d2b5a4fce9b93c6ddd7e245ea50434fe7c19aae907fc1ddb0237d diff --git a/tests/expectations/compiler/integers/i16/rem.out b/tests/expectations/compiler/integers/i16/rem.out index f6a210442a..f8ea019bdc 100644 --- a/tests/expectations/compiler/integers/i16/rem.out +++ b/tests/expectations/compiler/integers/i16/rem.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 02ba9e4bde00dc95ebbda7f802a7027c5d87fc7b2ce000aca350cdbde7d42ef7 - unrolled_ast: 02ba9e4bde00dc95ebbda7f802a7027c5d87fc7b2ce000aca350cdbde7d42ef7 - ssa_ast: 0715c027b8a20ad9a291688f8cae5e2a8339c683c3b84160569cca9a982a07e4 - flattened_ast: 3005391011ad2112e4f9d5ade752142c2d1489bd914c5fc8bcc350514549d09d + - initial_ast: 2597bde13c2ef7c9fe072ce17bc42b5130b0fc3bfb64c4d858c2a7f650e7c114 + unrolled_ast: 2597bde13c2ef7c9fe072ce17bc42b5130b0fc3bfb64c4d858c2a7f650e7c114 + ssa_ast: 897d784516bca09246e64e04293d8990efd0779da517b4af05f7d872fae12830 + flattened_ast: 827ba2fb2b5534d207f1832d20b4a94e07c38632e6864c817b13a4a41ed5f0ae + inlined_ast: 827ba2fb2b5534d207f1832d20b4a94e07c38632e6864c817b13a4a41ed5f0ae bytecode: 4bae84ce4d6380e7d41b5074b28652bcf2beae9c47004f480f45728d3fc076a8 diff --git a/tests/expectations/compiler/integers/i16/shl.out b/tests/expectations/compiler/integers/i16/shl.out index 288b9cf95d..4714f6c074 100644 --- a/tests/expectations/compiler/integers/i16/shl.out +++ b/tests/expectations/compiler/integers/i16/shl.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5b86cd3a2f81aba3aaa0c464a1e992b6f50ca1060b2d022c68f9644d54b7a5f4 - unrolled_ast: 5b86cd3a2f81aba3aaa0c464a1e992b6f50ca1060b2d022c68f9644d54b7a5f4 - ssa_ast: 9ae99a42943575dfb2dd954227256db3ca65d10256c6a04761598bfe373b7dd4 - flattened_ast: 3d1330e15d80f89164ba8e9bee0c2b2338cae6cd7fbe31122970749e59a05b61 + - initial_ast: 01dce520919d9520ce130b1ce3c52c74584229749adf1bfed0e66159988769c6 + unrolled_ast: 01dce520919d9520ce130b1ce3c52c74584229749adf1bfed0e66159988769c6 + ssa_ast: 15c61b9cac5a6754ede2394501b948292a21bc743dfe721f29264ceef6bbd02c + flattened_ast: 1f10a78b5621be6c2c101bc22d37937739e82e6b85dd645094973246ab8e145e + inlined_ast: 1f10a78b5621be6c2c101bc22d37937739e82e6b85dd645094973246ab8e145e bytecode: 51091a6c5b24e9575bad691bfd3e499a82465bebc851c624984a65d346a637a4 diff --git a/tests/expectations/compiler/integers/i16/shr.out b/tests/expectations/compiler/integers/i16/shr.out index 48f987ffd2..ed42b721aa 100644 --- a/tests/expectations/compiler/integers/i16/shr.out +++ b/tests/expectations/compiler/integers/i16/shr.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 7eab30d55be96ac5aee02181d38a0ce4ada350ca9fc686c1c07697b6a1901a8b - unrolled_ast: 7eab30d55be96ac5aee02181d38a0ce4ada350ca9fc686c1c07697b6a1901a8b - ssa_ast: 985d703376bbdecd07bad58ac7c17e5d2b5c2a9a43350ae51b0d82003d709f5b - flattened_ast: 78e3d390090c13da1db7a73a9a4b5db2a638d3f4060c2b21fc09179dd202eeef + - initial_ast: 812fb111a7bdd9e50cee33179e50004e3d727e1d555ecfd51271624bfafa7572 + unrolled_ast: 812fb111a7bdd9e50cee33179e50004e3d727e1d555ecfd51271624bfafa7572 + ssa_ast: 1106d4d8a8ff8c5e0ad2c4997f2ea9aa68144bffd74340b390746531df6eb6f6 + flattened_ast: ddf2d26132f221a20bb1610cd548717a4d291559f0a3aecbaa50e9082bc1d7d5 + inlined_ast: ddf2d26132f221a20bb1610cd548717a4d291559f0a3aecbaa50e9082bc1d7d5 bytecode: 000f236df936960490eede733dc994070d896c73e4652e79ed6a078d2631d1af diff --git a/tests/expectations/compiler/integers/i16/sub.out b/tests/expectations/compiler/integers/i16/sub.out index 913758221b..94a3d36d71 100644 --- a/tests/expectations/compiler/integers/i16/sub.out +++ b/tests/expectations/compiler/integers/i16/sub.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: efc127f14052fabab2ada5f1866ae54ec6e1085560aa0d2b89da309005b8b082 - unrolled_ast: efc127f14052fabab2ada5f1866ae54ec6e1085560aa0d2b89da309005b8b082 - ssa_ast: 40826cdaad6021b39986d5473c8d90a2290e671939ed6a4b317509b6ce77e0e1 - flattened_ast: 49ddf6b947d1e00c92a3d61ab4055426632a77bafd6731f3075ec89357ba0eca + - initial_ast: 1e4f8afb46a242008539609965e4719edfdcaf6cb608c792f390ad5b60fc89f3 + unrolled_ast: 1e4f8afb46a242008539609965e4719edfdcaf6cb608c792f390ad5b60fc89f3 + ssa_ast: 3a184a80e21152d861bd221475caa916b19b8b2b1a5203bf3979dcb445699b91 + flattened_ast: 9af89b7a6a95af5d2ed34db911150b22701c1f0e4a479807264a15ef434b3082 + inlined_ast: 9af89b7a6a95af5d2ed34db911150b22701c1f0e4a479807264a15ef434b3082 bytecode: d1ad9d0c658a951a98f1bb225937352b40b5e2870fd131c6a68c0ee5e25e7b33 diff --git a/tests/expectations/compiler/integers/i16/ternary.out b/tests/expectations/compiler/integers/i16/ternary.out index b06796457d..fec075b33b 100644 --- a/tests/expectations/compiler/integers/i16/ternary.out +++ b/tests/expectations/compiler/integers/i16/ternary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: c87e066b5c9fdaa5280fb48377d03732fcc911e75987f0edd7a75ccfda88e7a6 - unrolled_ast: c87e066b5c9fdaa5280fb48377d03732fcc911e75987f0edd7a75ccfda88e7a6 - ssa_ast: 8bdd5e909bc97970c78643f023a23fd2d065c7a86f09c54ed681cfdc0825a66d - flattened_ast: 2d1f8cc9a013457902a89066191d8645a75f6cc6ee70f90d3a0f4be212443703 + - initial_ast: 39df3243880e09119d10115530293e1818d0003bcad80df891ac736f1ac1f4a9 + unrolled_ast: 39df3243880e09119d10115530293e1818d0003bcad80df891ac736f1ac1f4a9 + ssa_ast: d67bb828f78f8ec2f8facfd985de32958db332f3beae361149a211c0251adb1c + flattened_ast: fd999660c023d3c5c3d1578852098c97ba89c14f1a10808836a64ca730b50142 + inlined_ast: fd999660c023d3c5c3d1578852098c97ba89c14f1a10808836a64ca730b50142 bytecode: 14e6a5f8a524c491e4fd3c49b81f89cf5ffaa68bea3b1ef60b9a86b65a77008f diff --git a/tests/expectations/compiler/integers/i16/xor.out b/tests/expectations/compiler/integers/i16/xor.out index 54914baaaa..0700f32315 100644 --- a/tests/expectations/compiler/integers/i16/xor.out +++ b/tests/expectations/compiler/integers/i16/xor.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 8e73007dbc41aba54e759b318f3a7e7589d0a28eb71f9cf9cf9dde36a6da100d - unrolled_ast: 8e73007dbc41aba54e759b318f3a7e7589d0a28eb71f9cf9cf9dde36a6da100d - ssa_ast: 780c9c49b9a421d90d87365b69db2607e864aa2aee81f0129e6f34198611e70c - flattened_ast: 1147730bef8102e74801540131d4124ba70c3dca431799cfd40ce6742485d075 + - initial_ast: 9b17cff9be2c510e22991e80e8d1d918a2830e58bf4361c9bb0f684e47f504e0 + unrolled_ast: 9b17cff9be2c510e22991e80e8d1d918a2830e58bf4361c9bb0f684e47f504e0 + ssa_ast: 53ed82cf21abc64b70249f0161bfe099c78243e14b63ed5d293d4e936709b1a3 + flattened_ast: 811c01719e47893ae4f99ae5c5fbdddd366f00815d62c5b32a0dd9ef71820b92 + inlined_ast: 811c01719e47893ae4f99ae5c5fbdddd366f00815d62c5b32a0dd9ef71820b92 bytecode: f35d4454526e753df023baf1761e228b4e7f75cc66b9268d8685cfd99f574004 diff --git a/tests/expectations/compiler/integers/i32/add.out b/tests/expectations/compiler/integers/i32/add.out index d6798621ff..13fd5e711d 100644 --- a/tests/expectations/compiler/integers/i32/add.out +++ b/tests/expectations/compiler/integers/i32/add.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 36f7bfd0e5026d2ae9ae5c1dce39d54e0d9a29f7193db79465a2542ca110073e - unrolled_ast: 36f7bfd0e5026d2ae9ae5c1dce39d54e0d9a29f7193db79465a2542ca110073e - ssa_ast: da4e236fe799d635e545ffa7e8992bc382ea6953ffb1c5cb06aca36697363145 - flattened_ast: ac5d76c55c0de24289dfe20efc696d385b6d695324a9c883475fc352b1479f31 + - initial_ast: c13f8929466d335ecb6682c572d568af53e963ec46b2ee06ce1f137b407cb89f + unrolled_ast: c13f8929466d335ecb6682c572d568af53e963ec46b2ee06ce1f137b407cb89f + ssa_ast: 75406ff5c633abb4ff17673cb5d3c28a11d9b71035162b5c8c490c396bd0e065 + flattened_ast: d78f419eabb4e31ea0d259b001d90a1b247dda9071a9bc99dcf7a8f0cd02ce19 + inlined_ast: d78f419eabb4e31ea0d259b001d90a1b247dda9071a9bc99dcf7a8f0cd02ce19 bytecode: 4a98642513ca0ed6ae3eae0b4a7d4e25a43bf2537b52dca4385bf83626aa6348 diff --git a/tests/expectations/compiler/integers/i32/and.out b/tests/expectations/compiler/integers/i32/and.out index bbcd70d01f..6babf49eca 100644 --- a/tests/expectations/compiler/integers/i32/and.out +++ b/tests/expectations/compiler/integers/i32/and.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: c7efc2ab5094addc6283d1ee756cbb97b7eb1e12278144172a7d5eb5126ddeb9 - unrolled_ast: c7efc2ab5094addc6283d1ee756cbb97b7eb1e12278144172a7d5eb5126ddeb9 - ssa_ast: 027ce6a776920e91ec020b9359810eb30af7bf066d70864097087e02039bfc4c - flattened_ast: 2d8c24706f795d5054efdd56987bdaaaa1fd921ab2d9c751c53682fee0646c46 + - initial_ast: 87d4b6b41fa65dd5fe17a7071a88c7268f53584a143ee3e95361e4dc3d40e4e0 + unrolled_ast: 87d4b6b41fa65dd5fe17a7071a88c7268f53584a143ee3e95361e4dc3d40e4e0 + ssa_ast: af92520a505ceaba6931fc38a61b32f887dd678ef721fd9550db9ad826b76342 + flattened_ast: 95e616a78ca269f7dad625e6ad38bbd330da3aee3130eed456e4ac7bd5c128fd + inlined_ast: 95e616a78ca269f7dad625e6ad38bbd330da3aee3130eed456e4ac7bd5c128fd bytecode: c83bc9d6ff309f026eaeb241d0fda881b4c06b706608171e54822ea576661785 diff --git a/tests/expectations/compiler/integers/i32/console_assert.out b/tests/expectations/compiler/integers/i32/console_assert.out index f97015aa2d..5bec838272 100644 --- a/tests/expectations/compiler/integers/i32/console_assert.out +++ b/tests/expectations/compiler/integers/i32/console_assert.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: f6146b5efa826e72ac3fe51df8f9e6d3aeddf6c44fb4e7ca4979fd0c4c35b444 - unrolled_ast: f6146b5efa826e72ac3fe51df8f9e6d3aeddf6c44fb4e7ca4979fd0c4c35b444 - ssa_ast: 631c3c1f8fc61b36e3f85e45559a30de0eaf72c678090f3a167929bafdfc05a7 - flattened_ast: c0bda22abed4d89793989f55415550c875f839a951ca28eb466a3c8d19753187 + - initial_ast: 8eb95014dc29775cfee0effe1058bd3547e27a215d593db304869c52fda6fa54 + unrolled_ast: 8eb95014dc29775cfee0effe1058bd3547e27a215d593db304869c52fda6fa54 + ssa_ast: 91ce3f8e0bc1c45cc6e12f57c2d56b0420c01b95175aa72b3fc2d3a0723eb416 + flattened_ast: 36dfdd9afab5263be6b6bf8cbace8e9ef88f7a16fb88d12219480b0ab579ab5f + inlined_ast: 36dfdd9afab5263be6b6bf8cbace8e9ef88f7a16fb88d12219480b0ab579ab5f bytecode: e93a461327025eb76bd362a69b2768d3edcc1864570406e44734686eaec84237 diff --git a/tests/expectations/compiler/integers/i32/div.out b/tests/expectations/compiler/integers/i32/div.out index 4406c4e7cc..72dc5cab54 100644 --- a/tests/expectations/compiler/integers/i32/div.out +++ b/tests/expectations/compiler/integers/i32/div.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 9d32b826fda0157d073120c5cfd982efabbc52adf03f06bd55086de008cf3545 - unrolled_ast: 9d32b826fda0157d073120c5cfd982efabbc52adf03f06bd55086de008cf3545 - ssa_ast: 4d5a06be078a5ae49a19c5ff4ce67e9e195dcdeb13ec2f6d2309e711c2c69f75 - flattened_ast: 442fabdb641cb000d06829603dbebe861ed0c9d0bea19eefb3c4c6a43647eaf5 + - initial_ast: 535ec581e824bc5ce8bc762a1eb59db10ad97fe09fdb1f9b4d3833572d5b22e6 + unrolled_ast: 535ec581e824bc5ce8bc762a1eb59db10ad97fe09fdb1f9b4d3833572d5b22e6 + ssa_ast: 7ed38e0e442687c8b2d6c929e7281ee4fceb7b92fdba7a3a5b242fe96a3ed29c + flattened_ast: ec4fb7edc255322670e44af0678a96ccfd0e6291bd4982ab96423d8edfdb286d + inlined_ast: ec4fb7edc255322670e44af0678a96ccfd0e6291bd4982ab96423d8edfdb286d bytecode: 7513cf41cc383d2f32c59f1fc1f0c08d966470080cc680b4e067a299840d447e diff --git a/tests/expectations/compiler/integers/i32/eq.out b/tests/expectations/compiler/integers/i32/eq.out index 60896bef1b..4609e277af 100644 --- a/tests/expectations/compiler/integers/i32/eq.out +++ b/tests/expectations/compiler/integers/i32/eq.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 186b78f8155be2d9737fc632e7cc16363c5cbc7f17b6ce2747930735b4478370 - unrolled_ast: 186b78f8155be2d9737fc632e7cc16363c5cbc7f17b6ce2747930735b4478370 - ssa_ast: be8ce092223c9befde13ae9b6bf472194815bb8c161c4b440f7c17d3beb2c6c1 - flattened_ast: 5a8c6ed8d09758b00d462e3e6d6adbbbb6b1ca05899bc788b1e68c49fc47ac6e + - initial_ast: 0e1c11db4d4a43699ef38921552c35ef7b93c2e30675c2c4799c50a9fab29062 + unrolled_ast: 0e1c11db4d4a43699ef38921552c35ef7b93c2e30675c2c4799c50a9fab29062 + ssa_ast: 49913d96c4e66c71feab72547e56eef107fed47107196ce0d124fdaa67817c44 + flattened_ast: e099251afaef6aaff31102dbccd9b1fbdf9fd7a72a0be5c5021bf2b8402b8f20 + inlined_ast: e099251afaef6aaff31102dbccd9b1fbdf9fd7a72a0be5c5021bf2b8402b8f20 bytecode: 0d9b72a5e1ee092b054a7f0884c63f028f5fca4db22b6d5c5046b9685481c56f diff --git a/tests/expectations/compiler/integers/i32/ge.out b/tests/expectations/compiler/integers/i32/ge.out index 42dda2602a..0e09d8fa04 100644 --- a/tests/expectations/compiler/integers/i32/ge.out +++ b/tests/expectations/compiler/integers/i32/ge.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 3991b5880e1d83378b5775ce756aa3a9aeed3e70b43e14f09f1fa99aa2424b5c - unrolled_ast: 3991b5880e1d83378b5775ce756aa3a9aeed3e70b43e14f09f1fa99aa2424b5c - ssa_ast: f4093eeae23fcfc818aa916ee0b3bc2b0dcc6bcb38845f4eea28424182de3183 - flattened_ast: 02afdce3bbef4126841d424e50ad52eceef3cc6bef96db01fd13e6d37e29e6e1 + - initial_ast: 43b2f0417daf6a536a31b1744d49b2dcbf40cf5de061f9e3da9dcefd6792b98d + unrolled_ast: 43b2f0417daf6a536a31b1744d49b2dcbf40cf5de061f9e3da9dcefd6792b98d + ssa_ast: 7f0c93a4de416d6a28447c23aefa3b3ae31fef4b239eb2eaf2d37f4ec04776d7 + flattened_ast: 5522b626e26a1b840abcdd2a1b38e59e7eca81290d3292d049c498b9df020f3f + inlined_ast: 5522b626e26a1b840abcdd2a1b38e59e7eca81290d3292d049c498b9df020f3f bytecode: e96d849b37da6f6ec972d154166606de44c27e8dffb03e0de68c0bd2193ce816 diff --git a/tests/expectations/compiler/integers/i32/gt.out b/tests/expectations/compiler/integers/i32/gt.out index 2b141bdf1f..0c8b7b3991 100644 --- a/tests/expectations/compiler/integers/i32/gt.out +++ b/tests/expectations/compiler/integers/i32/gt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 3aa82813eb0359278627070e87f2a706828c0db80eb81293f1d6683030512824 - unrolled_ast: 3aa82813eb0359278627070e87f2a706828c0db80eb81293f1d6683030512824 - ssa_ast: 49ad41fdcd02107db65acecc3e766644ea2345aab3065e6e097fd54195c30d05 - flattened_ast: f70c8eb7b8f332028436615984fb86fed1d80684aedd4fd6344973d05c5f2a58 + - initial_ast: 58b068a891e5a297682dc8dd44a5dbe22c4c2879cec17e385babf2829ef0cfe4 + unrolled_ast: 58b068a891e5a297682dc8dd44a5dbe22c4c2879cec17e385babf2829ef0cfe4 + ssa_ast: 3a7bfd83d227a4e485b8e024eff4523bfa9f4f9e8deb197e991bdcf9ff6906cc + flattened_ast: 7a04a1c69fdfcc4dd1a43111b0592c43f6c7ffdbfc0e439015f7ad5167430a77 + inlined_ast: 7a04a1c69fdfcc4dd1a43111b0592c43f6c7ffdbfc0e439015f7ad5167430a77 bytecode: 3397488866433f0960d9e392f25891d8b57a64a2395deb346b904d999546db9f diff --git a/tests/expectations/compiler/integers/i32/le.out b/tests/expectations/compiler/integers/i32/le.out index cbff8a4ec8..f5b4a44626 100644 --- a/tests/expectations/compiler/integers/i32/le.out +++ b/tests/expectations/compiler/integers/i32/le.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: cee61245c62d46748be1fb566cd2e90295e67a770cfd039b3d014321b01666c5 - unrolled_ast: cee61245c62d46748be1fb566cd2e90295e67a770cfd039b3d014321b01666c5 - ssa_ast: ddbc0ed2ac561c8544fcc70c2f7c2777601ff9e912aaf882e559f50d51a455f9 - flattened_ast: 982e03cf3e15a62dddf1207c63ab206f5e9e271a8c21360187c65f5e0d96475b + - initial_ast: 7994a4e560ca41616e3599a817d47a8233dd1baa04b57d5001d000863f693888 + unrolled_ast: 7994a4e560ca41616e3599a817d47a8233dd1baa04b57d5001d000863f693888 + ssa_ast: d9943f4dbd954d7b80396dc68106114c15d05d3382a293d746538de5591b2bdb + flattened_ast: bfe3178061d1208316948c3c384c540974d6e0f427075b960edfbc019257e113 + inlined_ast: bfe3178061d1208316948c3c384c540974d6e0f427075b960edfbc019257e113 bytecode: e2d82a67993557ac34d9e9945369fa907d4c6213c45feea19ad80bcb3cde4d68 diff --git a/tests/expectations/compiler/integers/i32/lt.out b/tests/expectations/compiler/integers/i32/lt.out index 06dfff153d..0929b75802 100644 --- a/tests/expectations/compiler/integers/i32/lt.out +++ b/tests/expectations/compiler/integers/i32/lt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 6ef01b6fc6417b5c4ed5f314752aeb531fb777ea019a218de7256fb5147110cc - unrolled_ast: 6ef01b6fc6417b5c4ed5f314752aeb531fb777ea019a218de7256fb5147110cc - ssa_ast: c172608a8a533db0d76acd72b1b5f51772bb519748a5f1f0dec1614f6272f462 - flattened_ast: f50e41220c286cd471259b9b9441189ca80645041eea69449112bec1113c613f + - initial_ast: 0f2e756a8c662c6cf5e4a0ebe5b3507522538b902adc26571aea798d431432cd + unrolled_ast: 0f2e756a8c662c6cf5e4a0ebe5b3507522538b902adc26571aea798d431432cd + ssa_ast: 593b75d8bfce8b63b32d18e70a4a6b99deef96e32efed606a6c31118d73d86d9 + flattened_ast: 357fb32b65c461722465b7cde492f9d2f9c36593765f5993d7219293ad78dd20 + inlined_ast: 357fb32b65c461722465b7cde492f9d2f9c36593765f5993d7219293ad78dd20 bytecode: 9227aa899da4b7ff37558be85d668ca336252c64e0687ea5d62f018b72127a04 diff --git a/tests/expectations/compiler/integers/i32/max.out b/tests/expectations/compiler/integers/i32/max.out index 0d9436218e..d4397ba5ca 100644 --- a/tests/expectations/compiler/integers/i32/max.out +++ b/tests/expectations/compiler/integers/i32/max.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 8a36a18077b598e420610d775f69cf6fca87b1ce9d7c71416f2f8aafc542f0e8 - unrolled_ast: 8a36a18077b598e420610d775f69cf6fca87b1ce9d7c71416f2f8aafc542f0e8 - ssa_ast: 69cea47efef9c1101a25da4a9ece27e438d3c748e197b1573e8df91c1ee64f26 - flattened_ast: 9b71044fb1bc3e3dc50d2cdddea24c1df6d61411371a09464982c337bd59499e + - initial_ast: d56c9a1c3bda7c29819f985704ecb6e35c27962ecdda701cdd3cbf5c47339299 + unrolled_ast: d56c9a1c3bda7c29819f985704ecb6e35c27962ecdda701cdd3cbf5c47339299 + ssa_ast: 5fa2f1d0cc48959a8f3c77e5c413fcf08940d8d17bdad74a14b383248df043cd + flattened_ast: 0749ccaa552a100971b6c8b69749022897abc8b4af32f271c4341146c89a4c25 + inlined_ast: 0749ccaa552a100971b6c8b69749022897abc8b4af32f271c4341146c89a4c25 bytecode: 57be3af9aea4c0676f2aa231ab3f3ad37c1f7c3210ef1428cb0acd9edcd86fe2 diff --git a/tests/expectations/compiler/integers/i32/min.out b/tests/expectations/compiler/integers/i32/min.out index b2bd9855ff..1dbbe2ad00 100644 --- a/tests/expectations/compiler/integers/i32/min.out +++ b/tests/expectations/compiler/integers/i32/min.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ff6660d80f5e4df44fe438051b539eea1aee5cc53785a1c19b66c22e388771ac - unrolled_ast: ff6660d80f5e4df44fe438051b539eea1aee5cc53785a1c19b66c22e388771ac - ssa_ast: 62a77ddf6f6d2e281e9a80fbb5e745d814d5a040eb3158c5136df389c1c5ff0c - flattened_ast: ede707ce40b05e4146eb56b44e3b66dcf50ed24e0c1945aca388bb5491304468 + - initial_ast: 742707b79565934bda1e31b8346336ee3b8c6537141e9388d8e38e231451fcc8 + unrolled_ast: 742707b79565934bda1e31b8346336ee3b8c6537141e9388d8e38e231451fcc8 + ssa_ast: 469e1f04cade5a27c58106f673675bd125a80434633c9dd9850a71972956ef19 + flattened_ast: 276b7994102cc308e942242a8e68474647b0407d774791e8b4848b4625ba033a + inlined_ast: 276b7994102cc308e942242a8e68474647b0407d774791e8b4848b4625ba033a bytecode: 14baafe414bb3db0919bce34efa2e0cb9be410e07822419abe1d221c68860ed3 diff --git a/tests/expectations/compiler/integers/i32/min_fail.out b/tests/expectations/compiler/integers/i32/min_fail.out index 799f65488a..7717cc7501 100644 --- a/tests/expectations/compiler/integers/i32/min_fail.out +++ b/tests/expectations/compiler/integers/i32/min_fail.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: f7a3a170ba6d57bbe91cdf065ae3ee44f97fde92d2730deeffed645ffdfce5d4 - unrolled_ast: f7a3a170ba6d57bbe91cdf065ae3ee44f97fde92d2730deeffed645ffdfce5d4 - ssa_ast: 71229a7b35742121e14cf828f2ce645ad5ff638d34c8bb1f33df539c7b272dbe - flattened_ast: 04d038e7b71b8253d39cee593501169d70e34a693459f6b35f2e03ff5298bf59 + - initial_ast: 3c8b0fcec0b009dfcced43755ebab2259bfb2d720823a5a73131944a1cf4cf3e + unrolled_ast: 3c8b0fcec0b009dfcced43755ebab2259bfb2d720823a5a73131944a1cf4cf3e + ssa_ast: 12ee129cc27501a6f34b4a6b38c248bbb0737e743b4b05c41d1d67cd15adbe11 + flattened_ast: 46c3156b85d00b6f5810b5c5140ba1c26915fa3f29f67bf59d4a26670b70278b + inlined_ast: 46c3156b85d00b6f5810b5c5140ba1c26915fa3f29f67bf59d4a26670b70278b bytecode: b7db7415e9a7e2872bdc1b803f5427a6632cc201dd4a91e3f11a337c30c37cf5 diff --git a/tests/expectations/compiler/integers/i32/mul.out b/tests/expectations/compiler/integers/i32/mul.out index 84ccc05198..07179b357b 100644 --- a/tests/expectations/compiler/integers/i32/mul.out +++ b/tests/expectations/compiler/integers/i32/mul.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 9bc02f0bac5537597c9679a65610b2d4b4ca9af2ad7ecd485b12ba1b86b787a7 - unrolled_ast: 9bc02f0bac5537597c9679a65610b2d4b4ca9af2ad7ecd485b12ba1b86b787a7 - ssa_ast: 062a77f76f33e255f2ec19206d30c1fee528597ffee62110943d969bfc014290 - flattened_ast: bc9d4e51523d0afff7e14399198e11249b70ed1cc438f710243cfb16a5ee66ff + - initial_ast: 003af22ca94442ef4c8e430a05528b307e6aee674f3221309155138786057788 + unrolled_ast: 003af22ca94442ef4c8e430a05528b307e6aee674f3221309155138786057788 + ssa_ast: 760de8ab14303d6fc6252412c24fce2ade74aaa1fc54c45e3854054ee24dbe15 + flattened_ast: f04e046302dfdb413f957677c766249d25743d0dbb188c55b5a89c0fffe59c64 + inlined_ast: f04e046302dfdb413f957677c766249d25743d0dbb188c55b5a89c0fffe59c64 bytecode: 0fae6466a2bf2de1231d59ee8579aaf8576385f781ec07b670799723b45090c1 diff --git a/tests/expectations/compiler/integers/i32/ne.out b/tests/expectations/compiler/integers/i32/ne.out index 51cb065580..0e6b612c24 100644 --- a/tests/expectations/compiler/integers/i32/ne.out +++ b/tests/expectations/compiler/integers/i32/ne.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: f28796eba1305513a97124712a252d3f38bbe4b2c12d3b973f1967fdb3f3720f - unrolled_ast: f28796eba1305513a97124712a252d3f38bbe4b2c12d3b973f1967fdb3f3720f - ssa_ast: 034889d962de26f2b72b337c6d827d7703df200643fca30b9dda84f3b6176e20 - flattened_ast: 397ef80c6e7cb3e5511527fc430eea5d6b1ba811c89eba2fab713c460722d25f + - initial_ast: 2b8283b54a9752866d8f514e5e359450a68f6e6b2b5fcece58b2a5f2d69ceef2 + unrolled_ast: 2b8283b54a9752866d8f514e5e359450a68f6e6b2b5fcece58b2a5f2d69ceef2 + ssa_ast: bbb27d503b543a2696866f16e04820ce8059726447036216ef6ee8a72735fbfa + flattened_ast: 01995d939ad860b0433f5e925f1697cfcb03fdbe1095fb109bd36737d5b3fd65 + inlined_ast: 01995d939ad860b0433f5e925f1697cfcb03fdbe1095fb109bd36737d5b3fd65 bytecode: 8b1b03539a77776abeaef8d0d2b0955c2e1ee92abc4418cafd336e2fd7e07d8c diff --git a/tests/expectations/compiler/integers/i32/negate.out b/tests/expectations/compiler/integers/i32/negate.out index e961d833b5..d92a8e5ee9 100644 --- a/tests/expectations/compiler/integers/i32/negate.out +++ b/tests/expectations/compiler/integers/i32/negate.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 22b33fc825b0cd6aa0875dfe5b98ca74f850da8aa5820987964b19db40a9459a - unrolled_ast: 22b33fc825b0cd6aa0875dfe5b98ca74f850da8aa5820987964b19db40a9459a - ssa_ast: 1aa82e537c3110c826af533d3db8fca889ae09b1da901d31ad2edc57cdb6293e - flattened_ast: b64f8d965606883023d3481a415dafb45aa7c518d1bce40462725c623b17294e + - initial_ast: 32ebca55eda838e33bfed94a43a234929c744fd0aea33e19a6549ac8e25b0c77 + unrolled_ast: 32ebca55eda838e33bfed94a43a234929c744fd0aea33e19a6549ac8e25b0c77 + ssa_ast: 7f5da7e86442794af8dc46a6c3168e05b0c5045f67cc0b74e404d7eb8253ed10 + flattened_ast: 371ba6ca525d4dcd2945a779b482aca26f353cefa5bad98500450bffc4d89ccd + inlined_ast: 371ba6ca525d4dcd2945a779b482aca26f353cefa5bad98500450bffc4d89ccd bytecode: 0926e920330080c9eb6e3b07960f4ac16ba62c2e93e7d2deaf2be56f21f64457 diff --git a/tests/expectations/compiler/integers/i32/negate_min_fail.out b/tests/expectations/compiler/integers/i32/negate_min_fail.out index d9c4dd081b..d64fc84f6a 100644 --- a/tests/expectations/compiler/integers/i32/negate_min_fail.out +++ b/tests/expectations/compiler/integers/i32/negate_min_fail.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 9a8d6859a3d65bcc8f69a242e69baa4e17270d9052c0e8884e5f2bb1c83ff3e7 - unrolled_ast: 9a8d6859a3d65bcc8f69a242e69baa4e17270d9052c0e8884e5f2bb1c83ff3e7 - ssa_ast: e674fc9166206b02451e9851f28dbebe45505e6ed1367082e3c8a83969f31453 - flattened_ast: 339886acbd03dcdfeab47e1f22f36bb6b9aadb53c4c5e54e2e6ca57afaa4668f + - initial_ast: 66f91182ba5ee40cfe7533f4dae47d68f7b326a25ab51e5cbc96303c501acb04 + unrolled_ast: 66f91182ba5ee40cfe7533f4dae47d68f7b326a25ab51e5cbc96303c501acb04 + ssa_ast: 967c94dad4c8543cc8533de1e4dc272f57ed62ca9956e372e23eb890bfe679b6 + flattened_ast: 5777b015a1adf3f2a59d9d12e08ed8b9a4a2f115c9dbab627b0fb8e4c3c9275e + inlined_ast: 5777b015a1adf3f2a59d9d12e08ed8b9a4a2f115c9dbab627b0fb8e4c3c9275e bytecode: 0df63ebe06d4d8d06c00c9b1d9591a683c5d13b9af12d4eb12c57a83ffbba471 diff --git a/tests/expectations/compiler/integers/i32/negate_zero.out b/tests/expectations/compiler/integers/i32/negate_zero.out index 65abc3f45d..e58222eed8 100644 --- a/tests/expectations/compiler/integers/i32/negate_zero.out +++ b/tests/expectations/compiler/integers/i32/negate_zero.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 73406285ee1ba91663b29aa6c5d35228a9309cb15185000626a499b37f2934c3 - unrolled_ast: 73406285ee1ba91663b29aa6c5d35228a9309cb15185000626a499b37f2934c3 - ssa_ast: 042f52bd3202567925354734ede0dd99598571ec079436e4dff7afc6539d6feb - flattened_ast: ea9437fecb1eb7879b82ad7baf4e621408d19398e3f35e56c053d184e5e03e43 + - initial_ast: 83916cc89b6b2b78a91b78bd4d9e527892ead898ada66ac167321058dd830a36 + unrolled_ast: 83916cc89b6b2b78a91b78bd4d9e527892ead898ada66ac167321058dd830a36 + ssa_ast: 0b5fd29d61cff564de8ba096f34488c7dd381bc82337c58656787b4dde85253c + flattened_ast: aee8008e8df4f8acc1b85bcf8479b16ea1dd708884609f454c69ef4ea0f58319 + inlined_ast: aee8008e8df4f8acc1b85bcf8479b16ea1dd708884609f454c69ef4ea0f58319 bytecode: b89559b0fd9e2790ecaef181d2af90bb7015a2c5894a07106eda104d8f572bed diff --git a/tests/expectations/compiler/integers/i32/operator_methods.out b/tests/expectations/compiler/integers/i32/operator_methods.out index 9e50a9ff5a..24cb2cb9dd 100644 --- a/tests/expectations/compiler/integers/i32/operator_methods.out +++ b/tests/expectations/compiler/integers/i32/operator_methods.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 3b74f77034a15dadb43593c9c13e1f246d015b8c8ade21c6009b8599a4c60ea4 - unrolled_ast: 3b74f77034a15dadb43593c9c13e1f246d015b8c8ade21c6009b8599a4c60ea4 - ssa_ast: 9b44a1f62001ea0a6ca5118db64fbfe610f99b6aee4e6e58764fb07198340863 - flattened_ast: 1e715e400f3e68d06500be21eb50e2d31dda565aca95063be350361c281eb1e1 + - initial_ast: 0975276579947ad8fb727d22e9861cda43a1c3938a30797eaa220de674cba792 + unrolled_ast: 0975276579947ad8fb727d22e9861cda43a1c3938a30797eaa220de674cba792 + ssa_ast: 7c116f6311daf0321afd5bacfe54252cf25030148239b75e20340f1d3616057d + flattened_ast: bbde81fbdb9bd53b73eaa0ec8a0c21b0c26b18695bb2f826af439d312856bd17 + inlined_ast: bbde81fbdb9bd53b73eaa0ec8a0c21b0c26b18695bb2f826af439d312856bd17 bytecode: 990e5c5e9f9079479ff3efb9871f8987145c808d38818b83948b09060cefca91 diff --git a/tests/expectations/compiler/integers/i32/or.out b/tests/expectations/compiler/integers/i32/or.out index e6d4e4841d..b271c6bd79 100644 --- a/tests/expectations/compiler/integers/i32/or.out +++ b/tests/expectations/compiler/integers/i32/or.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1410e7773fdb87aece7a0d922a0a4278692927f345234b70505177c52e7b5ab4 - unrolled_ast: 1410e7773fdb87aece7a0d922a0a4278692927f345234b70505177c52e7b5ab4 - ssa_ast: 2329fc40ceea4d6a2aebd34e87b28e734642c0d48e1c51d3869bdca676b28ea1 - flattened_ast: 1d96b46ddad6e40e8621be9eeb0f7bd55685a846ce1fb2b30c51c3b160adc9b9 + - initial_ast: 02531f7d0e73089e4d2aa0f15880dc8cb7a295397dac03d6222755eab24b9235 + unrolled_ast: 02531f7d0e73089e4d2aa0f15880dc8cb7a295397dac03d6222755eab24b9235 + ssa_ast: 3f53cfb647f82b9eb52bcc7c2f77351ccc5c6dfe85c908dc1dfbe9ba6aa6681d + flattened_ast: f1551f7b9d8b9e98a0e317e10d69a19225f24e13c7d50dbb4efe4885f2b8b923 + inlined_ast: f1551f7b9d8b9e98a0e317e10d69a19225f24e13c7d50dbb4efe4885f2b8b923 bytecode: 41b5a13222dbf0dd53c84da7f751c736e7356ce05e37db45e764d52e4f04331e diff --git a/tests/expectations/compiler/integers/i32/pow.out b/tests/expectations/compiler/integers/i32/pow.out index 09393f491e..02d5652a1d 100644 --- a/tests/expectations/compiler/integers/i32/pow.out +++ b/tests/expectations/compiler/integers/i32/pow.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 069e5d7d92629f17d6e1e74959a8bc9cc28cfa34e837295b35294dbaad92c04a - unrolled_ast: 069e5d7d92629f17d6e1e74959a8bc9cc28cfa34e837295b35294dbaad92c04a - ssa_ast: 7eea2064a76cd33441c02d4d1677adeaed1d42377e5a60ebc3ceeae598920277 - flattened_ast: 678cb1d61870c5cbd7381249edf9e1dcc0c093886dda2b5dd083ef68b82d099c + - initial_ast: 0d3f3887944ec6e8c1081a0d69e88d10ff6a229b2196de24748028053602a217 + unrolled_ast: 0d3f3887944ec6e8c1081a0d69e88d10ff6a229b2196de24748028053602a217 + ssa_ast: 9f55ff931c87f10022a41d9b9856f06afae62a776bbf567231c633f6ba9ddf07 + flattened_ast: 94a6e6ed3c2b112939d7d9c42721028abbf84255f3d371455b6ce2191a8c4bc0 + inlined_ast: 94a6e6ed3c2b112939d7d9c42721028abbf84255f3d371455b6ce2191a8c4bc0 bytecode: 8fde7f6968f5d5cc3ce9e9bbd5b9915995375f990bf41f7ac6e8f0a550b7c859 diff --git a/tests/expectations/compiler/integers/i32/rem.out b/tests/expectations/compiler/integers/i32/rem.out index c9ab301611..ff469156ed 100644 --- a/tests/expectations/compiler/integers/i32/rem.out +++ b/tests/expectations/compiler/integers/i32/rem.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: dfa513d1e08071be875cf677fdf717f064110e619ff6c2fb6ddc2d6208bcf450 - unrolled_ast: dfa513d1e08071be875cf677fdf717f064110e619ff6c2fb6ddc2d6208bcf450 - ssa_ast: 9f134b8eabb87f50489ff18ff93029b4a3f592373537c5945a6cbc101a677d03 - flattened_ast: 9b0cc00c2631fd9cc80c451f8054b5af71149ca916463266cd8fa3df2dad68bd + - initial_ast: 31492d69c8a7687b2c76f00cff2db072228644cd866887806c0bb36270fd4700 + unrolled_ast: 31492d69c8a7687b2c76f00cff2db072228644cd866887806c0bb36270fd4700 + ssa_ast: d7da3d17b641542c3600b1081960f63a862feced1f2af256db70db3b4b480fba + flattened_ast: bd2706f1637d0d0f5c29fab81cb91fd4b8e1287be8eebd017e655a135ac59204 + inlined_ast: bd2706f1637d0d0f5c29fab81cb91fd4b8e1287be8eebd017e655a135ac59204 bytecode: 5f3b856138f21abdccf6f7663995e7109d9a034bebc1c97573aabb9059a3a4ca diff --git a/tests/expectations/compiler/integers/i32/shl.out b/tests/expectations/compiler/integers/i32/shl.out index 3c5d739b1c..1d885d8773 100644 --- a/tests/expectations/compiler/integers/i32/shl.out +++ b/tests/expectations/compiler/integers/i32/shl.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 6f5cab1e1954664432e0c3fcdf88f9e5bdc37145b3c2d65206bf09f776ec8648 - unrolled_ast: 6f5cab1e1954664432e0c3fcdf88f9e5bdc37145b3c2d65206bf09f776ec8648 - ssa_ast: 88ec57f9420fc5af461c6acc9786e018713a222df65a01f2e0086d0813c08f6d - flattened_ast: f25689cae33ea7b887f83c512d66f6f331a27f585e7f397077a34d34df66522b + - initial_ast: 72cc14de90713951b62afb2c6f00794dd04a12fa6ad4a58fb5b8173cff686b41 + unrolled_ast: 72cc14de90713951b62afb2c6f00794dd04a12fa6ad4a58fb5b8173cff686b41 + ssa_ast: fa54e329fd0842e19f981f63090fac2c1bd42b2e32076005f6a93d12587f9814 + flattened_ast: d9405729b94dd28178fbae2b11a6f8d38d8d2eb942b09789257ae66af7789c79 + inlined_ast: d9405729b94dd28178fbae2b11a6f8d38d8d2eb942b09789257ae66af7789c79 bytecode: b069cb686a859904113693c69a78d951b07809cfec5a01f3178c7057287ba26f diff --git a/tests/expectations/compiler/integers/i32/shr.out b/tests/expectations/compiler/integers/i32/shr.out index 731a69aa31..9a87baeddc 100644 --- a/tests/expectations/compiler/integers/i32/shr.out +++ b/tests/expectations/compiler/integers/i32/shr.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ad824270f10a790c5293cc592764e9f787b7d7a23156bf4dd6ed0b1e6f7956f3 - unrolled_ast: ad824270f10a790c5293cc592764e9f787b7d7a23156bf4dd6ed0b1e6f7956f3 - ssa_ast: bd9160fc9dd62a0ba90c9b07187777c08571833095906bc2eed745ed7b170a5f - flattened_ast: 67ebf918c0e0cdcf7f454d6a24f118831330bc70871e091aba67d84226bb2c08 + - initial_ast: 721835a5ff0138c81a62ab34528b533123fd692c318cd2eff38facc2688046e6 + unrolled_ast: 721835a5ff0138c81a62ab34528b533123fd692c318cd2eff38facc2688046e6 + ssa_ast: 92445b5a175f352acf8fe0b62d85cc70aab87fba9d2e48ec748cfdaccef9c5b2 + flattened_ast: 73b2c90a88b48b0a9870f19c94bbf886b22e59481146d2fc4af2c6935d67ddeb + inlined_ast: 73b2c90a88b48b0a9870f19c94bbf886b22e59481146d2fc4af2c6935d67ddeb bytecode: 699eda9f97d2b6c417a0fba495fdf3ff6f05965d5bc9dbd5f65ff738d5df5d4f diff --git a/tests/expectations/compiler/integers/i32/sub.out b/tests/expectations/compiler/integers/i32/sub.out index e671fde315..635441d99c 100644 --- a/tests/expectations/compiler/integers/i32/sub.out +++ b/tests/expectations/compiler/integers/i32/sub.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b760112432da7d2f44caed56cbd1a9397b378aa3b9b8ae83520d89a1edbb2aac - unrolled_ast: b760112432da7d2f44caed56cbd1a9397b378aa3b9b8ae83520d89a1edbb2aac - ssa_ast: bebf6d70eaf850004593662ca0c6da8f2cb6740ec63d967e50706795a7a34514 - flattened_ast: 768fc58caa320d23f072796c22ceae962d5ad0ed48f08a542f205cf63b6e3668 + - initial_ast: 62a567be27d96098ba6bcd9e136aadfcba5d6d6d58274eab4ec03818809cb641 + unrolled_ast: 62a567be27d96098ba6bcd9e136aadfcba5d6d6d58274eab4ec03818809cb641 + ssa_ast: 2a64ad8ea4f81725eead1ad80f31f3e38208d9161304bff1fc7ccf3c90cb7aa3 + flattened_ast: c48774ddd7240e4fed8b0347bfd8cc6b745cbdc52bf33c1fdcda61b65257dbbb + inlined_ast: c48774ddd7240e4fed8b0347bfd8cc6b745cbdc52bf33c1fdcda61b65257dbbb bytecode: 181e307cfa4facef9fd4cb209e120f102fbd934b6bdaf6208f8578360b8bb707 diff --git a/tests/expectations/compiler/integers/i32/ternary.out b/tests/expectations/compiler/integers/i32/ternary.out index 145806c064..f2f29277c1 100644 --- a/tests/expectations/compiler/integers/i32/ternary.out +++ b/tests/expectations/compiler/integers/i32/ternary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: afb9f1fd4f1def77f05ccdfb456e9c07cfeb7e4ca7fc6baeb7f3a6fdabc62d22 - unrolled_ast: afb9f1fd4f1def77f05ccdfb456e9c07cfeb7e4ca7fc6baeb7f3a6fdabc62d22 - ssa_ast: 86788ca94205742aec0b732dbb2411430f46e4fa880fd4c0dce637ef43467653 - flattened_ast: 664a4fe4a4336c1fe32882d7b7a38ac84ed65f89eb9a89c4b4a567609aaa15f5 + - initial_ast: efe71b996f45113c33226796b7370784a645da43ae2bebadfe52736b2bb5c889 + unrolled_ast: efe71b996f45113c33226796b7370784a645da43ae2bebadfe52736b2bb5c889 + ssa_ast: cba7acecae2b084aadabac69c6b1f5e6dd3a9edd585ce973a31197beff098d62 + flattened_ast: a0c151d9765c85d125ee8d9c1a0ab359fa8c7d47c7cd35ce01b831edb5b53abf + inlined_ast: a0c151d9765c85d125ee8d9c1a0ab359fa8c7d47c7cd35ce01b831edb5b53abf bytecode: 5e573c847fa4f1ac29236a5eb9a8a5601cdc8ab9fc41d1fe57225be41ca1f38e diff --git a/tests/expectations/compiler/integers/i32/xor.out b/tests/expectations/compiler/integers/i32/xor.out index 4d2fe640a1..7eb116e207 100644 --- a/tests/expectations/compiler/integers/i32/xor.out +++ b/tests/expectations/compiler/integers/i32/xor.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: cb40f36627b10f1d5647e4a9e49ac766181c7ddfc0286bad3296d08ebf617fd9 - unrolled_ast: cb40f36627b10f1d5647e4a9e49ac766181c7ddfc0286bad3296d08ebf617fd9 - ssa_ast: d1ba917be39579d6fe1ec748d69656c38887c16fd3e4260579be9d9ef413f8cf - flattened_ast: 99ea74485b07febed6387372ede17412db400f351c73c84fbc227d3be957b460 + - initial_ast: 677f67b7b794e25f016127e50c1e715784a43498abb091afb08b1b781550d901 + unrolled_ast: 677f67b7b794e25f016127e50c1e715784a43498abb091afb08b1b781550d901 + ssa_ast: efa15b003f3e6c0a328ad9f5ad744c4f05febde5c5b7a82c702ca2c3957b074b + flattened_ast: 708d6b2ac2998b534f400d29e904127673d4aa611007ea67d03a4b291f52642e + inlined_ast: 708d6b2ac2998b534f400d29e904127673d4aa611007ea67d03a4b291f52642e bytecode: e11c7631389943bb7588bb83da0b213b8c135def3ae965cb4898c010e4a61d60 diff --git a/tests/expectations/compiler/integers/i64/add.out b/tests/expectations/compiler/integers/i64/add.out index fa89717ccc..3123293f86 100644 --- a/tests/expectations/compiler/integers/i64/add.out +++ b/tests/expectations/compiler/integers/i64/add.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 0e9611c67f0fcb81500bf7dcf6030dd66609dd1636ed3d2232b5117b13bbc5e1 - unrolled_ast: 0e9611c67f0fcb81500bf7dcf6030dd66609dd1636ed3d2232b5117b13bbc5e1 - ssa_ast: b772de5d785d694460c91c687d7c81bf025d843f7e615e22a10c0c791662ec30 - flattened_ast: 51dca2268aaac80efd0c28d76a6a4c257bcb868b6833d74b9555da9a31f69d13 + - initial_ast: 1a896ccb98416a459c5edfa245904e3d344ebd999d8eb5da23ce62ec741792ef + unrolled_ast: 1a896ccb98416a459c5edfa245904e3d344ebd999d8eb5da23ce62ec741792ef + ssa_ast: 8fbc1e30d9439e5e47a30ed4898631f933bb289388513e3481fdb4896b10d223 + flattened_ast: 5ce9d97a005bf5e2054b33ac761ef40d3f7dc90b79087638c68fbc9fe7f2bb7a + inlined_ast: 5ce9d97a005bf5e2054b33ac761ef40d3f7dc90b79087638c68fbc9fe7f2bb7a bytecode: 17d483203a936ddc245bdc0796535ea82eb4e2299e9c0ed1cb64273c004dce73 diff --git a/tests/expectations/compiler/integers/i64/and.out b/tests/expectations/compiler/integers/i64/and.out index 566ef748f3..7a0846314d 100644 --- a/tests/expectations/compiler/integers/i64/and.out +++ b/tests/expectations/compiler/integers/i64/and.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: f3c48ebe21e26679d5a08ec3ba816d4fb2bd64e95b6c2401af3dd3b64be2fa5c - unrolled_ast: f3c48ebe21e26679d5a08ec3ba816d4fb2bd64e95b6c2401af3dd3b64be2fa5c - ssa_ast: 3ed2f5d0b42eebf4c43970e223376091714c2f39b8d23dd516a94cd2e3dc076c - flattened_ast: 79f19351f49eed2148851d7a727ef360c5b1285f53d454fc7f8ec7d8d8cd9bc7 + - initial_ast: 45cded49e482043c6f99ecf68bdb3d95a9c172f72cb2b8dd45d04379f864914f + unrolled_ast: 45cded49e482043c6f99ecf68bdb3d95a9c172f72cb2b8dd45d04379f864914f + ssa_ast: 54518951d20d3e4ac3a473ca7871f680c7e017e9638779a888f29ade194962b9 + flattened_ast: fadf1c8f0085da6f47d2f9b8da27972ac89e8fa629c3eaedc8b997ba193f9330 + inlined_ast: fadf1c8f0085da6f47d2f9b8da27972ac89e8fa629c3eaedc8b997ba193f9330 bytecode: 1900494d905399f3c3cb4a321ccaceaf771e194ecffde3f9256f8a4236379d72 diff --git a/tests/expectations/compiler/integers/i64/console_assert.out b/tests/expectations/compiler/integers/i64/console_assert.out index 4a19b6fd85..8e23fd4d35 100644 --- a/tests/expectations/compiler/integers/i64/console_assert.out +++ b/tests/expectations/compiler/integers/i64/console_assert.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 4c90f83c312c6e7fcc8ce83b14fb321b5020e3bd8baf40878d60d44e5afd4c37 - unrolled_ast: 4c90f83c312c6e7fcc8ce83b14fb321b5020e3bd8baf40878d60d44e5afd4c37 - ssa_ast: 461e6d87ca947f6f837e063f2281976e0e0c3fbc601c19d3ece48c2b6aad7c69 - flattened_ast: e4228bf3d44761dbede153c1b6d471e7cb64e908add2ca148e288ab0bc3c7752 + - initial_ast: 9ece7486ef6f0e8e674d82ee52c2014814d3f60dac62b1b40e4f88dc6332f8c7 + unrolled_ast: 9ece7486ef6f0e8e674d82ee52c2014814d3f60dac62b1b40e4f88dc6332f8c7 + ssa_ast: 68a33454ce0c3672a579323c73e7ff54393ed2d2d33c392cd6ea0ad1e7210087 + flattened_ast: e600d74aa281e08c42dde9953ab63bc5f53bf5318cbac3df21be079ea8e1c1d4 + inlined_ast: e600d74aa281e08c42dde9953ab63bc5f53bf5318cbac3df21be079ea8e1c1d4 bytecode: a933fea3a225baaab4b8d1290eb57e8146b2c9d5b5f26d93c1d9e7b75f4ce004 diff --git a/tests/expectations/compiler/integers/i64/div.out b/tests/expectations/compiler/integers/i64/div.out index 49f0d3fcde..d8f82b0d81 100644 --- a/tests/expectations/compiler/integers/i64/div.out +++ b/tests/expectations/compiler/integers/i64/div.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ccaed7a5a093164baad702f4f6bd00e88d258501c758f88289439004c7297738 - unrolled_ast: ccaed7a5a093164baad702f4f6bd00e88d258501c758f88289439004c7297738 - ssa_ast: 6710b1f8786b15d9f53de6cff69b780e7e49c0ce77acafbcd65d7a142d94ce8e - flattened_ast: 11a69da937647f7d3f9cd74be04ed41c8c30921d6d94e44128861ec1d786880b + - initial_ast: dfb39354d18a9f1547df93beb4eb440921ab96ca76bb57c3633c076436c69b5a + unrolled_ast: dfb39354d18a9f1547df93beb4eb440921ab96ca76bb57c3633c076436c69b5a + ssa_ast: 7e4a07ee7f13c91f7bc65830119b729ef83d59949cdc83a43134a2d5ec5d4aa0 + flattened_ast: aae9504daf3baca0987ed7fcdc5a50f405673ef6299a53c308fbd7c4145bd3d9 + inlined_ast: aae9504daf3baca0987ed7fcdc5a50f405673ef6299a53c308fbd7c4145bd3d9 bytecode: 4ff31765b1127b297af44c6e74441b7c065df074c73f29c50a4284a207c399ad diff --git a/tests/expectations/compiler/integers/i64/eq.out b/tests/expectations/compiler/integers/i64/eq.out index 964b693104..bc3b57cfbf 100644 --- a/tests/expectations/compiler/integers/i64/eq.out +++ b/tests/expectations/compiler/integers/i64/eq.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ba5d1d70ae955f5423e69727ff0d60d5e7fedbb82adfa104f3817e1ad35f50b2 - unrolled_ast: ba5d1d70ae955f5423e69727ff0d60d5e7fedbb82adfa104f3817e1ad35f50b2 - ssa_ast: 958b409efcf194c45b3ac7b2998f6f950b2c21a2907d15991bcd9d9bcd7b9fcf - flattened_ast: 9204630c5a335b443cffd4c21099c8e47dc01e4b306f3a585151ca6208241ce3 + - initial_ast: 152ffc231e294688968f0697d008d822594e89953eb7a9bc8c50bcfb71639732 + unrolled_ast: 152ffc231e294688968f0697d008d822594e89953eb7a9bc8c50bcfb71639732 + ssa_ast: 7235d8d2e90a5cdcfa67d1496322c854fe549409bf174b8929867b69c203bb38 + flattened_ast: f9b91e5d31e12eb5eeeae64949b7866d36faff60003075b05c8d151b2bbb67b3 + inlined_ast: f9b91e5d31e12eb5eeeae64949b7866d36faff60003075b05c8d151b2bbb67b3 bytecode: d9eaaabc3cd4c2a71842849ab67c1774ea5b405de5b9e19c2569f55ee2f5ff0d diff --git a/tests/expectations/compiler/integers/i64/ge.out b/tests/expectations/compiler/integers/i64/ge.out index abbe818687..277e61d3f0 100644 --- a/tests/expectations/compiler/integers/i64/ge.out +++ b/tests/expectations/compiler/integers/i64/ge.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 234da5527febcac53d22d8d53984f0941aadc9a724ec83d7f8371ee2ceda5855 - unrolled_ast: 234da5527febcac53d22d8d53984f0941aadc9a724ec83d7f8371ee2ceda5855 - ssa_ast: 9b30e8d9e3a3af6ed8c72536282ea2d9e42af749b050a5122f515ebda9278a65 - flattened_ast: d518fca46d44edf6ff66a1840334788ba97b6eb3477698cd92c7bb538dee8745 + - initial_ast: 30f2caee73df49db72eb48a65af31001564fccdd828198dcbfae59c78d5ff848 + unrolled_ast: 30f2caee73df49db72eb48a65af31001564fccdd828198dcbfae59c78d5ff848 + ssa_ast: cb7be0fc685093bbb72d9a4a5943dc26c271c0e92233928cbc2dddfbbc01bc87 + flattened_ast: d28f84c6a585562bb3a519c26ca9dafaa619871acb8275073e455fe67bad718a + inlined_ast: d28f84c6a585562bb3a519c26ca9dafaa619871acb8275073e455fe67bad718a bytecode: a4e24f8e568e5e919da45bb4f5af3c2e9cee35eefb118416bff06c89854386f3 diff --git a/tests/expectations/compiler/integers/i64/gt.out b/tests/expectations/compiler/integers/i64/gt.out index de14085cff..4fb8714963 100644 --- a/tests/expectations/compiler/integers/i64/gt.out +++ b/tests/expectations/compiler/integers/i64/gt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 7922ab3f9f42065f80e233a2ebd76cf58fe5525d17996ffde046cabb39edf194 - unrolled_ast: 7922ab3f9f42065f80e233a2ebd76cf58fe5525d17996ffde046cabb39edf194 - ssa_ast: ed0f1e051b65e7efea61cb9722a0e316ea773e42101802a3e1c62ad135327187 - flattened_ast: c042e954131dcbe8c82a628e3779f3c54a70ade997f569aa20759f45a28a0027 + - initial_ast: b27a8b66b4e15a4b2f01e618cf6ee9c7157d58355fb6e71b5216d8a024862bd9 + unrolled_ast: b27a8b66b4e15a4b2f01e618cf6ee9c7157d58355fb6e71b5216d8a024862bd9 + ssa_ast: fa57bafc9b8fb0881aee16b1b589406127a582428a428e698b79f445a3f038ad + flattened_ast: 05f479f4eb618dcedf26be8248a4231cadd24be6e9a13bc0d99786eefe389551 + inlined_ast: 05f479f4eb618dcedf26be8248a4231cadd24be6e9a13bc0d99786eefe389551 bytecode: d4c954232923c21fa21d3bda6a7dcc582ea6bb1b83600053839b5f3186c722cf diff --git a/tests/expectations/compiler/integers/i64/le.out b/tests/expectations/compiler/integers/i64/le.out index c5d60bea8b..39b26e3112 100644 --- a/tests/expectations/compiler/integers/i64/le.out +++ b/tests/expectations/compiler/integers/i64/le.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e21f4de3d0fe67f5a7b534dcc941b0019c0ef847fc8429bf06f30a9b0517ca3d - unrolled_ast: e21f4de3d0fe67f5a7b534dcc941b0019c0ef847fc8429bf06f30a9b0517ca3d - ssa_ast: 280c2a27be29f07499d996781f4a03cd0b1b1d1555bd110587945de3af2af1db - flattened_ast: 22bd3a9c01e04f017bf6a2aa76a38d43327a495fb701500e6caf4de770d8bfc7 + - initial_ast: 7958c45fbe6812400273968cf53acf0739802db9c8a63f79d90f19f4f5454c24 + unrolled_ast: 7958c45fbe6812400273968cf53acf0739802db9c8a63f79d90f19f4f5454c24 + ssa_ast: da945779aafd95c703bbc42b09f9f8e7e1bd45330cab756f9fdfb01e04c57e8f + flattened_ast: 9b4d44041a020ee7b18ed19a6142f098b3586eb13ab60cd13d691c68e813774a + inlined_ast: 9b4d44041a020ee7b18ed19a6142f098b3586eb13ab60cd13d691c68e813774a bytecode: 5e52e11a750dd49054fbc4df94cca7d6d8a6e3500688ab9dff28a2840f2debce diff --git a/tests/expectations/compiler/integers/i64/lt.out b/tests/expectations/compiler/integers/i64/lt.out index f534dab0b5..bb01cdc066 100644 --- a/tests/expectations/compiler/integers/i64/lt.out +++ b/tests/expectations/compiler/integers/i64/lt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 07f4526fb4a91c2d0bb58c3d72e9fe316663ad8502d9bc2df24c5a7cfbc4e696 - unrolled_ast: 07f4526fb4a91c2d0bb58c3d72e9fe316663ad8502d9bc2df24c5a7cfbc4e696 - ssa_ast: 4941b98b931459e2dcd91d0caa8acb7755cbd061c452ce02c6908e65eca9baab - flattened_ast: 086559ac95f73a366a44b1a91a23891a441f9a0c1ab4a75f015428b6f8e3b312 + - initial_ast: d4e3a8f41b615757cdf99d4d609a10755ab118378b65eeee6a53ee9550033236 + unrolled_ast: d4e3a8f41b615757cdf99d4d609a10755ab118378b65eeee6a53ee9550033236 + ssa_ast: 564ec318ffcca962776790d045fc1ea06d4d4aa25aa0b954ec4494f3c9656906 + flattened_ast: c5b81cf64a4773e73543bc69f53eabbc60194f7d8fea08d77585a4d5cc5196ce + inlined_ast: c5b81cf64a4773e73543bc69f53eabbc60194f7d8fea08d77585a4d5cc5196ce bytecode: 4343e01aa9b8faa22e183d62b592ac2fdeadeddce9c27d195579daf09195035d diff --git a/tests/expectations/compiler/integers/i64/max.out b/tests/expectations/compiler/integers/i64/max.out index 66d42f4261..3cd250ff21 100644 --- a/tests/expectations/compiler/integers/i64/max.out +++ b/tests/expectations/compiler/integers/i64/max.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: fdad5019690949fac8c086a5255bee8b9973f115e2863a71c4be7ca90cf133a8 - unrolled_ast: fdad5019690949fac8c086a5255bee8b9973f115e2863a71c4be7ca90cf133a8 - ssa_ast: 6aeb1c07f6fc9f67b9c1ef31c51c52e4fae9ecb2ba81217aa9dba8e83a550873 - flattened_ast: 5bb31863685e087c58d0863e1d4adc2a856a98f5bcc6db68a283cf294f8531b1 + - initial_ast: ae45a3f2626e87be344d510c69b9d726f8c1259e3e0384157e6625a78c76b155 + unrolled_ast: ae45a3f2626e87be344d510c69b9d726f8c1259e3e0384157e6625a78c76b155 + ssa_ast: 4c1d249deb66448ff22d88f0414e1a42af6de03ebdbeab5863a6bd3b436e7d4d + flattened_ast: 66f0435dd502095b13769c76c5cfc5a42141eccf4a0057da9406d31aff5748ea + inlined_ast: 66f0435dd502095b13769c76c5cfc5a42141eccf4a0057da9406d31aff5748ea bytecode: 929c4b937a8a738bf0965e24eeedbc03e55d101c8e36cfe1291733c1669280a5 diff --git a/tests/expectations/compiler/integers/i64/min.out b/tests/expectations/compiler/integers/i64/min.out index fb4eb77708..2508c16d9c 100644 --- a/tests/expectations/compiler/integers/i64/min.out +++ b/tests/expectations/compiler/integers/i64/min.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: daf0bb14f7f7342d21f57f90c946eaf457bd50a18c1777f39a299b43c156f99e - unrolled_ast: daf0bb14f7f7342d21f57f90c946eaf457bd50a18c1777f39a299b43c156f99e - ssa_ast: e434f625689cd3549cce3a50c3f35c4ec54f4339fd9c21f4ccc486005378dfdc - flattened_ast: dfcb8d3c590bf10a19e03d36d30e5d11a1e71b7d5e5771abbabe0d5b6a23438a + - initial_ast: 89eefed60b3261e0c6af9479c75837ef3ac7de647c99a5876176ce0f8cbe99c0 + unrolled_ast: 89eefed60b3261e0c6af9479c75837ef3ac7de647c99a5876176ce0f8cbe99c0 + ssa_ast: 9a36e16e7906f75a4b58a9e9a7f07a20de1d4eecc3f15d0b2cc5b51c288bf2ab + flattened_ast: 27e4b193adda62809c5ff6b2752e48d939defff47125e36cdd2520baec6511a3 + inlined_ast: 27e4b193adda62809c5ff6b2752e48d939defff47125e36cdd2520baec6511a3 bytecode: c70650dc5c5f4290173474dc878e9507448aed41f0f9f91348871c76e1a0d743 diff --git a/tests/expectations/compiler/integers/i64/min_fail.out b/tests/expectations/compiler/integers/i64/min_fail.out index faf6c6d055..552407d924 100644 --- a/tests/expectations/compiler/integers/i64/min_fail.out +++ b/tests/expectations/compiler/integers/i64/min_fail.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1e8cd063ff228b6ee31f308dac919870d835c5e55190d5247c8b9edbfc4f9179 - unrolled_ast: 1e8cd063ff228b6ee31f308dac919870d835c5e55190d5247c8b9edbfc4f9179 - ssa_ast: 400b5d055969370c2a2cbda1a51bc680d5434076c4e6278483b73eba410eb339 - flattened_ast: 3e90c7fc84243febecf94b4a2b9b6100bf02823af57408cf61da674632f61512 + - initial_ast: 476bf1f6462e3e5e1088453848e3e857b53bd258b314b5870c4b412b93eec688 + unrolled_ast: 476bf1f6462e3e5e1088453848e3e857b53bd258b314b5870c4b412b93eec688 + ssa_ast: 6c221da2c29f57844de7b134f6d57a6933e17e2a2a8091581790b99da0a00e73 + flattened_ast: 5cf08f6bb13069b1b18b55a7105144b0ef27aaad3b38404a630afa1c3f03a298 + inlined_ast: 5cf08f6bb13069b1b18b55a7105144b0ef27aaad3b38404a630afa1c3f03a298 bytecode: 974c9ba823baf31ab404b852fea45c594b862ef0cc1f75b0a8c929dcbaa9beda diff --git a/tests/expectations/compiler/integers/i64/mul.out b/tests/expectations/compiler/integers/i64/mul.out index 4d39f930e9..f5bba5b615 100644 --- a/tests/expectations/compiler/integers/i64/mul.out +++ b/tests/expectations/compiler/integers/i64/mul.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 303de02eb3b78cacb095d68aff65a920320a8dde82251a8bc14a35dde1040ef0 - unrolled_ast: 303de02eb3b78cacb095d68aff65a920320a8dde82251a8bc14a35dde1040ef0 - ssa_ast: f343a8e41cd3010df7b412ca118f718badfbf99c5c04e746000c32a26f4ae75a - flattened_ast: d0fc6c6015fa427f5f475e9b62e5157bc1cddf900b808064ceb0727c2db5bba7 + - initial_ast: ebb39c461b8481a0a7c7b09eb36ea4fc304c52831a0b6d0310f68da1d8c5d66c + unrolled_ast: ebb39c461b8481a0a7c7b09eb36ea4fc304c52831a0b6d0310f68da1d8c5d66c + ssa_ast: b46aaa0651dc469592695168a757daf19b768a988303450495df7dc69ee27d50 + flattened_ast: 212ee0c5794ce1c1049572a9c9150128c602d0b309a01c79ca7a855d8b8ff7e3 + inlined_ast: 212ee0c5794ce1c1049572a9c9150128c602d0b309a01c79ca7a855d8b8ff7e3 bytecode: 99be027f5187d87654776502492f4f1978e42cc05f8f8f95182affbca89c3821 diff --git a/tests/expectations/compiler/integers/i64/ne.out b/tests/expectations/compiler/integers/i64/ne.out index bb67f9c519..5fd6a28fce 100644 --- a/tests/expectations/compiler/integers/i64/ne.out +++ b/tests/expectations/compiler/integers/i64/ne.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 638850c9e28b8e6c2823ccbf2697dd7ebbe30ffa0461e5d0f43758964fb731fc - unrolled_ast: 638850c9e28b8e6c2823ccbf2697dd7ebbe30ffa0461e5d0f43758964fb731fc - ssa_ast: 2648210da18d7f2d9974b8b36b0bb4c5592fd1acf30b5fdbda030003032b62dd - flattened_ast: df80dcbf1a7e682eb0ad8d45dfe0f33dd4e2faa603db4652004a23f695c5a8ad + - initial_ast: de4148f1e080f5c2a7987e500772567847f13af2ef6f00d48e2771e1e2a9a12f + unrolled_ast: de4148f1e080f5c2a7987e500772567847f13af2ef6f00d48e2771e1e2a9a12f + ssa_ast: e4c2a29baf4c409c4e2ff2b822607911d0ae845cce4795ff2fe3ca076b1a673c + flattened_ast: ad6eab48fea0964db8b32915464de08b246e4dea1fb700b918bd4a3f01ec4a39 + inlined_ast: ad6eab48fea0964db8b32915464de08b246e4dea1fb700b918bd4a3f01ec4a39 bytecode: b10e55267602daa0dad06640cb8fd5284e816f1186333a8fc5fa9d35af8e18a1 diff --git a/tests/expectations/compiler/integers/i64/negate.out b/tests/expectations/compiler/integers/i64/negate.out index 0e8687e95b..fa2d8ca07f 100644 --- a/tests/expectations/compiler/integers/i64/negate.out +++ b/tests/expectations/compiler/integers/i64/negate.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 85e48f5a10d8c03e7365fb253e0b8d14de2550285d527c7881c99060cf9bc454 - unrolled_ast: 85e48f5a10d8c03e7365fb253e0b8d14de2550285d527c7881c99060cf9bc454 - ssa_ast: 3f6c42f8910dfd61b1bc05b938ae2410d516023145df19bc550a5bbfb1bb76d4 - flattened_ast: 94bc1604f933c0e12eb47f75aca56f47ecdc63168e1aac70dce95c1f89219aa7 + - initial_ast: 9267e59358dc48676d40b707def027e00573e6403c5ef914b24a54e1bf3ec2ee + unrolled_ast: 9267e59358dc48676d40b707def027e00573e6403c5ef914b24a54e1bf3ec2ee + ssa_ast: 78a32a71f9ad153c60d2a402eef856c7620cf4e2372c5c6fa137261c648f01f0 + flattened_ast: da651dd5fe10a0c60dc0efd3bb55fcae21a06d19cef628f96562a423623b6023 + inlined_ast: da651dd5fe10a0c60dc0efd3bb55fcae21a06d19cef628f96562a423623b6023 bytecode: 1eb8ed3e4e4f46596178405f771a75b5eb12a6aa0f81de6ad95a5a0a1fa89923 diff --git a/tests/expectations/compiler/integers/i64/negate_min_fail.out b/tests/expectations/compiler/integers/i64/negate_min_fail.out index 2d98b071cc..9bd1f80391 100644 --- a/tests/expectations/compiler/integers/i64/negate_min_fail.out +++ b/tests/expectations/compiler/integers/i64/negate_min_fail.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 9c7636d38015ea24685c1573d9a3ecb1a476bde7458f1847516280757df694c1 - unrolled_ast: 9c7636d38015ea24685c1573d9a3ecb1a476bde7458f1847516280757df694c1 - ssa_ast: 5a3825576d4b8b1c5a5d79bfe76766e17685a134c73aa88fe58331fb010dd142 - flattened_ast: 66ba6984eab643ebe6ae07082ba1bc5002a4f9a9ff12a1ae9600733d46c5576b + - initial_ast: 898ffb157e0dceb1d024cacec2daeab027619787907001179f4da352e1bb2ae0 + unrolled_ast: 898ffb157e0dceb1d024cacec2daeab027619787907001179f4da352e1bb2ae0 + ssa_ast: 05fabac2842b95c4af0ec640c01eb470aa715ebf93975b9f5bfbd66cc35fb4ed + flattened_ast: a2451062ac9d92a4a3c752e8a2660ad2dd474a6e0d3cfaf4f2dcd78a1b93666f + inlined_ast: a2451062ac9d92a4a3c752e8a2660ad2dd474a6e0d3cfaf4f2dcd78a1b93666f bytecode: a1de0e06df0187d60cb76010969bb2ad1450e01f2b30f6de978c35898872e782 diff --git a/tests/expectations/compiler/integers/i64/negate_zero.out b/tests/expectations/compiler/integers/i64/negate_zero.out index d43cd75832..5558537be5 100644 --- a/tests/expectations/compiler/integers/i64/negate_zero.out +++ b/tests/expectations/compiler/integers/i64/negate_zero.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 58ac08730469dbb8822b1f8ac36475bb98f5866d45339af1c4e98eb2c4362ff0 - unrolled_ast: 58ac08730469dbb8822b1f8ac36475bb98f5866d45339af1c4e98eb2c4362ff0 - ssa_ast: d7dd0a931558bd23fd4f28f17f31940a95132ca6c99f9dab2eff46ca2babbc13 - flattened_ast: 8487fc6edaa1b52a2e442a518996f9488a4fd852abc18cb0f3f02460536c63aa + - initial_ast: 0fb4cc532e6e889e1735a45e8d1baa6545464e81390c78c1ce74881adcc0a8f8 + unrolled_ast: 0fb4cc532e6e889e1735a45e8d1baa6545464e81390c78c1ce74881adcc0a8f8 + ssa_ast: f6200a45c4fd92ef6f17c5a90f3bc761dff09eed899e899686b8bc03ecb80e7a + flattened_ast: 17e30330b1560aa133e03faa655b827f3f37a8fad9456263985dfc9f2fa3f991 + inlined_ast: 17e30330b1560aa133e03faa655b827f3f37a8fad9456263985dfc9f2fa3f991 bytecode: 0295112d7456742abc2395eeab5b9cb4ee8c80a439b0e861404330014260086e diff --git a/tests/expectations/compiler/integers/i64/operator_methods.out b/tests/expectations/compiler/integers/i64/operator_methods.out index 07e7248600..df1488679f 100644 --- a/tests/expectations/compiler/integers/i64/operator_methods.out +++ b/tests/expectations/compiler/integers/i64/operator_methods.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 9eb72528f32e178e1249fad730470d07b08e3afd8ad531fd7351b397e5e7a57e - unrolled_ast: 9eb72528f32e178e1249fad730470d07b08e3afd8ad531fd7351b397e5e7a57e - ssa_ast: 1fa123346e977d929643bff393e34784fc89f7f2e9a8323ea8c2b0187cf8ad41 - flattened_ast: 6c54de1868e89ed13f2abaa337ed384867a82b7bdbe3e8a1b367f0aeecc45310 + - initial_ast: aacae98aeedbd8eb16311d12874e2245ce8c205fbb67f7c5efdb8b3f71d4c605 + unrolled_ast: aacae98aeedbd8eb16311d12874e2245ce8c205fbb67f7c5efdb8b3f71d4c605 + ssa_ast: 7a9ea30b5ebc12987e117322db994faae028794aacc81ad91c48fdcab3c95b3b + flattened_ast: 4e635e9839a156e43a5b384f8236b4e5bfa0bd4b8628248b33bfd4fcdde51268 + inlined_ast: 4e635e9839a156e43a5b384f8236b4e5bfa0bd4b8628248b33bfd4fcdde51268 bytecode: 45e1a7496d8146d68d8b9e79a05867ae62ee1ef6d06ff6cdd69932bdd88ee66e diff --git a/tests/expectations/compiler/integers/i64/or.out b/tests/expectations/compiler/integers/i64/or.out index c57d717123..ffb355fa47 100644 --- a/tests/expectations/compiler/integers/i64/or.out +++ b/tests/expectations/compiler/integers/i64/or.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 0707d0a64a329bfa0f954d7221586dba2dcf82c2bb4c47d7822a059479da3390 - unrolled_ast: 0707d0a64a329bfa0f954d7221586dba2dcf82c2bb4c47d7822a059479da3390 - ssa_ast: 6fb984032e6e7f2226a1dafb799276e576acd6c17c2fafccd409925cde1ffd70 - flattened_ast: d98045b42cb37a5b0dcfa9364982a3057ac75caa3c55567b7107d043869227c3 + - initial_ast: 42b263a766182f5c5b89bbf28d293717330db5e9af310b31a867a82ba999cb9d + unrolled_ast: 42b263a766182f5c5b89bbf28d293717330db5e9af310b31a867a82ba999cb9d + ssa_ast: fd11513f1819924530b3c799eda59b6a6cbb4d12480cc51021ebcdf9ec030003 + flattened_ast: 262c943aefe96fe5c26afb9a5b65ff24f7823f3f3f19d0243807f3c0bfb277f8 + inlined_ast: 262c943aefe96fe5c26afb9a5b65ff24f7823f3f3f19d0243807f3c0bfb277f8 bytecode: 10d8b6e5560993921b85cea5a03c9e5af008271e9f540aa2a5e2232302ec215a diff --git a/tests/expectations/compiler/integers/i64/pow.out b/tests/expectations/compiler/integers/i64/pow.out index d8ba843b78..9235d9b468 100644 --- a/tests/expectations/compiler/integers/i64/pow.out +++ b/tests/expectations/compiler/integers/i64/pow.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5fcec92df3f257c1fe4701bf972073817692c12720a0e57f2e01b1ea91c62e0b - unrolled_ast: 5fcec92df3f257c1fe4701bf972073817692c12720a0e57f2e01b1ea91c62e0b - ssa_ast: 965e4b2b272f610bd98ea3a753d70b63aa9bff9a6b86f69cb1b29057e80c31f6 - flattened_ast: f136b122a950d2b61bee034e605aeb78b5bbf643f1ef884039b96b25ab26fb3e + - initial_ast: 726693eaa934c838e10f68447e8e16f0a3c0435b33812da3158350f98bceacfb + unrolled_ast: 726693eaa934c838e10f68447e8e16f0a3c0435b33812da3158350f98bceacfb + ssa_ast: fb0e4e20eacae26bd876f7ac928b89bb8a7c6d6437c70962a33918c3f53f7f76 + flattened_ast: fcaa27ce642795aab29e5f6980dc60312d8d6e44f30e3bcd9027de36bbf457ac + inlined_ast: fcaa27ce642795aab29e5f6980dc60312d8d6e44f30e3bcd9027de36bbf457ac bytecode: ed321c5f4fbf49d901732c6bc9c133d64b569cefca9a04dcc1445d98beb4b2f7 diff --git a/tests/expectations/compiler/integers/i64/rem.out b/tests/expectations/compiler/integers/i64/rem.out index 43353a35df..611195d461 100644 --- a/tests/expectations/compiler/integers/i64/rem.out +++ b/tests/expectations/compiler/integers/i64/rem.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b5be0067d7deb04ce490efa512c385fd74e713499edbce631aa1f609cdc07135 - unrolled_ast: b5be0067d7deb04ce490efa512c385fd74e713499edbce631aa1f609cdc07135 - ssa_ast: 6f96e181065ee5050caef99eeea08aecb03b4554b167b267fbd492b34ebaaab8 - flattened_ast: cfdbf3fff8678faa06d33a4be0c4574d2cd00fa584bb42e6ce49739f140074f3 + - initial_ast: eb8202fe7ed9388cba09c6a6ea1027b371753d99fcafeeadc54b6a19d9badac7 + unrolled_ast: eb8202fe7ed9388cba09c6a6ea1027b371753d99fcafeeadc54b6a19d9badac7 + ssa_ast: f87784d1c1cc0621cbbdadc598f81c3431c0f0b8ad06ce6e2405e367a6887633 + flattened_ast: 5b8da1482b72a6b30cfb8a37b4f6db18653e927cb272334c8cf8ef335b5ba1e4 + inlined_ast: 5b8da1482b72a6b30cfb8a37b4f6db18653e927cb272334c8cf8ef335b5ba1e4 bytecode: 554ac6af1c9ec6c453966a171f2b21b09c5c1f402d4fb316680b3bfde5842bac diff --git a/tests/expectations/compiler/integers/i64/shl.out b/tests/expectations/compiler/integers/i64/shl.out index 45bdbda05b..540a6ae275 100644 --- a/tests/expectations/compiler/integers/i64/shl.out +++ b/tests/expectations/compiler/integers/i64/shl.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 3b16a404be8487cb74f1f8b1ea4c9d9087982c8b5c9f0033bd379c9d4791dcc2 - unrolled_ast: 3b16a404be8487cb74f1f8b1ea4c9d9087982c8b5c9f0033bd379c9d4791dcc2 - ssa_ast: e74c7bec0cc85ec7c8bce03b1711fae9a2e8409e1a9d0d6cde8dea6dcd91a6cb - flattened_ast: f1738411b324649c4271f973c27f890608b26d04d856db244ae0390e740c576e + - initial_ast: a8db086bebdde5dd6002c4f6811241f5f0956bd4687021f65f070ad8ec555580 + unrolled_ast: a8db086bebdde5dd6002c4f6811241f5f0956bd4687021f65f070ad8ec555580 + ssa_ast: 7c74560fa7350efa82d400ee472693e640d63960224c59c319862ff68007ff07 + flattened_ast: 9d587bde21665a6192bbe0f312930f4d9cf42ff9bd910a5925883829786cd92d + inlined_ast: 9d587bde21665a6192bbe0f312930f4d9cf42ff9bd910a5925883829786cd92d bytecode: 98564fe7ce0c9a43bb88749f61cbbc6a62377e9df7a5711110138e10165d6dc3 diff --git a/tests/expectations/compiler/integers/i64/shr.out b/tests/expectations/compiler/integers/i64/shr.out index c5f5b04a5e..ff0fc57d7a 100644 --- a/tests/expectations/compiler/integers/i64/shr.out +++ b/tests/expectations/compiler/integers/i64/shr.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: effbd5159ccc6d6dbc35c7de00473f1001a09913c15c648bf0931d05416c1150 - unrolled_ast: effbd5159ccc6d6dbc35c7de00473f1001a09913c15c648bf0931d05416c1150 - ssa_ast: 20f005a7c8991c63bb5a63c84a0365b20892a58a1b07e4d8accb5a5426808326 - flattened_ast: ea41b0ba9a32d731182e424d6878db22e41c638993403c92d836453cf15208cc + - initial_ast: edb8879b54b4b966ebc55213523408f0ba847c504f5d0ced9a24be35dacebc53 + unrolled_ast: edb8879b54b4b966ebc55213523408f0ba847c504f5d0ced9a24be35dacebc53 + ssa_ast: 9d15b7bbc9533605bc3097cbb840be66c9d4e2a922e63602883d8d83f3a6335f + flattened_ast: de58053cda2d80760c7501f9e3db0af69e7fa40f543ff7cf1b0e40b0711c6730 + inlined_ast: de58053cda2d80760c7501f9e3db0af69e7fa40f543ff7cf1b0e40b0711c6730 bytecode: 70b6844282763edb6d61664583d2c30b38259b3e2df0c8fc95d1d72ff0514aa7 diff --git a/tests/expectations/compiler/integers/i64/sub.out b/tests/expectations/compiler/integers/i64/sub.out index 7c6da0b6bd..adecb07728 100644 --- a/tests/expectations/compiler/integers/i64/sub.out +++ b/tests/expectations/compiler/integers/i64/sub.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: c87630d8931e2ba04c3a021fb2ede27459550300eaeec5b714c5153cd75f8272 - unrolled_ast: c87630d8931e2ba04c3a021fb2ede27459550300eaeec5b714c5153cd75f8272 - ssa_ast: 2e8da253798101d438326724bf76f56ae55030f666f82d327b68e3b04119b41e - flattened_ast: 6a18a5a8f81546fc674b818f5381f97a9b695267ffb99dbd12403bdaee41145c + - initial_ast: cdf20cc524198a1be8022f73649282f582a2fd25a12c172f0c7acb42b7243ab9 + unrolled_ast: cdf20cc524198a1be8022f73649282f582a2fd25a12c172f0c7acb42b7243ab9 + ssa_ast: 216e0f94a762cae9c6b27ee944c9ecea0840c3f2ffb27524a6448e378553d735 + flattened_ast: dbe52b1feb534c6fbf1e8287647da8c8f110b73b8afad5e832c531ccbf246b79 + inlined_ast: dbe52b1feb534c6fbf1e8287647da8c8f110b73b8afad5e832c531ccbf246b79 bytecode: 85db7ab7875d071536eaf1c6f9e37e5ca41ad4039a62e92fd34efc7ccc432ddb diff --git a/tests/expectations/compiler/integers/i64/ternary.out b/tests/expectations/compiler/integers/i64/ternary.out index cf4e8a2132..4abe69a4a0 100644 --- a/tests/expectations/compiler/integers/i64/ternary.out +++ b/tests/expectations/compiler/integers/i64/ternary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 27210d6f7f5baec178ab877bddaa778e9d7cf5cc8420682619646d51e250ff6d - unrolled_ast: 27210d6f7f5baec178ab877bddaa778e9d7cf5cc8420682619646d51e250ff6d - ssa_ast: 7699affdbe67bf9d302e4ffb3e267f1d47d43dc31fcb9791fb5f8aa606dfd0b8 - flattened_ast: a4eca8a18cc6e02ff7656819dc74b929a7c1ee00714de4e2f2d81ae98b6072e0 + - initial_ast: 3eb27e3c6fac75daca7e66b076b9b228d5eac3fa5fc5f36c29b42d7519d406e8 + unrolled_ast: 3eb27e3c6fac75daca7e66b076b9b228d5eac3fa5fc5f36c29b42d7519d406e8 + ssa_ast: 3014b27dee241fd4f997a1a7e60b5b0e99b83895203d5f3b2e7bdd8fef2135b5 + flattened_ast: 57fb38e9d1c97d359d49225dc4d8c42d3277f8859bc8ed0ff73d8a8aeb44030e + inlined_ast: 57fb38e9d1c97d359d49225dc4d8c42d3277f8859bc8ed0ff73d8a8aeb44030e bytecode: efc50d9c273e04e053737ce892bd545a43ffd8bf293e1a9b60ac1b39f215a653 diff --git a/tests/expectations/compiler/integers/i64/xor.out b/tests/expectations/compiler/integers/i64/xor.out index 5334fed08d..aa2d0a21ba 100644 --- a/tests/expectations/compiler/integers/i64/xor.out +++ b/tests/expectations/compiler/integers/i64/xor.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 2ea5bd24852afeec9af7c16f6bc3c1f84ed9c897275cee982f48f3076742a911 - unrolled_ast: 2ea5bd24852afeec9af7c16f6bc3c1f84ed9c897275cee982f48f3076742a911 - ssa_ast: 98559cb342075b568f321fcdda66d0506457437817abfa9f478011a40d6f9a04 - flattened_ast: 263db620bf682a6bbaadff1fec56160e6282fefa0a2b93af571c53738f289997 + - initial_ast: bbc88045d49d59b365a47238fcb1eec6ef4f7061857d5670a188eb4494e16779 + unrolled_ast: bbc88045d49d59b365a47238fcb1eec6ef4f7061857d5670a188eb4494e16779 + ssa_ast: 26710675440c832642a4932ddb88a831e011eaf156da346c765d294d06beba17 + flattened_ast: 08c494674c216dc09227a09920e518389f2f92f08317e8713ecf1bb443c516b5 + inlined_ast: 08c494674c216dc09227a09920e518389f2f92f08317e8713ecf1bb443c516b5 bytecode: 79ef5c83b542f0975485816623a41084fca121d7a9cbb2b8701d5f819be7f2cb diff --git a/tests/expectations/compiler/integers/i8/add.out b/tests/expectations/compiler/integers/i8/add.out index 201f80143d..8467d6a0a2 100644 --- a/tests/expectations/compiler/integers/i8/add.out +++ b/tests/expectations/compiler/integers/i8/add.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: bce3c06582375ee862faf2c71b79ddf148ee5e3573841d576c4bb1b0c6d3eae2 - unrolled_ast: bce3c06582375ee862faf2c71b79ddf148ee5e3573841d576c4bb1b0c6d3eae2 - ssa_ast: dac027cadca1d2064ea754c5987c71aa9f5ad24aa5ece9e70061be3f98b55ffe - flattened_ast: deb554cc6a881c83133eb04f74a9ff803fb0ff6e6f47c71b6154cbac5a81608e + - initial_ast: e6d1d672f10e66d894a4e81d01095845b1a42ed474976d0f6cc07d046852255a + unrolled_ast: e6d1d672f10e66d894a4e81d01095845b1a42ed474976d0f6cc07d046852255a + ssa_ast: 0fb901d5786a0d4ede3e59492c23fa2f8c091d6450d460144bb7678c6496f977 + flattened_ast: 8530a2ad8f971963bb3410a8486e8dc12bb3f785f7d368b6872f37ffd82b94c9 + inlined_ast: 8530a2ad8f971963bb3410a8486e8dc12bb3f785f7d368b6872f37ffd82b94c9 bytecode: 53f7284ec0cee9952b67d8f531abc9fd7efe250af6a77880444ae5a64bcf5282 diff --git a/tests/expectations/compiler/integers/i8/and.out b/tests/expectations/compiler/integers/i8/and.out index 6c739a9548..c499ce4177 100644 --- a/tests/expectations/compiler/integers/i8/and.out +++ b/tests/expectations/compiler/integers/i8/and.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 4a1ae45c13daa0b5dc5162116becd947eed6d5def8f86be42a7817e40bf8bcc1 - unrolled_ast: 4a1ae45c13daa0b5dc5162116becd947eed6d5def8f86be42a7817e40bf8bcc1 - ssa_ast: 86d1774624cc426c6325f15f8d2e3d3ba479aa3ed5ccb2768ec13c2048c25cc3 - flattened_ast: 85864bf4127ae898cfe60ea90e0251e64fdbc31834c3e9db3e088ff82a7aaa1e + - initial_ast: 0e446a8352497996dd0e00e496da0dde0b4dd3e249632f1d9511dc66d38b6dbc + unrolled_ast: 0e446a8352497996dd0e00e496da0dde0b4dd3e249632f1d9511dc66d38b6dbc + ssa_ast: e306a4621aa5ab55b39817a5a7b0093a3a5e3827e2be287ceafbf2e177cf71fd + flattened_ast: f8bfce3a9a0f0e698cfe4e2d3fb2aaf0d3db7a8714b6c61d23bd7e11347d286b + inlined_ast: f8bfce3a9a0f0e698cfe4e2d3fb2aaf0d3db7a8714b6c61d23bd7e11347d286b bytecode: 6817590922be3c3e3daabc7006ee52ccbf790f4c133edfb2b20b6d93946f8534 diff --git a/tests/expectations/compiler/integers/i8/console_assert.out b/tests/expectations/compiler/integers/i8/console_assert.out index 256ae7babf..ff1d0da19b 100644 --- a/tests/expectations/compiler/integers/i8/console_assert.out +++ b/tests/expectations/compiler/integers/i8/console_assert.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 3512f169126d0aeafcf2abdaf8e8d8abc5549e86af2da76af18992a452b594ab - unrolled_ast: 3512f169126d0aeafcf2abdaf8e8d8abc5549e86af2da76af18992a452b594ab - ssa_ast: 8700257e598f8e34d033963b6b4ecfb67673529574c1f9ef9002c9efcf6b46ca - flattened_ast: 02ef57252baddf6a703b05df0e87b9c7b9ab3082c1ab5498ea7b4433d4f61f8a + - initial_ast: 00b70e003adb5374530f055a6ca7c671357e977ea45c4635269d15af9f23b082 + unrolled_ast: 00b70e003adb5374530f055a6ca7c671357e977ea45c4635269d15af9f23b082 + ssa_ast: 3ba6081289c76d13e2b68519aafd87d7209b88e0c8f30e061c9e75cc158492b6 + flattened_ast: 84f4f03d70d83253069e010860d94b99b60c0b88565245619fae625cdc7af5f5 + inlined_ast: 84f4f03d70d83253069e010860d94b99b60c0b88565245619fae625cdc7af5f5 bytecode: 9ccdd321e147afa7ed76ec9b6660c2e195eba447dfc9fb3049e3473461610686 diff --git a/tests/expectations/compiler/integers/i8/div.out b/tests/expectations/compiler/integers/i8/div.out index 6a00ee9586..6b7acee4fe 100644 --- a/tests/expectations/compiler/integers/i8/div.out +++ b/tests/expectations/compiler/integers/i8/div.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 012853a45a8c2bfbaec356eb27518ea3b52b0e9131eec8cdc8652e8a768c261c - unrolled_ast: 012853a45a8c2bfbaec356eb27518ea3b52b0e9131eec8cdc8652e8a768c261c - ssa_ast: ee8947bfb0cce8812a7cfe6ea3411f05dc1ba0857cdd77617e8eb329864b0287 - flattened_ast: 814f6bba240388a393f6ac241463b357bfb058caad27ab0a193f20e928817f0f + - initial_ast: 52fa8d014a0c43daf68813cc8e56eba15fe3030d17975b37150211b277a49e03 + unrolled_ast: 52fa8d014a0c43daf68813cc8e56eba15fe3030d17975b37150211b277a49e03 + ssa_ast: 7f220d64e2aa471c9d7102de474b3d905d87a6b06849f72a1d1fc12795a22ed9 + flattened_ast: 3639233d66f692e4de497a1858b14ce428ddfdbde008580886533bce4fcc8537 + inlined_ast: 3639233d66f692e4de497a1858b14ce428ddfdbde008580886533bce4fcc8537 bytecode: 21c6bdc9bd2cdebb8b2b912e0385d324aac170014c87be6722f084ebbc5ed4db diff --git a/tests/expectations/compiler/integers/i8/eq.out b/tests/expectations/compiler/integers/i8/eq.out index bb0bd248d1..0e66647750 100644 --- a/tests/expectations/compiler/integers/i8/eq.out +++ b/tests/expectations/compiler/integers/i8/eq.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 26f3d8bcd88a5cf7a551ab936afbb0c68e7eb4377d6e69e1c3c92e1745d14733 - unrolled_ast: 26f3d8bcd88a5cf7a551ab936afbb0c68e7eb4377d6e69e1c3c92e1745d14733 - ssa_ast: 2adebc919a80020ad060d979f27bea044d355ea35ba3ae64ea7ccc9e10b60d55 - flattened_ast: 8867feaf2c1710fa99432dd558b496cb8de3921aeef19554fb18a01c4f3d90a7 + - initial_ast: e0d67d3fc32d97e514f540ca35b1c7b0bf731c94654f9972e8821a6757555669 + unrolled_ast: e0d67d3fc32d97e514f540ca35b1c7b0bf731c94654f9972e8821a6757555669 + ssa_ast: af7995ecf79feeaf80b9ce9504d1ddc977870c0df863ad9f9f46d4b9bb7be2b0 + flattened_ast: a8b292eaeed679819c3e5f621e18459f98f5c1634a55265c849943d901f0c2cf + inlined_ast: a8b292eaeed679819c3e5f621e18459f98f5c1634a55265c849943d901f0c2cf bytecode: 3553218fd9386759250fd70bcba85e542a360420e40e2e9552438de21101057f diff --git a/tests/expectations/compiler/integers/i8/ge.out b/tests/expectations/compiler/integers/i8/ge.out index 6fbea455f4..50cfd6af25 100644 --- a/tests/expectations/compiler/integers/i8/ge.out +++ b/tests/expectations/compiler/integers/i8/ge.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: f376d864ffaec326cd662b1c847d0f1f187f0889da5ae6088b2e8eed48ad355e - unrolled_ast: f376d864ffaec326cd662b1c847d0f1f187f0889da5ae6088b2e8eed48ad355e - ssa_ast: 43002bc5548575cf233253e15723f2519dff11e4cba5f08235b8359c3cdfbeed - flattened_ast: 5594fad51dbd05f1619b189cd9632bf97c8d4c1bdbd20f39f09974036ffe4072 + - initial_ast: f74685e110f50e6bcea61849cdf19353602ba399d112f91a41eb92045b0e27e2 + unrolled_ast: f74685e110f50e6bcea61849cdf19353602ba399d112f91a41eb92045b0e27e2 + ssa_ast: bdb25a73f7c6f9384cb0f47549feafacb9805bff18fea3df28a785922368affc + flattened_ast: 4144c164a96551f3efb1ea77d88fe218327b72d7c0ff44205f552ff5481a7b51 + inlined_ast: 4144c164a96551f3efb1ea77d88fe218327b72d7c0ff44205f552ff5481a7b51 bytecode: 9e7146c34af0d087b4b34caf78d2f65deb95229eb41978c01b9c9fea88766703 diff --git a/tests/expectations/compiler/integers/i8/gt.out b/tests/expectations/compiler/integers/i8/gt.out index 791e934038..42b3b751e1 100644 --- a/tests/expectations/compiler/integers/i8/gt.out +++ b/tests/expectations/compiler/integers/i8/gt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 7b4302dceca146a7d53b46a802bf1d3654f43122251e0ea4329e0341e5c27bad - unrolled_ast: 7b4302dceca146a7d53b46a802bf1d3654f43122251e0ea4329e0341e5c27bad - ssa_ast: 181d2cab369c86ebc223406faeaa1547bb93fe0ba9afb81d61517aeb6e616ac5 - flattened_ast: 612a4ebfdcca7ceb4117198d18370cf1b6add2aa71299172a280e7bebc0c1817 + - initial_ast: 91ba0338a209a3f73456415eaa4f69da21afe5ea75743c8933fa39648bbc7959 + unrolled_ast: 91ba0338a209a3f73456415eaa4f69da21afe5ea75743c8933fa39648bbc7959 + ssa_ast: 7d4ee2d5f738ca289e95e3c6ad1e4a427fdeaa72390cc666178479a1e21cd0d7 + flattened_ast: 4bedba50d3ef72467b0e67bafd0eff6d092aa5a3bfd89f1c93430445e41105ca + inlined_ast: 4bedba50d3ef72467b0e67bafd0eff6d092aa5a3bfd89f1c93430445e41105ca bytecode: 4b9c1679d96af528d4ed9b013682aefc9c492f96be84961ea92c1a6929168bb6 diff --git a/tests/expectations/compiler/integers/i8/le.out b/tests/expectations/compiler/integers/i8/le.out index d4012b293e..0212de44d1 100644 --- a/tests/expectations/compiler/integers/i8/le.out +++ b/tests/expectations/compiler/integers/i8/le.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1f4a6177aa41f633c26fc2f52b23a9a87e9b026342e80c19f46c29ab8c67cdda - unrolled_ast: 1f4a6177aa41f633c26fc2f52b23a9a87e9b026342e80c19f46c29ab8c67cdda - ssa_ast: b78ffa61ee324ca2fe28fb98486424729c7647b53ca30d6442fa50be5367902b - flattened_ast: 0b8d6aca04af2ff69f2dd26d82c801340b22f13dd7d194151ed29aade9f820ca + - initial_ast: bf9c1f7e2437a7e804b99729b7594170a12aa70ff7bb15981cff020672bfbcee + unrolled_ast: bf9c1f7e2437a7e804b99729b7594170a12aa70ff7bb15981cff020672bfbcee + ssa_ast: 1b4f6d17179e7067161fabf7e589cb3681277723a5d724013b7910dfdcde97cd + flattened_ast: 2d41d96fe6053f86fce4ad540ce4f80eae4da959894c0a7756c9e089da04ad1f + inlined_ast: 2d41d96fe6053f86fce4ad540ce4f80eae4da959894c0a7756c9e089da04ad1f bytecode: 81333cc939429f1e8d89bb3f11ff35b75521e765dbc3ca0ee97540dc37952d9a diff --git a/tests/expectations/compiler/integers/i8/lt.out b/tests/expectations/compiler/integers/i8/lt.out index f55b248f35..2d51781f54 100644 --- a/tests/expectations/compiler/integers/i8/lt.out +++ b/tests/expectations/compiler/integers/i8/lt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 195c3c98dd7acb99a309b4675beadbf5498c0eb6c1a168a7a59a51810d68e05a - unrolled_ast: 195c3c98dd7acb99a309b4675beadbf5498c0eb6c1a168a7a59a51810d68e05a - ssa_ast: a8f7b1baee41c048f486bb06fac550ecdabc68ad6aa951851cbde579998c0840 - flattened_ast: 9ddef26d7a885c1f905d26df44d8f2cafdb365c293275773f4a39f51bd7c92c9 + - initial_ast: 9fabc1af69f04e169de479f8dfc743dbec447edabd05c348645d8923bf1c045b + unrolled_ast: 9fabc1af69f04e169de479f8dfc743dbec447edabd05c348645d8923bf1c045b + ssa_ast: 317a456d9810008dbdd71081c1289aeee8502daa9eeadde227d3fbfa7c0aa16c + flattened_ast: 66bdb46f660c9dda02c920ec21309a69fd9878c392c84847cd1dc65657b4f9f0 + inlined_ast: 66bdb46f660c9dda02c920ec21309a69fd9878c392c84847cd1dc65657b4f9f0 bytecode: f051e00dada12c993b7f40a69f919aea35c55ee397cde828a1bb7fabadb39f2f diff --git a/tests/expectations/compiler/integers/i8/max.out b/tests/expectations/compiler/integers/i8/max.out index ec4e95a238..366b7c2ebb 100644 --- a/tests/expectations/compiler/integers/i8/max.out +++ b/tests/expectations/compiler/integers/i8/max.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: c7fa85afc0b0400bfc9b7c2cf46bab3847036c02640e69e0c8804202c59ff428 - unrolled_ast: c7fa85afc0b0400bfc9b7c2cf46bab3847036c02640e69e0c8804202c59ff428 - ssa_ast: 82c837a2bb9b89241e2da4c12a8624ab6a0fb17c0e15ae94cc908969c8f61317 - flattened_ast: 85ee40df66f227256ca169b1e27bbe4dd7a23732a183644e99bf4f4ef2cf497e + - initial_ast: 68d39b0b099d534561b4712320da13b72c362028af6aaa9d458178d2c33c22bb + unrolled_ast: 68d39b0b099d534561b4712320da13b72c362028af6aaa9d458178d2c33c22bb + ssa_ast: 55be35ea4e54621696512eee88cc29df09de0829bffd08e0fea286c4dbce02e6 + flattened_ast: a01c517df77f672961c9259104ea38226693b878f43168a6a02f9c6d1623ea24 + inlined_ast: a01c517df77f672961c9259104ea38226693b878f43168a6a02f9c6d1623ea24 bytecode: dc0e9e85c05c9e036b868585f9bbc765c2ec6a8b456401fa5c21c58b68082942 diff --git a/tests/expectations/compiler/integers/i8/min.out b/tests/expectations/compiler/integers/i8/min.out index 7d4774b5c7..f89e86b9ac 100644 --- a/tests/expectations/compiler/integers/i8/min.out +++ b/tests/expectations/compiler/integers/i8/min.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 6af858b11ac8b82a25070902372adc92d5b6f236202582da759b82fe2aa55853 - unrolled_ast: 6af858b11ac8b82a25070902372adc92d5b6f236202582da759b82fe2aa55853 - ssa_ast: 7c63d4c496752c498ab77e39baa6afe89ab453b35c1f4d6529cbf614bbecd7ba - flattened_ast: b4c4c3e52b93254dcec40fccd17bf81841d703e5cd66a568119689d47f9e55c4 + - initial_ast: 5afc21c0bfe762f9041158429dd7fa61f322a3b46d7afa3828070d8ba7c7f1da + unrolled_ast: 5afc21c0bfe762f9041158429dd7fa61f322a3b46d7afa3828070d8ba7c7f1da + ssa_ast: e36a759a21327056409751ed81043379ee5fb9d029127a503a5bbe82c53a5f5f + flattened_ast: 2ac04b1cc91299008820aa8d988fce11f4e1f6fceced38664da0021b1f388cbb + inlined_ast: 2ac04b1cc91299008820aa8d988fce11f4e1f6fceced38664da0021b1f388cbb bytecode: 50d4e7ba4e53f4cbb291e2fb213c7d7d6e24261197c0a62dcaa6df341ada5804 diff --git a/tests/expectations/compiler/integers/i8/min_fail.out b/tests/expectations/compiler/integers/i8/min_fail.out index ccfcdc1dbf..b1faadff58 100644 --- a/tests/expectations/compiler/integers/i8/min_fail.out +++ b/tests/expectations/compiler/integers/i8/min_fail.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5f9c1940e7dea44b100b284034fdebdf99bae1a905b1816fcfc9de094bffe7a4 - unrolled_ast: 5f9c1940e7dea44b100b284034fdebdf99bae1a905b1816fcfc9de094bffe7a4 - ssa_ast: a620aa3fe1742830d9cdc1baf534319edf443fa4b150b08572f1370b107e0e6f - flattened_ast: a693b034aaa7f4ada656720633b2e1153b317a91df635ace42313b1294737405 + - initial_ast: c58f15d132479a0c98c60fbb82821c5ade35a14a14ca1c81a58d07bfa308375a + unrolled_ast: c58f15d132479a0c98c60fbb82821c5ade35a14a14ca1c81a58d07bfa308375a + ssa_ast: 7c495339daae561935481108ccf551280fc9e627469e316ad80a0c315515a4ab + flattened_ast: 94c9ddab261cde133ba5e8df9aeb58629169ad00d6ce724ff14e8eb04f12f8c7 + inlined_ast: 94c9ddab261cde133ba5e8df9aeb58629169ad00d6ce724ff14e8eb04f12f8c7 bytecode: f2757e9d4dd2a331b078e23183869798b8ce892aa472bf12d26d1e2a970c57d6 diff --git a/tests/expectations/compiler/integers/i8/mul.out b/tests/expectations/compiler/integers/i8/mul.out index e438d4e83f..afcc752aae 100644 --- a/tests/expectations/compiler/integers/i8/mul.out +++ b/tests/expectations/compiler/integers/i8/mul.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 7ebe47098ea623facd0c8bec80142e6d3ee970122eb0b35db7b711cf8b8d82ae - unrolled_ast: 7ebe47098ea623facd0c8bec80142e6d3ee970122eb0b35db7b711cf8b8d82ae - ssa_ast: 265e68e158d5b1919259789e9b21b5bacb222f89b88683a3a77d9a7c66e75796 - flattened_ast: d6e24261d106695ebf23768c40a33f4e895df3894f8b3f95c937c9f3f09672d9 + - initial_ast: a12e99d7175573ef19f84059c174591c6e882baba9ae5760b604f8bae52dbebf + unrolled_ast: a12e99d7175573ef19f84059c174591c6e882baba9ae5760b604f8bae52dbebf + ssa_ast: 2552dfa3ff781f9a9965f3afb5f0dfd0bf88b083bca60dda09ad6a7224b09c68 + flattened_ast: d4ff9d1e000b4b2f7cfde2d08c954be8b3c4abb6d5f83c4da65626a45abc2eea + inlined_ast: d4ff9d1e000b4b2f7cfde2d08c954be8b3c4abb6d5f83c4da65626a45abc2eea bytecode: 6013dacf54aae0c3cdad036a45deb1e4594ab929d29b46420a53a46cfaab4e29 diff --git a/tests/expectations/compiler/integers/i8/ne.out b/tests/expectations/compiler/integers/i8/ne.out index e49588be90..e0fd64bba9 100644 --- a/tests/expectations/compiler/integers/i8/ne.out +++ b/tests/expectations/compiler/integers/i8/ne.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 2bd7a1a7c95288e16332089fddfb3a50c5f110f30d28a0d9d550bcef6c7548d9 - unrolled_ast: 2bd7a1a7c95288e16332089fddfb3a50c5f110f30d28a0d9d550bcef6c7548d9 - ssa_ast: dc646aa6a2feca259c8fad4821e545327408cf9557c407b340de6f83a2aaf97d - flattened_ast: 275060e44da6984f9f87c86feb5001682360e0e77e275db04a37e6da1eb88c0b + - initial_ast: 026b12498978ddb8262387bf5c073bc6affc3300ece14709f83ebb818a1005e9 + unrolled_ast: 026b12498978ddb8262387bf5c073bc6affc3300ece14709f83ebb818a1005e9 + ssa_ast: 1cb9cb1696bf34f0376cb909b3f0d5681ca97cf4ea027f88389b570290b078b4 + flattened_ast: b6368914885ea0d858f17989dfca1f89167e5d9482b7748dc70eb39823cf2905 + inlined_ast: b6368914885ea0d858f17989dfca1f89167e5d9482b7748dc70eb39823cf2905 bytecode: 7a28f10ed9376765665eacbc7739f0e2241d640a6c4a82abf7036b8bafe73a0f diff --git a/tests/expectations/compiler/integers/i8/negate.out b/tests/expectations/compiler/integers/i8/negate.out index 2be9bdede2..c7b9530332 100644 --- a/tests/expectations/compiler/integers/i8/negate.out +++ b/tests/expectations/compiler/integers/i8/negate.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: abc36127507653f7e21ebe388447df439ad18aeb7f2abc33f71ecc90f189d484 - unrolled_ast: abc36127507653f7e21ebe388447df439ad18aeb7f2abc33f71ecc90f189d484 - ssa_ast: eb092a04f08d7c077955e6a70ced47e01ccd337fa92bbe22a6d01334e9d3b9ff - flattened_ast: 94741b8bb48d4f636d209c9edf985a5b2279de0cac4c800a429d92bb6884efcc + - initial_ast: 705b401aec213cbf435097c02683755c1022f365a36701dffa0af7cbc605feca + unrolled_ast: 705b401aec213cbf435097c02683755c1022f365a36701dffa0af7cbc605feca + ssa_ast: f1a3ce4038d3e104bfe80df50bb2dde68d7ecb37393a02eda7e635e1c1f327df + flattened_ast: 0530e5d3e08358efc24b198a1ab74e9874864c918d2cdf739e776879f9737788 + inlined_ast: 0530e5d3e08358efc24b198a1ab74e9874864c918d2cdf739e776879f9737788 bytecode: a721cf409ef6f324202d71cfa39ab808cf28bb7fb581e62b94b699e973dba18f diff --git a/tests/expectations/compiler/integers/i8/negate_min_fail.out b/tests/expectations/compiler/integers/i8/negate_min_fail.out index c71fb9f652..73eb957887 100644 --- a/tests/expectations/compiler/integers/i8/negate_min_fail.out +++ b/tests/expectations/compiler/integers/i8/negate_min_fail.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 8b4c807d2287ae08224c4ec4e705455f603b679074d489a35390526da60e5a61 - unrolled_ast: 8b4c807d2287ae08224c4ec4e705455f603b679074d489a35390526da60e5a61 - ssa_ast: c84a46f587a9fed57e2d044da1bfded8eb74caa33c10e37a90aba210217b1ddc - flattened_ast: 247b513b1acb3513ac0422faf4c2359ac24000043f965410f940de0f59c5a010 + - initial_ast: b5e18f9c7607639804dbe02ca8606597cff5e5e9e5f0521622822de4f5980bca + unrolled_ast: b5e18f9c7607639804dbe02ca8606597cff5e5e9e5f0521622822de4f5980bca + ssa_ast: 6d228cfe61adcdce9b215bbb3d10174d501f7d11a834cd03790c5680a3610347 + flattened_ast: 1efdcd5dd9083f12e7b87818640460713677b357aea5ceebde3e61d6d27d213c + inlined_ast: 1efdcd5dd9083f12e7b87818640460713677b357aea5ceebde3e61d6d27d213c bytecode: d141f4ef3f785d0a868f80fa465e961f271c66301506cc5269701f32f46e20d1 diff --git a/tests/expectations/compiler/integers/i8/negate_zero.out b/tests/expectations/compiler/integers/i8/negate_zero.out index e0b4913622..ee3f24c174 100644 --- a/tests/expectations/compiler/integers/i8/negate_zero.out +++ b/tests/expectations/compiler/integers/i8/negate_zero.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 9bd339db51a52a88f3e959dc9c58ed41fbbbb5300173e95e425b545c3495b3a1 - unrolled_ast: 9bd339db51a52a88f3e959dc9c58ed41fbbbb5300173e95e425b545c3495b3a1 - ssa_ast: d854ae5cdf1fae47367573a32b1c1221f4ca6902078ff7ad2ce95ecf57136116 - flattened_ast: bccbdabc7bb2bbe0e36c572da468b0a461a013544b24aee08b18c481967be32f + - initial_ast: b5341cbf13fd02d0044d7913302218f8790b6765c44b8baf3eb5448a8003a084 + unrolled_ast: b5341cbf13fd02d0044d7913302218f8790b6765c44b8baf3eb5448a8003a084 + ssa_ast: 6e995a7ef1b4811228430fe24132cec9e30be7d5b4b9b40a7dacf71060e415f8 + flattened_ast: 7513c3bce0ab530e48377d4016c1f438355c91a79d7d8a9b9eb40fbe35427035 + inlined_ast: 7513c3bce0ab530e48377d4016c1f438355c91a79d7d8a9b9eb40fbe35427035 bytecode: 03f172c9475df39921cf7bb70ce0544793ca7d90e3d57397cc5e425ef94c32b3 diff --git a/tests/expectations/compiler/integers/i8/operator_methods.out b/tests/expectations/compiler/integers/i8/operator_methods.out index 8177133a89..fe0bb15118 100644 --- a/tests/expectations/compiler/integers/i8/operator_methods.out +++ b/tests/expectations/compiler/integers/i8/operator_methods.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5c0a0b4f3b43f7959fa10fe382bb59ca1a01da3c3f03af366612dbd166a70300 - unrolled_ast: 5c0a0b4f3b43f7959fa10fe382bb59ca1a01da3c3f03af366612dbd166a70300 - ssa_ast: 6093a2c122527c6356b07861d6004abc2af91d9f5b37eb9f7a97149b0027d688 - flattened_ast: 9743c68919e03f336498eadc74d2e9dbe1d470939fba833b22cc5d106f858996 + - initial_ast: 1cba72665d1102f804f3fccb2ebf73f76ed10f974675c216bb1f6bf20fff96c4 + unrolled_ast: 1cba72665d1102f804f3fccb2ebf73f76ed10f974675c216bb1f6bf20fff96c4 + ssa_ast: b7d9af462493e5cc8637349fa61366916adf499048543450c162727bf12273dd + flattened_ast: 29ed8496d287dcc3ef9cc9cb6d35e45dc6b986204704fc73db39b78380fe7d50 + inlined_ast: 29ed8496d287dcc3ef9cc9cb6d35e45dc6b986204704fc73db39b78380fe7d50 bytecode: 9432c4ee33e957559427d6e9c1d377fcb91a66f14d8f3c30622a60b920d627ac diff --git a/tests/expectations/compiler/integers/i8/or.out b/tests/expectations/compiler/integers/i8/or.out index 5492b358ef..d423eedd8f 100644 --- a/tests/expectations/compiler/integers/i8/or.out +++ b/tests/expectations/compiler/integers/i8/or.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 222f81ea7738cd633c70526ecac4f8748e1c82dd774618ee1523b0df6d9275c7 - unrolled_ast: 222f81ea7738cd633c70526ecac4f8748e1c82dd774618ee1523b0df6d9275c7 - ssa_ast: c53182237b47fc21a56f522e9d4c654de833495f7c4555328d7119851832b10c - flattened_ast: 31e193b2cdfa87f218e068f02d0d3373927260090a4cb51badf5f2b913aac2f9 + - initial_ast: 7aef53f4e481743ab5adc8b4e9093f5edca3527a0e155f1c0e9d83285c6e961a + unrolled_ast: 7aef53f4e481743ab5adc8b4e9093f5edca3527a0e155f1c0e9d83285c6e961a + ssa_ast: 90998a5edc6e182a910cf7dc453b95cadc90152ec91897e7f6ae1d52942831e8 + flattened_ast: 4116ca47a89a051b8ba12558a21aa766ea7b8b1931dc73657571138def2296a5 + inlined_ast: 4116ca47a89a051b8ba12558a21aa766ea7b8b1931dc73657571138def2296a5 bytecode: 2c82186f9411e3971fe3d8d2107a84618be275c026cfb3e68c9c2b536ee7e899 diff --git a/tests/expectations/compiler/integers/i8/pow.out b/tests/expectations/compiler/integers/i8/pow.out index c099000ac2..17b7f1b1ca 100644 --- a/tests/expectations/compiler/integers/i8/pow.out +++ b/tests/expectations/compiler/integers/i8/pow.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 4fab65938924eca09bcf6dac20e0797e8c04e8acce8d8608fb2e043b957918c7 - unrolled_ast: 4fab65938924eca09bcf6dac20e0797e8c04e8acce8d8608fb2e043b957918c7 - ssa_ast: 9c7e6086b140a20ee54cb597b413bfdcb8c6ec48aecf54a26889f277a25c3ca0 - flattened_ast: e5ab1d01da873e9c1fdb3856f6a4b58f51a82cdc301567073224e16fd3b22503 + - initial_ast: adada3267028fc128c687cc2b2e560e7454a3b36045270653ad122f5462d5bf5 + unrolled_ast: adada3267028fc128c687cc2b2e560e7454a3b36045270653ad122f5462d5bf5 + ssa_ast: 218e881f156e12dff1f44954a4ce5c60a6608e8f491cf6c70d034bbe00d8b8fc + flattened_ast: 12d2c53c7209c7fae4d076e2610f533fc53956ad97cd47b7374c5500714d9289 + inlined_ast: 12d2c53c7209c7fae4d076e2610f533fc53956ad97cd47b7374c5500714d9289 bytecode: 31c2b5a31097f0c58d879ce7394e2e2f6fa929cfab0ee51d51f437fa2999badf diff --git a/tests/expectations/compiler/integers/i8/rem.out b/tests/expectations/compiler/integers/i8/rem.out index 7a410ec00f..15e8a634cd 100644 --- a/tests/expectations/compiler/integers/i8/rem.out +++ b/tests/expectations/compiler/integers/i8/rem.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 19f667dd1a7c3d1b2e5cc702acfa733149d1d8e9c4cb7e4d45bf81e2e6e38be7 - unrolled_ast: 19f667dd1a7c3d1b2e5cc702acfa733149d1d8e9c4cb7e4d45bf81e2e6e38be7 - ssa_ast: f92fbdf120ec31033942f039ad7f0cd22c8eb0519f4b09cbf718183b7209ea47 - flattened_ast: cd6c49c2ff7f22add35d15f11e5bdc20d66027db851930b69327f61f53e5fe1b + - initial_ast: bb698ebc9399086deae4565b142ffbc4a5e8a20df57f9d0d25119ce42202878e + unrolled_ast: bb698ebc9399086deae4565b142ffbc4a5e8a20df57f9d0d25119ce42202878e + ssa_ast: 22dadf186acd2ea600e61d3a9850962d08b3fc79539a9bca4b582d7339963687 + flattened_ast: a88b64d942969dc33fb248b6d12792c5a0259b3c7348c8941a394e445be14bbf + inlined_ast: a88b64d942969dc33fb248b6d12792c5a0259b3c7348c8941a394e445be14bbf bytecode: cf10196216f488130740d21789f69b9b4d107803b54e8bec5fbad6a69375507c diff --git a/tests/expectations/compiler/integers/i8/shl.out b/tests/expectations/compiler/integers/i8/shl.out index 4fe7c152e6..fe2c83459c 100644 --- a/tests/expectations/compiler/integers/i8/shl.out +++ b/tests/expectations/compiler/integers/i8/shl.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 71995a6a9805cf7ac286befdc7a6f2cbe295ac67b034b81130392c7cdf306706 - unrolled_ast: 71995a6a9805cf7ac286befdc7a6f2cbe295ac67b034b81130392c7cdf306706 - ssa_ast: e5b821f94537daf9630b73e8052e936e5c5cff04099afb44452df73c1f8eac36 - flattened_ast: 6ffff4f04b3d90d2c033ba8e3470223d3e3b76872705395d04445c080f5f6256 + - initial_ast: e09afcc2d7b8c6fc2abf5558907e978d4c62c99001f0737b96358d51f591ca15 + unrolled_ast: e09afcc2d7b8c6fc2abf5558907e978d4c62c99001f0737b96358d51f591ca15 + ssa_ast: 6b7a2b99bd28a3679d4189fe01c25e550b38fa3739df637796cdf06770f8c6fc + flattened_ast: 3ee1499ae33507b75bbba4656f03e8ee6b5a0ba1e0da6028bbd331370c531b3b + inlined_ast: 3ee1499ae33507b75bbba4656f03e8ee6b5a0ba1e0da6028bbd331370c531b3b bytecode: 82393c15429b8c3bc3354f69a541a23f74533e0d2a2f4669ad2f167bd6539a4d diff --git a/tests/expectations/compiler/integers/i8/shr.out b/tests/expectations/compiler/integers/i8/shr.out index 8a9fe658c0..a414384fe8 100644 --- a/tests/expectations/compiler/integers/i8/shr.out +++ b/tests/expectations/compiler/integers/i8/shr.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 8c1e8262e4053d4c1bda405e0f981929465747d425c6360628342b3ebba44884 - unrolled_ast: 8c1e8262e4053d4c1bda405e0f981929465747d425c6360628342b3ebba44884 - ssa_ast: 9c75b54991c05f7c1ae3e32d83730ef99e957eb069dd58f671a6d123812698d4 - flattened_ast: 63beff3bf3913b4c2b903377c8979b1e3fe772ad367400db085bd72de9e02b57 + - initial_ast: d1aa72c27f9fbfb313a3c5c9e1a5ca9f0232527c7ec8eb0b0885529983a0a48e + unrolled_ast: d1aa72c27f9fbfb313a3c5c9e1a5ca9f0232527c7ec8eb0b0885529983a0a48e + ssa_ast: 7f68a3617259688f4d454727b65849540ac22915bb851870240d2d364e6558cc + flattened_ast: d162a783e882c4c65d537a983a2a8cec6b77c2775658ac3c480a3f86a74dc6e1 + inlined_ast: d162a783e882c4c65d537a983a2a8cec6b77c2775658ac3c480a3f86a74dc6e1 bytecode: 34d3c84f73921c5e8ea3c9b71af860c90983a11174010569f7986bc7b4690856 diff --git a/tests/expectations/compiler/integers/i8/sub.out b/tests/expectations/compiler/integers/i8/sub.out index 69a5defce2..6ca7980343 100644 --- a/tests/expectations/compiler/integers/i8/sub.out +++ b/tests/expectations/compiler/integers/i8/sub.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b535e57938d8f98c23b6ad5b009926dc4e86aba5bcce271a0eac4f04ff2a58ea - unrolled_ast: b535e57938d8f98c23b6ad5b009926dc4e86aba5bcce271a0eac4f04ff2a58ea - ssa_ast: ee5d2842f56d4f14e22b79ce82639482988e705b7508236c0218ee1c2b997c9f - flattened_ast: c218acef22e60a19351067d9eed75549772502264b0c6341cb7a10322d121a5a + - initial_ast: 300cc30a566efb459fa9924ca9b6c60e004984f366d5414bb427c306adc979da + unrolled_ast: 300cc30a566efb459fa9924ca9b6c60e004984f366d5414bb427c306adc979da + ssa_ast: f66f26db69c2d458bf18de2d7d1bc348d86e2b9de0b4821a8d277fa51dc0939e + flattened_ast: 27d6020de1092d84b87e5549d7505d249cf51fc993b953f2737e0d99dc78370d + inlined_ast: 27d6020de1092d84b87e5549d7505d249cf51fc993b953f2737e0d99dc78370d bytecode: 240e913761c1b243df3d955ab56be82cf360f865a1458d1337c5bba09b1c9a0c diff --git a/tests/expectations/compiler/integers/i8/ternary.out b/tests/expectations/compiler/integers/i8/ternary.out index e2c5d146b8..4f889ea35e 100644 --- a/tests/expectations/compiler/integers/i8/ternary.out +++ b/tests/expectations/compiler/integers/i8/ternary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 8d2b93f36ffca66f69356531af6af1c802080aa9aa7c42e159356182c806837b - unrolled_ast: 8d2b93f36ffca66f69356531af6af1c802080aa9aa7c42e159356182c806837b - ssa_ast: 6fbb3759ba1fed28725614541fb163733c82459a546cacc0e913c19838b64a99 - flattened_ast: 260908b09fafe1438a79fc8f1720ae444fa1418cc793f1049ea57b1932a6648b + - initial_ast: 3194d0196b2fc111446e2f3c7415ed223eb0eddb7b961ce5df07fd1d27bb122e + unrolled_ast: 3194d0196b2fc111446e2f3c7415ed223eb0eddb7b961ce5df07fd1d27bb122e + ssa_ast: 7da779c6f1aea6c737205041396578d65fef400e0b33dbad95f001529321ecaf + flattened_ast: 55fabf15005eb7b482822787d93db714b9cdc9712084f65ee938466698f9cdff + inlined_ast: 55fabf15005eb7b482822787d93db714b9cdc9712084f65ee938466698f9cdff bytecode: 241a5a50c9244c5888a54aeb68d751fcf5f81cc3da3ab19cff1c2b258e03fc2c diff --git a/tests/expectations/compiler/integers/i8/xor.out b/tests/expectations/compiler/integers/i8/xor.out index 37b43671d0..b12c143289 100644 --- a/tests/expectations/compiler/integers/i8/xor.out +++ b/tests/expectations/compiler/integers/i8/xor.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: fb6934ef8db7a8e078cef86d48f30e9aa9ebdd07f3dec7a8d0d3368399a0881c - unrolled_ast: fb6934ef8db7a8e078cef86d48f30e9aa9ebdd07f3dec7a8d0d3368399a0881c - ssa_ast: fd2642bbbd1af991dc2443727c3b8dadc15782344c2bf52a847f5091917111b2 - flattened_ast: 39d3db72f05d2d55f0e807dead25e132382f8a2f9c2800d2663ae68fe33d83ab + - initial_ast: fbfea23087af1d74dc2143b60a24204b783f03f3d9be97bda5c2d814d2f443ae + unrolled_ast: fbfea23087af1d74dc2143b60a24204b783f03f3d9be97bda5c2d814d2f443ae + ssa_ast: f5a5e20e0ba2caea5669f492d71d2941147d2c6e67a261f8e09891d77b60d149 + flattened_ast: 5315c98493a9db25c87af42f4e7bc79d36c4fb709c2830995642151f83944621 + inlined_ast: 5315c98493a9db25c87af42f4e7bc79d36c4fb709c2830995642151f83944621 bytecode: a44911d526a8e5d7da1619dce04ae1557a436208025369cff33931eb20ad3ab2 diff --git a/tests/expectations/compiler/integers/u128/add.out b/tests/expectations/compiler/integers/u128/add.out index e0a994b597..0439306529 100644 --- a/tests/expectations/compiler/integers/u128/add.out +++ b/tests/expectations/compiler/integers/u128/add.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1023797fa605e2973277aa1d7746b6bbd2720125821b61354c282952f6f06675 - unrolled_ast: 1023797fa605e2973277aa1d7746b6bbd2720125821b61354c282952f6f06675 - ssa_ast: 5e891713fcab18704f9919f4f0c1ce0736fdcd07a122a58121b84962d3bf2201 - flattened_ast: 635511a119996f0172545a7ff31209d16ab5ffbbcec6b0c634cad6c37a225d1d + - initial_ast: 6122b0d3cb58e878a388cc226cf9d4bc040df3e5ed021102004d6ec570895602 + unrolled_ast: 6122b0d3cb58e878a388cc226cf9d4bc040df3e5ed021102004d6ec570895602 + ssa_ast: c9a3c5e6975156d3ba280e19dbd5778072ece399a8342e87bcdabb67cdc49029 + flattened_ast: 977b9983869b7e29880b37cd984037184b5413716a569bcbef33a95419acb609 + inlined_ast: 977b9983869b7e29880b37cd984037184b5413716a569bcbef33a95419acb609 bytecode: 9ff614ee709abb66471b95ed2f6358108616c96a2530d7e4fe7d8df047c5f6e7 diff --git a/tests/expectations/compiler/integers/u128/and.out b/tests/expectations/compiler/integers/u128/and.out index cf5d491199..330c9f7453 100644 --- a/tests/expectations/compiler/integers/u128/and.out +++ b/tests/expectations/compiler/integers/u128/and.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: fa46621c3a96b31893749ffd9e673152d447f29387834463e6101f45e54902a5 - unrolled_ast: fa46621c3a96b31893749ffd9e673152d447f29387834463e6101f45e54902a5 - ssa_ast: 9d18569cf8492aa51fb836c7ddbe30148832e02d690baef22c7467f402afa143 - flattened_ast: c6211e377a7d4b67f447435b5d81bd5d4c104af67cc4c136dbeecedcc5d5035b + - initial_ast: 27469b3351184e1494acff8a843225fb251ec9c476d2470735cb6f836a190b91 + unrolled_ast: 27469b3351184e1494acff8a843225fb251ec9c476d2470735cb6f836a190b91 + ssa_ast: 54efe625cac8b167377675109322714c2f12898ab5a9c5395c10dd85c19f8f1d + flattened_ast: e64be501e0e423226e484a90f7bfc99c4492a83fe98a991cc57a1af86573ebb3 + inlined_ast: e64be501e0e423226e484a90f7bfc99c4492a83fe98a991cc57a1af86573ebb3 bytecode: f86af89362dd5cc93bb266eac9d4f1c5413a5204f4390af61c3ece1f23f22d70 diff --git a/tests/expectations/compiler/integers/u128/console_assert.out b/tests/expectations/compiler/integers/u128/console_assert.out index 18acca4a27..81c9475a7a 100644 --- a/tests/expectations/compiler/integers/u128/console_assert.out +++ b/tests/expectations/compiler/integers/u128/console_assert.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: d24eda05a4e75d515d94d5b908de03a71d9522199f36893b5b372676282b59ea - unrolled_ast: d24eda05a4e75d515d94d5b908de03a71d9522199f36893b5b372676282b59ea - ssa_ast: fe02d50c6a2db1cac668e5dab3237e1a2ace0a98c2b5784be651866a8ceb9a4f - flattened_ast: 0e556a6c58354320212702005400ca088d4590672ef1859b0632be29d0d9f71f + - initial_ast: ecef776d197016bb917ee83c41a6c000a019dd890c4ad9ec4de4628d55401aba + unrolled_ast: ecef776d197016bb917ee83c41a6c000a019dd890c4ad9ec4de4628d55401aba + ssa_ast: 0431e603923761f3642bea4c7674eff20ccc8a745c38d9332ee661b0968c19cc + flattened_ast: 972f88c94c85c6c2741d5582dcf3fb10178db56e65f71caa85b5297af924f86e + inlined_ast: 972f88c94c85c6c2741d5582dcf3fb10178db56e65f71caa85b5297af924f86e bytecode: d20b54c7ca0603e085ee81b6cbead9e5f0287ea391d80d47ed25df97a51daa78 diff --git a/tests/expectations/compiler/integers/u128/div.out b/tests/expectations/compiler/integers/u128/div.out index b0b67fa0dd..2ee462756b 100644 --- a/tests/expectations/compiler/integers/u128/div.out +++ b/tests/expectations/compiler/integers/u128/div.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: bba8aca3e8bd4aea1b0f4f1308baef06d39bfe4028ba7441f13c05e84b9e8ac6 - unrolled_ast: bba8aca3e8bd4aea1b0f4f1308baef06d39bfe4028ba7441f13c05e84b9e8ac6 - ssa_ast: 46c02f30cb185a974b8eb7b96960a2ae9dcb8051daac3de8dca8fe84e93008cb - flattened_ast: 57b2f702ccd7070175acec9a7bba672946889b4471ee8a28cb6ab2241f213484 + - initial_ast: c10b17fcc9ce6b400240da1a0459b59bab5df5ab4814afd9747803da801480f0 + unrolled_ast: c10b17fcc9ce6b400240da1a0459b59bab5df5ab4814afd9747803da801480f0 + ssa_ast: 1029d5387a586719f59593722c1ea8f5419b97d8aeeebe984d22e2e5e692fda6 + flattened_ast: 1df160afe1913e794932db88934823780582e97b28d22648b97547a100239b24 + inlined_ast: 1df160afe1913e794932db88934823780582e97b28d22648b97547a100239b24 bytecode: 7710b74d9f772c456d4a1e183756d567b3f7723306b1e6b5f4cc931f8494e357 diff --git a/tests/expectations/compiler/integers/u128/eq.out b/tests/expectations/compiler/integers/u128/eq.out index 70eebc568e..90aea3d2d3 100644 --- a/tests/expectations/compiler/integers/u128/eq.out +++ b/tests/expectations/compiler/integers/u128/eq.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 29662cd95c110aa32f0663ec5068df3c086400b3c1fdf92dda0f1d896ef19840 - unrolled_ast: 29662cd95c110aa32f0663ec5068df3c086400b3c1fdf92dda0f1d896ef19840 - ssa_ast: b6acf0e315e35aea463a753a95e946345cfbb4a53c150da94d64994704504438 - flattened_ast: cbc20b98cabc91a2d9e7739b28bde40000830910d2646b4f58099b2b9967318b + - initial_ast: 3202d4aa18bc6baebc15adf5dc6acb8845a9d27ffc2b8c5f12a9055215f738f8 + unrolled_ast: 3202d4aa18bc6baebc15adf5dc6acb8845a9d27ffc2b8c5f12a9055215f738f8 + ssa_ast: fe5034e47db98c2403eafcf9224bf7f344d25cbf09767ee9fec76499f76589ac + flattened_ast: 2ae01dbe584e02795a941816eaa08496a0c7cc07b182a14a05a72b6d8e420267 + inlined_ast: 2ae01dbe584e02795a941816eaa08496a0c7cc07b182a14a05a72b6d8e420267 bytecode: 521ca5d8ee20c09793be83bbaa47205e8dc6839845b3e3e714b5bf5318ba1f7a diff --git a/tests/expectations/compiler/integers/u128/ge.out b/tests/expectations/compiler/integers/u128/ge.out index 2a0aa93a49..cd7849565a 100644 --- a/tests/expectations/compiler/integers/u128/ge.out +++ b/tests/expectations/compiler/integers/u128/ge.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1089778715e56ae10d27f6052d2859f800b5322459d2aa7c52633df13d155ad0 - unrolled_ast: 1089778715e56ae10d27f6052d2859f800b5322459d2aa7c52633df13d155ad0 - ssa_ast: 65a33071c858ae76a59723a213334c55a61adf8ce1e9760e26cd0d0b939a3a00 - flattened_ast: 50f3ce6d3534dfd734205fb56119e5240fa4eb8666213a3bdb04000efb83d3de + - initial_ast: 6b806255efe8c2e9022350dd7419ce603a1728f7e80c55fc7c893881c11c41e6 + unrolled_ast: 6b806255efe8c2e9022350dd7419ce603a1728f7e80c55fc7c893881c11c41e6 + ssa_ast: 967cf0cccde79f8d8cf8d5c5da8541c7b51e9cd759897b92a2e955f60853282f + flattened_ast: ed902c976e8f1eda1286516f5d92040ad1b4fa9c9dba7bb4c194e30cb32258ed + inlined_ast: ed902c976e8f1eda1286516f5d92040ad1b4fa9c9dba7bb4c194e30cb32258ed bytecode: e699a9c69f5724cb8dfec843b6b82e47837249aa7f5293ac3c5045ab1a1cc2ca diff --git a/tests/expectations/compiler/integers/u128/gt.out b/tests/expectations/compiler/integers/u128/gt.out index 6187efccb8..ad83a43605 100644 --- a/tests/expectations/compiler/integers/u128/gt.out +++ b/tests/expectations/compiler/integers/u128/gt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 47e8473412a8ec8337d0f871f7fdf553e4c7d0e320250c568474e92fd9aef7cf - unrolled_ast: 47e8473412a8ec8337d0f871f7fdf553e4c7d0e320250c568474e92fd9aef7cf - ssa_ast: b7a105990a4a18046e0d38ffd2ce581f36827a3aa130ec0da321cf0e876a2187 - flattened_ast: 2c1b6dd37fb84ea0b7f685c2b0369a3f66b0ec7cba5395935936d32259903edd + - initial_ast: 28fb8538b8ee3643466e75141f378deddb799223d83a51da1a728dda8ea719f3 + unrolled_ast: 28fb8538b8ee3643466e75141f378deddb799223d83a51da1a728dda8ea719f3 + ssa_ast: 12a3a904f5b43f0f5a54ca64784cb19ca42e92c267754816e755a77e5a12487c + flattened_ast: 1ecb0d6fe25281e2e4f7388315ab5df921b20057f382266f94bb17106a6fe3bf + inlined_ast: 1ecb0d6fe25281e2e4f7388315ab5df921b20057f382266f94bb17106a6fe3bf bytecode: 817c700c1047a1eef944b8e6eb001bb5b301c98ff80872c134cb5d65e6e739ec diff --git a/tests/expectations/compiler/integers/u128/le.out b/tests/expectations/compiler/integers/u128/le.out index bf701d3875..dadd380991 100644 --- a/tests/expectations/compiler/integers/u128/le.out +++ b/tests/expectations/compiler/integers/u128/le.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1d3103bd5c2158ccec714d4d04bfd8627be23694e09f02cffc5141b1a00cfd1a - unrolled_ast: 1d3103bd5c2158ccec714d4d04bfd8627be23694e09f02cffc5141b1a00cfd1a - ssa_ast: 330e8e68e4b259e80da570e3cf4f9b6dc57df01e487147db15256048e28d3bee - flattened_ast: c981c3c60e7f1d4a4bd25f1f3ae90387bb638b8dd3021791ba3e7bb50f3a6a57 + - initial_ast: c7d70bd6615205ce47296bdb788ec10c2701a9d87383209efad4d8088de6753c + unrolled_ast: c7d70bd6615205ce47296bdb788ec10c2701a9d87383209efad4d8088de6753c + ssa_ast: 077ad0751860ed38500eaa2e8452fcace1d368e2447f35761ecaab012eaab497 + flattened_ast: b80739cca6a1e9e7b1637adaaaa99942f10ddce3adfbfa396440e04d300103b2 + inlined_ast: b80739cca6a1e9e7b1637adaaaa99942f10ddce3adfbfa396440e04d300103b2 bytecode: ea874d6bda8fcbe9a6c2f6ee73161ab55431bc3a3df4bbdb298f18bfa9535461 diff --git a/tests/expectations/compiler/integers/u128/lt.out b/tests/expectations/compiler/integers/u128/lt.out index 49c73370e7..29317f0c0e 100644 --- a/tests/expectations/compiler/integers/u128/lt.out +++ b/tests/expectations/compiler/integers/u128/lt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 633170c01b2b364d36b0a3920d756ca88b89947dab9e6e3629781bf9f8a37bce - unrolled_ast: 633170c01b2b364d36b0a3920d756ca88b89947dab9e6e3629781bf9f8a37bce - ssa_ast: 8cdd627667705aa750a92d68f02e2c47f216b8ffe25d7f5fe0a5ef7ed6057b8c - flattened_ast: 84f6e86217b3de932a81c9c49360409ed76e19fb99078a93cc6085fca2824eea + - initial_ast: e87ace87f953afe39ae1aec4aa85d420277afe2190d54480c675fd70f5f9d02a + unrolled_ast: e87ace87f953afe39ae1aec4aa85d420277afe2190d54480c675fd70f5f9d02a + ssa_ast: e2c657b2433b39611b73e33630f6acac37e5215ca545661d28e9fdc241daad01 + flattened_ast: 9e4cf4284856d10b17ebddd07541a780d14a5d171d46f95ccd4d141c6a1a369e + inlined_ast: 9e4cf4284856d10b17ebddd07541a780d14a5d171d46f95ccd4d141c6a1a369e bytecode: cc2553063e610afba4410eb902aee6984b0b58e341069d9ad7e452fd199f75c5 diff --git a/tests/expectations/compiler/integers/u128/max.out b/tests/expectations/compiler/integers/u128/max.out index 6b69e74232..e7e8be5d61 100644 --- a/tests/expectations/compiler/integers/u128/max.out +++ b/tests/expectations/compiler/integers/u128/max.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 31956b40077979b61ca6ac0cf8ca59006d58990ce6e753a8d20adf49f6a827c8 - unrolled_ast: 31956b40077979b61ca6ac0cf8ca59006d58990ce6e753a8d20adf49f6a827c8 - ssa_ast: c19a694f2f4a3d427472c1b8564bfa70f66eb4e6138dd5dcbc1c77f3d57d5bf5 - flattened_ast: e970f4cb72d27953be3996faf89681e4ef44b7c9ce7ab72985cd6edde0fca1ba + - initial_ast: a12fbacea5b94c58bad96e2a7971789f47c3b3f32d747474ec45338a60f41cc5 + unrolled_ast: a12fbacea5b94c58bad96e2a7971789f47c3b3f32d747474ec45338a60f41cc5 + ssa_ast: 3a1a6e2b3e4d0ae92ca4d1e4d206ec5a27e520b49c45805d812bb336e12428b0 + flattened_ast: 7ed664d3151924f1530126d1c19a0f7367eba9720b9863d9b7d1392b6cc78ff6 + inlined_ast: 7ed664d3151924f1530126d1c19a0f7367eba9720b9863d9b7d1392b6cc78ff6 bytecode: 9a1e5bb7b8d932d4afd347a856bfb38db144771f49a0d9589ef14236338e3dcf diff --git a/tests/expectations/compiler/integers/u128/min.out b/tests/expectations/compiler/integers/u128/min.out index 928594f66f..0b3b1d3b37 100644 --- a/tests/expectations/compiler/integers/u128/min.out +++ b/tests/expectations/compiler/integers/u128/min.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 2214dc268e5799e0f26559d627b586cd4d904d3621bb305e0ec69823c3f510fb - unrolled_ast: 2214dc268e5799e0f26559d627b586cd4d904d3621bb305e0ec69823c3f510fb - ssa_ast: 713f2ec28e92fcdf5fef5e746ff653f843552da9e6421e7719c2f988ef558fc0 - flattened_ast: 4751ad5ed526b687736cc56399641082b6e6a750296ca1e00c16a193ca79cf40 + - initial_ast: 73aa8a590478524f4a2b3cc875acee5b44cc56a398ce67d87cd844a323f42bf3 + unrolled_ast: 73aa8a590478524f4a2b3cc875acee5b44cc56a398ce67d87cd844a323f42bf3 + ssa_ast: 9f3b3d5555e9eb167eaafeb8580372050dc77b89b3d99a7f6915ba6407c50c10 + flattened_ast: 93292fffa76f4ba41530664247a92b4533cf512c0607daf69cdbc53452d2abf1 + inlined_ast: 93292fffa76f4ba41530664247a92b4533cf512c0607daf69cdbc53452d2abf1 bytecode: 9a1e5bb7b8d932d4afd347a856bfb38db144771f49a0d9589ef14236338e3dcf diff --git a/tests/expectations/compiler/integers/u128/mul.out b/tests/expectations/compiler/integers/u128/mul.out index 1178d0e568..fa5f617899 100644 --- a/tests/expectations/compiler/integers/u128/mul.out +++ b/tests/expectations/compiler/integers/u128/mul.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b77fc1cfcd0158f1250da583449ae5a63b09d3f205adf9f973e5348a2aafbd2d - unrolled_ast: b77fc1cfcd0158f1250da583449ae5a63b09d3f205adf9f973e5348a2aafbd2d - ssa_ast: 71f9744854dcaf5ebae46ca4a7c9e7706031e475f911ac1d7abf25d05b0f890a - flattened_ast: 4648ef890cb95c9c59757b54b1c578e82bf83aa7c85716dcc1be6001bd9e99b1 + - initial_ast: f6bd085d2926371833b188a11e15229d4cfbe822d99528b54a6823f91c680d80 + unrolled_ast: f6bd085d2926371833b188a11e15229d4cfbe822d99528b54a6823f91c680d80 + ssa_ast: 8591edc1735aecf5eda9fdf3c1d711d20d34931096761aa481425ef311da1f10 + flattened_ast: 8faf13a95561257f0052f6fc7fe62cf0e959f4d904d329300c1180734e2f8213 + inlined_ast: 8faf13a95561257f0052f6fc7fe62cf0e959f4d904d329300c1180734e2f8213 bytecode: b88aaf04313129225fa502629bc4997e455c06134fec78104d6b0227a2fc98ba diff --git a/tests/expectations/compiler/integers/u128/ne.out b/tests/expectations/compiler/integers/u128/ne.out index 6d29d2a937..7b878226be 100644 --- a/tests/expectations/compiler/integers/u128/ne.out +++ b/tests/expectations/compiler/integers/u128/ne.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 2f9094552204a966531afe7acb8984ff8b9cb5a9a3ef253b4c7ac79ddaf9e8a2 - unrolled_ast: 2f9094552204a966531afe7acb8984ff8b9cb5a9a3ef253b4c7ac79ddaf9e8a2 - ssa_ast: 5e9fc70305ab740948db8a8a5611e51ea173585004c7171db60bea08f5ba06d1 - flattened_ast: 01262f2ef4399c706402d21aebc1d671cc10ff80b8e60994c65cd4cbce5b4424 + - initial_ast: 64b505f13172cf9d18f180c6d58296bebd644f861dd8ca204312553570a7d2d5 + unrolled_ast: 64b505f13172cf9d18f180c6d58296bebd644f861dd8ca204312553570a7d2d5 + ssa_ast: d049f4f34fa52bf5d691e4f9e31c63baad7128f6c63469b934e744b0ca17d735 + flattened_ast: 420dd5f54ad85e55df3743d63374e3f5195192b3fc3b5a07120605c9f4bb0e30 + inlined_ast: 420dd5f54ad85e55df3743d63374e3f5195192b3fc3b5a07120605c9f4bb0e30 bytecode: a8ebe7242de33b5e98e7b486f64b67aa14c0661fd8a3b0e850e57ea014f502a4 diff --git a/tests/expectations/compiler/integers/u128/operator_methods.out b/tests/expectations/compiler/integers/u128/operator_methods.out index aa9f1c5c8f..1a79a0c933 100644 --- a/tests/expectations/compiler/integers/u128/operator_methods.out +++ b/tests/expectations/compiler/integers/u128/operator_methods.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b4746dfb4ff603bff9cb2cc8d8f7f75ece9b80a2017a5a560c48f2a9738143ff - unrolled_ast: b4746dfb4ff603bff9cb2cc8d8f7f75ece9b80a2017a5a560c48f2a9738143ff - ssa_ast: 8da5982d4b022e77edf7fb18ad91fbe6febbd579ffa93e142853f0b76a4e977a - flattened_ast: ebe70c5ee9f00a3451e29f52fa452601908f7f0eb65623ca4d65f0823cbf30d2 + - initial_ast: 547210f3b161436d3e94ed5f33a3d515c96cb558d6b7c2d88ebf46b094ea8065 + unrolled_ast: 547210f3b161436d3e94ed5f33a3d515c96cb558d6b7c2d88ebf46b094ea8065 + ssa_ast: 4e66aede3441b08af5970d8cc6c836767e05a2c7c51d4a2e829f306390bcf841 + flattened_ast: 47d4fe543e46da21be791a057d7f9d8ff47b433c8925b92d330a7a26f6765897 + inlined_ast: 47d4fe543e46da21be791a057d7f9d8ff47b433c8925b92d330a7a26f6765897 bytecode: 25a6afbece7c0aa0ca9620f50c35e9a3dd242270f5c68eed206a11e2574b8c09 diff --git a/tests/expectations/compiler/integers/u128/or.out b/tests/expectations/compiler/integers/u128/or.out index d3b133675c..13103ccffd 100644 --- a/tests/expectations/compiler/integers/u128/or.out +++ b/tests/expectations/compiler/integers/u128/or.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5f9da03eda15b935c7469e2e85c6e21f64d26c3fb98826c41c530d0c53c5f086 - unrolled_ast: 5f9da03eda15b935c7469e2e85c6e21f64d26c3fb98826c41c530d0c53c5f086 - ssa_ast: ac469701183f7dc8a85554ea91e4357db19f60722e0027337032e46a4253fd13 - flattened_ast: 51e55854433b74b5eb2bd29a2e53af96c10ae00b281942d283769e362008ce6b + - initial_ast: 8923a186696cc1c76ed9cce9ddf1fe905a4a76c787bfeaae54d0713135c9785e + unrolled_ast: 8923a186696cc1c76ed9cce9ddf1fe905a4a76c787bfeaae54d0713135c9785e + ssa_ast: e41146608c1cfd4fad63374584fa0908b40aad79725a02e7d7cf1782daeae845 + flattened_ast: 6ba829e0dfa82ea1ae9d27413d96a0b142cf96d6f14d29f0126cf7ecbfa8d126 + inlined_ast: 6ba829e0dfa82ea1ae9d27413d96a0b142cf96d6f14d29f0126cf7ecbfa8d126 bytecode: 497d7538eec379ede5751c5787659362e7567f22f4d9c8f377a62f2ebf95fb83 diff --git a/tests/expectations/compiler/integers/u128/pow.out b/tests/expectations/compiler/integers/u128/pow.out index 31ecc64e02..060a32fbb6 100644 --- a/tests/expectations/compiler/integers/u128/pow.out +++ b/tests/expectations/compiler/integers/u128/pow.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1b41d6d2fb9b33c3bc4b4581787bbf37cf6384199dcc6f12f237e5b6b754a884 - unrolled_ast: 1b41d6d2fb9b33c3bc4b4581787bbf37cf6384199dcc6f12f237e5b6b754a884 - ssa_ast: 5d6113e46827fae058c04550b916810c8f5bfd1964c042c915c04399741fab2d - flattened_ast: 35d97bdab97d229a5d1df8253c094a3b4e9b12d1ea641ff6d14f1cfb2b620a2e + - initial_ast: 6eb72d6107e7273725f4d0747ef42fd3df86c863016a5773513902ff84022e2d + unrolled_ast: 6eb72d6107e7273725f4d0747ef42fd3df86c863016a5773513902ff84022e2d + ssa_ast: 2d504509adaaded54f14dae15542a0eb94157cadc1a2210b7620a8a4c7333551 + flattened_ast: 87487ab5798c41102fda2615dfd2ad124f96906ac727e8456be0a04d18852f85 + inlined_ast: 87487ab5798c41102fda2615dfd2ad124f96906ac727e8456be0a04d18852f85 bytecode: b295d69a85960d23951d7906d80b47c30eaa713612ca063e6f70bed0e36fb779 diff --git a/tests/expectations/compiler/integers/u128/rem.out b/tests/expectations/compiler/integers/u128/rem.out index 69e2ed079c..4101d2f1cd 100644 --- a/tests/expectations/compiler/integers/u128/rem.out +++ b/tests/expectations/compiler/integers/u128/rem.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ec91c506729cf0da0be48f642def3e8b2f9e966e2a814ddb95953961eec6022a - unrolled_ast: ec91c506729cf0da0be48f642def3e8b2f9e966e2a814ddb95953961eec6022a - ssa_ast: b642a686204c379afb643295b8f3d330f00ee0699832fa5731648fd865d7d042 - flattened_ast: 70985b50a89ae6cc10c6aebfd5bd463360dc81c8c1dacd4fcc82345046bd0592 + - initial_ast: 3ef72b99957a3f834b9286292e77975438791cce512d74751032a54c5efe4068 + unrolled_ast: 3ef72b99957a3f834b9286292e77975438791cce512d74751032a54c5efe4068 + ssa_ast: 424478618e94f6350edad86336a877adb3f65561e4da4243b43a74fd01cd20d3 + flattened_ast: 3f48698144f9a93f0e1c3eb0b54bb652a5854fee69afec857758d31c1d9200ef + inlined_ast: 3f48698144f9a93f0e1c3eb0b54bb652a5854fee69afec857758d31c1d9200ef bytecode: cffeb79a503e9b27acabb15cfb42d54ea3f43fed9f9a5ded7374e4eb6961d1c8 diff --git a/tests/expectations/compiler/integers/u128/shl.out b/tests/expectations/compiler/integers/u128/shl.out index 9879b91e4b..74317cd19b 100644 --- a/tests/expectations/compiler/integers/u128/shl.out +++ b/tests/expectations/compiler/integers/u128/shl.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 4b63b0047e0e2fd93f813a8bd766f051d0789d9fa08db64523dc2d950d8aab56 - unrolled_ast: 4b63b0047e0e2fd93f813a8bd766f051d0789d9fa08db64523dc2d950d8aab56 - ssa_ast: 408e2ddf5debcee451febc3b8ba054f529fa115427db82c4aee17ef3ada9b635 - flattened_ast: 1422edf4001afc1d41c3c4a151aef1a6a191f92e549db843b0b7180c4732cb7f + - initial_ast: e77ca25b4959636a5871dca2c2229d9b9626a3445f5ddafc717079aff4360df6 + unrolled_ast: e77ca25b4959636a5871dca2c2229d9b9626a3445f5ddafc717079aff4360df6 + ssa_ast: c06a5ef9d1da4904904830fb71e831da7c23d67e678a165256123ca09fc2e0cb + flattened_ast: 69f9b90759f98d42106226e987c60db25210e6471cda72443f0192d6cea205c3 + inlined_ast: 69f9b90759f98d42106226e987c60db25210e6471cda72443f0192d6cea205c3 bytecode: 0042cfa5fe883c54d18c04df2847071d491cdf6f1833d0e9a2e169c96ecd2402 diff --git a/tests/expectations/compiler/integers/u128/shr.out b/tests/expectations/compiler/integers/u128/shr.out index 2e1a7fc2a0..1ff8112640 100644 --- a/tests/expectations/compiler/integers/u128/shr.out +++ b/tests/expectations/compiler/integers/u128/shr.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 3d78d602c90bc036f6cd2d455a31c95bb63bc787977bea3bb23864d156bf80d6 - unrolled_ast: 3d78d602c90bc036f6cd2d455a31c95bb63bc787977bea3bb23864d156bf80d6 - ssa_ast: cece3aa100d730e50341e432023ac17251bb081d75f00f9bf856276111b8f422 - flattened_ast: d5237b3772a1fe9096507da4a9b4b99bb3c46a295c0bfcc7f6dae3ae0ef7c1fc + - initial_ast: bf4cf13b15eb361e70ebfd4e4314012a6c98673613648608fc6c9eacbb5d6d55 + unrolled_ast: bf4cf13b15eb361e70ebfd4e4314012a6c98673613648608fc6c9eacbb5d6d55 + ssa_ast: d0f234da21487724af2dcbca9bc42ca790394e6bb8b2cad73ddd03ad9edf3bd1 + flattened_ast: 89e43dbeca86bdebbcff27b337ebf22619eed4e7e94e1aa8b200a1aad724161f + inlined_ast: 89e43dbeca86bdebbcff27b337ebf22619eed4e7e94e1aa8b200a1aad724161f bytecode: dedaeab84a7c50d76bc53c8fb37937007409f5fcf347ba122e024119511c5529 diff --git a/tests/expectations/compiler/integers/u128/sub.out b/tests/expectations/compiler/integers/u128/sub.out index 4e77cf1197..37c9e875da 100644 --- a/tests/expectations/compiler/integers/u128/sub.out +++ b/tests/expectations/compiler/integers/u128/sub.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: eeb4f0eb50f1b7c0d4b510c153454e0eacd7ef79a36873e89107d2c83d7c27b2 - unrolled_ast: eeb4f0eb50f1b7c0d4b510c153454e0eacd7ef79a36873e89107d2c83d7c27b2 - ssa_ast: 32eaa2b395479dfed3abda74b167855fa39c3e30ce1b73d25aa443f093dce825 - flattened_ast: ed4bdec4cb1dc2e782b11942856d4e99a357dcfd6c6262b9b52c9ddb680a1026 + - initial_ast: 4d3571e3ac9be29fdeeaffc090d0077ac3d845c781ae1ec76be2e1baeff0da80 + unrolled_ast: 4d3571e3ac9be29fdeeaffc090d0077ac3d845c781ae1ec76be2e1baeff0da80 + ssa_ast: 8a6cc69352dd1cccb81f0ff1f73b646ee9d19a949da1a68515b340113b16b131 + flattened_ast: 23cfb28b3a4d305483282a9fb549ef4194693a22290b078b6d6bff70c98f0c67 + inlined_ast: 23cfb28b3a4d305483282a9fb549ef4194693a22290b078b6d6bff70c98f0c67 bytecode: 314254f7afdccd71d00e9823190312578171c602ebcef017e5aee843aa9636d7 diff --git a/tests/expectations/compiler/integers/u128/ternary.out b/tests/expectations/compiler/integers/u128/ternary.out index 73960c172f..b9c38c680a 100644 --- a/tests/expectations/compiler/integers/u128/ternary.out +++ b/tests/expectations/compiler/integers/u128/ternary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 77ae56c3d97ab4d718e80a3759d3768645a252262ba3fa20a965698e758172b0 - unrolled_ast: 77ae56c3d97ab4d718e80a3759d3768645a252262ba3fa20a965698e758172b0 - ssa_ast: dadd945cd387719be9ec846a7a36d387fd1cc040b3b3f2fa64b6a9495c8005fa - flattened_ast: 213de723e6fe7795df42b9157420175fdf2aab3f65650bcb9277818ecf71181d + - initial_ast: 4a02f9ecdc70b12ae94d5128bcdc1d2d5924bcbcdc781079b504b7ba6b6d0a9a + unrolled_ast: 4a02f9ecdc70b12ae94d5128bcdc1d2d5924bcbcdc781079b504b7ba6b6d0a9a + ssa_ast: 32a9bdf1d452ef5892a810463ec4d5ef78337ab9f84f791eb917dd521220d9b7 + flattened_ast: a7be17492218eb2392ac4fde1908070e9388c0ca1e55285b09d5511b8859d9a6 + inlined_ast: a7be17492218eb2392ac4fde1908070e9388c0ca1e55285b09d5511b8859d9a6 bytecode: f18cc6c6b3c37ca606a0bc61608df529ddc102ca0844d944f906fec91c4f9b52 diff --git a/tests/expectations/compiler/integers/u128/xor.out b/tests/expectations/compiler/integers/u128/xor.out index d8d6c82f4e..5d93ba97ab 100644 --- a/tests/expectations/compiler/integers/u128/xor.out +++ b/tests/expectations/compiler/integers/u128/xor.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ede6a5e8212d741ea498e34be46ad3321c117072cdce3be044b2ad854af044dd - unrolled_ast: ede6a5e8212d741ea498e34be46ad3321c117072cdce3be044b2ad854af044dd - ssa_ast: e8e4e4f34371ccf4d48fa97c73fb64c2812b80255cd2cbca74a1217b7ec974c3 - flattened_ast: a47a8a1ff3c6bc853f4b3a8f213f46bf9d6fc9d5f1e49f9795a9dcb40a76de2c + - initial_ast: 3fddd97c446668e076512dd4653473da5c29c4edb2c6d7fa583e3bd8481556ad + unrolled_ast: 3fddd97c446668e076512dd4653473da5c29c4edb2c6d7fa583e3bd8481556ad + ssa_ast: aa37a23164561609c026989b4b728eb60bf6a5a3e2ebbc7c06ea1e36c65bafc8 + flattened_ast: 1058743d1fc64584bdf5d37749f2e043618e55f1b139c30172cfe8159a575ebe + inlined_ast: 1058743d1fc64584bdf5d37749f2e043618e55f1b139c30172cfe8159a575ebe bytecode: afd938366b81cd0861406fd62db4c863d1c8b505f04a4db8bacbb9c43f5b29a3 diff --git a/tests/expectations/compiler/integers/u16/add.out b/tests/expectations/compiler/integers/u16/add.out index 1099bf8e32..9abeea9b0b 100644 --- a/tests/expectations/compiler/integers/u16/add.out +++ b/tests/expectations/compiler/integers/u16/add.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: c095ece86ff8f2933f22d44dd77600cc33ae9066d851479fcc16446f7916b430 - unrolled_ast: c095ece86ff8f2933f22d44dd77600cc33ae9066d851479fcc16446f7916b430 - ssa_ast: c63b2bbd32719a6de1909f3d44e77db88b5be03ea50be25c8a2a4ae64a512c1d - flattened_ast: eedfd4a2e0c932564be43fcee6175a3206b0330690be8a5fc858f7c66c8d44e9 + - initial_ast: b063ad3f5376903a66607fb60033b220f0c8c58a97984f260ad24b9c6978711e + unrolled_ast: b063ad3f5376903a66607fb60033b220f0c8c58a97984f260ad24b9c6978711e + ssa_ast: ac80a1455fdec82690c6e72c31c6791c10c7c67570c0c83fac2d9cdf6f64a359 + flattened_ast: 354d79f48548ecb179eafadbb532b29b463291b4c0aa6b0588f40fe8adaadbe3 + inlined_ast: 354d79f48548ecb179eafadbb532b29b463291b4c0aa6b0588f40fe8adaadbe3 bytecode: f547c15f7844d25b54b1ebd86cdd705e3fbdc09564a611fd3cd0f239eff93f53 diff --git a/tests/expectations/compiler/integers/u16/and.out b/tests/expectations/compiler/integers/u16/and.out index 1909769a2a..95fe9902f6 100644 --- a/tests/expectations/compiler/integers/u16/and.out +++ b/tests/expectations/compiler/integers/u16/and.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ff1db2d7a6b2dc73c30da9becbde6b2b8fc8861ec3037e89b870f269bc9062d5 - unrolled_ast: ff1db2d7a6b2dc73c30da9becbde6b2b8fc8861ec3037e89b870f269bc9062d5 - ssa_ast: d84c509dfe19ae478900eb7038d7b62f28a5225080336dac26a01ea3491edef5 - flattened_ast: 8f5d6aaeac43b000125a0adb3ef2afd68b24186fbec9d4b996129e9260dcc842 + - initial_ast: ef1d3454cfb7459465d8fb9ab1e83df214b3a0eee857712b3b3ffeba3e6cf210 + unrolled_ast: ef1d3454cfb7459465d8fb9ab1e83df214b3a0eee857712b3b3ffeba3e6cf210 + ssa_ast: 7b1a00aedaf9e0a5deeedae92b406caac067fc7928008d0459e62b549f2af106 + flattened_ast: 5777ffe416ddd8ffe3fdc64a137eaf4bacd33552f499985a021f318992c692c0 + inlined_ast: 5777ffe416ddd8ffe3fdc64a137eaf4bacd33552f499985a021f318992c692c0 bytecode: b92fd2503ffc225d448965784485e100166c08fe16458b2832978a7ccb123c89 diff --git a/tests/expectations/compiler/integers/u16/console_assert.out b/tests/expectations/compiler/integers/u16/console_assert.out index 78018a23a1..6fdf1913bf 100644 --- a/tests/expectations/compiler/integers/u16/console_assert.out +++ b/tests/expectations/compiler/integers/u16/console_assert.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: a27dbd99f9d996f11be9db4dc1c305bfb22f7c9f5b10a8a6e51435056f883cfd - unrolled_ast: a27dbd99f9d996f11be9db4dc1c305bfb22f7c9f5b10a8a6e51435056f883cfd - ssa_ast: 0ef684de971b25a2f060f21ea8f2543a03f562c09b79a6033aedf68f7f521f7f - flattened_ast: c77973144ea15b18446a9a80fa92bdb01e89096d090b49cd565c618498b3236b + - initial_ast: c9b320ad9ebc1c3dd9fe3e5855b19eb33658e6543d94d3036353458c559e42dd + unrolled_ast: c9b320ad9ebc1c3dd9fe3e5855b19eb33658e6543d94d3036353458c559e42dd + ssa_ast: 36b7d7bf6d4deed645a68ffc77e70ca12e184750db54dd9a7d690a1df55807c9 + flattened_ast: 0e3c9686e20fe9cefa06f5e06677db44d7cde90a05bf452645fe4d78ff31aa94 + inlined_ast: 0e3c9686e20fe9cefa06f5e06677db44d7cde90a05bf452645fe4d78ff31aa94 bytecode: 5c2e38abbf8dbb49fc4211f11a583c8b75ff3355dc64b234008c6bb61f312fbc diff --git a/tests/expectations/compiler/integers/u16/div.out b/tests/expectations/compiler/integers/u16/div.out index 76919d0901..6e01f1d1c2 100644 --- a/tests/expectations/compiler/integers/u16/div.out +++ b/tests/expectations/compiler/integers/u16/div.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 53b3ba8e7cc063721db15a3f63a54cb56610721b88b7ded5cea8632c34e62391 - unrolled_ast: 53b3ba8e7cc063721db15a3f63a54cb56610721b88b7ded5cea8632c34e62391 - ssa_ast: a40f6f3a8a299fe5b4c68dd79f5cd6cea4a1941a30d125facba0f3314eb210b7 - flattened_ast: 705669c1206fc10aa311a71370d8e6869829a65b4c6b12a0319c966615c9da23 + - initial_ast: ab4e10d6e8df3b3cbfc661713778d45067aa66d52895ba42ce803e1eeae073a8 + unrolled_ast: ab4e10d6e8df3b3cbfc661713778d45067aa66d52895ba42ce803e1eeae073a8 + ssa_ast: 3631d345acef169e3cd240030d9db85434cbbd00436b85da8eab14080a6f5b36 + flattened_ast: 057dca8142bae49572af775a098e68a3afc03ca62925b50b8c2c0e3f1b668552 + inlined_ast: 057dca8142bae49572af775a098e68a3afc03ca62925b50b8c2c0e3f1b668552 bytecode: 87be9771a97c045c6ebd5640f02ca09f79ae9b424c41ac6955c23fd426ae9c23 diff --git a/tests/expectations/compiler/integers/u16/eq.out b/tests/expectations/compiler/integers/u16/eq.out index 109bd109f0..db643068a8 100644 --- a/tests/expectations/compiler/integers/u16/eq.out +++ b/tests/expectations/compiler/integers/u16/eq.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 834d90808c6fd007a16c7c3433ae1e3e6970c9136d7f5f22160cbe3f460b6255 - unrolled_ast: 834d90808c6fd007a16c7c3433ae1e3e6970c9136d7f5f22160cbe3f460b6255 - ssa_ast: c816336ec2f5429ffe6d2acb478113c8e8d8e029047a1736f22234d7d24cc962 - flattened_ast: a2a7006adac59667f4ee6fb47b8f86c570c276d1d41411a35fa25e72e29183aa + - initial_ast: d7b554451296c46485218160254b40e42ee5674ffaee32cd8dade3bd1b7909eb + unrolled_ast: d7b554451296c46485218160254b40e42ee5674ffaee32cd8dade3bd1b7909eb + ssa_ast: 5cda29ba1106c568d8a0d0913a34a73bfd3b8ee695d6582638bb542272ef0115 + flattened_ast: d1f4ba6d47af24d5cad53d1031b1b14eec2a258c41f2331641687b5e56e2765c + inlined_ast: d1f4ba6d47af24d5cad53d1031b1b14eec2a258c41f2331641687b5e56e2765c bytecode: 4087dea44779fb2c700e31777a0aa999053335f645cecece86bde0b509f3266d diff --git a/tests/expectations/compiler/integers/u16/ge.out b/tests/expectations/compiler/integers/u16/ge.out index 78435616c0..c20b148ece 100644 --- a/tests/expectations/compiler/integers/u16/ge.out +++ b/tests/expectations/compiler/integers/u16/ge.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e2da920fa9530a9bf37055be743feed434e2df22b6e8e79ed2c893ac8b2f8e84 - unrolled_ast: e2da920fa9530a9bf37055be743feed434e2df22b6e8e79ed2c893ac8b2f8e84 - ssa_ast: 01a4e856a6441c0f9619fb4465147e88e06042d637afaa8fc9e771f6522f1b64 - flattened_ast: f9af9dad2d8d70e3e08e63547f4a75f2a950254733389d8134319c321fb127f1 + - initial_ast: 744a86f0b02080fcbdb51ab8795b498c6293cc75873d558ed0f886f9f75e9fec + unrolled_ast: 744a86f0b02080fcbdb51ab8795b498c6293cc75873d558ed0f886f9f75e9fec + ssa_ast: 583ec6110210d04aa1474cd477533cf8d4d25d36c1c2d11374a8e0a87576395e + flattened_ast: fe4fda7da71f631fbdcdb2167339867a2e6374697e5f4365fd9ad03a9ca572da + inlined_ast: fe4fda7da71f631fbdcdb2167339867a2e6374697e5f4365fd9ad03a9ca572da bytecode: 38b90d61922501f8a660d56599d9939e5b0238c3987c20a08abfbcc28b42a78b diff --git a/tests/expectations/compiler/integers/u16/gt.out b/tests/expectations/compiler/integers/u16/gt.out index f6b9ebc4fb..98c859874a 100644 --- a/tests/expectations/compiler/integers/u16/gt.out +++ b/tests/expectations/compiler/integers/u16/gt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 9b9ee7b04b5262206eb0cb5a080189ca8cb2a02c31a55f7c75555408ec331379 - unrolled_ast: 9b9ee7b04b5262206eb0cb5a080189ca8cb2a02c31a55f7c75555408ec331379 - ssa_ast: 9dc4e4cc64b2db8de9decd12ccd33c951e6521946308b363c89263b671c77acf - flattened_ast: fa0d0ad16ada549eb17d461eed4c79994f68a2667f7353abc54116b2c5730880 + - initial_ast: 5f31306e206e987b5bd32a87893b0d23e47c456880e2b9d405abdfb2acd0f6a4 + unrolled_ast: 5f31306e206e987b5bd32a87893b0d23e47c456880e2b9d405abdfb2acd0f6a4 + ssa_ast: 9b23997c821fe06a7bef40899769618577aacb8173a94c1f579c2122364bd6c3 + flattened_ast: 85f0c92fef3f9bb920edbdf7e074e584534a2e9c7f1ff624028ec8e71d1ad16e + inlined_ast: 85f0c92fef3f9bb920edbdf7e074e584534a2e9c7f1ff624028ec8e71d1ad16e bytecode: dcf677cdf5a9b3aa14bcc744cb4e7638f393334301ad27109301bd7eef063714 diff --git a/tests/expectations/compiler/integers/u16/le.out b/tests/expectations/compiler/integers/u16/le.out index fc62909ba3..3c245761d7 100644 --- a/tests/expectations/compiler/integers/u16/le.out +++ b/tests/expectations/compiler/integers/u16/le.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 012aadcf5b62631a31986e4112e647ac33a602de63f5fc2118e137170ff61e47 - unrolled_ast: 012aadcf5b62631a31986e4112e647ac33a602de63f5fc2118e137170ff61e47 - ssa_ast: 05e03c984e68811ccd6af323621f671b2b0a7bff856cbcbc9a75af3978921429 - flattened_ast: 6c0004d8cf837a93b5bfffad60a6b386e30048766cbf845a41ab64651036f41e + - initial_ast: dade6175723cedb9c5bb47497ea544466d3bec07371d62eee5dd4f7b2ca37e96 + unrolled_ast: dade6175723cedb9c5bb47497ea544466d3bec07371d62eee5dd4f7b2ca37e96 + ssa_ast: 6b863d552bc10406948f6e74acf2682c9af9d89c78b2802dfb118e9badca4b44 + flattened_ast: de14c443c06ce37324afe9cfe9c700638bbd86563286c0be02f7561120c71dc3 + inlined_ast: de14c443c06ce37324afe9cfe9c700638bbd86563286c0be02f7561120c71dc3 bytecode: b42efbdfdc8e45e9ec1d3c09bd411d1a35618f03edb7d937d7634a4e763e75f9 diff --git a/tests/expectations/compiler/integers/u16/lt.out b/tests/expectations/compiler/integers/u16/lt.out index 1a0ca33ce9..672097a0be 100644 --- a/tests/expectations/compiler/integers/u16/lt.out +++ b/tests/expectations/compiler/integers/u16/lt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 7231a901544e7c57fd18ee78e7bd723c9dc427c0a10f3d1f001bb32d3983ddf9 - unrolled_ast: 7231a901544e7c57fd18ee78e7bd723c9dc427c0a10f3d1f001bb32d3983ddf9 - ssa_ast: 4945dd53d0be2ccbed193e4a0926a4a0d39027aec4fa5dc6c9c6dea6e25a6c27 - flattened_ast: cd98af542b67a630f6de120c9bc019ed2f957a7ab47adc2de2788ba322e16e36 + - initial_ast: 3247bc2a685b5768ba5c767017a30d687e9b0e19b77c33ae029a009f7069b71c + unrolled_ast: 3247bc2a685b5768ba5c767017a30d687e9b0e19b77c33ae029a009f7069b71c + ssa_ast: c9d6b6d3dc360353fc1f2c2f9669b241fa53c5dcce86cf90adb2d32374186ee1 + flattened_ast: 1a20cb3f1ab7cb46f1f4e670e9b9c2f3f3425268f9f57d106d5af75690335854 + inlined_ast: 1a20cb3f1ab7cb46f1f4e670e9b9c2f3f3425268f9f57d106d5af75690335854 bytecode: b10dd4efbabfac0d4db75433e8711f07213062647e3c9e319647a0889144452a diff --git a/tests/expectations/compiler/integers/u16/max.out b/tests/expectations/compiler/integers/u16/max.out index 033dba7d6c..dadf38c624 100644 --- a/tests/expectations/compiler/integers/u16/max.out +++ b/tests/expectations/compiler/integers/u16/max.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 83947b82ce12be753df4c2966496de2d37323916b25ed3a7c567ad36b5482260 - unrolled_ast: 83947b82ce12be753df4c2966496de2d37323916b25ed3a7c567ad36b5482260 - ssa_ast: 09083edbb79bf099f3ee26da3fcf130d4cb528360a4a4097af86193f6c00a267 - flattened_ast: 5941d9035c061cc4b664b635b70b21957958d6529b999e12d0051091c19ce41c + - initial_ast: d82ec11b40ae6ec9aece91a8deb07878748616cf0012be2e866ae3d146da4d30 + unrolled_ast: d82ec11b40ae6ec9aece91a8deb07878748616cf0012be2e866ae3d146da4d30 + ssa_ast: 7ad78643ea410f0574ede8e4f72f06509021b164e366c67c6579d8b17bed0097 + flattened_ast: 2aa7e58a385d815098148c86ff13f66de042111b04bb473907c7cdba7319d988 + inlined_ast: 2aa7e58a385d815098148c86ff13f66de042111b04bb473907c7cdba7319d988 bytecode: 9a1e5bb7b8d932d4afd347a856bfb38db144771f49a0d9589ef14236338e3dcf diff --git a/tests/expectations/compiler/integers/u16/min.out b/tests/expectations/compiler/integers/u16/min.out index 223d1ca11e..d45ec5ebd2 100644 --- a/tests/expectations/compiler/integers/u16/min.out +++ b/tests/expectations/compiler/integers/u16/min.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: c0ab98fe966dd058142cfd588b78a385cf18579c0b6e8189f82d1ab9953d09fa - unrolled_ast: c0ab98fe966dd058142cfd588b78a385cf18579c0b6e8189f82d1ab9953d09fa - ssa_ast: 74e50b8560bc88a9d45722de4d3883ffdcfc67608b38e7620c19e8deb18e0c64 - flattened_ast: 547404583faa67e0d4b283a7064e7cfd56d54e695bac40a2b9215ef510b60a33 + - initial_ast: c1a8b7a7454c82fc6ff07704e5ec6132dd19723db9b89c4f29481498c65cf0fa + unrolled_ast: c1a8b7a7454c82fc6ff07704e5ec6132dd19723db9b89c4f29481498c65cf0fa + ssa_ast: 14fdd1ea6d7d61a4b3c32defe8d8146720701e8dcd33d018d30d194c29814915 + flattened_ast: d34819a49c177566cb1512fd69e42a51326e3bff2e17d826e06d01214cd728bf + inlined_ast: d34819a49c177566cb1512fd69e42a51326e3bff2e17d826e06d01214cd728bf bytecode: 9a1e5bb7b8d932d4afd347a856bfb38db144771f49a0d9589ef14236338e3dcf diff --git a/tests/expectations/compiler/integers/u16/mul.out b/tests/expectations/compiler/integers/u16/mul.out index 85b6446e7f..8f3610133e 100644 --- a/tests/expectations/compiler/integers/u16/mul.out +++ b/tests/expectations/compiler/integers/u16/mul.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ebce8850a60cf1de55644cdbdc4c189cd612828a3552882cb89163f25ee51016 - unrolled_ast: ebce8850a60cf1de55644cdbdc4c189cd612828a3552882cb89163f25ee51016 - ssa_ast: f1cb93682f7be8ecb351f52879e9ac67001635e0fb1f16c53e181c7d2a256112 - flattened_ast: 947134f1fb7294ad9c9985f7cbc263f8569143c554f6b879a4746ef691a40d3b + - initial_ast: e7706cdb97ca3b829a86575ef74ebb8aaaeb5dff4d1cc9d49179bbed1cfaf959 + unrolled_ast: e7706cdb97ca3b829a86575ef74ebb8aaaeb5dff4d1cc9d49179bbed1cfaf959 + ssa_ast: ee493bfb73e20dde837525b0b758d59d254371f152f5560eded84a71e57aae8f + flattened_ast: 46ff8392f48a36958e140ce5a358a498485b5d31ac394846c44ae8e74c86076f + inlined_ast: 46ff8392f48a36958e140ce5a358a498485b5d31ac394846c44ae8e74c86076f bytecode: 640898c0221b29b96bb54c04f62f0551ab5015287a2d0465afcd03eb0496922a diff --git a/tests/expectations/compiler/integers/u16/ne.out b/tests/expectations/compiler/integers/u16/ne.out index bb3e1b5214..3f2ea04545 100644 --- a/tests/expectations/compiler/integers/u16/ne.out +++ b/tests/expectations/compiler/integers/u16/ne.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ef617cb90b014b5c64ee4cdc8866715e243f5d3ed94db062f27935dbbdc06101 - unrolled_ast: ef617cb90b014b5c64ee4cdc8866715e243f5d3ed94db062f27935dbbdc06101 - ssa_ast: 39411e60db203817399b25a2601cd99306f26dea556b0c923be7e2b27354ce7b - flattened_ast: eec5a44b08ca800d9fdd0d02f0f4a3dbb418442e652fbd4c26f4ecef671b1d3e + - initial_ast: 49be6ca28b09bc8b6e937b3c0d85be80d61bef080ca276cff9ade683eb524375 + unrolled_ast: 49be6ca28b09bc8b6e937b3c0d85be80d61bef080ca276cff9ade683eb524375 + ssa_ast: 0c8df0c9a504ffc89b5a343d0746ffcc4afa5a4819c975f419e4d86a2e6b2855 + flattened_ast: d1870490a563ad5156c1e550583af41428e338167ee588a6f115bb51dcbb7acd + inlined_ast: d1870490a563ad5156c1e550583af41428e338167ee588a6f115bb51dcbb7acd bytecode: 62201638b499e66c0503d022d2521704c9476c18e906af29dba710c86658348a diff --git a/tests/expectations/compiler/integers/u16/operator_methods.out b/tests/expectations/compiler/integers/u16/operator_methods.out index 19c042dec4..afb76625ff 100644 --- a/tests/expectations/compiler/integers/u16/operator_methods.out +++ b/tests/expectations/compiler/integers/u16/operator_methods.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 77815f5c2c33977a41a54a5a559a54e080d7f144faa4ace19360dc7286d5494e - unrolled_ast: 77815f5c2c33977a41a54a5a559a54e080d7f144faa4ace19360dc7286d5494e - ssa_ast: 2c1fee7633cc7440147771b402690e5cfd27dd2d800a1d7b28fc49e8f628a603 - flattened_ast: 6204725effc5051f362782626a8af4ac84b43156570608e50d132bb06c89cd85 + - initial_ast: f5b3b17bd093c0341f5bbe9d0718cd5b6c74912b533adde36f9c5da0ff6a6af6 + unrolled_ast: f5b3b17bd093c0341f5bbe9d0718cd5b6c74912b533adde36f9c5da0ff6a6af6 + ssa_ast: d87bf4a15278c93037efe57db3743f27fc09a08eba958612b24f8226db12a1a9 + flattened_ast: 35825530ad88a4714cf076b345a501380859366316436a02a7afc3c2fa6d6655 + inlined_ast: 35825530ad88a4714cf076b345a501380859366316436a02a7afc3c2fa6d6655 bytecode: 0ed6c120433247bb3f147323abe1e05242d623d8ef8dfe69e26795c181b88888 diff --git a/tests/expectations/compiler/integers/u16/or.out b/tests/expectations/compiler/integers/u16/or.out index c974989211..7bb278ee42 100644 --- a/tests/expectations/compiler/integers/u16/or.out +++ b/tests/expectations/compiler/integers/u16/or.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 9bf79aa1d140791b10980e86525956f92433e97445adef4f08170871a7d35635 - unrolled_ast: 9bf79aa1d140791b10980e86525956f92433e97445adef4f08170871a7d35635 - ssa_ast: f6fdcc5cdb6d53d6e86e8da31f27b7f6cf4e885ef46ffafd63705a6ba0ce4e17 - flattened_ast: 3f21269b0736bd1e529aaa9d0d19c60cab13dfa2f1f8d52e7d9ca50ff3ada344 + - initial_ast: b57fb93fa65fc7987238d460273c8cba16dd1a79a9f5158baa3ef2c1fba64926 + unrolled_ast: b57fb93fa65fc7987238d460273c8cba16dd1a79a9f5158baa3ef2c1fba64926 + ssa_ast: 8571757cdadcb8c59a90deecba6c48727764137eb636b5c5038d512b25407a41 + flattened_ast: 249683377464651592429c5dad882cd0a9d0bd8a1c8554f6a168a92b1431a2b0 + inlined_ast: 249683377464651592429c5dad882cd0a9d0bd8a1c8554f6a168a92b1431a2b0 bytecode: f3ae8aae74e39312aba21f142a98675531f60dca221ceefec1a5f5168b675daa diff --git a/tests/expectations/compiler/integers/u16/pow.out b/tests/expectations/compiler/integers/u16/pow.out index e5cf789da7..4789a1d202 100644 --- a/tests/expectations/compiler/integers/u16/pow.out +++ b/tests/expectations/compiler/integers/u16/pow.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 3cf3511cb699bb0aeae01341c4cc05845fec8919294fc0f8362bb3ee1b453965 - unrolled_ast: 3cf3511cb699bb0aeae01341c4cc05845fec8919294fc0f8362bb3ee1b453965 - ssa_ast: a0b0159881063b49c22d8cd120dfe3db34b95ef4a8f984056a8d59be8c35188b - flattened_ast: 5f6a54342c7664114ba5e491c43d79b3304c1fc92b30bed4191db52c40b7a1b7 + - initial_ast: 871be497192eb6e477d884b6ac795b3261c10e13dec5d83557a2cf2506986a9f + unrolled_ast: 871be497192eb6e477d884b6ac795b3261c10e13dec5d83557a2cf2506986a9f + ssa_ast: 64f6ac62fc058b91f0565eeffe9f8f99c0b73d0a9e6acab8665a20fa82e0763a + flattened_ast: 0352a01ef89390d1cafd1d9c89f53428f2d7a3af41b3deac7360a1b77fecb305 + inlined_ast: 0352a01ef89390d1cafd1d9c89f53428f2d7a3af41b3deac7360a1b77fecb305 bytecode: 02f54418a16f130b642d241c152edae7921a53c84ce4e6c76a6f021e88816d81 diff --git a/tests/expectations/compiler/integers/u16/rem.out b/tests/expectations/compiler/integers/u16/rem.out index 98c5ddec9e..12feddcc60 100644 --- a/tests/expectations/compiler/integers/u16/rem.out +++ b/tests/expectations/compiler/integers/u16/rem.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 79e44f8d2ac8bb1a892315e5447760ce165d0222e7af7fccec38c507bafd5bf0 - unrolled_ast: 79e44f8d2ac8bb1a892315e5447760ce165d0222e7af7fccec38c507bafd5bf0 - ssa_ast: 1dd57df55082456c934054d58fc1b0c086bf777737ad12bc546512e808dfdf01 - flattened_ast: 009ce79e070debefaf2ae08fa9b021442ceeffc82ce8990fb53713db4b9b5d9e + - initial_ast: 6f815d85e39807361167556d43e362d591bb140a00bc4777be380059b3218736 + unrolled_ast: 6f815d85e39807361167556d43e362d591bb140a00bc4777be380059b3218736 + ssa_ast: 5e5f19ab679d53c26c801641ae634ea9aa8298960cf0460b5e4fafe33b815fe4 + flattened_ast: 86ac35549edf64a46f924de609f931f3bd162568ed5cb804a748f83ff1108fc0 + inlined_ast: 86ac35549edf64a46f924de609f931f3bd162568ed5cb804a748f83ff1108fc0 bytecode: 47409f2d1e5aa02662a482ee2c1abfc392d6d46e16b260ed9a96680745e2f237 diff --git a/tests/expectations/compiler/integers/u16/shl.out b/tests/expectations/compiler/integers/u16/shl.out index 1965a2074f..93591a976c 100644 --- a/tests/expectations/compiler/integers/u16/shl.out +++ b/tests/expectations/compiler/integers/u16/shl.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 14bdeb0bc62ca7a25ba07dcd353b99f9f911e99e7f4b689535f106385aca6215 - unrolled_ast: 14bdeb0bc62ca7a25ba07dcd353b99f9f911e99e7f4b689535f106385aca6215 - ssa_ast: 34d484f650e4a4c53d4ee15faad28f81bca949afa8c819fab3d2eb60bef83f89 - flattened_ast: 4a0101b470e3d40946e27e4e23af22cfe567caf78b455446ac9923bc2016702f + - initial_ast: 25005e3cb01d03d9a62316ab1303efc28ec19c636b1b814e472b372687552b63 + unrolled_ast: 25005e3cb01d03d9a62316ab1303efc28ec19c636b1b814e472b372687552b63 + ssa_ast: 9a08c16dcad9964d3071074a12b639733e0a23a7d5ec8881dc932e20902e892e + flattened_ast: ad596add937c514080162dd8bc3a49bdc9046775da1b3c650cf6afb9ccd7b39f + inlined_ast: ad596add937c514080162dd8bc3a49bdc9046775da1b3c650cf6afb9ccd7b39f bytecode: 40c7270774b37bcbe32743ffb6c4500b87338670c0f188181135c6a069711375 diff --git a/tests/expectations/compiler/integers/u16/shr.out b/tests/expectations/compiler/integers/u16/shr.out index fe73f1f81c..1a580b8b12 100644 --- a/tests/expectations/compiler/integers/u16/shr.out +++ b/tests/expectations/compiler/integers/u16/shr.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ba77d5f6cad684639e0d52b2dfc29e0dcf549a77c490471ab168b165fe9396c9 - unrolled_ast: ba77d5f6cad684639e0d52b2dfc29e0dcf549a77c490471ab168b165fe9396c9 - ssa_ast: cce9ae2f7af3386ff2cc8e3182c8f31e174bef60bfe4dd4185d339a9d46ac359 - flattened_ast: 963263742e1a2dde3daf2cb336a1530f5daf253893d29cf61b7befbddec8c0af + - initial_ast: d7811788d12d0b5b0031d060b1e487c8f6b2207161304952328056dcb215995b + unrolled_ast: d7811788d12d0b5b0031d060b1e487c8f6b2207161304952328056dcb215995b + ssa_ast: aea74fbf7a1b3ec5db03d101400d5ab27d63b5502139c212eeddb535d7e98d24 + flattened_ast: b455af78c7e7aa177ed96e50be06aab6d444b43a752f65dbe4caf4d83dd20b9a + inlined_ast: b455af78c7e7aa177ed96e50be06aab6d444b43a752f65dbe4caf4d83dd20b9a bytecode: 1e5f18a7a17246b9383073ddde5d563ef4d68cba62d0ea61812548c152baa1f8 diff --git a/tests/expectations/compiler/integers/u16/sub.out b/tests/expectations/compiler/integers/u16/sub.out index 708c75dd8d..15ff2981ce 100644 --- a/tests/expectations/compiler/integers/u16/sub.out +++ b/tests/expectations/compiler/integers/u16/sub.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 65d1aaebb1bbc5104aa4c66f68650d9402d823ecec0d7d59f09bd17dbc4f543a - unrolled_ast: 65d1aaebb1bbc5104aa4c66f68650d9402d823ecec0d7d59f09bd17dbc4f543a - ssa_ast: 2de02a510bc8766a711c8fa8715732560ee6bfc3be4a79f49d88dd1403db4823 - flattened_ast: 6d90e63da6335b6bb611b750225f07a02bbf33110381dbcf124ab01f6b55150e + - initial_ast: 904ce2692504614925dd2e1c795e942d6a3d95be6386e2d39c80e10853aed58d + unrolled_ast: 904ce2692504614925dd2e1c795e942d6a3d95be6386e2d39c80e10853aed58d + ssa_ast: 1ea35d9b48678da661b4d2c5acc2dc65dde01b05b3e6b599d8597a1cc17e8978 + flattened_ast: 17ec2af58cc3e05d378c752f52cb055ec5c92e5dbf57b0b20dc07e1ef2a8cd84 + inlined_ast: 17ec2af58cc3e05d378c752f52cb055ec5c92e5dbf57b0b20dc07e1ef2a8cd84 bytecode: 3f7aa687c1b915adc86646e735591713028a9edbb51ce82964b3343a4cb597d0 diff --git a/tests/expectations/compiler/integers/u16/ternary.out b/tests/expectations/compiler/integers/u16/ternary.out index a9c4d4fa0c..9a508bacd2 100644 --- a/tests/expectations/compiler/integers/u16/ternary.out +++ b/tests/expectations/compiler/integers/u16/ternary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 137a94b39c1dcde6fd20917e5e95ceb6b56fbe9d5cf1642531c13a5ca0a38850 - unrolled_ast: 137a94b39c1dcde6fd20917e5e95ceb6b56fbe9d5cf1642531c13a5ca0a38850 - ssa_ast: c0468ccd627878cc0509a9924861bfb646e675c18eeecd86f8a44cad4375a5a0 - flattened_ast: 5f37a3f10a884a29d4efb0712fefee5c11005b3732baa03a94fc99a8027b65d3 + - initial_ast: 5b50eb42138b8047d2aa92a4dc6ee3aabd9cae993c700c2ec80b9f1ab2158572 + unrolled_ast: 5b50eb42138b8047d2aa92a4dc6ee3aabd9cae993c700c2ec80b9f1ab2158572 + ssa_ast: 9df0962538ec769507a8abf527305d9bd0c55bb42a06f2c1ab2d84527784a14b + flattened_ast: 4783454d1abf799d7550ac6a8bc9e60313808bd867e371d14f5b9cda6a4aef52 + inlined_ast: 4783454d1abf799d7550ac6a8bc9e60313808bd867e371d14f5b9cda6a4aef52 bytecode: d0305b1f09132642d928c6bf349f6153a7da91fefd95b8f16e2e33f182836ddf diff --git a/tests/expectations/compiler/integers/u16/xor.out b/tests/expectations/compiler/integers/u16/xor.out index f80c382988..65b14807d2 100644 --- a/tests/expectations/compiler/integers/u16/xor.out +++ b/tests/expectations/compiler/integers/u16/xor.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 384a83bbed4385b4f2ae647984ebfcbed1d15dab3a8a4a7576a2be4360d35651 - unrolled_ast: 384a83bbed4385b4f2ae647984ebfcbed1d15dab3a8a4a7576a2be4360d35651 - ssa_ast: afb81872d5d96faf7e304ffdce0fac5088b5b70a6cb3543400e23f28ed97787f - flattened_ast: 03f4aa19e1dce5fc851c7fb34cea5d80603acb08b614c06120a9ad0216e3348c + - initial_ast: 3081b6dcf0d71d95570ad89d560b6944302a26e40efe6c6b6f7c4841c610d8b7 + unrolled_ast: 3081b6dcf0d71d95570ad89d560b6944302a26e40efe6c6b6f7c4841c610d8b7 + ssa_ast: c05f3f4cc6d3421a4b71434e646c1aac0eb9e70c93688e4c74ad631d175f982c + flattened_ast: 5a9df71d9f9675a327af583ce47d2912adc7242b2431461bdb6e0bdb51d22680 + inlined_ast: 5a9df71d9f9675a327af583ce47d2912adc7242b2431461bdb6e0bdb51d22680 bytecode: 42cad1b1ce1e09199ad8861f797a95a2cb43d406825a88becb41a5d318f9341f diff --git a/tests/expectations/compiler/integers/u32/add.out b/tests/expectations/compiler/integers/u32/add.out index b68581b93a..b4ee5ae8dc 100644 --- a/tests/expectations/compiler/integers/u32/add.out +++ b/tests/expectations/compiler/integers/u32/add.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: a5801bd577fcef4ec8be5f9bacdbf637e98a1a505b7d6a9e0df199985f8ae891 - unrolled_ast: a5801bd577fcef4ec8be5f9bacdbf637e98a1a505b7d6a9e0df199985f8ae891 - ssa_ast: bc3391df2b6f1193051499cb0411135ae7042752ca6b3e4a09ba385d1be9288e - flattened_ast: 6b1234939e9404d6cb15e8391cf1161fa7c39ce6794b6659e94c7050a94a9e0e + - initial_ast: 4c814578eaaf5780b23208a299f264526d26390fbb6e0d68b7cebf54c851d58f + unrolled_ast: 4c814578eaaf5780b23208a299f264526d26390fbb6e0d68b7cebf54c851d58f + ssa_ast: beb29f2d2e0a444f972809410d04a4f4431cfc6777b669cec1f21671fb7fc876 + flattened_ast: 75787bfa50c735748ef3ad59fcec3e56d62ff0d3ebabdd19f463a4839b7df0a7 + inlined_ast: 75787bfa50c735748ef3ad59fcec3e56d62ff0d3ebabdd19f463a4839b7df0a7 bytecode: 3ded1a7996eb0f11477cad2c5c5e8d182e09170240812cbdb636ae16b9b7aa5b diff --git a/tests/expectations/compiler/integers/u32/and.out b/tests/expectations/compiler/integers/u32/and.out index ad21464d40..5d9fb6b843 100644 --- a/tests/expectations/compiler/integers/u32/and.out +++ b/tests/expectations/compiler/integers/u32/and.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: c9bd8f821125ef87cf4b8beac01a44186400d4137c6476a43f7df56512bc5552 - unrolled_ast: c9bd8f821125ef87cf4b8beac01a44186400d4137c6476a43f7df56512bc5552 - ssa_ast: 6cf002c2ecc587a11d7a52d40418046b26bdd75fad7db0e3ad8fb4175f7333e5 - flattened_ast: 29d02569ae9bcfe64186f385b5c763ceb30b8a3b268e50c677c6cac6d6f758b6 + - initial_ast: b9d7bcb1d2e63b483d50df63353e036743ead5687e5cd8e196216139c8bb21bc + unrolled_ast: b9d7bcb1d2e63b483d50df63353e036743ead5687e5cd8e196216139c8bb21bc + ssa_ast: 9558905205633f78ed47b7fc0cb43d8d7b964dbb2d8316c4a2bbabbb45a1fb74 + flattened_ast: 46cfabd88848b9cd37ec596eb13f894cf516506961d4a5f1ba2e8a3d8b560740 + inlined_ast: 46cfabd88848b9cd37ec596eb13f894cf516506961d4a5f1ba2e8a3d8b560740 bytecode: 3a5f76958a4110b8d0388a7e489e68542029338cf78070798ea397107d10c9a6 diff --git a/tests/expectations/compiler/integers/u32/console_assert.out b/tests/expectations/compiler/integers/u32/console_assert.out index 848a224d10..6b93895e6d 100644 --- a/tests/expectations/compiler/integers/u32/console_assert.out +++ b/tests/expectations/compiler/integers/u32/console_assert.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1359d8d99bf89ee32819e8623ae352b30c0367c13ae4d01eaa58054ea58902d9 - unrolled_ast: 1359d8d99bf89ee32819e8623ae352b30c0367c13ae4d01eaa58054ea58902d9 - ssa_ast: e55325d6209ea31c85148aefee496b119a85fbfae39aa1464e9ac8a4f19a868c - flattened_ast: e2b4847f9e88eb833a7a3ab3c4305e73f023cb3357c454b07ed6d6285a6e1d8d + - initial_ast: afc2125bb26c04f6e5e37ddf486efa1d2ec3fb373b5a98a304441df31552e908 + unrolled_ast: afc2125bb26c04f6e5e37ddf486efa1d2ec3fb373b5a98a304441df31552e908 + ssa_ast: 65590c9a5be6c5ecfa92376f3f45f775a69ad19047a9033e94361198dbee25ee + flattened_ast: 5c04309fa64b931f489402df810c54e7aba1211f084d92726cdddd0cc6243336 + inlined_ast: 5c04309fa64b931f489402df810c54e7aba1211f084d92726cdddd0cc6243336 bytecode: f4c9bffb3e7a32c2e6922f2322af66153f047899fdc383d654dceeaee0b75936 diff --git a/tests/expectations/compiler/integers/u32/div.out b/tests/expectations/compiler/integers/u32/div.out index a7c3429e84..76ec99a57c 100644 --- a/tests/expectations/compiler/integers/u32/div.out +++ b/tests/expectations/compiler/integers/u32/div.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: a001addffe81304d56953fd8ba54dda5a43d2796337c1de0ec8672f86c32533b - unrolled_ast: a001addffe81304d56953fd8ba54dda5a43d2796337c1de0ec8672f86c32533b - ssa_ast: c070642e63e42b7b7ace71b96b96983aab43af3dc9b7ac44f397fd81dfd95723 - flattened_ast: cbaaf49bcf4f12df6df88806c5e71fca0fffbafac025ab7cd5b18fa4f33aea84 + - initial_ast: 5a67486325e1ed6073ff3b51946baecc18d0e69ec09ad7843561d2c762097e84 + unrolled_ast: 5a67486325e1ed6073ff3b51946baecc18d0e69ec09ad7843561d2c762097e84 + ssa_ast: 27076ac9ff23699926621a3bef8d7624cf8128811a873caa3174c4f13da49637 + flattened_ast: 434eb58a7feb217d67026a5e4061604f64a937505ed0612b306eb068a726fad5 + inlined_ast: 434eb58a7feb217d67026a5e4061604f64a937505ed0612b306eb068a726fad5 bytecode: f17af0312ab97ed5f1cd2af6b3c745b673cb447581bef6f1c358a81594e02b63 diff --git a/tests/expectations/compiler/integers/u32/eq.out b/tests/expectations/compiler/integers/u32/eq.out index 1fd4fd7974..fc573f26c9 100644 --- a/tests/expectations/compiler/integers/u32/eq.out +++ b/tests/expectations/compiler/integers/u32/eq.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 97c979e1594fe0588f8b0adf1f699d4d994a87184b695b32f84444b4d3b4b9ff - unrolled_ast: 97c979e1594fe0588f8b0adf1f699d4d994a87184b695b32f84444b4d3b4b9ff - ssa_ast: f90b714069ebe259ecbe411a3dc1d80af4163c26ba4f71394db54d92f1d219f9 - flattened_ast: 9093930d341b32102ba3a50597f19cb6fcbf3de8033186dfbb9c295aa85be6ce + - initial_ast: 0c52f37d6ff3efe6de65305a65eed31a9ecf4da7056af20aa0e4c1933604f253 + unrolled_ast: 0c52f37d6ff3efe6de65305a65eed31a9ecf4da7056af20aa0e4c1933604f253 + ssa_ast: ca5cea87808c7593b0081108fc2af5e512f60244a5941e427746a6eef6dd093d + flattened_ast: c9e2cc1b48f83af3571fbb9c019b14e2160a4c8b188b1cbf622673a0b641b7d9 + inlined_ast: c9e2cc1b48f83af3571fbb9c019b14e2160a4c8b188b1cbf622673a0b641b7d9 bytecode: e1a8bdccbb21108530629a18d3a73db59da82ece3c0e1f83022f160ed099d90a diff --git a/tests/expectations/compiler/integers/u32/ge.out b/tests/expectations/compiler/integers/u32/ge.out index 90bd8ee1e0..fd93e2ba20 100644 --- a/tests/expectations/compiler/integers/u32/ge.out +++ b/tests/expectations/compiler/integers/u32/ge.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b1701c11c58e5e1f4378ebf52026f8389a83e9b54363837dffe9988960514b04 - unrolled_ast: b1701c11c58e5e1f4378ebf52026f8389a83e9b54363837dffe9988960514b04 - ssa_ast: 9da330f7023798aa39024f63d468bc6127a587e6cefd769c08a7b208120665e0 - flattened_ast: 4a8ff1c01b0d1fd3d4e14de10ada0a583102191f077ee7224fb6a1bdcfd595f6 + - initial_ast: fdfc8cabc81692dbc56e5e28a6f07df18872b2b307a2a7ef68698f4451df9a16 + unrolled_ast: fdfc8cabc81692dbc56e5e28a6f07df18872b2b307a2a7ef68698f4451df9a16 + ssa_ast: fb36cb3733be081ed0852dcaaa69f4b33af636b4fe2d270cc02a28487f00ffe9 + flattened_ast: 5788793459555260aefda2bb1078307a645960bcd37cdc058bf70663c3f796fd + inlined_ast: 5788793459555260aefda2bb1078307a645960bcd37cdc058bf70663c3f796fd bytecode: 83b53d924626a5d279185858585b6a826be3670399330a38b51230716460cac9 diff --git a/tests/expectations/compiler/integers/u32/gt.out b/tests/expectations/compiler/integers/u32/gt.out index d986325ac8..47dcdcf412 100644 --- a/tests/expectations/compiler/integers/u32/gt.out +++ b/tests/expectations/compiler/integers/u32/gt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: bc3bfaa1441a4227eff6de35e63ac982e55689e3e99ce28d299a875d02166232 - unrolled_ast: bc3bfaa1441a4227eff6de35e63ac982e55689e3e99ce28d299a875d02166232 - ssa_ast: ba07f3fd8d75d8feadfa1254c6ffbb32f6109d6bc1c261edbafe1cae3a8d3103 - flattened_ast: 58e383eda974c74854d19af5bc1c1526612bb5d2ed8301edd1ba2624b173c3bf + - initial_ast: b1cadc049ad47022d6d0edbf94cc7af9d09783abc8a2c269dfa577f9fcbb88fa + unrolled_ast: b1cadc049ad47022d6d0edbf94cc7af9d09783abc8a2c269dfa577f9fcbb88fa + ssa_ast: 1545f76da55f60b4ba0fb51600604d21c2fed58dfa00448d15cf3350e2d7dacc + flattened_ast: 8fc9715eec00b4beccd1323da8623669682d8cd93ef184750549e1d116e5ded0 + inlined_ast: 8fc9715eec00b4beccd1323da8623669682d8cd93ef184750549e1d116e5ded0 bytecode: a7d5e36441243461635f13035d4c2b17e257b340d905c6d9368a25aaae6e7c78 diff --git a/tests/expectations/compiler/integers/u32/le.out b/tests/expectations/compiler/integers/u32/le.out index 2064e2a39c..5104be2abb 100644 --- a/tests/expectations/compiler/integers/u32/le.out +++ b/tests/expectations/compiler/integers/u32/le.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: c69424c99b06258e019d8cc553325a34161604493d7e6365c21e537e4c1a177e - unrolled_ast: c69424c99b06258e019d8cc553325a34161604493d7e6365c21e537e4c1a177e - ssa_ast: 71458cd742c00d80c2175438fbf989eb401ef0a552f18e4c3ad225ab66b91e8a - flattened_ast: a46ba8ef8ed76706555b55dc9e01ef000a52cb228fb4974119ee0d4a78ec1ae1 + - initial_ast: 5ae7c2d0952490eb2e363cc2d577f2f76a2b41108a61e24a895275aa7fd4976b + unrolled_ast: 5ae7c2d0952490eb2e363cc2d577f2f76a2b41108a61e24a895275aa7fd4976b + ssa_ast: 7be366e748aee8cd0d8ec5f4f05fdad16983da2b7860c443caa6836aa097cf2c + flattened_ast: 9d54c9dfa92b3338ca90473773f6ae761109214137d1b5f91a08bfe6723ba154 + inlined_ast: 9d54c9dfa92b3338ca90473773f6ae761109214137d1b5f91a08bfe6723ba154 bytecode: 84835e4d314e3795b36935bfc3412ca7794bcbafd8dcedaa48855b1b63e030c3 diff --git a/tests/expectations/compiler/integers/u32/lt.out b/tests/expectations/compiler/integers/u32/lt.out index 3feadab940..72997cc990 100644 --- a/tests/expectations/compiler/integers/u32/lt.out +++ b/tests/expectations/compiler/integers/u32/lt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: a75de99798d0cce8da3420963e49c5b97c0296b3e78df92162e30132606b0383 - unrolled_ast: a75de99798d0cce8da3420963e49c5b97c0296b3e78df92162e30132606b0383 - ssa_ast: 68923f9ed4d878fdbc2ef474ffc1ba89bcc502eeda8582c6bef7eca3d5b0abbd - flattened_ast: 3224271fd51d337c989c1457b36393232b88f609629d839eb5fa5ef5eee8ab4d + - initial_ast: 39b471a72591df256c5859b6df1c4bc06129fb0a5ebd805d420ff52a8b5b3771 + unrolled_ast: 39b471a72591df256c5859b6df1c4bc06129fb0a5ebd805d420ff52a8b5b3771 + ssa_ast: 1071c082adb922599e57ac8cf549497631abf40034c2debe57ceed71c441b4b2 + flattened_ast: 397785ad8ef12f977d798ff747f8cce7bbeb287d0fd658369256f5b4096ffae3 + inlined_ast: 397785ad8ef12f977d798ff747f8cce7bbeb287d0fd658369256f5b4096ffae3 bytecode: 64a3bc8031d302c5bf6b6edb51dbd350c3209b28045d3cfebd6b837c0e246826 diff --git a/tests/expectations/compiler/integers/u32/max.out b/tests/expectations/compiler/integers/u32/max.out index 8bbb3dff35..c6befec74e 100644 --- a/tests/expectations/compiler/integers/u32/max.out +++ b/tests/expectations/compiler/integers/u32/max.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b6b318d428063def3324a3f9ac64b08c3f9e329df68709111da7b993b2adaf27 - unrolled_ast: b6b318d428063def3324a3f9ac64b08c3f9e329df68709111da7b993b2adaf27 - ssa_ast: 7bb6ab7b16f40cb76394aecf75a63e6edc7abbdaaa5d1d1cd3c1ab52a579c607 - flattened_ast: a13abbe849e8b34d24d1e2ea26e088440e092587b9fd307705c23533760500c8 + - initial_ast: 9d902865f4a3acbaf871137bedaf016f8e979972eb29d53d933c973838159642 + unrolled_ast: 9d902865f4a3acbaf871137bedaf016f8e979972eb29d53d933c973838159642 + ssa_ast: b5d6ca4d390a5a64d3253c2e6ada96677927bce094a8d57b72ec876ce4288446 + flattened_ast: e89e05dc38efd435b5c807e035567c138444a7babbfa7f8be2ece73fafe56440 + inlined_ast: e89e05dc38efd435b5c807e035567c138444a7babbfa7f8be2ece73fafe56440 bytecode: 9a1e5bb7b8d932d4afd347a856bfb38db144771f49a0d9589ef14236338e3dcf diff --git a/tests/expectations/compiler/integers/u32/min.out b/tests/expectations/compiler/integers/u32/min.out index 23c5a8baa3..9b92e7c5ac 100644 --- a/tests/expectations/compiler/integers/u32/min.out +++ b/tests/expectations/compiler/integers/u32/min.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 6a82d8768a8ba396e73039c3f0769721950589374c1fcdc53b8d60994106cba4 - unrolled_ast: 6a82d8768a8ba396e73039c3f0769721950589374c1fcdc53b8d60994106cba4 - ssa_ast: f0d57aa61ab4a5d22c26a3a8225378f817970a45c76d486f0fe6968a780d77c0 - flattened_ast: 18e21f7557ae696c8a511931a49166dbb01aacdfd4887864ee02fad85ec7c9ad + - initial_ast: d37e6bd3f00cd13ba85cc573e65b7786f5d151d7fbb25141a22009f6dceb90f1 + unrolled_ast: d37e6bd3f00cd13ba85cc573e65b7786f5d151d7fbb25141a22009f6dceb90f1 + ssa_ast: 3258134abebb6620ec9c02875692934dfd642bf555b413e7a32493c13b3f208f + flattened_ast: faeb3f6dfdeabf4a09ecc24c23217f9f08462345dca4e1351d87b4ba0ff2ce1a + inlined_ast: faeb3f6dfdeabf4a09ecc24c23217f9f08462345dca4e1351d87b4ba0ff2ce1a bytecode: 9a1e5bb7b8d932d4afd347a856bfb38db144771f49a0d9589ef14236338e3dcf diff --git a/tests/expectations/compiler/integers/u32/mul.out b/tests/expectations/compiler/integers/u32/mul.out index b154d7368d..15453cfa5e 100644 --- a/tests/expectations/compiler/integers/u32/mul.out +++ b/tests/expectations/compiler/integers/u32/mul.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 3efdcb73605bb437acaae813bb9e2170049d590d172e1e80f42f8da13c8626a6 - unrolled_ast: 3efdcb73605bb437acaae813bb9e2170049d590d172e1e80f42f8da13c8626a6 - ssa_ast: 8d5e63a4d400a570b36ae0483e264f1f91bc7ee0da43840d9924316825e42752 - flattened_ast: a719975f3fad99624e57ca6cd7b075a37d588d6d059b0916046901effa33cc9c + - initial_ast: 15ed1dc3f0c59f586ccb582f40b66050bcef56928e35a0f289f7b3cbe1c79bc0 + unrolled_ast: 15ed1dc3f0c59f586ccb582f40b66050bcef56928e35a0f289f7b3cbe1c79bc0 + ssa_ast: 399c38f1b33cec850031ed59321509d5acac4cd9670964d84b92e9ea1521ecc0 + flattened_ast: 75fc444954a90b8f61a265a413f59d45026ebf09e32dfcde71ab09b1d725e83a + inlined_ast: 75fc444954a90b8f61a265a413f59d45026ebf09e32dfcde71ab09b1d725e83a bytecode: 7af3a41a18b6d5e929c72eb42b1dcf26553676d4297e8477c85c2660199e4843 diff --git a/tests/expectations/compiler/integers/u32/ne.out b/tests/expectations/compiler/integers/u32/ne.out index 32fe5e044e..fb6417e194 100644 --- a/tests/expectations/compiler/integers/u32/ne.out +++ b/tests/expectations/compiler/integers/u32/ne.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b1cfaec449a41fc559fd8bcb7cb1cbd533ae84a2ec742a6f1ff7092a735217fa - unrolled_ast: b1cfaec449a41fc559fd8bcb7cb1cbd533ae84a2ec742a6f1ff7092a735217fa - ssa_ast: c9ea73e61d79801814902f9a989b8ccda1d6b8e3741bf640d761b6ff33215ecc - flattened_ast: fe72cf5348e4bfafce67adaa7c4c8db77aadad0dafb320a73488322e9eabf7a2 + - initial_ast: 0c7eef2a89c686c4b78b0184bfd84e77c845d9fbd6c39da0b6d011e3a66335a2 + unrolled_ast: 0c7eef2a89c686c4b78b0184bfd84e77c845d9fbd6c39da0b6d011e3a66335a2 + ssa_ast: 904d39cde7eedaa780f566561223b4cc5c504249530ea0cfd4135a45a837172d + flattened_ast: 1792ca92cfb95dbd1e1e6324e4f422db9c90ea35a68ef0c867a40c6a216a32a8 + inlined_ast: 1792ca92cfb95dbd1e1e6324e4f422db9c90ea35a68ef0c867a40c6a216a32a8 bytecode: 1297340f0d83c34cfcd5e861de7b4358083ecfb96f9bdc75ae2f78ffa20831cc diff --git a/tests/expectations/compiler/integers/u32/operator_methods.out b/tests/expectations/compiler/integers/u32/operator_methods.out index 6947b4b7cf..2d8457322e 100644 --- a/tests/expectations/compiler/integers/u32/operator_methods.out +++ b/tests/expectations/compiler/integers/u32/operator_methods.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e542850da93986b4a76dcbf27ee30e49ed8887608821422601855925ce24ff85 - unrolled_ast: e542850da93986b4a76dcbf27ee30e49ed8887608821422601855925ce24ff85 - ssa_ast: ea9a54f4ae25524edfe74fc86aad3ee83f8c24909aec5df50778b22cf7dd2eb0 - flattened_ast: 71794362f5a4d497010a8df9e6bd5659d54f1cc988cac6cdda680577ec699f7f + - initial_ast: 4122e0f35832c94f02c0402ccd3e119d2959fa0622d853236aee221c9ce75321 + unrolled_ast: 4122e0f35832c94f02c0402ccd3e119d2959fa0622d853236aee221c9ce75321 + ssa_ast: f7da86e7baa8412cedcf072b206aa14bc9066783623248d66016bbdab5b2f609 + flattened_ast: ecca31afbdf9d9cc9576617e607fcc9e6abe332e627032ac0203f39e85421bbc + inlined_ast: ecca31afbdf9d9cc9576617e607fcc9e6abe332e627032ac0203f39e85421bbc bytecode: b579a343446b8730bb6b28fee10fce002a41de1f622896bf8b19a14121e55bfc diff --git a/tests/expectations/compiler/integers/u32/or.out b/tests/expectations/compiler/integers/u32/or.out index 1e53c0bbf9..670ee68bb4 100644 --- a/tests/expectations/compiler/integers/u32/or.out +++ b/tests/expectations/compiler/integers/u32/or.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 90ab809f08348a9c7fb6f68508d8a5ff71f370c6c627bb8f2e85af9275b1c383 - unrolled_ast: 90ab809f08348a9c7fb6f68508d8a5ff71f370c6c627bb8f2e85af9275b1c383 - ssa_ast: ddddf1bfa333231e6bf2593401bf99ea65f37f286b6033fb7380eeb66b13e679 - flattened_ast: 8da35e3027bef8ebfe4db9a6119b4669bd9945e88b62811abca624a37f8d2879 + - initial_ast: 2900346cde32b37f3ec042632a68bbf406c2393c230cbb66daa7a91599b0b322 + unrolled_ast: 2900346cde32b37f3ec042632a68bbf406c2393c230cbb66daa7a91599b0b322 + ssa_ast: ebac1b96baed77daf97ffbc9a92a30dbcedc3b916dfe712132062f1714da23e5 + flattened_ast: 8a9a73f08d8c89cf849997fd1a0097a01f147da6c77fbe4bd0c27f7fe320af4a + inlined_ast: 8a9a73f08d8c89cf849997fd1a0097a01f147da6c77fbe4bd0c27f7fe320af4a bytecode: b4a60f9a659d2a10c8bd120e5849e06315701c890b9a042eb42161693f600082 diff --git a/tests/expectations/compiler/integers/u32/pow.out b/tests/expectations/compiler/integers/u32/pow.out index 768da51be2..348eec735a 100644 --- a/tests/expectations/compiler/integers/u32/pow.out +++ b/tests/expectations/compiler/integers/u32/pow.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: edc0d4cbad41e827c02eec40fe465b64b6c0197b810393296884dd915984e1d0 - unrolled_ast: edc0d4cbad41e827c02eec40fe465b64b6c0197b810393296884dd915984e1d0 - ssa_ast: dc9eecfed619a6875516fbca435c9567b22125e02884286beefaa3ac6e68bdd6 - flattened_ast: b27e7adaaa3b8aab296b38239faa98d4889e69a7fd37ad0e9fb95c9f4619b38e + - initial_ast: 9c30f840d788ab85da87ef4eb9efa6bc038a88a33b214820508bdb7322bded12 + unrolled_ast: 9c30f840d788ab85da87ef4eb9efa6bc038a88a33b214820508bdb7322bded12 + ssa_ast: 998ae7cc01e814ab0ee19eff0dc25ad48a4dac1c5b01fbbec3dfe8679356d2fd + flattened_ast: 4a6a43f2db71c97d71a729a2d1f364ab97552006c237653f47625d49f217e2f0 + inlined_ast: 4a6a43f2db71c97d71a729a2d1f364ab97552006c237653f47625d49f217e2f0 bytecode: 5bbd2123413f7834055a8f71617bd2569dcc574e486736eeec7810a5a8642ee0 diff --git a/tests/expectations/compiler/integers/u32/rem.out b/tests/expectations/compiler/integers/u32/rem.out index 71609c040c..031f513f13 100644 --- a/tests/expectations/compiler/integers/u32/rem.out +++ b/tests/expectations/compiler/integers/u32/rem.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 772cabbf4ef65eb53cd0a2d43424307e9a7a952d3c9d13a6acd9ba5c7b962470 - unrolled_ast: 772cabbf4ef65eb53cd0a2d43424307e9a7a952d3c9d13a6acd9ba5c7b962470 - ssa_ast: 2ce0b613385f8c98c20cc557f79d2cab64cd78f80c27b3b107c12222b45bbc85 - flattened_ast: 169f626b5a295be49056214e1e9772eac395563f6810244feecc9f773e48c44b + - initial_ast: 327cd4390904928b6cf35efe51c5e4886948194480806bca4b925ae96680bfc1 + unrolled_ast: 327cd4390904928b6cf35efe51c5e4886948194480806bca4b925ae96680bfc1 + ssa_ast: 6ddb1e9da49b0932744a0a4a5fe70c002ca2a66051f558848f0eed5ed6a6e438 + flattened_ast: 9e28544d33cb83ddbeac5722db779423fd0e8220afe4f621fbf3dc5b0c76b1e7 + inlined_ast: 9e28544d33cb83ddbeac5722db779423fd0e8220afe4f621fbf3dc5b0c76b1e7 bytecode: cfc8529a88bc370481e0596e79d20913a011b529a210ef909d9d66c445b9ec98 diff --git a/tests/expectations/compiler/integers/u32/shl.out b/tests/expectations/compiler/integers/u32/shl.out index e38a0b99cb..c5515826ec 100644 --- a/tests/expectations/compiler/integers/u32/shl.out +++ b/tests/expectations/compiler/integers/u32/shl.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 92e4b5595e378451d0dbd7b35ff36000d23a7b251c7b29f8694b7d122d79d37a - unrolled_ast: 92e4b5595e378451d0dbd7b35ff36000d23a7b251c7b29f8694b7d122d79d37a - ssa_ast: b46fbc11a9458a3bf920cce13869582e069324092184f6a996ea31f3803fdd7d - flattened_ast: e5ab29f4075b3b115ede3751dcf31401508e1b2d79998ac3dcb5944ed5eece34 + - initial_ast: 442a85256236f5716abada3e8c31c079b56546d5241a86c9575a2ae062540827 + unrolled_ast: 442a85256236f5716abada3e8c31c079b56546d5241a86c9575a2ae062540827 + ssa_ast: dcc25ec939a8a31cf1f7af9a26ffe400d36ea215c2a2c9da0d15ccb737b2681d + flattened_ast: 8eecdaeddfe4b39472ea7df3ed93fa7da28c15bfd7379ec426b00f2ed6431ffc + inlined_ast: 8eecdaeddfe4b39472ea7df3ed93fa7da28c15bfd7379ec426b00f2ed6431ffc bytecode: c9269f19329dd9d6e5faaa84693b869ff8040297c2ce894b35a244330f1f6ced diff --git a/tests/expectations/compiler/integers/u32/shr.out b/tests/expectations/compiler/integers/u32/shr.out index def6de9123..66e2f38b6b 100644 --- a/tests/expectations/compiler/integers/u32/shr.out +++ b/tests/expectations/compiler/integers/u32/shr.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 4e3e54f0993ae8da3f5d35e427208c633f7ed14e9d4d1cb9a4b1482ef59f5f41 - unrolled_ast: 4e3e54f0993ae8da3f5d35e427208c633f7ed14e9d4d1cb9a4b1482ef59f5f41 - ssa_ast: dc79ab76a712100bd6632b9022c8a88c6001cb7b57659d197916f99236c0c1d6 - flattened_ast: a3896ec8fbcd2471cca1207960e925c8aa5e9a4ed2f4833c1a8784a5cccc36f4 + - initial_ast: e1f0496bd75c23d6fb4e07f2e967e5132e7b6fe6778a955464ba6fff12e21fe3 + unrolled_ast: e1f0496bd75c23d6fb4e07f2e967e5132e7b6fe6778a955464ba6fff12e21fe3 + ssa_ast: 71850a7915199e9a2e49667a0c7fb4628dadb93aa69137909d1229d0f10f4c5e + flattened_ast: 54779c1fa9fe4e7563504a8f07241e2d241ebfb02fa1f57b8f48544f8739055d + inlined_ast: 54779c1fa9fe4e7563504a8f07241e2d241ebfb02fa1f57b8f48544f8739055d bytecode: 0ed67d20829238f0a85c90cdeefb7d0463ffc0bdc7ba9523550c62849a69176b diff --git a/tests/expectations/compiler/integers/u32/sub.out b/tests/expectations/compiler/integers/u32/sub.out index ef608053ff..25fcbfa815 100644 --- a/tests/expectations/compiler/integers/u32/sub.out +++ b/tests/expectations/compiler/integers/u32/sub.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b2096b3fe3f1f04c396982615783f5e11d35791a42619341816eeedf2ec60350 - unrolled_ast: b2096b3fe3f1f04c396982615783f5e11d35791a42619341816eeedf2ec60350 - ssa_ast: eadee144c33adbea24e40805c8a29b87d9f65c9a75ec2f760c189e0c072962c6 - flattened_ast: 40c68b187491a42a49a92b2ad311aef172434d057597e80e8f91d91fc132511c + - initial_ast: a8325d66093d93f8378a5e19b30856077750bec2f0581735b80561a0180af49b + unrolled_ast: a8325d66093d93f8378a5e19b30856077750bec2f0581735b80561a0180af49b + ssa_ast: 514e0a25eb0a59ce6de775b1b8218f51aedbe1c711c338eb563cb4483f412c2e + flattened_ast: ad2452326217e256b8d915c2c9156e191ee5ff0737cc5c721db1e9a6e56a0fd5 + inlined_ast: ad2452326217e256b8d915c2c9156e191ee5ff0737cc5c721db1e9a6e56a0fd5 bytecode: a302075ca2b4aac635c7d45ad379a2b599cfcf7092c99fd104a5c1e5de7ce50f diff --git a/tests/expectations/compiler/integers/u32/ternary.out b/tests/expectations/compiler/integers/u32/ternary.out index 5a2c1058a9..32473ed5d0 100644 --- a/tests/expectations/compiler/integers/u32/ternary.out +++ b/tests/expectations/compiler/integers/u32/ternary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 3ec482b818b01a2704e71c12cfa0b251b96442c6ab36ef2b715a90ceedc64e31 - unrolled_ast: 3ec482b818b01a2704e71c12cfa0b251b96442c6ab36ef2b715a90ceedc64e31 - ssa_ast: 57f63d0776068a14a5eb69aeb4d050341c808ec5a64077ff178611e2f30b0788 - flattened_ast: 2d8f418b5255f5b436fd74bae9d9cf7fe33914ed3d4cc6eb311a592be69904d0 + - initial_ast: a2eed438beb0fb1924c816a910aae00589b11de0da62226aebc9c3d1faffe8a5 + unrolled_ast: a2eed438beb0fb1924c816a910aae00589b11de0da62226aebc9c3d1faffe8a5 + ssa_ast: 100318f3918fc545497f851f6a19bb455d522148de6599bb15a294738ad66e49 + flattened_ast: 698150b9405efb682dd60a1d235b2e6cb9a862060cbcf2a2806da1d1d890431b + inlined_ast: 698150b9405efb682dd60a1d235b2e6cb9a862060cbcf2a2806da1d1d890431b bytecode: d095ae12af5337bd905f4f2cbb4b480905afe97216959e968bee1a5c6910af2a diff --git a/tests/expectations/compiler/integers/u32/xor.out b/tests/expectations/compiler/integers/u32/xor.out index 5267f415d5..02a09775bb 100644 --- a/tests/expectations/compiler/integers/u32/xor.out +++ b/tests/expectations/compiler/integers/u32/xor.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: a776975ed1e58de71bafc88742ac7ebf1712ba51668d524777f29f2c3a194c93 - unrolled_ast: a776975ed1e58de71bafc88742ac7ebf1712ba51668d524777f29f2c3a194c93 - ssa_ast: e379f43c82393ece64a9e6b8c797760d244883d07b1a772542c510b0adf181a2 - flattened_ast: 5566e1fbfc02816bb3f86bc0ac4fa7810a540eef684f9f83e1fdfd120eaceeef + - initial_ast: 30c2fa6afdd640ed915f0b16104397c295c8cfe6aa23ae38fa71ef152dae88c3 + unrolled_ast: 30c2fa6afdd640ed915f0b16104397c295c8cfe6aa23ae38fa71ef152dae88c3 + ssa_ast: 0168badbc647c09912b30b7a7bea508cc3e35d39065278e1c8c8104f5f49acfd + flattened_ast: a986ff3547fba993b81cce679bfdf11a6cbc53c9870d4f9aff1c1c5846fe5779 + inlined_ast: a986ff3547fba993b81cce679bfdf11a6cbc53c9870d4f9aff1c1c5846fe5779 bytecode: f0b8958f3f4c4311e2308c5aed950b9a660d3eacdea6299d6e78c33e064c9cd1 diff --git a/tests/expectations/compiler/integers/u64/add.out b/tests/expectations/compiler/integers/u64/add.out index 061e028a94..ca94c2e324 100644 --- a/tests/expectations/compiler/integers/u64/add.out +++ b/tests/expectations/compiler/integers/u64/add.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 0dc28187ac897d6a78385b051920d3ba8147219438ffcd996d016f4999277e0e - unrolled_ast: 0dc28187ac897d6a78385b051920d3ba8147219438ffcd996d016f4999277e0e - ssa_ast: e118828e592bba9d9b598838b180d24e58fbcdc5a907c4b37b223f1d560e72da - flattened_ast: f0fb85463f1d2e2a32bd643ad88ba51dc4d37588d3e00bc1afb92a56ccf55615 + - initial_ast: 77904693232a619edb9dfd847a2e5f372aa37539e300f7baa081017f54688d64 + unrolled_ast: 77904693232a619edb9dfd847a2e5f372aa37539e300f7baa081017f54688d64 + ssa_ast: e96e5f845a68746524fd9ce325d766afecf8bd5c1c6f4a9696360ea6de45c485 + flattened_ast: e35df553d77d5cdf6dd3f2f963416b9e0172c8482177f98a8dc5d9100212060a + inlined_ast: e35df553d77d5cdf6dd3f2f963416b9e0172c8482177f98a8dc5d9100212060a bytecode: abb8c69d4bd2b5834d385969f49c8ead068036e07c0afe9a96c6c022ce3d491f diff --git a/tests/expectations/compiler/integers/u64/and.out b/tests/expectations/compiler/integers/u64/and.out index 00f0e6e6e0..1ace77c3b0 100644 --- a/tests/expectations/compiler/integers/u64/and.out +++ b/tests/expectations/compiler/integers/u64/and.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 98e97639bbfb6cc5bbd7041f1d541dc67d598f94d8b7a86879a10ce865d05258 - unrolled_ast: 98e97639bbfb6cc5bbd7041f1d541dc67d598f94d8b7a86879a10ce865d05258 - ssa_ast: 0ca8fcdc0e147b4d9c53f0a8f44e9c8932063385e05ef2e76f95236c4b7cdc20 - flattened_ast: 202fe52c391c02f514e549efe4ad9a984f6645eeafc71c050746d764557b0d45 + - initial_ast: 0d6e55e99c314cd034fd91f9714bd8d6de3a3d988991cdcf52c57b4f1b37b548 + unrolled_ast: 0d6e55e99c314cd034fd91f9714bd8d6de3a3d988991cdcf52c57b4f1b37b548 + ssa_ast: 7d9986e5155ad64bf59b8b8f85cff39b1278ede15241c15b7602d7bb862e64e0 + flattened_ast: 227779e9b08f9f2c30486b2aae031354b40767978dd73d82d47e4fcb0977660f + inlined_ast: 227779e9b08f9f2c30486b2aae031354b40767978dd73d82d47e4fcb0977660f bytecode: e15f4b54f9f4f2380c49a61ea310f77ebc2837f0058dac3255a3743d3ce31b49 diff --git a/tests/expectations/compiler/integers/u64/console_assert.out b/tests/expectations/compiler/integers/u64/console_assert.out index 717a4138e9..5717cc2e2e 100644 --- a/tests/expectations/compiler/integers/u64/console_assert.out +++ b/tests/expectations/compiler/integers/u64/console_assert.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: a11798b3a5edf58be034eb12fe0a3811855af528ec3904ba8c5fe2eadd57cca2 - unrolled_ast: a11798b3a5edf58be034eb12fe0a3811855af528ec3904ba8c5fe2eadd57cca2 - ssa_ast: 60fc106798752dc16c57e67289358899ca5eaa48d70eb35c555996432c1d2e03 - flattened_ast: c326a2f1c2a18800615aa3e0808fe685116312b0ab52d8083a24d51f582b63a4 + - initial_ast: 8957d366fe7f99c4a3629a197c2acba651509e1045d176fff4d767557fdc1bb5 + unrolled_ast: 8957d366fe7f99c4a3629a197c2acba651509e1045d176fff4d767557fdc1bb5 + ssa_ast: c2c58c4275c84281ba279cd27da5fbc87220f0c7e29cb34bfb0979c1a3d6757f + flattened_ast: a931b17e4b6d87ab9dc1f70adfd00462502c6e25290060fcc43225882f7a5db1 + inlined_ast: a931b17e4b6d87ab9dc1f70adfd00462502c6e25290060fcc43225882f7a5db1 bytecode: 528d0e5eae513b94ac63a4b48646f04deae2de5b41de4488bec74d196b1a3177 diff --git a/tests/expectations/compiler/integers/u64/div.out b/tests/expectations/compiler/integers/u64/div.out index bc67909da1..3c2f6daeeb 100644 --- a/tests/expectations/compiler/integers/u64/div.out +++ b/tests/expectations/compiler/integers/u64/div.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 27de2397d201aa941553c88b3ff2c23e85f1980e8530d27ec27d9a027e2246df - unrolled_ast: 27de2397d201aa941553c88b3ff2c23e85f1980e8530d27ec27d9a027e2246df - ssa_ast: 885b3105453a72fffd1ff429c1ba01d99be7b8e3fad9125a0e6b613f9a0e41a1 - flattened_ast: 83af310a603b680d4702361669c490d70348e398b687d899aaafcd8c371fa06a + - initial_ast: 063b86d78c56d953e707d0eeb1a8624e5ab09a76e7f3b2c009fd3bd54827aeb3 + unrolled_ast: 063b86d78c56d953e707d0eeb1a8624e5ab09a76e7f3b2c009fd3bd54827aeb3 + ssa_ast: 2fffb1cf3fd6065068d20443f2ef8da133cbcb0619dc5f328ddc71f6fa71cdcb + flattened_ast: 0cbeef911b466f39e73259f94d01876fd0f954a5ac0948a97a2dfbe1d5142998 + inlined_ast: 0cbeef911b466f39e73259f94d01876fd0f954a5ac0948a97a2dfbe1d5142998 bytecode: 6f756295de250a5a5c917f41e42c3b7fb0ff9387e25e0384b48058bf4093c35e diff --git a/tests/expectations/compiler/integers/u64/eq.out b/tests/expectations/compiler/integers/u64/eq.out index 8cc55f905f..0967f07425 100644 --- a/tests/expectations/compiler/integers/u64/eq.out +++ b/tests/expectations/compiler/integers/u64/eq.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 24cc971e1a09c53cfbd30ea81b0909f0ed24809577d564de336e4e8a687072a3 - unrolled_ast: 24cc971e1a09c53cfbd30ea81b0909f0ed24809577d564de336e4e8a687072a3 - ssa_ast: df30e092f2cdb8caaabeaaaa00284c1d3388aaefbd64b0749db283a26be285b7 - flattened_ast: d0132a729c1e1e5b53154627e70c9cbedd0fe162160e67854211ae138bce4420 + - initial_ast: a0880907fe29ccdf61c3682e55ddfe6080b4e8aedaab10bdb308cf9177fd0b00 + unrolled_ast: a0880907fe29ccdf61c3682e55ddfe6080b4e8aedaab10bdb308cf9177fd0b00 + ssa_ast: ce3dbcab3daddd57ef474987cb34581271601c0f5db6f4f7e056f29eb07adeb5 + flattened_ast: f661262eb0e62b587959284cbd5e7dd6be5ef09d40ebbb38d6e64789ed063399 + inlined_ast: f661262eb0e62b587959284cbd5e7dd6be5ef09d40ebbb38d6e64789ed063399 bytecode: 3dc2579c9b4376c0ac3c15d6c791992bbc13baed767b4a84313db47aa14296f1 diff --git a/tests/expectations/compiler/integers/u64/ge.out b/tests/expectations/compiler/integers/u64/ge.out index caf5759984..b2d4d0d68e 100644 --- a/tests/expectations/compiler/integers/u64/ge.out +++ b/tests/expectations/compiler/integers/u64/ge.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: c4a862fa50d5dcfa0ae301f80e8a33c5dde1671924d2eccedfce11f9513f7db5 - unrolled_ast: c4a862fa50d5dcfa0ae301f80e8a33c5dde1671924d2eccedfce11f9513f7db5 - ssa_ast: 0005ae843f7454cf58b324a40d2f2abce397e2942f747d9ac8fa91eb3b35daf6 - flattened_ast: e1af49000d72bb436ce7b00f8ed4ef4cd133643787c54c5eda56b7def1d4acc0 + - initial_ast: 2348d1221bcf28772aaa19979444d0c1bb5d28e21c29ab4a8e03698952697da6 + unrolled_ast: 2348d1221bcf28772aaa19979444d0c1bb5d28e21c29ab4a8e03698952697da6 + ssa_ast: 5406211b916c820d0de1a68a927c7c49e8b3624e4a5b5f0daf2b83cd5af1a294 + flattened_ast: 8ecac1101bcaad31e826399a5be8f5e16bcee2be5cd920dec535cf3d95df6e2f + inlined_ast: 8ecac1101bcaad31e826399a5be8f5e16bcee2be5cd920dec535cf3d95df6e2f bytecode: a614338051a535a74ee0794a7b2e1f4617263a3bca7be899ba2e68beae7748da diff --git a/tests/expectations/compiler/integers/u64/gt.out b/tests/expectations/compiler/integers/u64/gt.out index 24fafcd4c1..459629c2a1 100644 --- a/tests/expectations/compiler/integers/u64/gt.out +++ b/tests/expectations/compiler/integers/u64/gt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 7638b452e08ad812dda4f144129b87058cf1f934c9bf78ca005057878691a294 - unrolled_ast: 7638b452e08ad812dda4f144129b87058cf1f934c9bf78ca005057878691a294 - ssa_ast: 9300685cb30171e279a1d49f6bceae4b681cd8002058f3a514d83f518e7d24b0 - flattened_ast: a9ad38c59ff0a10012b297b996ec6459cd7ceaba62139b66bc43c69f6ab3eaec + - initial_ast: 9c3decab653a0b6e25ccc9d45790d0e9e143f04f2464ddc1ebc4d51cd2397d2c + unrolled_ast: 9c3decab653a0b6e25ccc9d45790d0e9e143f04f2464ddc1ebc4d51cd2397d2c + ssa_ast: f8071ff1e6c7ab61417b51679345247302f714e1817b7c3df8b52fb09f292417 + flattened_ast: ea5f9d82d269a53e25bb6a3cc2645acc803274a3eb25cdee10b4252c47ccd4fa + inlined_ast: ea5f9d82d269a53e25bb6a3cc2645acc803274a3eb25cdee10b4252c47ccd4fa bytecode: 3977504f6f75064e9a2125af4f7773742771babbfc1c290a3d0a794d42423663 diff --git a/tests/expectations/compiler/integers/u64/le.out b/tests/expectations/compiler/integers/u64/le.out index 50ed92cd24..9c5542d4f8 100644 --- a/tests/expectations/compiler/integers/u64/le.out +++ b/tests/expectations/compiler/integers/u64/le.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: c37d70527e6706d12f957f6e1736bbb569256b762bde18cf4ca19714d925a753 - unrolled_ast: c37d70527e6706d12f957f6e1736bbb569256b762bde18cf4ca19714d925a753 - ssa_ast: a8bbf1cb18477f59fdde5a00a10018ee73c97be0b6da7d939b088c47ddae4b63 - flattened_ast: ebb98ca3c21a3a079341e91dbe0071805b5635e22b26d87bab2d0f7f29e55e48 + - initial_ast: 3f0fdec0d74d7c7bf3f4c6822b50db267605f55d37d944dcc370489f25a4458a + unrolled_ast: 3f0fdec0d74d7c7bf3f4c6822b50db267605f55d37d944dcc370489f25a4458a + ssa_ast: 96e672bfdf8320ae5e771ca76beaac4215cea8dc0471ec554fe7c179742adfd8 + flattened_ast: 422a4619d2486041f289d05a77150f074fcd61bbad5c2657242066551696d3ea + inlined_ast: 422a4619d2486041f289d05a77150f074fcd61bbad5c2657242066551696d3ea bytecode: 8dc4649ab97faa73e36c483cda23375d32ab95a137908e5862c449fb4ddafe21 diff --git a/tests/expectations/compiler/integers/u64/lt.out b/tests/expectations/compiler/integers/u64/lt.out index c006ebcab0..0f820a787b 100644 --- a/tests/expectations/compiler/integers/u64/lt.out +++ b/tests/expectations/compiler/integers/u64/lt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b06ded2cca19bc72791584cfc9ad6870bba71144a49d69c9c6e91f1f3ecc5b58 - unrolled_ast: b06ded2cca19bc72791584cfc9ad6870bba71144a49d69c9c6e91f1f3ecc5b58 - ssa_ast: b76a6a230cfda21801efb1415dd55460e0c308b730e26af267cc81f67216cb39 - flattened_ast: d82a37f797a289874020f7994c92a149cc3d24b42ed339d7c62107042ecd5264 + - initial_ast: 138ae391c3a630ab32470462bf0238fdb4918dc1cdecbe2e7e35f76bffe7a82a + unrolled_ast: 138ae391c3a630ab32470462bf0238fdb4918dc1cdecbe2e7e35f76bffe7a82a + ssa_ast: 2325bb825c3648c98856f719d4d90087b47c034a289d5e71feff8337d966737d + flattened_ast: db346f11570f06954cea1cdbc84efd81a1b8ee9a618930a6b1bf46770a7e0662 + inlined_ast: db346f11570f06954cea1cdbc84efd81a1b8ee9a618930a6b1bf46770a7e0662 bytecode: 63f280b70417f356c8a73c6b8e1f9ad16075516df68abdc4cc5d704f905141f2 diff --git a/tests/expectations/compiler/integers/u64/max.out b/tests/expectations/compiler/integers/u64/max.out index 18ecccc41a..b01a5c4fab 100644 --- a/tests/expectations/compiler/integers/u64/max.out +++ b/tests/expectations/compiler/integers/u64/max.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b4b410616ccbe4feaa96988e98c6c41e17e897a66933e66d9956b8878bc0abdd - unrolled_ast: b4b410616ccbe4feaa96988e98c6c41e17e897a66933e66d9956b8878bc0abdd - ssa_ast: 714839f1735aff62fd474306f45956973a66a2b26207de395594e6c1b2642ade - flattened_ast: b3abc35bae3a10020dd24afe1a593fcf96abf8cb05a57ee358a8de4029432918 + - initial_ast: 73461dfec279c92400ea4cedec0d119cde3b6400fe5583c1166fe36042bf26f6 + unrolled_ast: 73461dfec279c92400ea4cedec0d119cde3b6400fe5583c1166fe36042bf26f6 + ssa_ast: fccd1527b1232e19651565100d12f0a28ffc7d8c608ea34912066de41e3c0e4d + flattened_ast: a800c61485010662f1279382899f900e8cd92b0ffc3bc16947d2b2e580e7dbdc + inlined_ast: a800c61485010662f1279382899f900e8cd92b0ffc3bc16947d2b2e580e7dbdc bytecode: 9a1e5bb7b8d932d4afd347a856bfb38db144771f49a0d9589ef14236338e3dcf diff --git a/tests/expectations/compiler/integers/u64/min.out b/tests/expectations/compiler/integers/u64/min.out index 0db9a88d9b..3c22d8e079 100644 --- a/tests/expectations/compiler/integers/u64/min.out +++ b/tests/expectations/compiler/integers/u64/min.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: d58c0d550facdc12fa5fc2ed5c4526802b16e6ad016ddde29bae11b766cb4d91 - unrolled_ast: d58c0d550facdc12fa5fc2ed5c4526802b16e6ad016ddde29bae11b766cb4d91 - ssa_ast: f2a644aa5c2e291cea8c05e294f016798db54b6461c14ab48232a9914fcc9897 - flattened_ast: 17c476e11530843bbff9b4d0b731639d5a1bb8631370e536509767446ff63b2d + - initial_ast: 1f7e91061df4442c354206fcd8e5141a687ac1b77f552770eaad45552a4d8fd0 + unrolled_ast: 1f7e91061df4442c354206fcd8e5141a687ac1b77f552770eaad45552a4d8fd0 + ssa_ast: 0e284814c031aa508e0bbd9d2df3133046ba1a53a92bafc9a64150c6c902d748 + flattened_ast: b4e0e5863d90a7509a77d0086365ae2a5b9885157b226df921a10192474d3d62 + inlined_ast: b4e0e5863d90a7509a77d0086365ae2a5b9885157b226df921a10192474d3d62 bytecode: 9a1e5bb7b8d932d4afd347a856bfb38db144771f49a0d9589ef14236338e3dcf diff --git a/tests/expectations/compiler/integers/u64/mul.out b/tests/expectations/compiler/integers/u64/mul.out index 0476bf8ad3..b66833b5b4 100644 --- a/tests/expectations/compiler/integers/u64/mul.out +++ b/tests/expectations/compiler/integers/u64/mul.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1057c23f7ed1be66d0f127111cf34ea67fedb532b14c3f21c5161ee5b6a4e94b - unrolled_ast: 1057c23f7ed1be66d0f127111cf34ea67fedb532b14c3f21c5161ee5b6a4e94b - ssa_ast: 61c28a4da8fed9e78eae6dada40989d6149cb599807ff4c162ffcee2d385fdc2 - flattened_ast: df682933482e35d6163ad15daf1b5102f8382aec03857d4490585821bf1b0807 + - initial_ast: 2af627ac3b1b48f1cf5d9709ca0bc7b0121172daf7d3f3bb56560e7934322d87 + unrolled_ast: 2af627ac3b1b48f1cf5d9709ca0bc7b0121172daf7d3f3bb56560e7934322d87 + ssa_ast: 5dbb4026abb5b39b4c8816c9b3053329a4b90f546ac9208069f53c784e0414e4 + flattened_ast: 360dc932f93796d8893b0011ff3b762f31778bd45e026cb71b51cf301acd2525 + inlined_ast: 360dc932f93796d8893b0011ff3b762f31778bd45e026cb71b51cf301acd2525 bytecode: 486a84afaf57084573210907b90196cb1114fa7410653ca1e6fb6e3c6c79b6b7 diff --git a/tests/expectations/compiler/integers/u64/ne.out b/tests/expectations/compiler/integers/u64/ne.out index 387cb257ec..f311924e1b 100644 --- a/tests/expectations/compiler/integers/u64/ne.out +++ b/tests/expectations/compiler/integers/u64/ne.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 6f2afb2723010375b1b97763106841798da1c2e13ea8e465db053c77883268b2 - unrolled_ast: 6f2afb2723010375b1b97763106841798da1c2e13ea8e465db053c77883268b2 - ssa_ast: f7897d2eb3a0055bdae8a3ee84d2503975f55cb2234d09b497546b66263e52e7 - flattened_ast: c177e659d8b8cfce44dc00d06a4abb4753e68f3b7a48bbe609ad01972a362098 + - initial_ast: 57f15e7b6aad64f87d0bca076d4fd738fba7205e408df6ec07d5c2c8ea7945fa + unrolled_ast: 57f15e7b6aad64f87d0bca076d4fd738fba7205e408df6ec07d5c2c8ea7945fa + ssa_ast: f96f4a440fda9f8a7d15c61add6cfe029c5bc78522e4a094afa9fb4dffccf7c7 + flattened_ast: afe06e8f8a2ab8099c1da2e14054958d4f2a63891d713532ff05241c7b872172 + inlined_ast: afe06e8f8a2ab8099c1da2e14054958d4f2a63891d713532ff05241c7b872172 bytecode: 8e8a975522ad3ffca502e1571834b1c8970eef450662ac7fddd3c49efeb639b6 diff --git a/tests/expectations/compiler/integers/u64/operator_methods.out b/tests/expectations/compiler/integers/u64/operator_methods.out index f7a51f67df..2568eb0bb1 100644 --- a/tests/expectations/compiler/integers/u64/operator_methods.out +++ b/tests/expectations/compiler/integers/u64/operator_methods.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: fa7e15886458d23c094aeafbb9ebe4897519ddab14f29dda28b6ba0e243c92a6 - unrolled_ast: fa7e15886458d23c094aeafbb9ebe4897519ddab14f29dda28b6ba0e243c92a6 - ssa_ast: 97b107fc347eee6926647e6de325a3d6a9f0356438eb4ee1b1f514ead67b1263 - flattened_ast: 7932b1495a691e8b77ef911a307102354bd17f4176f997671e0bc433a031f900 + - initial_ast: 65c6030ba915545327bfe7cdcdca627aa4682ee2cf90d94fb02690994523b08f + unrolled_ast: 65c6030ba915545327bfe7cdcdca627aa4682ee2cf90d94fb02690994523b08f + ssa_ast: 61f1e1380cc21c57ef71044e708ad8bc66cd1716dd137f15b589d3a145f54d5c + flattened_ast: 267033e0527434ffdfaeb8e6925490f3167499efc4dd8438c21dcbb4c6d66368 + inlined_ast: 267033e0527434ffdfaeb8e6925490f3167499efc4dd8438c21dcbb4c6d66368 bytecode: 193cb1040ce4d18bf27ff8bb0bbfe6803dabc2bbf390137c35e7dde921ee5684 diff --git a/tests/expectations/compiler/integers/u64/or.out b/tests/expectations/compiler/integers/u64/or.out index e380d7698e..64bad4ac74 100644 --- a/tests/expectations/compiler/integers/u64/or.out +++ b/tests/expectations/compiler/integers/u64/or.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 2fa19baffe354daeff34a8c61a0aa0f0493cd0c1a09be937b3584fe63216cd5c - unrolled_ast: 2fa19baffe354daeff34a8c61a0aa0f0493cd0c1a09be937b3584fe63216cd5c - ssa_ast: 5ae24b41d8aa24186b4a62b03e4d68b4d6470365480d4e9cb4e6fe693b3337b5 - flattened_ast: f67a713d80a4d96e137b46a1b269d40e048dd38414019a2706d888fc7290e2a5 + - initial_ast: 83176cdc5c11beb15f2912ab2f6b09396e5aba388dc658526d3d63fc004680bb + unrolled_ast: 83176cdc5c11beb15f2912ab2f6b09396e5aba388dc658526d3d63fc004680bb + ssa_ast: 14e893cf9b252a4d6ae2a42b6a2beb45461d4cd760d47ae2f7df4e05df597c2c + flattened_ast: 4424c64eb29b4e6c04bf7f91c52cc978521b47eb28cb41fb69acad39a6ef2da7 + inlined_ast: 4424c64eb29b4e6c04bf7f91c52cc978521b47eb28cb41fb69acad39a6ef2da7 bytecode: 47598c8cd14b5c8d64211a0047245b3f871e19edd70e1522bc53b499086ddadb diff --git a/tests/expectations/compiler/integers/u64/pow.out b/tests/expectations/compiler/integers/u64/pow.out index 3f8ec5736b..23db144db9 100644 --- a/tests/expectations/compiler/integers/u64/pow.out +++ b/tests/expectations/compiler/integers/u64/pow.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e7e7f349709881fd5c9e768010ac7672cfc244057881971fee4c3a4abe3a2248 - unrolled_ast: e7e7f349709881fd5c9e768010ac7672cfc244057881971fee4c3a4abe3a2248 - ssa_ast: f320efc8a5808936b9153f04cdcb68f848033745b796a0f614ea17e0b99d4f51 - flattened_ast: add58901945b0aaad945de755195a3d6e1cd81460668f6d3c5b9ccde9f790419 + - initial_ast: fbafcd3120e0f7204e18568a9627d61a4e3f5bbc7e70d02ff0155e8c03759f71 + unrolled_ast: fbafcd3120e0f7204e18568a9627d61a4e3f5bbc7e70d02ff0155e8c03759f71 + ssa_ast: 81248e235bc86234017d05e11a464c8b13d0064e5d0ea46807f2aa83f8b8b152 + flattened_ast: 425b3c314048ee546660740f365c6f15c9463f54733c1757a37d62d7724c0400 + inlined_ast: 425b3c314048ee546660740f365c6f15c9463f54733c1757a37d62d7724c0400 bytecode: 83a4a3e6bf44d3c123dddb1e75daf9ce1646eb28f1ab8cb29ef54f655f01d896 diff --git a/tests/expectations/compiler/integers/u64/rem.out b/tests/expectations/compiler/integers/u64/rem.out index 0ec14f123b..2fb8bbf415 100644 --- a/tests/expectations/compiler/integers/u64/rem.out +++ b/tests/expectations/compiler/integers/u64/rem.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 7fd037f1b4e49dfb7e0c72c1fc563ff9c8fb0b6c09888aa26387890a03ff0572 - unrolled_ast: 7fd037f1b4e49dfb7e0c72c1fc563ff9c8fb0b6c09888aa26387890a03ff0572 - ssa_ast: a2ffd9b8382c13d669fe7352056ec85db7e4c610d363bfee4d8d1ca6b85097df - flattened_ast: 78ff6b1093432a9e6173fec056dcef00a044a0588252b1aafc53ec7bc1db630d + - initial_ast: 46a267a3807ce59cb21f54023452e51a37079952f7346dbf63d1b6f28af8c253 + unrolled_ast: 46a267a3807ce59cb21f54023452e51a37079952f7346dbf63d1b6f28af8c253 + ssa_ast: d30cab3974a13d4f52236f8c97649c364947ecfe88cbb3f3d256423f6f8d498f + flattened_ast: e32c8161d43b85bc2b7bfd91add942969f37d1c418c30ffe98b71ae6d7ae1a59 + inlined_ast: e32c8161d43b85bc2b7bfd91add942969f37d1c418c30ffe98b71ae6d7ae1a59 bytecode: 38c33340281b18d18928cf039ba05883bcf41ef355d7471a588657758ee7fafb diff --git a/tests/expectations/compiler/integers/u64/shl.out b/tests/expectations/compiler/integers/u64/shl.out index 60b9a82dc3..6b618615ae 100644 --- a/tests/expectations/compiler/integers/u64/shl.out +++ b/tests/expectations/compiler/integers/u64/shl.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 0da7ed73604fbb71d3cf22093e7a4712de5371b12e07bd72e994c4973093565e - unrolled_ast: 0da7ed73604fbb71d3cf22093e7a4712de5371b12e07bd72e994c4973093565e - ssa_ast: 9c71291a47f4f92a3f5bd5525f6c3cf8ac9493f675a8d57b089a7668dcc74303 - flattened_ast: b59634ef5da0b0b7fd072271a150e74f75755efae3d494ba08084b308f12d0cf + - initial_ast: 17c10f575cfbca658b2c795a497b45432885d43950b22ce8fec879beeb87156b + unrolled_ast: 17c10f575cfbca658b2c795a497b45432885d43950b22ce8fec879beeb87156b + ssa_ast: 69f8108645f53f817de010c64f4a432d232f33187a28acfcff8488127209f600 + flattened_ast: 2cf167168467a6012ac71a83820a290334b4f0fd6aeafd6615d9cc91f5d3cffd + inlined_ast: 2cf167168467a6012ac71a83820a290334b4f0fd6aeafd6615d9cc91f5d3cffd bytecode: 6abd2392fd4bdf825472989ac1375279ed65c8085607e574567a29036577a83b diff --git a/tests/expectations/compiler/integers/u64/shr.out b/tests/expectations/compiler/integers/u64/shr.out index b8a825cc96..2f0c5490cf 100644 --- a/tests/expectations/compiler/integers/u64/shr.out +++ b/tests/expectations/compiler/integers/u64/shr.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: bd036534f2610dd4f4ed24b07b0928b6ef86cd62db1ad6fed0e394d79d6e0111 - unrolled_ast: bd036534f2610dd4f4ed24b07b0928b6ef86cd62db1ad6fed0e394d79d6e0111 - ssa_ast: 73800536da731fdfafb737adbcf0efee6f5a330d9be60a490ecf63c0787998b9 - flattened_ast: 77b25631a41b0f0bdad2b86f665a29e9ba9ecb8ad6ac55fd3ffc39b87ca0f2c7 + - initial_ast: 55d8e55854852ae2724cd59b9f4be83e64e845803dbc0ffccd51e66e09a97f8b + unrolled_ast: 55d8e55854852ae2724cd59b9f4be83e64e845803dbc0ffccd51e66e09a97f8b + ssa_ast: b4b9eb2d3042a3334aa4c6f6514303bd9a1d74422d0b205f466469a34294a54b + flattened_ast: b9c0e491b0614b816d6162ebe034a301347aaec852501cad2001e73c26b8d7fd + inlined_ast: b9c0e491b0614b816d6162ebe034a301347aaec852501cad2001e73c26b8d7fd bytecode: fe81994a0915f712640ac94938914b1c35ed04f10bc82050aeb7bb88fa92681e diff --git a/tests/expectations/compiler/integers/u64/sub.out b/tests/expectations/compiler/integers/u64/sub.out index 3dfe51420e..31327255af 100644 --- a/tests/expectations/compiler/integers/u64/sub.out +++ b/tests/expectations/compiler/integers/u64/sub.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 03718b3dc68acc4c12697b0a96ec89f52361bd71043097d528e4970267bcc358 - unrolled_ast: 03718b3dc68acc4c12697b0a96ec89f52361bd71043097d528e4970267bcc358 - ssa_ast: c62cb75b18725362143ca8912acf74e1a574867c79b9548f1854faaefc5a29e0 - flattened_ast: 508c29808115f14e8f3b270cc3c236cb2186fb6f99fcbc89b553e3ad55d41a3d + - initial_ast: c702954e9404b94ce40669050e2ef956daa9f24dd6b9c8201969f06d6061007b + unrolled_ast: c702954e9404b94ce40669050e2ef956daa9f24dd6b9c8201969f06d6061007b + ssa_ast: 1e748f62c1ae57afd54f2f0d400b9e004927030b71751b7e250fd6b69e0358e6 + flattened_ast: 4c2110e5b9ec3b3a78691e522918ea9f5236cd11602ef780ad8363e1eacee1c8 + inlined_ast: 4c2110e5b9ec3b3a78691e522918ea9f5236cd11602ef780ad8363e1eacee1c8 bytecode: ef94f9ad01c6c378473388209a8d3c21f2071e447c5370032f52abbe3df13b0d diff --git a/tests/expectations/compiler/integers/u64/ternary.out b/tests/expectations/compiler/integers/u64/ternary.out index 95b5012c49..acc1b4bfa9 100644 --- a/tests/expectations/compiler/integers/u64/ternary.out +++ b/tests/expectations/compiler/integers/u64/ternary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e5aab6f122856f40f8d4fcaa2dd50c6543a37f6bfba56de42bfa0082ca389fa8 - unrolled_ast: e5aab6f122856f40f8d4fcaa2dd50c6543a37f6bfba56de42bfa0082ca389fa8 - ssa_ast: 4a0250cf13610d5cc2abe9f2cb84ba8e1d0c36607b072904569c9a1a451d3a81 - flattened_ast: b40c5db3cfe14b2f8b6ea1a082361c67086bb9b00a5356f9b1c2b4ea53f674be + - initial_ast: 6cf9d56ddea61750c730fe1d73bdce39c4a242e824cd87bf25ea78849f94ab65 + unrolled_ast: 6cf9d56ddea61750c730fe1d73bdce39c4a242e824cd87bf25ea78849f94ab65 + ssa_ast: 3046a4802596d57c3a3701b06be2169860135bcdff6c74196ea5b2da6fbb2e59 + flattened_ast: 1e128bc7c199d9657fda2a861dc43157e1e06273b9d2241483ad5294018b350c + inlined_ast: 1e128bc7c199d9657fda2a861dc43157e1e06273b9d2241483ad5294018b350c bytecode: cf2304e9005774e8f4d611278dc0c52a55c4430daa32c89f4a039b7502672341 diff --git a/tests/expectations/compiler/integers/u64/xor.out b/tests/expectations/compiler/integers/u64/xor.out index 2532031020..5ac4fcfba7 100644 --- a/tests/expectations/compiler/integers/u64/xor.out +++ b/tests/expectations/compiler/integers/u64/xor.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 7a97534f4bbb52508c8e37745ae18da9fc162eece84857e175af35d7ebb5c253 - unrolled_ast: 7a97534f4bbb52508c8e37745ae18da9fc162eece84857e175af35d7ebb5c253 - ssa_ast: 8e4fdb6fa80bb1580a32a6251348d35eecf264ec415db67e78806490b4d7f06f - flattened_ast: 3bf7d5edbc4f55290158d5c0428a651a5ebc0c540040e4f72766807868b25dd7 + - initial_ast: 310fd8d99011a0c06a161592a5eff8f8929d6da3271f9929c090d5595d341be9 + unrolled_ast: 310fd8d99011a0c06a161592a5eff8f8929d6da3271f9929c090d5595d341be9 + ssa_ast: 7219586aec50a82e4bcc44b2ea1dd7041daae5c907064b3a7127c18fe2356d59 + flattened_ast: 8a838aa5ef69f4fcf00c58cceddb1282db41076faf5370c8769e2ddf02591a32 + inlined_ast: 8a838aa5ef69f4fcf00c58cceddb1282db41076faf5370c8769e2ddf02591a32 bytecode: fb6acd4ab6b90eb96a5fcbcad3bd407750c44e7e8c0d75bce53a5fb7c454f54b diff --git a/tests/expectations/compiler/integers/u8/add.out b/tests/expectations/compiler/integers/u8/add.out index 84c7a779c9..c6c2f964e7 100644 --- a/tests/expectations/compiler/integers/u8/add.out +++ b/tests/expectations/compiler/integers/u8/add.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 2970b3fe96cd4e3f283f5962e096d97a5e760d3b0867a631ddec952d5fb45659 - unrolled_ast: 2970b3fe96cd4e3f283f5962e096d97a5e760d3b0867a631ddec952d5fb45659 - ssa_ast: 4d75173ee27211ef60c240ab8e979fb0b2b2c9d53225ea50cf16f60f488556f2 - flattened_ast: d5b3e01458230b724a1c99486ffa57005d4b571f6d1eecb702019ef5afa9f47a + - initial_ast: 5bacf3ac23a24523ebf517f94da81805616856d42a4c29d7f4601d05bfdb5230 + unrolled_ast: 5bacf3ac23a24523ebf517f94da81805616856d42a4c29d7f4601d05bfdb5230 + ssa_ast: 0c360692d37a897e945979abcd4466e1dcbf1a645f91445a2514c7953c42ab5c + flattened_ast: 0264a701954bcfdd88d18cb31b80359495bc7ff3ad59929875ebf39c5ca18d0d + inlined_ast: 0264a701954bcfdd88d18cb31b80359495bc7ff3ad59929875ebf39c5ca18d0d bytecode: 5d87202e1d7ba9963bb54a1ee27ce00a44317ae7a231302898e8be40fe76610d diff --git a/tests/expectations/compiler/integers/u8/and.out b/tests/expectations/compiler/integers/u8/and.out index 0f61f70dae..d3f566b7d8 100644 --- a/tests/expectations/compiler/integers/u8/and.out +++ b/tests/expectations/compiler/integers/u8/and.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ee7056d7f3be8d1dac33400be79c9316b01bfb79a516eb7cccc4d210037e44eb - unrolled_ast: ee7056d7f3be8d1dac33400be79c9316b01bfb79a516eb7cccc4d210037e44eb - ssa_ast: cc10049f1a669fb4c58451c7b9ab77424bee632eff57329faaabd777a17ca020 - flattened_ast: e7a9c15da16ad3d034018accf952dabb0cb9526e7be36ade782ab5348fad4bf0 + - initial_ast: f2acb80cf2ab6df6abcf83e5a4753e7dbb6b1fec0b323372b99b6830c52b43f0 + unrolled_ast: f2acb80cf2ab6df6abcf83e5a4753e7dbb6b1fec0b323372b99b6830c52b43f0 + ssa_ast: d00859ee377361b83c25be8592434a86d86bb432744b944e0cd377bc53e61a0c + flattened_ast: 85e26923486c803b0c57e09dd54767c6e36d2852e896744e24d6735f3ab26f71 + inlined_ast: 85e26923486c803b0c57e09dd54767c6e36d2852e896744e24d6735f3ab26f71 bytecode: a039f2ce7be6da12461e29fb69ece10e8a6ccc0345328d2203e36df9398930af diff --git a/tests/expectations/compiler/integers/u8/console_assert.out b/tests/expectations/compiler/integers/u8/console_assert.out index b9e62748cb..ba636485c7 100644 --- a/tests/expectations/compiler/integers/u8/console_assert.out +++ b/tests/expectations/compiler/integers/u8/console_assert.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: d647c93abe9151a7c6ae9fe7098e08eaf9db3bf8dda43e96d1500f3187b4d340 - unrolled_ast: d647c93abe9151a7c6ae9fe7098e08eaf9db3bf8dda43e96d1500f3187b4d340 - ssa_ast: 2bfa986237f2624c544ad9f8fdc82c6dfce06e92fadfe5e03fb27b03a30328b7 - flattened_ast: 17d9b9e60bfc8819624537799302899162396a7dffa2504f1d85741007ddc516 + - initial_ast: c2673758071f2bb74e1bcaaf14e0a50db1af889a6e8d2cd31b65f367bee43344 + unrolled_ast: c2673758071f2bb74e1bcaaf14e0a50db1af889a6e8d2cd31b65f367bee43344 + ssa_ast: 457be461ca27e85b6e69e12cc8a562d431875801db61997fea57e16896746f07 + flattened_ast: 2dc73f74412c554a439864c8cad58070161d7558ef527e6e29052143f509f8be + inlined_ast: 2dc73f74412c554a439864c8cad58070161d7558ef527e6e29052143f509f8be bytecode: a941d570e21a54677e4f738fa6b5b10eaf3c665a31f700ac998f3fa5991d3f96 diff --git a/tests/expectations/compiler/integers/u8/div.out b/tests/expectations/compiler/integers/u8/div.out index b2bea8f5fa..28e6ce4d77 100644 --- a/tests/expectations/compiler/integers/u8/div.out +++ b/tests/expectations/compiler/integers/u8/div.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e7f7957feca5f994087003de388e946ce867bbf5d7b21cd016db709f317eccab - unrolled_ast: e7f7957feca5f994087003de388e946ce867bbf5d7b21cd016db709f317eccab - ssa_ast: 0e4bdc463bac5d6846b8b58cb6e0318c8109aec0c1c1889feecbe6d47d2f5e2e - flattened_ast: 7ef42e112c1446b4761379154e862c4837a6ec36f88c863bb863c396e0715998 + - initial_ast: 5b103b8c1bef53742ee83aaafa057c45220eb80f24a80e7c5d2ea3bf1cc673d4 + unrolled_ast: 5b103b8c1bef53742ee83aaafa057c45220eb80f24a80e7c5d2ea3bf1cc673d4 + ssa_ast: bf3f28c183d6dbec24d03ffe311529adafd5646cbecd95f7f7f1519d46f87262 + flattened_ast: d8d16982d63f3066336e5de4bc97583787efee6c643ab2790a839da587ff6ad4 + inlined_ast: d8d16982d63f3066336e5de4bc97583787efee6c643ab2790a839da587ff6ad4 bytecode: cfb3e8b0339e3774c4dd6d936a8d82b20c9bf0930974cd751daf5c39b8cea38a diff --git a/tests/expectations/compiler/integers/u8/eq.out b/tests/expectations/compiler/integers/u8/eq.out index d878bf8616..9282d6b236 100644 --- a/tests/expectations/compiler/integers/u8/eq.out +++ b/tests/expectations/compiler/integers/u8/eq.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 6cb78438d021a01917083c62ac54065607180b625ad5544c08e39865af4a037a - unrolled_ast: 6cb78438d021a01917083c62ac54065607180b625ad5544c08e39865af4a037a - ssa_ast: 1ac6319c479ab6432a77988724f7c2898fe669e44f5bd84860daa6aa4e9786ae - flattened_ast: 0578c3c1cd213cb583c477a927dbfdf5aa4ee0c63dc19d9c5e22e4f8cfa66907 + - initial_ast: 550caa3b10566610ed11087c26e7b65c018f483a76dd8fc8684eed401967e77b + unrolled_ast: 550caa3b10566610ed11087c26e7b65c018f483a76dd8fc8684eed401967e77b + ssa_ast: 59564d920a2e494f95604234ccdd0f4a6bbb82cfa4366c24bbe2d2eddce7e7f7 + flattened_ast: 76c6fcfed2e4ff717d484c88088292632d0ac3260d1bc98ede85920f11d5de91 + inlined_ast: 76c6fcfed2e4ff717d484c88088292632d0ac3260d1bc98ede85920f11d5de91 bytecode: 99f56a83a13830f7dc6fc2f1a80063a3882a8756f8bc33f3134c64d1b596958f diff --git a/tests/expectations/compiler/integers/u8/ge.out b/tests/expectations/compiler/integers/u8/ge.out index de90a3be74..7a7e14ebb7 100644 --- a/tests/expectations/compiler/integers/u8/ge.out +++ b/tests/expectations/compiler/integers/u8/ge.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 032da7c07fdb71154e8d489d23b4b575e6318d65cdea9d1585fe7f6ffeeab6fa - unrolled_ast: 032da7c07fdb71154e8d489d23b4b575e6318d65cdea9d1585fe7f6ffeeab6fa - ssa_ast: f72a447b0d799e292fd8cf50ef6826370122cc4f9905f2b622921e17820b34bf - flattened_ast: 56984e49baac53c8e8edfeca8b585f258d680e85c41bf6ffa2f425a9a0c380b5 + - initial_ast: b3f377c03af077c585378d2b83dd247780db01fff46cfc5e9c845e4e4c085af1 + unrolled_ast: b3f377c03af077c585378d2b83dd247780db01fff46cfc5e9c845e4e4c085af1 + ssa_ast: 8fbac44e7f495d4a68ab95a8b38ea9b9209540612738f90edc69f8e0b36e8ba6 + flattened_ast: 5d135e76eaf58d0133dec0d40d2a4cfe727fc9e9ef1ada95300ae533e8ec640c + inlined_ast: 5d135e76eaf58d0133dec0d40d2a4cfe727fc9e9ef1ada95300ae533e8ec640c bytecode: b6c443f36f4e05d0bf1b0c714281eb0ea5502d3899762df421a382656c3f2a0d diff --git a/tests/expectations/compiler/integers/u8/gt.out b/tests/expectations/compiler/integers/u8/gt.out index 1e8684a3c0..995113cd12 100644 --- a/tests/expectations/compiler/integers/u8/gt.out +++ b/tests/expectations/compiler/integers/u8/gt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ef4db3611b84fa6b94185de591c8087f6a2d90c023f2b547064ba20215542c9e - unrolled_ast: ef4db3611b84fa6b94185de591c8087f6a2d90c023f2b547064ba20215542c9e - ssa_ast: ebe401a2075dc273ef321b5f5699dd878a09f8eca5bf8116ca937395435de499 - flattened_ast: 0df97830d3319d91193d9994a9e1db388d0fb941019ad0f41df05cd0a982ac51 + - initial_ast: cde23b8490d2dfd66f9fbf3f722fb491fccda3c86beaba473bfdabdd9fca180b + unrolled_ast: cde23b8490d2dfd66f9fbf3f722fb491fccda3c86beaba473bfdabdd9fca180b + ssa_ast: d3ac5d41aced051be5e105db478e96fd562a811087d71bcad4ebe2362d187c42 + flattened_ast: f4f8f73a564e03ab7c5cb3348c438549d3ac814df5711701feacc606d7764831 + inlined_ast: f4f8f73a564e03ab7c5cb3348c438549d3ac814df5711701feacc606d7764831 bytecode: da7592d9bb8e0e8af0e5b9d9ddd8921411c7dd0d705c9a87fdd508169d0ad1f7 diff --git a/tests/expectations/compiler/integers/u8/le.out b/tests/expectations/compiler/integers/u8/le.out index c0f85b138e..1593f09de0 100644 --- a/tests/expectations/compiler/integers/u8/le.out +++ b/tests/expectations/compiler/integers/u8/le.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: ae858a04fc6aa29ab7dc32f3bb58f3aca4e54e295b56fa2804cdafaffeed874c - unrolled_ast: ae858a04fc6aa29ab7dc32f3bb58f3aca4e54e295b56fa2804cdafaffeed874c - ssa_ast: d0b04ba0eeb5771c8e312ebc1f547dddf5c28e4d45ec5ed91a140a4810b994fa - flattened_ast: 711d289e920e6290192c9f34bbac161069daec05d1e5ea4adb39f7155ec1f969 + - initial_ast: 05399cf6b2f04b69efeebbd681d7a725db2134adac7c9364d115570012f6630b + unrolled_ast: 05399cf6b2f04b69efeebbd681d7a725db2134adac7c9364d115570012f6630b + ssa_ast: 07cdb8e6bce506bd81f393de371da545dd08824d030cec6351ff07ab8b9e0fa3 + flattened_ast: e45b2685d1bc207aa5fb052b858a1e68fd1cf578cbaa030d3f3ecfc1cf3950dd + inlined_ast: e45b2685d1bc207aa5fb052b858a1e68fd1cf578cbaa030d3f3ecfc1cf3950dd bytecode: e869ef253f8fdaefc80e84abd98141ab16355d333ddbfae3d7cca25fb7ebe10b diff --git a/tests/expectations/compiler/integers/u8/lt.out b/tests/expectations/compiler/integers/u8/lt.out index 90327f0033..2a8882ef51 100644 --- a/tests/expectations/compiler/integers/u8/lt.out +++ b/tests/expectations/compiler/integers/u8/lt.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b0d4b768371bf8222bad214a4c1d7eae1ff56c12384b164a818a7815bc5bc03c - unrolled_ast: b0d4b768371bf8222bad214a4c1d7eae1ff56c12384b164a818a7815bc5bc03c - ssa_ast: 9f5247ec070fbb1c12edb0e70330cc44e49660d3af7168fa665339ceceaa4d8a - flattened_ast: c4e8a72d64c4dc35c7d0c90b6676741dc3281e2437f839bf3852c4a305905ccb + - initial_ast: 498a31ab20522b620afd634a3c6db944c67f2152e2b014abf9e9c564ed8d1481 + unrolled_ast: 498a31ab20522b620afd634a3c6db944c67f2152e2b014abf9e9c564ed8d1481 + ssa_ast: a58a9093250c1c8c8073e6c4babfaa5ff102f1527f605a271e47a7f13a77ac8a + flattened_ast: 8e9f41da39c86b1e6e3d81056dafedb1393ba3492ce4822c76233f7b2f807343 + inlined_ast: 8e9f41da39c86b1e6e3d81056dafedb1393ba3492ce4822c76233f7b2f807343 bytecode: 8b3b1c73d15c3f5ac4854c5e9c18cbfafae589747c9de009718ec757b099c267 diff --git a/tests/expectations/compiler/integers/u8/max.out b/tests/expectations/compiler/integers/u8/max.out index ea27521283..4024b03b1a 100644 --- a/tests/expectations/compiler/integers/u8/max.out +++ b/tests/expectations/compiler/integers/u8/max.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 4446a938fbba71bc000ddedebb7a1c7b328f065af676cbf21b089c46fb04078e - unrolled_ast: 4446a938fbba71bc000ddedebb7a1c7b328f065af676cbf21b089c46fb04078e - ssa_ast: 9b366714ef01d42650100ab49e838eb1c29b1437d97b9ed1ffd2b64f6c87681e - flattened_ast: 06462f74aa74532b3cfabed4d771d4d1479745460f752b03b8bf9b0e1239857d + - initial_ast: 5ece8db64753d968d8e5c843169f82b65fb2ea0813e50e088d66e4493596077a + unrolled_ast: 5ece8db64753d968d8e5c843169f82b65fb2ea0813e50e088d66e4493596077a + ssa_ast: 5549fb3b4d6d01f52d77200694ad148b0a88e9877b448b139e0189f21134b2c9 + flattened_ast: 6020ce12a08094b66e73227b7a15d25231e124c170ab347cc02e53a9587c8c7c + inlined_ast: 6020ce12a08094b66e73227b7a15d25231e124c170ab347cc02e53a9587c8c7c bytecode: 9a1e5bb7b8d932d4afd347a856bfb38db144771f49a0d9589ef14236338e3dcf diff --git a/tests/expectations/compiler/integers/u8/min.out b/tests/expectations/compiler/integers/u8/min.out index a0df6cabec..3043643317 100644 --- a/tests/expectations/compiler/integers/u8/min.out +++ b/tests/expectations/compiler/integers/u8/min.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 63fef59187e392efa191aa06e983b4aad3942475a097295e8db8f86b9ac5b94e - unrolled_ast: 63fef59187e392efa191aa06e983b4aad3942475a097295e8db8f86b9ac5b94e - ssa_ast: 2ee0e7ebabb71733fddbe55a2bcafcabe91e47241cd8ec83c32a39e63a3c9083 - flattened_ast: 92b935e04101d60e836774b2dd25ad04d5e00463edd810ee3ae3cd25d76f2377 + - initial_ast: c663814851c225d2a4d0b27885f10476554dd64aaf1851865b7e6fb671ed01a7 + unrolled_ast: c663814851c225d2a4d0b27885f10476554dd64aaf1851865b7e6fb671ed01a7 + ssa_ast: 887739c340de0bd5a1ec0b6fc98b9e140a9367db94185b7439ca3b75384e0223 + flattened_ast: f56934f5be0b32d9b5703dbd09582c78a86682ff78192a55decfc0f2b2858723 + inlined_ast: f56934f5be0b32d9b5703dbd09582c78a86682ff78192a55decfc0f2b2858723 bytecode: 9a1e5bb7b8d932d4afd347a856bfb38db144771f49a0d9589ef14236338e3dcf diff --git a/tests/expectations/compiler/integers/u8/mul.out b/tests/expectations/compiler/integers/u8/mul.out index 9189c3ae13..1c7d7e2bc1 100644 --- a/tests/expectations/compiler/integers/u8/mul.out +++ b/tests/expectations/compiler/integers/u8/mul.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 8072e2c166461d55fe5f08c9d2acc77fb9e657ab4ec405e9b8cb715ba077df76 - unrolled_ast: 8072e2c166461d55fe5f08c9d2acc77fb9e657ab4ec405e9b8cb715ba077df76 - ssa_ast: 532a81d76848559a85bf90e1c50ce15450fd50c8101371555fc5da5ee3a1a7eb - flattened_ast: f9c435cebe2d76c2b0da0f78de679d3601621dfb9a159605d7f0bdc920c98621 + - initial_ast: af85afadf48bf782a70a44cf90b92f0fe9f418957921858df92245f5133978d0 + unrolled_ast: af85afadf48bf782a70a44cf90b92f0fe9f418957921858df92245f5133978d0 + ssa_ast: aae5a7fec8f06f526fea2186a91e0e22643a73ff85bc51f15aa9902a49ae09c9 + flattened_ast: 9920a8ab7749898ac69d54411548b0d2638e3ce6fcf7005d29bce0952aafac92 + inlined_ast: 9920a8ab7749898ac69d54411548b0d2638e3ce6fcf7005d29bce0952aafac92 bytecode: f3e8f78be42f2b1c4ffe738c22be8ed69d93030768e1493e91704069624161d1 diff --git a/tests/expectations/compiler/integers/u8/ne.out b/tests/expectations/compiler/integers/u8/ne.out index c0d9b7a2ba..834256b35b 100644 --- a/tests/expectations/compiler/integers/u8/ne.out +++ b/tests/expectations/compiler/integers/u8/ne.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b517510706e500161c638fdd381264b12627f2fbc74c7c0ba0c8efd37c880d7e - unrolled_ast: b517510706e500161c638fdd381264b12627f2fbc74c7c0ba0c8efd37c880d7e - ssa_ast: bd4ade2bd57d7d68268cfe7916ae9bc13c92a9089276da07e03a11c51fdefa63 - flattened_ast: b3a685fed1692db4daa4867b36a6ebf10d1827111b41ec4eed64df2cf91f2a41 + - initial_ast: 6b259d8abc38eef47ba61508d4491ffe92099452034c2c84e02c4999a51385e0 + unrolled_ast: 6b259d8abc38eef47ba61508d4491ffe92099452034c2c84e02c4999a51385e0 + ssa_ast: e8a2bd12468908d67f152128fb94bddb0bc7a74350ba36a1338d7ee1267507c1 + flattened_ast: 2f0b57531f69f0870f65c56f45f6079c324babfa141890773962e2b2e6a97224 + inlined_ast: 2f0b57531f69f0870f65c56f45f6079c324babfa141890773962e2b2e6a97224 bytecode: f3d5151dee5a9dc4ec37146ba94693a876f6520de94c3c6a3d8bad7ba513f5d8 diff --git a/tests/expectations/compiler/integers/u8/operator_methods.out b/tests/expectations/compiler/integers/u8/operator_methods.out index e9dbc63ccb..235a5c7699 100644 --- a/tests/expectations/compiler/integers/u8/operator_methods.out +++ b/tests/expectations/compiler/integers/u8/operator_methods.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5f62c556cb77a8e5ab3c022ac8d1e0a748e317779bc795a9fff0a7947b41c3f8 - unrolled_ast: 5f62c556cb77a8e5ab3c022ac8d1e0a748e317779bc795a9fff0a7947b41c3f8 - ssa_ast: df419fc00beabbf9493f814e01dea2da59f24e09db6227180c2329e93dc761f0 - flattened_ast: f02112665f8cf1aeb141ad54f8ef1e29496d6b050360d2b907ef57297a10b8a5 + - initial_ast: 1f718cbf12cf368295b0cd0181e429f6d95565a13a13f148aa6593622e7f0c94 + unrolled_ast: 1f718cbf12cf368295b0cd0181e429f6d95565a13a13f148aa6593622e7f0c94 + ssa_ast: 5ebc40518c5fa13c810f4a30528552720e2fde023f2685a7c71bbace0c2d06b2 + flattened_ast: fb9676ebfc259e6d7925fe4cf2b55e99e47ab6c208eeb7256c741b25eda962ad + inlined_ast: fb9676ebfc259e6d7925fe4cf2b55e99e47ab6c208eeb7256c741b25eda962ad bytecode: 87035e18e5b9c111a9e8a5b223cfe3ba5f622b32fb3357ada76e0e441423d9a8 diff --git a/tests/expectations/compiler/integers/u8/or.out b/tests/expectations/compiler/integers/u8/or.out index 6584dc78d5..7e61f8aaea 100644 --- a/tests/expectations/compiler/integers/u8/or.out +++ b/tests/expectations/compiler/integers/u8/or.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: d1cd037758f04af2a818aeb0ca0459dc68d57d5e6d24f24d0f6d0008ec965596 - unrolled_ast: d1cd037758f04af2a818aeb0ca0459dc68d57d5e6d24f24d0f6d0008ec965596 - ssa_ast: c07776965801a4a70249838a02572f812c8de95e14b735ac81355098b8de6bdf - flattened_ast: fdec7f6a1e48a8e3db6650f2b6a4abcd32b0ab9e7a2e8ea22b9b5d3b7711f2cc + - initial_ast: 003d86dd72c5dacc2cda3851a8219721a634aafda6e75859981d394d1d0685fa + unrolled_ast: 003d86dd72c5dacc2cda3851a8219721a634aafda6e75859981d394d1d0685fa + ssa_ast: 2187419697522ae22b0eae11657df9f8a714534bbede8b72b2a2e638638c1919 + flattened_ast: 0a0e5f89ba01bdc296b7dc046f86e4dabf11cc7cec22314e611f291ad6040445 + inlined_ast: 0a0e5f89ba01bdc296b7dc046f86e4dabf11cc7cec22314e611f291ad6040445 bytecode: e074a88150455ba45e3055ec3e3ab7046242f12f6b6632e0b008a96e84818654 diff --git a/tests/expectations/compiler/integers/u8/pow.out b/tests/expectations/compiler/integers/u8/pow.out index 2ebb28731b..3b6eb2902b 100644 --- a/tests/expectations/compiler/integers/u8/pow.out +++ b/tests/expectations/compiler/integers/u8/pow.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 17b04a9c481d1c8fd4932bf96a240ce930a170ab3e1da5f56691364056cc579f - unrolled_ast: 17b04a9c481d1c8fd4932bf96a240ce930a170ab3e1da5f56691364056cc579f - ssa_ast: 042205ab3f1c305eb835ccf3fab10343d7ad8f49f966b11ce4e5411e86dcb0d8 - flattened_ast: 838ba236353e74fc79dff956d975b5ef9bc22f2690577ce7b3c62c5205d09fe8 + - initial_ast: 9240ac92cf0a2bb2969182ca7fb629f585656f05a94a474538a3019b194e69de + unrolled_ast: 9240ac92cf0a2bb2969182ca7fb629f585656f05a94a474538a3019b194e69de + ssa_ast: 13be297637ee6aca3c6f33144678c76b529c81a3065622bcf19e416724daae57 + flattened_ast: ede7087588a69a34953b68b632c70219d6ee58b5834d7a825a671b7a0197d1c9 + inlined_ast: ede7087588a69a34953b68b632c70219d6ee58b5834d7a825a671b7a0197d1c9 bytecode: a48814ab5a0a2eb63c017974e4b5d5b80ee85a75baefb0f01c9d4794aa44f427 diff --git a/tests/expectations/compiler/integers/u8/rem.out b/tests/expectations/compiler/integers/u8/rem.out index 21742c48a3..0f80658c2e 100644 --- a/tests/expectations/compiler/integers/u8/rem.out +++ b/tests/expectations/compiler/integers/u8/rem.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 483f92c5f4c830b810c9dd630d07de6a88f46b46ff24fe1a6052047675829dfb - unrolled_ast: 483f92c5f4c830b810c9dd630d07de6a88f46b46ff24fe1a6052047675829dfb - ssa_ast: 398fa81614ed01ec227ed549ce3b75724436ea628525a0b4958bc7abb3820b0b - flattened_ast: 41c981394c0e4897c6f30434c73bf7064712137fe624231c367dddd6a1347225 + - initial_ast: b8a417c5c3bc5faae23a0e672dd990f400f54a0bbffb597c49d6b7b23411264a + unrolled_ast: b8a417c5c3bc5faae23a0e672dd990f400f54a0bbffb597c49d6b7b23411264a + ssa_ast: d76bad65d0cf3d4dfc6848292c830846c68c117b2036862cefc499c1af037977 + flattened_ast: 74b529c97baa8f89aed8777843c7304c7d17a28831b10e5aa2fc79c6c762b2a9 + inlined_ast: 74b529c97baa8f89aed8777843c7304c7d17a28831b10e5aa2fc79c6c762b2a9 bytecode: 2159912f354d44e770662e90da4184d94de184fa49e44a6228fb4fb9e9ce5bf3 diff --git a/tests/expectations/compiler/integers/u8/shl.out b/tests/expectations/compiler/integers/u8/shl.out index 319bff4009..aa6455eb33 100644 --- a/tests/expectations/compiler/integers/u8/shl.out +++ b/tests/expectations/compiler/integers/u8/shl.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 912cf46b787d0276f330027efb35fc6a33b7c239ff1bbdc0da5cf89f9f31ba18 - unrolled_ast: 912cf46b787d0276f330027efb35fc6a33b7c239ff1bbdc0da5cf89f9f31ba18 - ssa_ast: 0088806492e388d7b21772a1b2a6efc303b3915e020e1b4ab75f78fe1e120146 - flattened_ast: 8a7e8f7130cde94569d404553418d63baac1ca795d6d5b3c7a577fd71d56bc07 + - initial_ast: abe74c6e1afdcd52c84d96fa218703c6a21e746744e5bb3d22d6314ad29c91e7 + unrolled_ast: abe74c6e1afdcd52c84d96fa218703c6a21e746744e5bb3d22d6314ad29c91e7 + ssa_ast: ff8d1fd3c2e5f9aae910d70da1d191de38fe343d9fa8ce5dd90fedf6963e7eb0 + flattened_ast: c396310012e96d891b068ed6cf5be512d1e22bd5ae5b0289840d042f4db94dcb + inlined_ast: c396310012e96d891b068ed6cf5be512d1e22bd5ae5b0289840d042f4db94dcb bytecode: dabf4b298971b553d5d0009a749e4d4a993d58a0a5aa20453a0241716bceaaad diff --git a/tests/expectations/compiler/integers/u8/shr.out b/tests/expectations/compiler/integers/u8/shr.out index 022d068e59..8a56f913d2 100644 --- a/tests/expectations/compiler/integers/u8/shr.out +++ b/tests/expectations/compiler/integers/u8/shr.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 4fe0a149eed2b794f9bffa6605765c1aede5805deb0a8973a915b06e66bc12a5 - unrolled_ast: 4fe0a149eed2b794f9bffa6605765c1aede5805deb0a8973a915b06e66bc12a5 - ssa_ast: c94399a679381f8a66c65e6c9f4dbecedd9f9a3a9614ce17790f086fc6e1a69e - flattened_ast: c95508e016dc67e8df291effe6553a35aa361a50a366a1825440ae8dfd81c4b1 + - initial_ast: 8c9088a9a4261940cb4f2ec20318c2875d8813b0b57eb12a5b8f2af0e71f5f22 + unrolled_ast: 8c9088a9a4261940cb4f2ec20318c2875d8813b0b57eb12a5b8f2af0e71f5f22 + ssa_ast: 9c2e76526aa89d21856fe51ef086e8d22e6b7de8188f7ff6b99cce63d7553e87 + flattened_ast: 7e90bf94ce350eb5aaac9995d06cd14c5a63965f77abf01e08dbfdd036032a7f + inlined_ast: 7e90bf94ce350eb5aaac9995d06cd14c5a63965f77abf01e08dbfdd036032a7f bytecode: 5c4619b95890e250d3c57ecdcd585a9a20b1c5b4ca615b23c6ddf7fe5bd9b6c3 diff --git a/tests/expectations/compiler/integers/u8/sub.out b/tests/expectations/compiler/integers/u8/sub.out index e5715ef4cb..ea2f16bfe8 100644 --- a/tests/expectations/compiler/integers/u8/sub.out +++ b/tests/expectations/compiler/integers/u8/sub.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 43d74291b251e8fd1d37a52081d3663f3f7ba4e19ec7ad423dbf0a64ce2600e3 - unrolled_ast: 43d74291b251e8fd1d37a52081d3663f3f7ba4e19ec7ad423dbf0a64ce2600e3 - ssa_ast: 4a588a82d900135b1674869981855c9f998bd6aceea03c26d03f86bb72e71b15 - flattened_ast: 9c5854a1007cfec0d746d29e7ef0ca3373fdcc2029a5f9e9125175991aac29eb + - initial_ast: df2650ba086d2ef699d5aba01ca40ed16bc8d6179b58fa1df88399a4318a78ea + unrolled_ast: df2650ba086d2ef699d5aba01ca40ed16bc8d6179b58fa1df88399a4318a78ea + ssa_ast: 99d442386b9c5f64e9b46c309ce2739e396017e2c2dab2d06288aae49b9d948f + flattened_ast: eef19c7cd1c41f05f5dee131db1762751c774729c969768cba30249e8f27b071 + inlined_ast: eef19c7cd1c41f05f5dee131db1762751c774729c969768cba30249e8f27b071 bytecode: d0baeac7c2175f2a975d1d36d8605405062fb8dbb8513604a5ea9d3e9902c6d2 diff --git a/tests/expectations/compiler/integers/u8/ternary.out b/tests/expectations/compiler/integers/u8/ternary.out index 335522894a..3c190ba808 100644 --- a/tests/expectations/compiler/integers/u8/ternary.out +++ b/tests/expectations/compiler/integers/u8/ternary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1e23710b1f38c7c76f921a8c783a602ae941307c353ea601bd57b3f80cbe11ca - unrolled_ast: 1e23710b1f38c7c76f921a8c783a602ae941307c353ea601bd57b3f80cbe11ca - ssa_ast: 952c257443a2724236a50d8dfa7758b0b708ea45e4f6156aa33cdf85cdacd771 - flattened_ast: 121216b8da30c32cf96ddd6165c3e51a93f6531d40a14cd54442208a09842d23 + - initial_ast: a032a228dd494bd45aae57ea84ae8c437b412f0041014b30637106738fa6105b + unrolled_ast: a032a228dd494bd45aae57ea84ae8c437b412f0041014b30637106738fa6105b + ssa_ast: 80e952804bfbeca02020c6c53ad6ffcc100cc008bc1e2a436eb4fdb8c24e3bd5 + flattened_ast: f212d9074cea7541f75163a60c18bdd269b29c69c4675aef5b772e9220551282 + inlined_ast: f212d9074cea7541f75163a60c18bdd269b29c69c4675aef5b772e9220551282 bytecode: 943036760ae202cb77ff7f514a6a556c890a8f542d7e8fef482b4185d6786b66 diff --git a/tests/expectations/compiler/integers/u8/xor.out b/tests/expectations/compiler/integers/u8/xor.out index 7ce38319c2..107468e331 100644 --- a/tests/expectations/compiler/integers/u8/xor.out +++ b/tests/expectations/compiler/integers/u8/xor.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 953ffc76e6712094bb4a0d9888a04e1ce694f4ab6247f45746b0debd4e3c2b3a - unrolled_ast: 953ffc76e6712094bb4a0d9888a04e1ce694f4ab6247f45746b0debd4e3c2b3a - ssa_ast: c3ce0d6b496cba5c345a5647ebf1c3f2cd23278c980b78a90c0b7a24ed2eea91 - flattened_ast: e192e4bf87eb9fb6f10aadd3615c609af4fd1d57321b93a3e741b7d70b673290 + - initial_ast: e6ccaa14c2eb3997e4ad573ff7be949715028ac647cbe019b5e6e73599434515 + unrolled_ast: e6ccaa14c2eb3997e4ad573ff7be949715028ac647cbe019b5e6e73599434515 + ssa_ast: 42829852d13fd54c6463e3890767d8acd18981dbac4b6e3e187025b8cfdfdfed + flattened_ast: 4e12edb61d9baee40099181b51649a489a943282924fd976a7a2a2c39e470443 + inlined_ast: 4e12edb61d9baee40099181b51649a489a943282924fd976a7a2a2c39e470443 bytecode: 8b7e98a7f450a6280c0427907077db96a5194953ac878f3096c126a8d8b75f62 diff --git a/tests/expectations/compiler/records/declaration.out b/tests/expectations/compiler/records/declaration.out index d00f1601e8..f4fdcdc2f6 100644 --- a/tests/expectations/compiler/records/declaration.out +++ b/tests/expectations/compiler/records/declaration.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: bb7307edb38c7db57600f41289a531f3217986306065bd46f93d3c9f4a5f8c17 - unrolled_ast: bb7307edb38c7db57600f41289a531f3217986306065bd46f93d3c9f4a5f8c17 - ssa_ast: e6349909555c268ac418138ae06a0f39db94644406da8963fc6e9166d173ac49 - flattened_ast: 4e319787a57e5682933de2c56c28b321c4b8721a1cef840c8e23680440089a4b + - initial_ast: cfd6c3d188c189e78d8ac46b0160e71ca1ca626e64e111aa30adf8c9c4c8e402 + unrolled_ast: cfd6c3d188c189e78d8ac46b0160e71ca1ca626e64e111aa30adf8c9c4c8e402 + ssa_ast: 1b6f7468d4f5c9f1c516dcf17357e4d4758a6ce65e6f46e36ee1246dd81c04f7 + flattened_ast: 7459fc1c17dd58cb8e94205bfa5e9d7aea727670e719a9eb8e9f4ce09d104b25 + inlined_ast: 7459fc1c17dd58cb8e94205bfa5e9d7aea727670e719a9eb8e9f4ce09d104b25 bytecode: e6c7836da70dcac19600a14bc49655ff3aff5f254ca77a24b39564a3987cdb7f diff --git a/tests/expectations/compiler/records/init_expression.out b/tests/expectations/compiler/records/init_expression.out index c250e66bb6..5c56c07b60 100644 --- a/tests/expectations/compiler/records/init_expression.out +++ b/tests/expectations/compiler/records/init_expression.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: af8688e7fec694325b1df4310b5dade523d3d1f532f8eb8a3f188551b8a54a5a - unrolled_ast: af8688e7fec694325b1df4310b5dade523d3d1f532f8eb8a3f188551b8a54a5a - ssa_ast: 208d1844d8c905bb651c6c765d5fe3e4c2f92d3330976423732f37f2b221500d - flattened_ast: 00f7eb5a7313a9f278c4c087d540a7779f775f7f9f90e9cb6b6984438bfef541 + - initial_ast: 0db80a5b166ba3b28b3b4fdaca2a4dce7a8e7546241c1458035dea67db3a1822 + unrolled_ast: 0db80a5b166ba3b28b3b4fdaca2a4dce7a8e7546241c1458035dea67db3a1822 + ssa_ast: 1394f793dc345fabc539dee98b1a04fa204ba1e9c5085ecb326fff9888823924 + flattened_ast: b89a0a81efaa8172de5f8c11439070e34a4632f48c32ff8e51ec9884cf63efa3 + inlined_ast: b89a0a81efaa8172de5f8c11439070e34a4632f48c32ff8e51ec9884cf63efa3 bytecode: 1cfa6fc08a9f2902f0fef6da253abd33115459891219263928dbaa69b44be3cf diff --git a/tests/expectations/compiler/records/init_expression_shorthand.out b/tests/expectations/compiler/records/init_expression_shorthand.out index 217dbeb845..ea3c6cd54d 100644 --- a/tests/expectations/compiler/records/init_expression_shorthand.out +++ b/tests/expectations/compiler/records/init_expression_shorthand.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b47c9ef287b42ddf6c86b3c5ee1fc4114b7afdfd4b6b4c639e070af7de31a15a - unrolled_ast: b47c9ef287b42ddf6c86b3c5ee1fc4114b7afdfd4b6b4c639e070af7de31a15a - ssa_ast: f71e0aae7438d2e2c8d8943dc8f1224b61e25a0544060f38b61bf31c05b935da - flattened_ast: 5948d420fe0e1ec682f1bc1f4cfe31c844f95d3fda8a035fe70ebb2c01f3ff78 + - initial_ast: 16999e9e38bd07cf0fe8b361446117160feb1d175c65b5be9acf1a8a366d9d7f + unrolled_ast: 16999e9e38bd07cf0fe8b361446117160feb1d175c65b5be9acf1a8a366d9d7f + ssa_ast: 49a5a813bbc4c0db3c90366470c4fdfba258380874db5095ee4f813724e2ebe9 + flattened_ast: 10b6b65555c9eeb4b68cc2218ea09b54df73d573bc718ecd31bdf4db88fbd817 + inlined_ast: 10b6b65555c9eeb4b68cc2218ea09b54df73d573bc718ecd31bdf4db88fbd817 bytecode: 1cfa6fc08a9f2902f0fef6da253abd33115459891219263928dbaa69b44be3cf diff --git a/tests/expectations/compiler/records/init_expression_type_fail.out b/tests/expectations/compiler/records/init_expression_type_fail.out index 94b8f653c7..ad910a9a39 100644 --- a/tests/expectations/compiler/records/init_expression_type_fail.out +++ b/tests/expectations/compiler/records/init_expression_type_fail.out @@ -2,4 +2,4 @@ namespace: Compile expectation: Fail outputs: - - "Error [ETYC0372064]: A `function` cannot output a record.\n --> compiler-test:13:44\n |\n 13 | function mint(r0: address, r1: u64) -> Token {\n | ^^^^^\nError [ETYC0372003]: Expected type `address` but type `u64` was found\n --> compiler-test:15:20\n |\n 15 | owner: r1, // This variable should be type address.\n | ^^\nError [ETYC0372003]: Expected type `u64` but type `address` was found\n --> compiler-test:17:21\n |\n 17 | amount: r0, // This variable should be type u64.\n | ^^\nError [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:23:24\n |\n 23 | let t: Token = mint(x, c);\n | ^^^^^^^^^^\n" + - "Error [ETYC0372064]: A `function` cannot output a record.\n --> compiler-test:13:44\n |\n 13 | function mint(r0: address, r1: u64) -> Token {\n | ^^^^^\nError [ETYC0372003]: Expected type `address` but type `u64` was found\n --> compiler-test:15:20\n |\n 15 | owner: r1, // This variable should be type address.\n | ^^\nError [ETYC0372003]: Expected type `u64` but type `address` was found\n --> compiler-test:17:21\n |\n 17 | amount: r0, // This variable should be type u64.\n | ^^\nError [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:23:24\n |\n 23 | let t: Token = mint(x, c);\n | ^^^^^^^^^^\n" diff --git a/tests/expectations/compiler/records/init_expression_var_fail.out b/tests/expectations/compiler/records/init_expression_var_fail.out index 8a742132d8..df65c10f76 100644 --- a/tests/expectations/compiler/records/init_expression_var_fail.out +++ b/tests/expectations/compiler/records/init_expression_var_fail.out @@ -2,4 +2,4 @@ namespace: Compile expectation: Fail outputs: - - "Error [ETYC0372064]: A `function` cannot output a record.\n --> compiler-test:13:44\n |\n 13 | function mint(r0: address, r1: u64) -> Token {\n | ^^^^^\nError [ETYC0372013]: Struct initialization expression for `Token` is missing member `owner`.\n --> compiler-test:14:16\n |\n 14 | return Token {\n 15 | sender: r0, // This variable should be named `owner`.\n 16 | gates: 0u64,\n 17 | amount: r1,\n 18 | };\n | ^^^^^^\nError [ETYC0372047]: Cannot call another function from a standard function.\n --> compiler-test:23:24\n |\n 23 | let t: Token = mint(x, c);\n | ^^^^^^^^^^\n" + - "Error [ETYC0372064]: A `function` cannot output a record.\n --> compiler-test:13:44\n |\n 13 | function mint(r0: address, r1: u64) -> Token {\n | ^^^^^\nError [ETYC0372013]: Struct initialization expression for `Token` is missing member `owner`.\n --> compiler-test:14:16\n |\n 14 | return Token {\n 15 | sender: r0, // This variable should be named `owner`.\n 16 | gates: 0u64,\n 17 | amount: r1,\n 18 | };\n | ^^^^^^\nError [ETYC0372047]: Only `inline` can be called from a `function` or `inline`.\n --> compiler-test:23:24\n |\n 23 | let t: Token = mint(x, c);\n | ^^^^^^^^^^\n" diff --git a/tests/expectations/compiler/records/nested_record.out b/tests/expectations/compiler/records/nested_record.out index fb6478c850..5b67e97279 100644 --- a/tests/expectations/compiler/records/nested_record.out +++ b/tests/expectations/compiler/records/nested_record.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 3293c9012d90ddb83b5c9a0d38bc54ef1427271fbfbd657ef32b50467b098159 - unrolled_ast: 3293c9012d90ddb83b5c9a0d38bc54ef1427271fbfbd657ef32b50467b098159 - ssa_ast: b97087356212f6fd7f3cb9a2fa28528d8f43958cac268790116a446bb7d40b3f - flattened_ast: 6555a6b47a3842f6edd2deecf4eeb4b69f39dd439b3a22e8e14f8386dbd15c82 + - initial_ast: 4e4896ad3bc1dba9d358f5bd1d0eba339cefce9cdf61288e17b6825b64a19fc0 + unrolled_ast: 4e4896ad3bc1dba9d358f5bd1d0eba339cefce9cdf61288e17b6825b64a19fc0 + ssa_ast: 7e301a4d63bf9a1c708a7c2e080ca9da7ac83c7f91149a338ce400e15d79403c + flattened_ast: 1774826b8df005b3456d8980136852fdc4123221976e25fac43d348413274bb2 + inlined_ast: 1774826b8df005b3456d8980136852fdc4123221976e25fac43d348413274bb2 bytecode: 6c9eb1193b8d4f71dd8b701ae0f297d12212933b670ab59c89f0a20ab982f08a diff --git a/tests/expectations/compiler/records/record_declaration_out_of_order.out b/tests/expectations/compiler/records/record_declaration_out_of_order.out index 859a9e3fe9..34f0aec18a 100644 --- a/tests/expectations/compiler/records/record_declaration_out_of_order.out +++ b/tests/expectations/compiler/records/record_declaration_out_of_order.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: cac9f749af7eb2ac5acefa19d653705e28085406b4bd89c9c047fdca98b7681e - unrolled_ast: cac9f749af7eb2ac5acefa19d653705e28085406b4bd89c9c047fdca98b7681e - ssa_ast: b60f4c39976269cff9b12e5e477945ab79b37be03e5313fb9b6f47102b46b4eb - flattened_ast: 4f99c8fb8e7f17667f1093f79b20d28597cc5df24d81408e4177ff49674da46b + - initial_ast: 73f31314f7616936ceaee9860262cd16628ead8bf7ddc261379ae7911e03e23e + unrolled_ast: 73f31314f7616936ceaee9860262cd16628ead8bf7ddc261379ae7911e03e23e + ssa_ast: 6a542d5d9fab2a4bbc6ec3a3e5f81c1fdf1fe696947386752a627250db9ea159 + flattened_ast: 48bc3f7e1d967c33d0ceb5f4d2d071fd0fb09db8ed04913facf6a16c6975af28 + inlined_ast: 48bc3f7e1d967c33d0ceb5f4d2d071fd0fb09db8ed04913facf6a16c6975af28 bytecode: e6c7836da70dcac19600a14bc49655ff3aff5f254ca77a24b39564a3987cdb7f diff --git a/tests/expectations/compiler/records/record_init_out_of_order.out b/tests/expectations/compiler/records/record_init_out_of_order.out index 8cb18944a8..76f2f1c19d 100644 --- a/tests/expectations/compiler/records/record_init_out_of_order.out +++ b/tests/expectations/compiler/records/record_init_out_of_order.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 42c56652c3fb3a31a6f85489f5022a32403b0545a554bf38e302c582d1524fcd - unrolled_ast: 42c56652c3fb3a31a6f85489f5022a32403b0545a554bf38e302c582d1524fcd - ssa_ast: 084ca3351316cb42f9f27f2fbe4ba1b812b2691c2f8ae2d38b034df6e6f53d4e - flattened_ast: f7483a9a8dde1baf59ca88ae6dab649ddfdb761de61bd48d06ccaf4eb99fc6d2 + - initial_ast: a330dc6e12e8ea179686ec4ffd59b207247eae12d335790e446681705d80f105 + unrolled_ast: a330dc6e12e8ea179686ec4ffd59b207247eae12d335790e446681705d80f105 + ssa_ast: 1ef8cc1fcc044b5b3b4daf6b80bcf21a795ac02dc50d1f6e1b36e8780d8c0e34 + flattened_ast: fcf72e21d754747d727fc7edbdd8ee8cb1c6db1bc9b22985bc0173d2ffa3fc5c + inlined_ast: fcf72e21d754747d727fc7edbdd8ee8cb1c6db1bc9b22985bc0173d2ffa3fc5c bytecode: 29844f1ea8a798be999d7a958052e759df9664aa3efb0d17a92534caa532ce89 diff --git a/tests/expectations/compiler/scalar/add.out b/tests/expectations/compiler/scalar/add.out index 3f0b1035b9..e83e64be17 100644 --- a/tests/expectations/compiler/scalar/add.out +++ b/tests/expectations/compiler/scalar/add.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 42c912b1e1a53d4b0f6145e2152d46a6f4fcc7e565216eb1ce4b679e7863bbc1 - unrolled_ast: 42c912b1e1a53d4b0f6145e2152d46a6f4fcc7e565216eb1ce4b679e7863bbc1 - ssa_ast: 583e5ebee461167aaaa9e73ed11ef73dc361ad6018f756104fafb2e32e68b81f - flattened_ast: 43093dd80c23decb821f9de2c13da251ecd9156e19bc7294e9b6fdc656072eba + - initial_ast: 1cfbf4c61141ec0b5130effd58114aaabe8aba3b1bc08710f1401a32d1f7663d + unrolled_ast: 1cfbf4c61141ec0b5130effd58114aaabe8aba3b1bc08710f1401a32d1f7663d + ssa_ast: 5bd8cd0fa84cf78575401a1a49bcd89c561c39fd418b009679ebbd177a22da22 + flattened_ast: 66c385a68f2d8920acae616ef4eea69562589dcd25e2afb46223209ed7c637ac + inlined_ast: 66c385a68f2d8920acae616ef4eea69562589dcd25e2afb46223209ed7c637ac bytecode: 90d57d70bb80ee3a60cbf18b20fe23889d36521d4d7e0fc2d478846deb16f1e2 diff --git a/tests/expectations/compiler/scalar/cmp.out b/tests/expectations/compiler/scalar/cmp.out index 79052a18fd..d26e74cfa6 100644 --- a/tests/expectations/compiler/scalar/cmp.out +++ b/tests/expectations/compiler/scalar/cmp.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: affad337b16ff74015a871fb06337b11eec266c345dcfe7fb5fabbfff4cf604b - unrolled_ast: affad337b16ff74015a871fb06337b11eec266c345dcfe7fb5fabbfff4cf604b - ssa_ast: 55fb96f90253035efa8edec804296d6e29c7bb07bb02e29613966c242fe42713 - flattened_ast: b973a5930d4db5669abd8cc97047ea03a55c1ae79d8d252944b8cb9700dc7886 + - initial_ast: fc642c52770495107e5c2dd10dc283b0a38006c192165b543c7d4d9f6f7945b4 + unrolled_ast: fc642c52770495107e5c2dd10dc283b0a38006c192165b543c7d4d9f6f7945b4 + ssa_ast: ea9a3015ee16aa3d249a5c7cc5275cf45e8971bae6cc36d9f925704c70cdacae + flattened_ast: 20fcf84c0609382e9f3b7732385f891dfbdd645ebfa77b8c96df43d9259756e6 + inlined_ast: 20fcf84c0609382e9f3b7732385f891dfbdd645ebfa77b8c96df43d9259756e6 bytecode: 11169bc0814efae73bb117306b656bcd8b9142527ec4d4350fc7bc6ca73f7ecb diff --git a/tests/expectations/compiler/scalar/eq.out b/tests/expectations/compiler/scalar/eq.out index 48c3cf3056..1ae822c98c 100644 --- a/tests/expectations/compiler/scalar/eq.out +++ b/tests/expectations/compiler/scalar/eq.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 082bc2628c9800118835b00f7eecfa019dd0695bb98f2147b1748cee5ae99cc5 - unrolled_ast: 082bc2628c9800118835b00f7eecfa019dd0695bb98f2147b1748cee5ae99cc5 - ssa_ast: 058605098b04af88ef27c35e695229030fc4db49dc16b549dc6caaeef4c98a5d - flattened_ast: dbb847038ac96d3d58f1e56a1a6e9b5f728286e0e822823969d6b8c52b5ce00b + - initial_ast: 3b983b36536a299812563e4fec41806281a2d421a3e5cc28b783380eb5bd8876 + unrolled_ast: 3b983b36536a299812563e4fec41806281a2d421a3e5cc28b783380eb5bd8876 + ssa_ast: 453ec10c1cb464ab72b290c22294dbd66c025b52c00329db62df4848eaf7796e + flattened_ast: 29e10bdcfb654d912859e17adb3a177d7338a31f9fbaa805f38189e477573723 + inlined_ast: 29e10bdcfb654d912859e17adb3a177d7338a31f9fbaa805f38189e477573723 bytecode: 8ee10dd27a2cce44dfbc5fad350e90aecd3bca09a0138b7b877f69e914615b88 diff --git a/tests/expectations/compiler/scalar/operator_methods.out b/tests/expectations/compiler/scalar/operator_methods.out index 8dd3a036f7..895a91c6dc 100644 --- a/tests/expectations/compiler/scalar/operator_methods.out +++ b/tests/expectations/compiler/scalar/operator_methods.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: f95a48e7733e338d62e3da6a34f277bb8ded025b7c6f0157b515183d29faf785 - unrolled_ast: f95a48e7733e338d62e3da6a34f277bb8ded025b7c6f0157b515183d29faf785 - ssa_ast: 35cc858274c7ec2a6d14d93fa158fb85cca0ac824e501b5bfda06a7171604908 - flattened_ast: f3c3a4c3a8e3b55c40b04ce7b89aad18974f02f94840e6db4c876c377cf1cfdd + - initial_ast: 1db046563517e701f758da93f440f92bfbaa10f365c087bdaca1cd90d3e120fd + unrolled_ast: 1db046563517e701f758da93f440f92bfbaa10f365c087bdaca1cd90d3e120fd + ssa_ast: 19ab9c23e39040b2261fab680c480e06a0ba3c169b4240e19ca859da4c492954 + flattened_ast: 9ee0deed6354215705d9cfbf9988f1ff5f690b3975ff7507e71b087ca721ba45 + inlined_ast: 9ee0deed6354215705d9cfbf9988f1ff5f690b3975ff7507e71b087ca721ba45 bytecode: 862939980a9659205eb6679bd91bf6eb401de987960788e65fd7e88948ad4b08 diff --git a/tests/expectations/compiler/scalar/scalar.out b/tests/expectations/compiler/scalar/scalar.out index 14964e4b27..386711b595 100644 --- a/tests/expectations/compiler/scalar/scalar.out +++ b/tests/expectations/compiler/scalar/scalar.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 7026ac1246d209b3065fb57c37974d0d4671a0b980c934265517f665019a2f51 - unrolled_ast: 7026ac1246d209b3065fb57c37974d0d4671a0b980c934265517f665019a2f51 - ssa_ast: 6accf439b526bb637642b6ee39536b1d1be064f056f0b3f2f25485142ea110e9 - flattened_ast: 409b2fbe931e982f5d502a63b9b6ef075ea5fe2bf6f191f701a09685285bda3a + - initial_ast: d1de43a19b0ec8aabace25a085611bf2c31b10ccf75b0c3253ca5c11e43c4e78 + unrolled_ast: d1de43a19b0ec8aabace25a085611bf2c31b10ccf75b0c3253ca5c11e43c4e78 + ssa_ast: 2d9df28f6df864b9ccfe5444a4228361aaee01519fc3b10939d2eae616f1bd0e + flattened_ast: 0308555a82c0401b4c3056d8c34d42b0551b0240794c8990cb5e2b50abda9241 + inlined_ast: 0308555a82c0401b4c3056d8c34d42b0551b0240794c8990cb5e2b50abda9241 bytecode: 59d4999dee3d39ffa16d0f41c6be0ef11d294b63ab99f9950b7213badcd4a2f5 diff --git a/tests/expectations/compiler/scalar/ternary.out b/tests/expectations/compiler/scalar/ternary.out index 6d5db239ac..506b819a1f 100644 --- a/tests/expectations/compiler/scalar/ternary.out +++ b/tests/expectations/compiler/scalar/ternary.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b44306c55e789ea23acd47511e2ac803a646f6738fb0c8f29f363185239e2631 - unrolled_ast: b44306c55e789ea23acd47511e2ac803a646f6738fb0c8f29f363185239e2631 - ssa_ast: 0c6149daeefd5e16fa1e5e61d8ec8682e32435633534a41f232c24c65cdb143e - flattened_ast: c491a52835e5562d7104ddd67b74407ea1b5085168f229b0755455fd1dc2c6c1 + - initial_ast: ed68b645ecc50fd6f81109b5b3b5d12182520e800bb8c970e41c6e15db87c516 + unrolled_ast: ed68b645ecc50fd6f81109b5b3b5d12182520e800bb8c970e41c6e15db87c516 + ssa_ast: ff877cc70cf128cc14879497f9309d1f6807609f9395bb651a6373e58d69f891 + flattened_ast: 63a4c22fdfb921e2a65cc597d72586ea554a579c4729ba9982546e6273aa0760 + inlined_ast: 63a4c22fdfb921e2a65cc597d72586ea554a579c4729ba9982546e6273aa0760 bytecode: b43493bafe4f9d08e8dc30a46f254b482eded7ba195ee4b06a546bd844cfe44c diff --git a/tests/expectations/compiler/statements/assign.out b/tests/expectations/compiler/statements/assign.out index 3a47b069c9..8ba174565f 100644 --- a/tests/expectations/compiler/statements/assign.out +++ b/tests/expectations/compiler/statements/assign.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 8c40e0f2c19aa0677f43f6a65b9b28aada4e103a8903007dd751919a847953a1 - unrolled_ast: 8c40e0f2c19aa0677f43f6a65b9b28aada4e103a8903007dd751919a847953a1 - ssa_ast: ec457fd8beec2ad9f7a3dcec8d047554c12ae7d6b069f0dd1c8eb309ea117ed0 - flattened_ast: 30da8009cc4d9139aace5a9fbec44179ce7a56a80380c21c8ba5c6e3801da9fe + - initial_ast: 73306dda9c8185ea39ed6d3cd1cb36f687d644fbf7cc72a12f54f8e6612226a4 + unrolled_ast: 73306dda9c8185ea39ed6d3cd1cb36f687d644fbf7cc72a12f54f8e6612226a4 + ssa_ast: 396b5ec2b04ec5a616cd77e77ec87ed85408e9049cab4cbec2f857a9b8d4618d + flattened_ast: b48b0e8010449366b79a8461c2dd18692def73afffc836c6271d3535af0f27d3 + inlined_ast: b48b0e8010449366b79a8461c2dd18692def73afffc836c6271d3535af0f27d3 bytecode: 2ea7539936b0c489d167990b0abe8ba6b864ef981a8d77e97be46df11d7f78f5 diff --git a/tests/expectations/compiler/statements/block.out b/tests/expectations/compiler/statements/block.out index b788098b5d..678e87dcf5 100644 --- a/tests/expectations/compiler/statements/block.out +++ b/tests/expectations/compiler/statements/block.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 33a43127eeeb0289799ef900b49b7a149da36cfaefee6e1ca49a73c354b79a4c - unrolled_ast: 33a43127eeeb0289799ef900b49b7a149da36cfaefee6e1ca49a73c354b79a4c - ssa_ast: 977226b4afcbe88f8ecad10ab991e1d3caa3f23b4a77e762ad2d14f57495364d - flattened_ast: 10fb7b3067dfffc93252849fd34dc155bba530a5be420388a3e3e99fc4f8675b + - initial_ast: f2049c3c5193550c9578ba06f3e8fb908242d86cef4f538b7d2403d6081e8eaa + unrolled_ast: f2049c3c5193550c9578ba06f3e8fb908242d86cef4f538b7d2403d6081e8eaa + ssa_ast: 487a535f5a8eabaed9219a6463b9f57241aa631d7cdac1f4eb3445b7edf740b1 + flattened_ast: db9d77759f6d3baabb009380e64aee2ccf47428e1a0093f48a23d31473366548 + inlined_ast: db9d77759f6d3baabb009380e64aee2ccf47428e1a0093f48a23d31473366548 bytecode: ce399e998b6e09f8bc8733bfa797b1fcd0680de149fa4a3e21d0be4be7987f4b diff --git a/tests/expectations/compiler/statements/chain.out b/tests/expectations/compiler/statements/chain.out index 5a17374c61..12b7a4905d 100644 --- a/tests/expectations/compiler/statements/chain.out +++ b/tests/expectations/compiler/statements/chain.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5e92f6e0387ee4ced587a7074847327de62f8e40294c40d6fd502f933cf687f1 - unrolled_ast: 5e92f6e0387ee4ced587a7074847327de62f8e40294c40d6fd502f933cf687f1 - ssa_ast: 317614734ff9e301b2d006c01bf5526b12e58843e0f5b460ba673886dd2e9162 - flattened_ast: e4dbc7abe2e4587260b7bff79508c7eb1d1fb32d4530790d45e7fa741cf0a680 + - initial_ast: fbcd232837a4d65205e0b4c78f693c65f34c1f5e8e997bc237d24f67aa86c637 + unrolled_ast: fbcd232837a4d65205e0b4c78f693c65f34c1f5e8e997bc237d24f67aa86c637 + ssa_ast: b364518cd8e798730dc7212e50ed4e7c3dba6a95bb2f9c02f75b0beecee25129 + flattened_ast: 416e3b4f88d5a2d9356296356d07c44e4a0083f47a3dc429bb81c9ae9d2c27d8 + inlined_ast: 416e3b4f88d5a2d9356296356d07c44e4a0083f47a3dc429bb81c9ae9d2c27d8 bytecode: b26e7efafe9624ccaa5ebe73afb04f718bffd1dd4094724a1a040dffd96ee6e8 diff --git a/tests/expectations/compiler/statements/expr_statement.out b/tests/expectations/compiler/statements/expr_statement.out index 5e949be242..520a3ba22e 100644 --- a/tests/expectations/compiler/statements/expr_statement.out +++ b/tests/expectations/compiler/statements/expr_statement.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b39a9a9105dcb2de0fe915866f0e401cd3dfd5a96930bfe29950edf323ce5614 - unrolled_ast: b39a9a9105dcb2de0fe915866f0e401cd3dfd5a96930bfe29950edf323ce5614 - ssa_ast: 893057d66fa89c650a16d1bbe85438ce69904f583dc06c3b007e6adce2e6d910 - flattened_ast: 6edbf099085b9dbbfad5411c0e50c60b2a61cd6314a7bf220f5ff5993e6f56e9 + - initial_ast: 91ab2532658863188be28710a7d3a772e9e240408352e424fc430149d7a85a3f + unrolled_ast: 91ab2532658863188be28710a7d3a772e9e240408352e424fc430149d7a85a3f + ssa_ast: 6aac0bfb6e7d744e1e52a3614439d51625f87bf57141b55498173f644b5b315e + flattened_ast: 38b34a5c44c130267c42f641f5d37fcf695573f06b128f01dd3070c6552046df + inlined_ast: 38b34a5c44c130267c42f641f5d37fcf695573f06b128f01dd3070c6552046df bytecode: b55cf7fc6a466a6a3c045ce7c5a62416ff39e9f195f7afc5cebce98a9149031c diff --git a/tests/expectations/compiler/statements/iteration_basic.out b/tests/expectations/compiler/statements/iteration_basic.out index 3e44334998..38545946c1 100644 --- a/tests/expectations/compiler/statements/iteration_basic.out +++ b/tests/expectations/compiler/statements/iteration_basic.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 32fb7ed3299adcd65281f9f043031c0ad963139e4bc57a9b01f5a1d5ff67143f - unrolled_ast: 1155ed8bd23fb6e9f03560a14b61fa999716c73f596228a50b86073afeca3e7d - ssa_ast: 4a88ae03ae334e122ae52f9d598b7db29d0515a16749fcccf3b8a56b3e381016 - flattened_ast: 1303e9f0e24514c3f8c5d82276c06fdea1f4adb6a36e5491d3e009238d0d3701 + - initial_ast: e39d5a2d5baf725c211971a7172531a82a5428c6ee68904f2e53ea872eb41e96 + unrolled_ast: dcc96d1a32ce402ffe8136245c89a6cc087c101e650ad2e5c9d5afb13022cca0 + ssa_ast: e25906e5105564137bd9ae892c5bcfaa74283905af0ae26bcd288aad15abfb1e + flattened_ast: d2cadd421c1f9dd196e37638cfb78a2230164a4a32e923e5e3a87cde4b73dcab + inlined_ast: d2cadd421c1f9dd196e37638cfb78a2230164a4a32e923e5e3a87cde4b73dcab bytecode: d81714c646dc5825b148fba33931cabbb7a60c0e48cd8d7154f0906092f7849a diff --git a/tests/expectations/compiler/statements/iteration_nested.out b/tests/expectations/compiler/statements/iteration_nested.out index cd95106e3f..8c3d3ed828 100644 --- a/tests/expectations/compiler/statements/iteration_nested.out +++ b/tests/expectations/compiler/statements/iteration_nested.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: b747abe5293374462645ba4b68ae3c0b4ca5afc783086768e315f7be3d233823 - unrolled_ast: fcb0bb8e86e103e8583944ece2eb84ba869bc8d675087d7864592aadd8ac11b7 - ssa_ast: 0c4bea83791c1d37ac267098bc1c536966850fb02abc66b9f57980245da69058 - flattened_ast: 64a9e978257b9de7fe2c4f321327cf0bffd0fb0c74b6a3e42c7e4507bc17e02a + - initial_ast: 98bd584397eb367fd78528d76ab8d814626adb2108028726b2c2905fa1d9698f + unrolled_ast: 52b3461d444d042062b6a62f2ddd48d5c5ee5c57b4a1036f1881027e471037f8 + ssa_ast: f45378ffec8e1493464c7f8986e29bf8bdd2606a365205373cb38b8d0c64fdae + flattened_ast: a16e17188c10a8fd3ad2f430327afa4b110412a78877d28f837cb85e7f046abd + inlined_ast: a16e17188c10a8fd3ad2f430327afa4b110412a78877d28f837cb85e7f046abd bytecode: a3b17d7db0a6f5298cf87c19baf24046e97725bf1f92177d7251bd85014b18a1 diff --git a/tests/expectations/compiler/statements/multiple_returns.out b/tests/expectations/compiler/statements/multiple_returns.out index d35594155c..ea110b7870 100644 --- a/tests/expectations/compiler/statements/multiple_returns.out +++ b/tests/expectations/compiler/statements/multiple_returns.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: a040a0e1c56324458b3cc0364e31b9207a39894f02404e758f87bb14be139115 - unrolled_ast: a040a0e1c56324458b3cc0364e31b9207a39894f02404e758f87bb14be139115 - ssa_ast: f5b45c95e7a8624bbcc0e0b88c56f54175d23d8bab0eeea53477653aa19af80f - flattened_ast: 0fdfe3661d295a7540f2cbdf15ef52c169bbdd177f85dc763b595664144f2ea5 + - initial_ast: 0d35d54b5fdd8de11f8d93f0eb285b765ccff47e37e4d03a840ec4f040829eb7 + unrolled_ast: 0d35d54b5fdd8de11f8d93f0eb285b765ccff47e37e4d03a840ec4f040829eb7 + ssa_ast: 0adeb2b905205041482fe24d7ae318dbe28cee031399aa085edf88b5449788d8 + flattened_ast: 0821cabc6ecf6cb4aa8b4ae63e7e8dafa0bd151dfa4e7a3a3eb9a1c590554dd8 + inlined_ast: 0821cabc6ecf6cb4aa8b4ae63e7e8dafa0bd151dfa4e7a3a3eb9a1c590554dd8 bytecode: c723974f88ddcec03425c959564231cbc891a32389e9ed5ccb04f582fce98ced diff --git a/tests/expectations/compiler/statements/mutate.out b/tests/expectations/compiler/statements/mutate.out index b34b36b8ad..c351279b1e 100644 --- a/tests/expectations/compiler/statements/mutate.out +++ b/tests/expectations/compiler/statements/mutate.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 45430f4f6209bd6df299fb2662238b88b6241c350918a968d4955e964e4f010f - unrolled_ast: 45430f4f6209bd6df299fb2662238b88b6241c350918a968d4955e964e4f010f - ssa_ast: 614d1648cefe4214b03ad4eb49d2f63094d344622d808de84d5844e93851738b - flattened_ast: 4f7c702dd8166072aa9221ba7e85657de73a2771b0b736e4739f2bf57ddcae6f + - initial_ast: 54167d71dcc69af84eafed38c7944c4c53061ebc54947f1782b57d3d128af8b1 + unrolled_ast: 54167d71dcc69af84eafed38c7944c4c53061ebc54947f1782b57d3d128af8b1 + ssa_ast: f72f10adda09e7528112f83455e59b855f4801c1714dab3018eb34ecb59adf18 + flattened_ast: e3637632648521485ca79666a402fb86ca8e652c34cf7cd2cdc2093ba6ef2daf + inlined_ast: e3637632648521485ca79666a402fb86ca8e652c34cf7cd2cdc2093ba6ef2daf bytecode: cc5b20b180a055db2277f296cff25f9c0fdfbf4ae278d88425bdd7481ba12592 diff --git a/tests/expectations/compiler/statements/operations/add_assign.out b/tests/expectations/compiler/statements/operations/add_assign.out index df88376985..cc66fde611 100644 --- a/tests/expectations/compiler/statements/operations/add_assign.out +++ b/tests/expectations/compiler/statements/operations/add_assign.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e21d8c9c70057f40b76649098332f2d6a3e2ebfc84e857baa5f34f866fffdc7d - unrolled_ast: e21d8c9c70057f40b76649098332f2d6a3e2ebfc84e857baa5f34f866fffdc7d - ssa_ast: a224b2a506a6703696e4258ef243ac98d8bc2c9062118c9e2f32186d68e64ae3 - flattened_ast: 5313dfe1df585dd91cd490b0805162dadbd4ee3bcea00fccf3d08fa082158190 + - initial_ast: ef0196ae468b3e4a5f52581ece18c8f06f9c8d788b38430ed5e72f5f3e871838 + unrolled_ast: ef0196ae468b3e4a5f52581ece18c8f06f9c8d788b38430ed5e72f5f3e871838 + ssa_ast: 406f3fe8c927d05a81920cd582960192c4d928ff1497475076840b5e8064f402 + flattened_ast: 24f08a0cf3f2bbe162529bc4098f03afd7f23d04870657e6df83c89573afc06a + inlined_ast: 24f08a0cf3f2bbe162529bc4098f03afd7f23d04870657e6df83c89573afc06a bytecode: 205bb73339d403ed74a8caee04e44c4092e998410ac23fe675e57c2dc28b52ea diff --git a/tests/expectations/compiler/statements/operations/and_assign.out b/tests/expectations/compiler/statements/operations/and_assign.out index 1267947611..a36a7cfb05 100644 --- a/tests/expectations/compiler/statements/operations/and_assign.out +++ b/tests/expectations/compiler/statements/operations/and_assign.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 7b97542baa30b955c3353a4e89d1ac7a10084cb9da768be6a8a77c201c296de3 - unrolled_ast: 7b97542baa30b955c3353a4e89d1ac7a10084cb9da768be6a8a77c201c296de3 - ssa_ast: 2a593d0b1a2e6868fa7fe69f420f20206a762b63a80278be4e15ff52bd65c370 - flattened_ast: a18881cb52deb0808f66f396277442b103d9bc0f51c9e45ef6c6761d0364d8cd + - initial_ast: 347cb3c52da22d271ea6960b303016f697b6d91362abc827d91255519bf562a6 + unrolled_ast: 347cb3c52da22d271ea6960b303016f697b6d91362abc827d91255519bf562a6 + ssa_ast: 14107612d87ea4fddbf03cd776ff65ed091e272664a3b87e7152a1095c44a599 + flattened_ast: 2385f395ff5bef8b7cfe44d82d4c63cd18d36f5443a9d9304ddf7053a7a57c0d + inlined_ast: 2385f395ff5bef8b7cfe44d82d4c63cd18d36f5443a9d9304ddf7053a7a57c0d bytecode: 81396ad998cb48a02cd66339e769582c2dc445fa2f78d64ac28b78dd00be64c4 diff --git a/tests/expectations/compiler/statements/operations/bitand_assign.out b/tests/expectations/compiler/statements/operations/bitand_assign.out index a97d1a5a4c..09f0e048bb 100644 --- a/tests/expectations/compiler/statements/operations/bitand_assign.out +++ b/tests/expectations/compiler/statements/operations/bitand_assign.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 74b73aef65800f40d96322c48e472a18b475f9e8b44e3c2e11c5e0884d0ce686 - unrolled_ast: 74b73aef65800f40d96322c48e472a18b475f9e8b44e3c2e11c5e0884d0ce686 - ssa_ast: b0da38f6ef49751da5fec33861be6cda192209f61a58e6a93f134ae9e4872284 - flattened_ast: 32276913ad6b0ff7042c98ef8f9ce1790b496e431060e74caca8f6595c95d4b2 + - initial_ast: e90b7f4fe0b8dc3c4ee753ad9772e8b13ea1c01bc9cfdd74f217a33b41dc7440 + unrolled_ast: e90b7f4fe0b8dc3c4ee753ad9772e8b13ea1c01bc9cfdd74f217a33b41dc7440 + ssa_ast: ea4f3838276a1a5bbac90ff2229db823e47c4484bf159a27088f249e95095e7a + flattened_ast: 05708b8d3ba54ec6f0371a756c31628b14775b01fa24ca48b52f38f2328254a7 + inlined_ast: 05708b8d3ba54ec6f0371a756c31628b14775b01fa24ca48b52f38f2328254a7 bytecode: 351e6362887a12504057143cc97596fbbd42153d0a64f338eb57641e84343159 diff --git a/tests/expectations/compiler/statements/operations/bitor_assign.out b/tests/expectations/compiler/statements/operations/bitor_assign.out index d65573f6cf..3e503288ec 100644 --- a/tests/expectations/compiler/statements/operations/bitor_assign.out +++ b/tests/expectations/compiler/statements/operations/bitor_assign.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: fdc160b1f29bb028aa2a5bb9ceef5c009660daa22b4680f99fdf884c87ae322f - unrolled_ast: fdc160b1f29bb028aa2a5bb9ceef5c009660daa22b4680f99fdf884c87ae322f - ssa_ast: 2bc88b253975dd1846fd5130fb60c172e9ca9af2d7811b66d0fb97dd4ebdc1d5 - flattened_ast: c5d1369849dd794d8159a9556886a28c9baf8abbd7c68bfb2ead9c170d348d9f + - initial_ast: fa779000b25964ee8afb1a3b50724147f0c15b4809fedd8b2b8b4d55938b0fad + unrolled_ast: fa779000b25964ee8afb1a3b50724147f0c15b4809fedd8b2b8b4d55938b0fad + ssa_ast: 285f58025d4e93204038f87122d18618519ac02791b344e087be0beb536679b4 + flattened_ast: 8e8de20ac44abc4c720772a57e9fee418fc4ab09118bc098790c078d9d6238c7 + inlined_ast: 8e8de20ac44abc4c720772a57e9fee418fc4ab09118bc098790c078d9d6238c7 bytecode: 447d6082c0ca8f0c7c26a97e452e262649883e98cf4875b5c593da83c787901e diff --git a/tests/expectations/compiler/statements/operations/bitxor_assign.out b/tests/expectations/compiler/statements/operations/bitxor_assign.out index 90e2a081ea..774cf2712d 100644 --- a/tests/expectations/compiler/statements/operations/bitxor_assign.out +++ b/tests/expectations/compiler/statements/operations/bitxor_assign.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 9c1d94db65ec2e55bb6bd01e59f6a5da5edeba71bcd3ffcdbc1f1b6bedd31a79 - unrolled_ast: 9c1d94db65ec2e55bb6bd01e59f6a5da5edeba71bcd3ffcdbc1f1b6bedd31a79 - ssa_ast: f9eaffc47f22a1e4ebe13dae7dc3f95debe4b41bb95443f820453d8ffa0091aa - flattened_ast: 2f0138989d8527ccfb807dac80cef06cd3828c5b83cfeccce864eba3aa0fe97a + - initial_ast: fec4d3cdf1ec3f8a6a8583027f7186f02e37ac69aab519925556586d34f922c4 + unrolled_ast: fec4d3cdf1ec3f8a6a8583027f7186f02e37ac69aab519925556586d34f922c4 + ssa_ast: 1a6a9ae27d8bab993ec1ff948244d34e0cfb47464ce253b3ec3d51e5d72c9ca2 + flattened_ast: 95cf30aa11e1d695e89fa52aabe42059059eddfbf4daa89732cd58a824b27045 + inlined_ast: 95cf30aa11e1d695e89fa52aabe42059059eddfbf4daa89732cd58a824b27045 bytecode: fedca756e063b895f8cc4bf76f1d9d1c88ff1cf9f4b1208a725edde115f9b42a diff --git a/tests/expectations/compiler/statements/operations/div_assign.out b/tests/expectations/compiler/statements/operations/div_assign.out index e6e039de9f..ab6cb66c15 100644 --- a/tests/expectations/compiler/statements/operations/div_assign.out +++ b/tests/expectations/compiler/statements/operations/div_assign.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: dabcd44e46797bc591010b07216931df069338141184fbad5aa4388bbb213b59 - unrolled_ast: dabcd44e46797bc591010b07216931df069338141184fbad5aa4388bbb213b59 - ssa_ast: 576ae2b82885dab2fca7d25833121229bb69347094c31fda047507fbb9c8fb34 - flattened_ast: b3038af4499648a03f9d7b78218aba90dae5a9dbad5a0e613df51ef5eb17e99b + - initial_ast: 6dae25d257b6a910a6439a56f8f9a0cf5d0f4a4dfa6fd300989ed43e82c77919 + unrolled_ast: 6dae25d257b6a910a6439a56f8f9a0cf5d0f4a4dfa6fd300989ed43e82c77919 + ssa_ast: d35eb23d5585362243c38d7aa6bdcbe9db8649b0a6f0658c7b04a7941bcced19 + flattened_ast: 27c6d6ef683b66eea49757a486eb2fad8e01162800ee65519062fe1f144d8723 + inlined_ast: 27c6d6ef683b66eea49757a486eb2fad8e01162800ee65519062fe1f144d8723 bytecode: fb1dc12922cf851957984a8e2ee0dd72ee0fcff48ac8b0daf3443fa9fa2a4cd2 diff --git a/tests/expectations/compiler/statements/operations/mul_assign.out b/tests/expectations/compiler/statements/operations/mul_assign.out index e41d5c5051..88974ea5c1 100644 --- a/tests/expectations/compiler/statements/operations/mul_assign.out +++ b/tests/expectations/compiler/statements/operations/mul_assign.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 6efe93af34dfbb871dd930029738f114912886c92030182b99f6a82fff363fd9 - unrolled_ast: 6efe93af34dfbb871dd930029738f114912886c92030182b99f6a82fff363fd9 - ssa_ast: 7a2b8a8de8b02984833ee488c8b0a79acebb5b74d2e2d000a9361bcf4c25f442 - flattened_ast: 4b2457fbd57be059218a79f5b754d40e6b5c5d85b53874c05b06be474e8614aa + - initial_ast: e0d9f6856a4f338e60168e2cbb4f71ed81c48da9caf305231d87d080c8fde124 + unrolled_ast: e0d9f6856a4f338e60168e2cbb4f71ed81c48da9caf305231d87d080c8fde124 + ssa_ast: e33a956110373c8f1c0d160cf6c59d7b4cb20b232821d300c58006c25ee2cd92 + flattened_ast: b66f9c52a1da1f215c583239cce069e1ac0bcd69945ef7780cdfd55e585e26ed + inlined_ast: b66f9c52a1da1f215c583239cce069e1ac0bcd69945ef7780cdfd55e585e26ed bytecode: b71e1622ce24f72e85d8bea2b611bbb30b73ba24acbcd0ce7c560d9e86906bfb diff --git a/tests/expectations/compiler/statements/operations/or_assign.out b/tests/expectations/compiler/statements/operations/or_assign.out index e1e3130780..2dd73d181e 100644 --- a/tests/expectations/compiler/statements/operations/or_assign.out +++ b/tests/expectations/compiler/statements/operations/or_assign.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 2415c175c9fe999bf8d5b380e50b55e80cf468997c80d0d97fb4a1ebf9a57ae8 - unrolled_ast: 2415c175c9fe999bf8d5b380e50b55e80cf468997c80d0d97fb4a1ebf9a57ae8 - ssa_ast: 8c1bbbfba871dbcfd7618a6a091a379eea5ad25fae2f3589507301a00c8e14a8 - flattened_ast: 7068c66117fdfc9f953c1f33f62e678769a1d764cb41ea4cfc1f17712a5c89ac + - initial_ast: 2579d15b67853eaacce88986cfe8c2604a03a1f7384d1c9272019f74893e5de2 + unrolled_ast: 2579d15b67853eaacce88986cfe8c2604a03a1f7384d1c9272019f74893e5de2 + ssa_ast: 0aadaf5837c3b723a60741478b06a57ea70d49c9e8b685b9af333322278e3c4c + flattened_ast: 6a293e6919e8e2b2d5fb48404b9965c0107e3c93a657c7e9a5562de6e8d64984 + inlined_ast: 6a293e6919e8e2b2d5fb48404b9965c0107e3c93a657c7e9a5562de6e8d64984 bytecode: da955e601b890215b4c0e7b8c1a0f86e02f8069c33085a8897b6d976a7759139 diff --git a/tests/expectations/compiler/statements/operations/pow_assign.out b/tests/expectations/compiler/statements/operations/pow_assign.out index 3daf59baa2..194e8a9eab 100644 --- a/tests/expectations/compiler/statements/operations/pow_assign.out +++ b/tests/expectations/compiler/statements/operations/pow_assign.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 0772c0e4ebecdc104f81361924d78fa04296d5481c221934a12e1fe99e82247d - unrolled_ast: 0772c0e4ebecdc104f81361924d78fa04296d5481c221934a12e1fe99e82247d - ssa_ast: fd76f18bdd32ef4a16bdf51b91dc4275690df73e5bdf58973da60468551e1171 - flattened_ast: f2df5791fcc7e90a6cddc41230ca6ea0e431e3a85e76c2d57f6c7ca3edf1a2ab + - initial_ast: 4868053eb3fafdfdb2202252885ff65312794e8ce9b5e2119f7b3f85cb42a4b4 + unrolled_ast: 4868053eb3fafdfdb2202252885ff65312794e8ce9b5e2119f7b3f85cb42a4b4 + ssa_ast: 7b1291f30c41cdb25c52b61c47a27c22142451c739a9704c931aa3d724396498 + flattened_ast: 9ab131136ab1ae59d8952d07ac7990337a3ae6a2f1d88d00f4b7152cc3786fa6 + inlined_ast: 9ab131136ab1ae59d8952d07ac7990337a3ae6a2f1d88d00f4b7152cc3786fa6 bytecode: 4108ac88f7fdefec52773508ff4e95349dce1f77b55123870ccf6bb1adedc423 diff --git a/tests/expectations/compiler/statements/operations/rem_assign.out b/tests/expectations/compiler/statements/operations/rem_assign.out index a091f09fd2..e1354d2f64 100644 --- a/tests/expectations/compiler/statements/operations/rem_assign.out +++ b/tests/expectations/compiler/statements/operations/rem_assign.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: feb6e94fae01e9bfb3f7a7c5cc362fd6da30a8ad1f79b3544a3982cc815335ad - unrolled_ast: feb6e94fae01e9bfb3f7a7c5cc362fd6da30a8ad1f79b3544a3982cc815335ad - ssa_ast: 64578deaa56286c58892886ec4fa1314e813e2c6aabf10fefba67859d4a6442c - flattened_ast: ad93e5bb1af9648b6514f04e6439c4a4c87c10dcf3353aaae27731c1b2154f18 + - initial_ast: 336265cd7129cba865898735d54b9c20073bff52696ba6c212ae8a6e66452106 + unrolled_ast: 336265cd7129cba865898735d54b9c20073bff52696ba6c212ae8a6e66452106 + ssa_ast: d0c71f2f1de2e8ccded3356e307757cf08f78009742a8f3c0b5d8305a9835560 + flattened_ast: 3dc73fa2723342d30d858ef6d3fc485f94df34567bec51ecdc39391ea4ea29c6 + inlined_ast: 3dc73fa2723342d30d858ef6d3fc485f94df34567bec51ecdc39391ea4ea29c6 bytecode: 9b3c12479efabe9d85d3b8c07f1872c8d846425a5451c59a2127d69b7ca3a229 diff --git a/tests/expectations/compiler/statements/operations/shl_assign.out b/tests/expectations/compiler/statements/operations/shl_assign.out index 753475ec26..5f5ea5e2d6 100644 --- a/tests/expectations/compiler/statements/operations/shl_assign.out +++ b/tests/expectations/compiler/statements/operations/shl_assign.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 6b94ad7099fe8f5d16e06347155437428d32cbff69bfbaa61ac81eaba7bb317b - unrolled_ast: 6b94ad7099fe8f5d16e06347155437428d32cbff69bfbaa61ac81eaba7bb317b - ssa_ast: 3fddfdc7b221cd3c3330860fde0f9f00f401cce764db209681cb827a089b8bfe - flattened_ast: b1fd4cdefbe1b6a390c5720b39f3e363da34cd5be093379894e05db0e685e221 + - initial_ast: d018ac16daaac9ba7f9020cc0aee2084333fd737bb1e4894b7293a8d4eaa9ae3 + unrolled_ast: d018ac16daaac9ba7f9020cc0aee2084333fd737bb1e4894b7293a8d4eaa9ae3 + ssa_ast: 1d0cccfd79e4dcdea37eab9e26a4c87bed815c1cd5faf28acf74d30054f4bb9e + flattened_ast: a2e7c80905ee9e5201cbcce79342f06f9d3d1a8b4aa08e41f83bdb022b39d628 + inlined_ast: a2e7c80905ee9e5201cbcce79342f06f9d3d1a8b4aa08e41f83bdb022b39d628 bytecode: e3a22ebc4bc203291d1190f9711b5578da0f4c83b292d9f3adcf281db4922126 diff --git a/tests/expectations/compiler/statements/operations/shr_assign.out b/tests/expectations/compiler/statements/operations/shr_assign.out index 3cb9e92116..e495eccc28 100644 --- a/tests/expectations/compiler/statements/operations/shr_assign.out +++ b/tests/expectations/compiler/statements/operations/shr_assign.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 3ddc4b1a4f5735cabcac4e4771fc8558bcc3324d606b1c3a80ed132f72cc1544 - unrolled_ast: 3ddc4b1a4f5735cabcac4e4771fc8558bcc3324d606b1c3a80ed132f72cc1544 - ssa_ast: 3797d72aa0c84b13f7e992573f3bfa2510a6f4ad24725737f99c08159b9ad544 - flattened_ast: 775eb85eee4f0c044af1e5d6e22f9933eb756b7ba6f41060af821356abb09747 + - initial_ast: 583a4ba4ff7216777c266bff6599d88ed2522c9d687e2bbf2005563bb63153d0 + unrolled_ast: 583a4ba4ff7216777c266bff6599d88ed2522c9d687e2bbf2005563bb63153d0 + ssa_ast: 7c37b49480906456cf49bcf1be82916c2044d3eb07d6cb6cb7e840b0a0498d37 + flattened_ast: 0b9d3680dbb567eadec23a09e6ef3dcdbc270bc7fd5c76a103691e56648d5b92 + inlined_ast: 0b9d3680dbb567eadec23a09e6ef3dcdbc270bc7fd5c76a103691e56648d5b92 bytecode: 8bde890ff271b82f5c35c517fa95e2fec5654dee843f5d1ca8771153410d9816 diff --git a/tests/expectations/compiler/statements/operations/sub_assign.out b/tests/expectations/compiler/statements/operations/sub_assign.out index ded8235e00..9f59d76e17 100644 --- a/tests/expectations/compiler/statements/operations/sub_assign.out +++ b/tests/expectations/compiler/statements/operations/sub_assign.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e0d4ab83a553d192b9c5dc318969458b6be8084a637d8f0e01c76bed50008680 - unrolled_ast: e0d4ab83a553d192b9c5dc318969458b6be8084a637d8f0e01c76bed50008680 - ssa_ast: 4ec0f00e2ff085fc7be1b0aa6af78090133f16a0b6ee2fa83f1d49610760cd32 - flattened_ast: a3dd70c4531c03e7fb568d5bcf8b38aacbd743fde23dfc6ac42514bfc9dc6dbc + - initial_ast: 7fff01bb9eb5253f00dc49106bbc17ff8c90dd5e8f6dd94c0ab6da5947e2df47 + unrolled_ast: 7fff01bb9eb5253f00dc49106bbc17ff8c90dd5e8f6dd94c0ab6da5947e2df47 + ssa_ast: c85d6514d10aaa44ff66e89977b98fa70cb140229951764103b1563164e93a8e + flattened_ast: d36c7de601eac9e77aa4e9aac0f9edec4a1f80c43e62e7d1c15a05ecc41c67b2 + inlined_ast: d36c7de601eac9e77aa4e9aac0f9edec4a1f80c43e62e7d1c15a05ecc41c67b2 bytecode: d1392a0607452a3256f9289af243a6700d69f63c0b507ac9a52ceb3616f5a742 diff --git a/tests/expectations/compiler/statements/ternary_explicit_and_implicit.out b/tests/expectations/compiler/statements/ternary_explicit_and_implicit.out index 4750aa8f69..6b8c50b265 100644 --- a/tests/expectations/compiler/statements/ternary_explicit_and_implicit.out +++ b/tests/expectations/compiler/statements/ternary_explicit_and_implicit.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e5307c5a6339383407552eaf75b21ac0f0ff65059045631532a1f2c655d32a68 - unrolled_ast: e5307c5a6339383407552eaf75b21ac0f0ff65059045631532a1f2c655d32a68 - ssa_ast: 3003ef83a93f48b08803c66b16c704bde2d0a67f420bdd4a75ae93c7784474e8 - flattened_ast: 7e174242fa8f0e50773a72682d6a8a9d42229d81f0c833ce14e6f632033c8359 + - initial_ast: 57d0b6f6aa70eb7794804338471642bb7d3afbe22839e481e3db043c96429c64 + unrolled_ast: 57d0b6f6aa70eb7794804338471642bb7d3afbe22839e481e3db043c96429c64 + ssa_ast: ac3d8c3a3a404ec9d3bdc6012d9dba7c54c8da3d2e18e09378c867089cee3cae + flattened_ast: 8eac9b122ec47ee96061b25b50feb4188f5b85bee63006a999ec1b75dd1d6be5 + inlined_ast: 8eac9b122ec47ee96061b25b50feb4188f5b85bee63006a999ec1b75dd1d6be5 bytecode: 29c7986430a76fc69c77d416ab7581c42dbb7f2fc7821991cb7365b145079200 diff --git a/tests/expectations/compiler/structs/inline.out b/tests/expectations/compiler/structs/inline.out index 68edff9ca5..b40c8231b8 100644 --- a/tests/expectations/compiler/structs/inline.out +++ b/tests/expectations/compiler/structs/inline.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 833a9489a2a633e9a295cd1ab0bd607826d63747858eb83ad23167c7059ae095 - unrolled_ast: 833a9489a2a633e9a295cd1ab0bd607826d63747858eb83ad23167c7059ae095 - ssa_ast: 46b22193b16905cb2c2b5cafd609b434194ff90c687095a67d200495448d2121 - flattened_ast: 58f481fdd9f4f0a1b06c07f3b8df37be370fb96c58dd5a8ba7874257100822a8 + - initial_ast: 7818747ae39ad9c3d3e38f33ef04779e9a1263a6237daa44b7fb2659554c0d95 + unrolled_ast: 7818747ae39ad9c3d3e38f33ef04779e9a1263a6237daa44b7fb2659554c0d95 + ssa_ast: a104cc64f516736f3ce574106897b78f60a848422c837e4df90c86923ef86a28 + flattened_ast: be9e8e22f34e3fdabc73fe56a8c161ed6b84c797194fe83d11f886308215dfc8 + inlined_ast: be9e8e22f34e3fdabc73fe56a8c161ed6b84c797194fe83d11f886308215dfc8 bytecode: 8ee7f077a54a80ac5ce5d1cc894c81c880730a3d60857397dc6028d0d8423125 diff --git a/tests/expectations/compiler/structs/member_variable.out b/tests/expectations/compiler/structs/member_variable.out index c78e70c270..4da40ef4fe 100644 --- a/tests/expectations/compiler/structs/member_variable.out +++ b/tests/expectations/compiler/structs/member_variable.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 1e712899bd83225f751b5f9f5ad20373717e908d1fef5f39235f28454a0ad295 - unrolled_ast: 1e712899bd83225f751b5f9f5ad20373717e908d1fef5f39235f28454a0ad295 - ssa_ast: 2f437b91e9b21e0a501ad759bc20636f60ccc3cf11b36fbec78b3bfdd1aac1d1 - flattened_ast: ec8bbe315ace7a787d5c4667b8263f5eb7137206d7f65c67d1894b27fd5a592c + - initial_ast: dd331d498c91fa4895e531ff78e9dfd5fafafb67edce153d7aefa6f246dca9b9 + unrolled_ast: dd331d498c91fa4895e531ff78e9dfd5fafafb67edce153d7aefa6f246dca9b9 + ssa_ast: 4cfa347ec55602a04cdf079ff561c05e5d5b9105bd1b77bb3d58ef75549bcf4a + flattened_ast: 4ac1527e7f607e0021cc91b53a1045a7da9100b4a4308b4656a9d3142ee1aee8 + inlined_ast: 4ac1527e7f607e0021cc91b53a1045a7da9100b4a4308b4656a9d3142ee1aee8 bytecode: a8874b5e3d3a000703943de2f132677372f9a275003bccf176c4ebfdf1b86466 diff --git a/tests/expectations/compiler/structs/struct_declaration_out_of_order.out b/tests/expectations/compiler/structs/struct_declaration_out_of_order.out index 4fab74816c..8051452190 100644 --- a/tests/expectations/compiler/structs/struct_declaration_out_of_order.out +++ b/tests/expectations/compiler/structs/struct_declaration_out_of_order.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: f72bdc4075f8df04335f1ba943e103ffb347e2ef543ac78d09e9b23bb5e9b5ca - unrolled_ast: f72bdc4075f8df04335f1ba943e103ffb347e2ef543ac78d09e9b23bb5e9b5ca - ssa_ast: 3fbaa1d3291e3db9138bec025038bc5a72d61b1b9a57bca284d7fdca360f27eb - flattened_ast: 840256ffdb159fc8b17ae81304f7173dc4c4d1c88d72d90ec9466d8ca754087e + - initial_ast: 1637364caa1b5af80b377e1f61ed60a96154f89c5aaf6a3f9434a19dd1d4ad7d + unrolled_ast: 1637364caa1b5af80b377e1f61ed60a96154f89c5aaf6a3f9434a19dd1d4ad7d + ssa_ast: d614bad2a7c9cd413f125c6e14414d0ef7af2c2f7f7b4900297505c644680fee + flattened_ast: db15a99e033ef6ff98aa896a09367cc324b633da0e8dfa8410a4158818310072 + inlined_ast: db15a99e033ef6ff98aa896a09367cc324b633da0e8dfa8410a4158818310072 bytecode: 6cc7359d48deaf0b2c03bdd35b80693511afe0033aeafeceb7065267697f022a diff --git a/tests/expectations/compiler/structs/struct_init_out_of_order.out b/tests/expectations/compiler/structs/struct_init_out_of_order.out index 7024965086..e5e599cb3e 100644 --- a/tests/expectations/compiler/structs/struct_init_out_of_order.out +++ b/tests/expectations/compiler/structs/struct_init_out_of_order.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 6309cee270f16e07195581b2b698dd65d261112a4e875fd13d811c8247e65dba - unrolled_ast: 6309cee270f16e07195581b2b698dd65d261112a4e875fd13d811c8247e65dba - ssa_ast: 5d222042ed63771b08876d0623674f81a8fdcbe60d223927df9cd31038738044 - flattened_ast: c3514496a8fed91adcd4146e1a438d3bf3ff301d50e43e681e91e570366a42ea + - initial_ast: ca0df5eeaf225ccc6d56c12c0b8cf2f86176245cbd5caa2844dcf18f4fa3ff7c + unrolled_ast: ca0df5eeaf225ccc6d56c12c0b8cf2f86176245cbd5caa2844dcf18f4fa3ff7c + ssa_ast: 538d8c68d07639040c30cc3a954a0ffddd8d8d02e9a8e896baf989877593497f + flattened_ast: bfd2540607e813ffcaef69617df1dc66265badc3c016d878d3b8ef4a9d366ca3 + inlined_ast: bfd2540607e813ffcaef69617df1dc66265badc3c016d878d3b8ef4a9d366ca3 bytecode: 035a98875b76db42e72bba26b053403c2c629c47683376fe1a33f3a61b3ad53f diff --git a/tests/expectations/compiler/tuple/function_call_returns_tuple.out b/tests/expectations/compiler/tuple/function_call_returns_tuple.out index 2d969441ba..d59abdcdcc 100644 --- a/tests/expectations/compiler/tuple/function_call_returns_tuple.out +++ b/tests/expectations/compiler/tuple/function_call_returns_tuple.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 07e1c5a9a3d0f029169d096165d90d4db77da7fd92bc37dd095c40b4f183e103 - unrolled_ast: 07e1c5a9a3d0f029169d096165d90d4db77da7fd92bc37dd095c40b4f183e103 - ssa_ast: ffdec84b904fce4b3baa0f35f7b1fb0bfc064ae0fac4b5099564b2fc39180952 - flattened_ast: c50388961b33589150b80846157f64d929e50a51ea79168f96a3bacc6d548ed1 + - initial_ast: 3b55815480779f25bc79dc7b3bbe74de65fd82c6e180c063440c316ed623e8a8 + unrolled_ast: 3b55815480779f25bc79dc7b3bbe74de65fd82c6e180c063440c316ed623e8a8 + ssa_ast: a21d90ca17c1a7731a3434cb78f70f4486adc033a2482335ff634e37f216cd58 + flattened_ast: 789b45607257d91514782f67b6229b8d5bd88e8c2be169e60e81d7dbe11c873c + inlined_ast: 789b45607257d91514782f67b6229b8d5bd88e8c2be169e60e81d7dbe11c873c bytecode: c154c5c9344d976d14c6455e9f24f6d9d9dbffde47e9bf76b6ed35ffb3a75006 diff --git a/tests/expectations/compiler/tuple/function_early_return.out b/tests/expectations/compiler/tuple/function_early_return.out index f454680333..d24deac44c 100644 --- a/tests/expectations/compiler/tuple/function_early_return.out +++ b/tests/expectations/compiler/tuple/function_early_return.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 7a150fc05747c84a3f6d44e549cd379b241defde04162c9f2799213b0b770ec3 - unrolled_ast: 7a150fc05747c84a3f6d44e549cd379b241defde04162c9f2799213b0b770ec3 - ssa_ast: a72574094f846873420a14fff0ebe2a1df9aeac1a0e32d6bb5a615634ea893dc - flattened_ast: 1c52d3030429bd3238be592b79ba99f17e4da29878e5bd354e6dff50bda35a08 + - initial_ast: 07639c360dc3eefc9b4d4be7f00e897df1d1da0ff18bba6311e6bf11352ce638 + unrolled_ast: 07639c360dc3eefc9b4d4be7f00e897df1d1da0ff18bba6311e6bf11352ce638 + ssa_ast: d657cd3d890ad5e0408a2ba756df214ecaf9f778712fc24b8254cef50ba1f172 + flattened_ast: 0013e29af14bf798ff2713e3fa8623296c38dfd2aab1192fd5da4a33458586eb + inlined_ast: 0013e29af14bf798ff2713e3fa8623296c38dfd2aab1192fd5da4a33458586eb bytecode: c5b9380beb403e862b352234944450588999c9314abceaff6166d98c8882a4b6 diff --git a/tests/expectations/compiler/tuple/function_return.out b/tests/expectations/compiler/tuple/function_return.out index 53f26d8845..6e439849a1 100644 --- a/tests/expectations/compiler/tuple/function_return.out +++ b/tests/expectations/compiler/tuple/function_return.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 0b2bfd171b852c4a6c4184ece345a7e855611fd515732dc02b516c6009d1a06d - unrolled_ast: 0b2bfd171b852c4a6c4184ece345a7e855611fd515732dc02b516c6009d1a06d - ssa_ast: 16ef33fe7fbe8247aefe45e09ef9541b1c2321914453404fb658591c52388e60 - flattened_ast: ee75622d552cee9dfece49ca40c171faa3b16ed9004730c01cd470560b1bdbed + - initial_ast: 7bf33d550793efc6d619f987e9c8f5f5942c38bd6506641879ac097371799e84 + unrolled_ast: 7bf33d550793efc6d619f987e9c8f5f5942c38bd6506641879ac097371799e84 + ssa_ast: 237563de1ae2b5eb51b7a8bb8c31bc53651bf6d9f708913d3963b4bf28bdcbf5 + flattened_ast: 33262f1952c8586a6bbac3933b945561e3883706902c8e6e8fa6091ac51fbf08 + inlined_ast: 33262f1952c8586a6bbac3933b945561e3883706902c8e6e8fa6091ac51fbf08 bytecode: 2c8abaf0758c39eaedd2fe6bb2747525a452084cd96ce540fd75a7c63395c7ca diff --git a/tests/expectations/compiler/tuple/function_return_nothing.out b/tests/expectations/compiler/tuple/function_return_nothing.out index 1ae15ce64c..8d946a314e 100644 --- a/tests/expectations/compiler/tuple/function_return_nothing.out +++ b/tests/expectations/compiler/tuple/function_return_nothing.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 23b933ce376492c9dd9d6aae7be44e6ee351469b97c05691185dccf12c183ba9 - unrolled_ast: 23b933ce376492c9dd9d6aae7be44e6ee351469b97c05691185dccf12c183ba9 - ssa_ast: 23b933ce376492c9dd9d6aae7be44e6ee351469b97c05691185dccf12c183ba9 - flattened_ast: c4ad5783b89aaa701ced8f63ab0f9dc6add22f1e0126921c92896e3168e6b554 + - initial_ast: 23268f71897aadaecd46cd2ace516815f6f9c60323af8581da66eb4c0b8b4ecb + unrolled_ast: 23268f71897aadaecd46cd2ace516815f6f9c60323af8581da66eb4c0b8b4ecb + ssa_ast: 23268f71897aadaecd46cd2ace516815f6f9c60323af8581da66eb4c0b8b4ecb + flattened_ast: 7ff0d9cf3ab00fa646f5789412329e615534a34a9cb4f942f711af86959c3d19 + inlined_ast: 7ff0d9cf3ab00fa646f5789412329e615534a34a9cb4f942f711af86959c3d19 bytecode: 3dd2872e02c8030587f796df543d94855437d87460d22c177e74eb6647c1c7b1 diff --git a/tests/expectations/compiler/tuple/function_return_unit.out b/tests/expectations/compiler/tuple/function_return_unit.out index 1ae15ce64c..8d946a314e 100644 --- a/tests/expectations/compiler/tuple/function_return_unit.out +++ b/tests/expectations/compiler/tuple/function_return_unit.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 23b933ce376492c9dd9d6aae7be44e6ee351469b97c05691185dccf12c183ba9 - unrolled_ast: 23b933ce376492c9dd9d6aae7be44e6ee351469b97c05691185dccf12c183ba9 - ssa_ast: 23b933ce376492c9dd9d6aae7be44e6ee351469b97c05691185dccf12c183ba9 - flattened_ast: c4ad5783b89aaa701ced8f63ab0f9dc6add22f1e0126921c92896e3168e6b554 + - initial_ast: 23268f71897aadaecd46cd2ace516815f6f9c60323af8581da66eb4c0b8b4ecb + unrolled_ast: 23268f71897aadaecd46cd2ace516815f6f9c60323af8581da66eb4c0b8b4ecb + ssa_ast: 23268f71897aadaecd46cd2ace516815f6f9c60323af8581da66eb4c0b8b4ecb + flattened_ast: 7ff0d9cf3ab00fa646f5789412329e615534a34a9cb4f942f711af86959c3d19 + inlined_ast: 7ff0d9cf3ab00fa646f5789412329e615534a34a9cb4f942f711af86959c3d19 bytecode: 3dd2872e02c8030587f796df543d94855437d87460d22c177e74eb6647c1c7b1 diff --git a/tests/expectations/compiler/tuple/function_return_varying_modes.out b/tests/expectations/compiler/tuple/function_return_varying_modes.out index c708d32555..90cf87056f 100644 --- a/tests/expectations/compiler/tuple/function_return_varying_modes.out +++ b/tests/expectations/compiler/tuple/function_return_varying_modes.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: e614de44d880fd94f9fd03625b6ad84e8637e7b9450b4a9731d773d11368a311 - unrolled_ast: e614de44d880fd94f9fd03625b6ad84e8637e7b9450b4a9731d773d11368a311 - ssa_ast: bef731f003fcc180bd82979f0365ead4a351837d14a13e305a56f2f06cfc54c7 - flattened_ast: 3667e8dd26a3a4cb9072b0da3bfe65d0f45ebebdfa8934d49e7e81900266d80e + - initial_ast: 926c535d42c3e31ff98b0c0abe4004ae3eb6fdbd0f0e90652548e4256b15b6b8 + unrolled_ast: 926c535d42c3e31ff98b0c0abe4004ae3eb6fdbd0f0e90652548e4256b15b6b8 + ssa_ast: 2d72b389548e73e8cdd6d40a56876e3972047174e1d9573b9d99fcfc17ef158c + flattened_ast: 5c8a19f4f9c878b116e922e3ea421fba31fc22837293d4ada30425a2b5b3e541 + inlined_ast: 5c8a19f4f9c878b116e922e3ea421fba31fc22837293d4ada30425a2b5b3e541 bytecode: 712d619af623624abea3ee1932a204f2c7901f2d815a4f3c612386e6b457a430 diff --git a/tests/expectations/compiler/tuple/return_with_different_modes.out b/tests/expectations/compiler/tuple/return_with_different_modes.out index 51178659ea..046fbe8d4c 100644 --- a/tests/expectations/compiler/tuple/return_with_different_modes.out +++ b/tests/expectations/compiler/tuple/return_with_different_modes.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 95da1f892800d24dff40c26661e11aa0f21ae829dc0729dba1805215886cea4a - unrolled_ast: 95da1f892800d24dff40c26661e11aa0f21ae829dc0729dba1805215886cea4a - ssa_ast: 5f32d4138cb3bb0d8df91d4d4287fad79e823bd014495a1fca562410dc141758 - flattened_ast: 3062da8a091d1d44226eb4d5603cfc331e29c118d50fb964f737176fd1acab12 + - initial_ast: 063e4be66382f9133b59a86612971b32a780014113ed99b038d030825c129730 + unrolled_ast: 063e4be66382f9133b59a86612971b32a780014113ed99b038d030825c129730 + ssa_ast: f1225db8f825c11bdadbf472eb1f3a94a173e44461b85e4f9a0de42a5489b2f3 + flattened_ast: c50916f5dee3140ee7ccfe337cfd1b0d8da17f8f1779e867d04e58285f83439e + inlined_ast: c50916f5dee3140ee7ccfe337cfd1b0d8da17f8f1779e867d04e58285f83439e bytecode: 712d619af623624abea3ee1932a204f2c7901f2d815a4f3c612386e6b457a430 diff --git a/tests/expectations/compiler/tuple/tuple_access.out b/tests/expectations/compiler/tuple/tuple_access.out index 64c7e1d41d..895613f17b 100644 --- a/tests/expectations/compiler/tuple/tuple_access.out +++ b/tests/expectations/compiler/tuple/tuple_access.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: fca830511e1a0c1891d5209808abb10b6ecaf61d2977c9d3b36aef0cf5a7fbdc - unrolled_ast: fca830511e1a0c1891d5209808abb10b6ecaf61d2977c9d3b36aef0cf5a7fbdc - ssa_ast: e8f0dc54fe43c3866ddc5c043a4edb99e5c22f94b6d3ccaaef707566fd99b736 - flattened_ast: c8850b1205bae1d9f85a952bedd1c9ab040c58e9572232eca636145467beecaa + - initial_ast: bd012de01926a8ae26a191dc875e28fdc93a2310040222621c27cf8f89317c3d + unrolled_ast: bd012de01926a8ae26a191dc875e28fdc93a2310040222621c27cf8f89317c3d + ssa_ast: 9deec2d9e0aa1b0f820c50629e125361784be0f70b0a6b1971f1ce20763dbe49 + flattened_ast: 74414bccb00a4939c920daa2fb4cfb479a9a6e06757b16b47822202344a1e402 + inlined_ast: 74414bccb00a4939c920daa2fb4cfb479a9a6e06757b16b47822202344a1e402 bytecode: 01001f0a4197adc24393c88758ad4747a51b21ee9119ec969b42a7f5ad3703cd diff --git a/tests/expectations/compiler/tuple/tuple_destructure.out b/tests/expectations/compiler/tuple/tuple_destructure.out index c96d57b0e4..ad096880fd 100644 --- a/tests/expectations/compiler/tuple/tuple_destructure.out +++ b/tests/expectations/compiler/tuple/tuple_destructure.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 5de6e70195b821d3fe0184f177a222a841d024dcb3156d1b786a6e38895a4c2f - unrolled_ast: 5de6e70195b821d3fe0184f177a222a841d024dcb3156d1b786a6e38895a4c2f - ssa_ast: 14c2e02509b555182de3257416cfd9b1144539cc61e89eea91013885582316a6 - flattened_ast: 6a838d9101551fd578faac5f373a0db2c7e801755d34a22e179c1b71311b8c4b + - initial_ast: 7ad7e4f9cbde235823f14095d7fd03a7b4ba7f7d55b4c3b493e7f52caeeccace + unrolled_ast: 7ad7e4f9cbde235823f14095d7fd03a7b4ba7f7d55b4c3b493e7f52caeeccace + ssa_ast: 2aa9253234af25833497dde3be12e0f28b16e3c55517f40d8d6f443fcd7a28c0 + flattened_ast: e53e8075bbd1702ef0dfc55748810af5adaecf6feee3e62a5e2a6c7a1bc246be + inlined_ast: e53e8075bbd1702ef0dfc55748810af5adaecf6feee3e62a5e2a6c7a1bc246be bytecode: 4ea7af7cc45ebc1c65534c344f557881f7ad985a7cf7b2d1135f5fc1c1b11bf5 diff --git a/tests/expectations/compiler/tuple/tuple_in_assignment.out b/tests/expectations/compiler/tuple/tuple_in_assignment.out index ab68f14a08..48779acb6c 100644 --- a/tests/expectations/compiler/tuple/tuple_in_assignment.out +++ b/tests/expectations/compiler/tuple/tuple_in_assignment.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 671825fcf613f43a5396e97399501987793909013566a1fcfe87e9d568b388cf - unrolled_ast: 671825fcf613f43a5396e97399501987793909013566a1fcfe87e9d568b388cf - ssa_ast: b62bf59e58e4efb2c1889f6943d18ff586bcccb77b7e63a5c3c5102e5c97a7fc - flattened_ast: d3073942753075247bc73f82ebd4e059efb9b8ed373948f4ccb3cd0051b36dc0 + - initial_ast: 5ffd06da2f8179ac1575830eec4845c89361b78b57acd3d82c00460e8ff23726 + unrolled_ast: 5ffd06da2f8179ac1575830eec4845c89361b78b57acd3d82c00460e8ff23726 + ssa_ast: feb601f0542392c0ff6f6e65771e1a3f78a3d502afd78dedb9da62701e15eafb + flattened_ast: 7c4aa29c9260a7b27fcb908522c574d1db078c225faa869a73464227053d665d + inlined_ast: 7c4aa29c9260a7b27fcb908522c574d1db078c225faa869a73464227053d665d bytecode: ca2bd4a18e97ee288c1e21bd35be693a6541d52293a94eacca62e48af67d3588 diff --git a/tests/expectations/compiler/tuple/tuple_in_definition.out b/tests/expectations/compiler/tuple/tuple_in_definition.out index 2df0d85373..7de9da3775 100644 --- a/tests/expectations/compiler/tuple/tuple_in_definition.out +++ b/tests/expectations/compiler/tuple/tuple_in_definition.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 889cb21e97d3f486b00b09445efb2cf010188e9c640a4b7c52d30c94723e6fdd - unrolled_ast: 889cb21e97d3f486b00b09445efb2cf010188e9c640a4b7c52d30c94723e6fdd - ssa_ast: c08548614893ecaadeb0dcae18ce19c366a10d75d1d722508e184b291eb28583 - flattened_ast: 8cd65358f5e6653fa7af3b894c84f1c7a0aea3f9e3a7f4e21789dd2bacc0ac8a + - initial_ast: ca793163024f08df22c1c442769aaf0d97d6471b7ad855ba9fcc9c5e3bef5ae2 + unrolled_ast: ca793163024f08df22c1c442769aaf0d97d6471b7ad855ba9fcc9c5e3bef5ae2 + ssa_ast: 094dd7841fd9c22b2b5fd5d77a4fda74555e2b0c2bef02f84d14e704c4118602 + flattened_ast: 88ba11daed1c76380a5ffc7fe96164872daa773d050078faedaf2452d78564c2 + inlined_ast: 88ba11daed1c76380a5ffc7fe96164872daa773d050078faedaf2452d78564c2 bytecode: 5a4f25e917512c7596cf0eecb61d2fa9688ada34ded5714d5d1f58356c8b8910 diff --git a/tests/expectations/compiler/tuple/tuple_in_loop.out b/tests/expectations/compiler/tuple/tuple_in_loop.out index e3b6ae68e9..37725d0431 100644 --- a/tests/expectations/compiler/tuple/tuple_in_loop.out +++ b/tests/expectations/compiler/tuple/tuple_in_loop.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: dc17c931b283f3d3c926fd7ebd459fd1199d44e5d34bb7d80101761831466d8e - unrolled_ast: 6560e1d1944be40dc585b77394eb8575a134407f68152f9d511cdd5f2102c5d2 - ssa_ast: b7d7687498671fe73f17cc59016bbc035d4c3a04f046f6c17048cb4acdd3385d - flattened_ast: 0420ce25a4930b15fb786ac49caf697b59cb7a05e7e383d83f13b99887865996 + - initial_ast: fc30e94ed8cdf2e684c59da34b62a93b9aec95b52769e824a26b5b751ba1c922 + unrolled_ast: 29925df425337b040f528a3779ed804368eebc55b92e91ab504d20338391ea78 + ssa_ast: 0f8aef0018ff70f83d760868a1a5b00d4c766b0e0aa015f4609efd60e4f0d9fa + flattened_ast: f75b1b72be86460c9c349ec8dc61996b973307d8e56fca72b2b0d4516853ad8a + inlined_ast: f75b1b72be86460c9c349ec8dc61996b973307d8e56fca72b2b0d4516853ad8a bytecode: f4577938c5c2372899e3894134e21850f7dd2dcc06830a3856b9e8a989ddff2e diff --git a/tests/expectations/compiler/tuple/unit.out b/tests/expectations/compiler/tuple/unit.out index 9d443eab84..7bbfe910b8 100644 --- a/tests/expectations/compiler/tuple/unit.out +++ b/tests/expectations/compiler/tuple/unit.out @@ -2,8 +2,9 @@ namespace: Compile expectation: Pass outputs: - - initial_ast: 09a18b5b95816d46b1532923b9b59970b1fe67db0125bae53b32eafb1a22b14a - unrolled_ast: 09a18b5b95816d46b1532923b9b59970b1fe67db0125bae53b32eafb1a22b14a - ssa_ast: 09a18b5b95816d46b1532923b9b59970b1fe67db0125bae53b32eafb1a22b14a - flattened_ast: 66f2d1ce15cc515ea89ce156961c87561c893ffbb9489e5ee54cab1fd5182398 + - initial_ast: 98f4d3670d7ae0c3ca7ded9e668b7fae1ad912cf468df712c40f48049d25e6b3 + unrolled_ast: 98f4d3670d7ae0c3ca7ded9e668b7fae1ad912cf468df712c40f48049d25e6b3 + ssa_ast: 98f4d3670d7ae0c3ca7ded9e668b7fae1ad912cf468df712c40f48049d25e6b3 + flattened_ast: a77fdf051383ff91fd5282969762682d47fd0276f8bda134b6ad6d684b6e35f5 + inlined_ast: a77fdf051383ff91fd5282969762682d47fd0276f8bda134b6ad6d684b6e35f5 bytecode: 6d63927b268b0e319d418ace15149e807636dff02ce5f14e037145ead86d2258 diff --git a/tests/expectations/execution/chain.out b/tests/expectations/execution/chain.out index 10a0626066..459cb7ed24 100644 --- a/tests/expectations/execution/chain.out +++ b/tests/expectations/execution/chain.out @@ -2,10 +2,11 @@ namespace: Execute expectation: Pass outputs: - - initial_ast: 3c1a4035879a71f0f4b9a29f5ae565055141d2fccdd180071a4b228ad83c2d9b - unrolled_ast: 3c1a4035879a71f0f4b9a29f5ae565055141d2fccdd180071a4b228ad83c2d9b - ssa_ast: ad31bc1da505ff74ba0dc532e74c5b36603cb1f912c616bbe1694751b2557f61 - flattened_ast: 6c838e3ae060537709075ea5cd05afdd745815bbd4925daf174268dfa5d58d64 + - initial_ast: 1aea137b987a163e453144e62d25345f812658b3a0ab0869aeff7fa418e2cff5 + unrolled_ast: 1aea137b987a163e453144e62d25345f812658b3a0ab0869aeff7fa418e2cff5 + ssa_ast: a32466203633115b461c407faa1472f4faf0f4fe7eafa65922cdf2983cb97b6c + flattened_ast: 38dd6655713ffd14ce11592d2cd71d4c5db7da452cf1eb00baa4275e79da7794 + inlined_ast: 38dd6655713ffd14ce11592d2cd71d4c5db7da452cf1eb00baa4275e79da7794 bytecode: b26e7efafe9624ccaa5ebe73afb04f718bffd1dd4094724a1a040dffd96ee6e8 results: main: diff --git a/tests/expectations/execution/eq.out b/tests/expectations/execution/eq.out index e1f6838778..a65604b650 100644 --- a/tests/expectations/execution/eq.out +++ b/tests/expectations/execution/eq.out @@ -2,10 +2,11 @@ namespace: Execute expectation: Pass outputs: - - initial_ast: 587c36a1a4e1585d53211eea86221014a6b8a816d0657f29de282b2984bf31c9 - unrolled_ast: 587c36a1a4e1585d53211eea86221014a6b8a816d0657f29de282b2984bf31c9 - ssa_ast: 587c36a1a4e1585d53211eea86221014a6b8a816d0657f29de282b2984bf31c9 - flattened_ast: 587c36a1a4e1585d53211eea86221014a6b8a816d0657f29de282b2984bf31c9 + - initial_ast: e384bbb19d9c6c31a1f7793869f62db14b66859be16bc50c89cbbbd392010ea8 + unrolled_ast: e384bbb19d9c6c31a1f7793869f62db14b66859be16bc50c89cbbbd392010ea8 + ssa_ast: e384bbb19d9c6c31a1f7793869f62db14b66859be16bc50c89cbbbd392010ea8 + flattened_ast: e384bbb19d9c6c31a1f7793869f62db14b66859be16bc50c89cbbbd392010ea8 + inlined_ast: e384bbb19d9c6c31a1f7793869f62db14b66859be16bc50c89cbbbd392010ea8 bytecode: e82dc85d86570ddd2ae71f8a7f9e150e43061697a6d0152a0c354fecd6bfd15d results: main: diff --git a/tests/expectations/execution/flattened_function_and_inline_matches.out b/tests/expectations/execution/flattened_function_and_inline_matches.out new file mode 100644 index 0000000000..c0e46a1ee0 --- /dev/null +++ b/tests/expectations/execution/flattened_function_and_inline_matches.out @@ -0,0 +1,29 @@ +--- +namespace: Execute +expectation: Pass +outputs: + - initial_ast: 4f771e398a6a7dd30e05b1a2733a4c3d41654e3f5a116a02ed7a862bd3267a06 + unrolled_ast: 4f771e398a6a7dd30e05b1a2733a4c3d41654e3f5a116a02ed7a862bd3267a06 + ssa_ast: 82daba4fefc51c3e851850edd804ac76ced396d25f82c68e808d3953028fa780 + flattened_ast: 14521ee56079b67838d1dd0d9b26e464fc6bfd5e6cc649621c0210a8b2b34ed2 + inlined_ast: 0fd1095d0790c80c3114d8e45b6409f1810eb5b6e05224dbc5843092150e6520 + bytecode: 1887edbf4dd13f3913bebb36b012a4513cb26d8a8570d99bd0ac542f4bdb1c73 + results: + bar: + - input: "[true, true, 1u8, 0u8]" + output: "[1u8, 1u8, {\n a: 1u8,\n b: 0u8,\n c: {\n c: 1u8\n }\n}]" + - input: "[true, false, 1u8, 1u8]" + output: "[1u8, 1u8, {\n a: 1u8,\n b: 1u8,\n c: {\n c: 1u8\n }\n}]" + - input: "[false, true, 2u8, 1u8]" + output: "[3u8, 1u8, {\n a: 2u8,\n b: 1u8,\n c: {\n c: 2u8\n }\n}]" + - input: "[false, false, 2u8, 2u8]" + output: "[2u8, 2u8, {\n a: 2u8,\n b: 2u8,\n c: {\n c: 2u8\n }\n}]" + blar: + - input: "[true, true, 1u8, 0u8]" + output: "[1u8, 1u8, {\n a: 1u8,\n b: 1u8,\n c: {\n c: 1u8\n }\n}]" + - input: "[true, false, 1u8, 1u8]" + output: "[1u8, 1u8, {\n a: 1u8,\n b: 1u8,\n c: {\n c: 1u8\n }\n}]" + - input: "[false, true, 2u8, 1u8]" + output: "[1u8, 1u8, {\n a: 1u8,\n b: 1u8,\n c: {\n c: 1u8\n }\n}]" + - input: "[false, false, 2u8, 2u8]" + output: "[2u8, 2u8, {\n a: 2u8,\n b: 2u8,\n c: {\n c: 2u8\n }\n}]" diff --git a/tests/expectations/parser/finalize/finalize.out b/tests/expectations/parser/finalize/finalize.out index 213ec693c1..d0a2c95628 100644 --- a/tests/expectations/parser/finalize/finalize.out +++ b/tests/expectations/parser/finalize/finalize.out @@ -11,7 +11,7 @@ outputs: functions: main: annotations: [] - call_type: Standard + variant: Standard identifier: "{\"name\":\"main\",\"span\":\"{\\\"lo\\\":123,\\\"hi\\\":127}\"}" input: [] output: diff --git a/tests/expectations/parser/functions/annotated_arg_not_ident_fail.out b/tests/expectations/parser/functions/annotated_arg_not_ident_fail.out index f2c51fd743..e406fe0c57 100644 --- a/tests/expectations/parser/functions/annotated_arg_not_ident_fail.out +++ b/tests/expectations/parser/functions/annotated_arg_not_ident_fail.out @@ -2,4 +2,4 @@ namespace: Parse expectation: Fail outputs: - - "Error [EPAR0370005]: expected 'function', 'transition' -- found '('\n --> test:4:9\n |\n 4 | @foo(?, bar, ?)\n | ^" + - "Error [EPAR0370005]: expected 'function', 'transition', or 'inline' -- found '('\n --> test:4:9\n |\n 4 | @foo(?, bar, ?)\n | ^" diff --git a/tests/expectations/parser/functions/annotated_context.out b/tests/expectations/parser/functions/annotated_context.out index 8812152ee1..65cb34befc 100644 --- a/tests/expectations/parser/functions/annotated_context.out +++ b/tests/expectations/parser/functions/annotated_context.out @@ -15,7 +15,7 @@ outputs: span: lo: 30 hi: 38 - call_type: Standard + variant: Standard identifier: "{\"name\":\"f\",\"span\":\"{\\\"lo\\\":52,\\\"hi\\\":53}\"}" input: [] output: @@ -56,7 +56,7 @@ outputs: span: lo: 99 hi: 107 - call_type: Standard + variant: Standard identifier: "{\"name\":\"g\",\"span\":\"{\\\"lo\\\":141,\\\"hi\\\":142}\"}" input: [] output: diff --git a/tests/expectations/parser/functions/annotated_functions.out b/tests/expectations/parser/functions/annotated_functions.out index 7f3b773f42..70c133b7e8 100644 --- a/tests/expectations/parser/functions/annotated_functions.out +++ b/tests/expectations/parser/functions/annotated_functions.out @@ -15,7 +15,7 @@ outputs: span: lo: 170 hi: 178 - call_type: Standard + variant: Standard identifier: "{\"name\":\"foo\",\"span\":\"{\\\"lo\\\":192,\\\"hi\\\":195}\"}" input: [] output: @@ -39,7 +39,7 @@ outputs: hi: 206 mint: annotations: [] - call_type: Transition + variant: Transition identifier: "{\"name\":\"mint\",\"span\":\"{\\\"lo\\\":101,\\\"hi\\\":105}\"}" input: [] output: @@ -67,7 +67,7 @@ outputs: span: lo: 126 hi: 131 - call_type: Standard + variant: Standard identifier: "{\"name\":\"test\",\"span\":\"{\\\"lo\\\":145,\\\"hi\\\":149}\"}" input: [] output: diff --git a/tests/expectations/parser/functions/bounded_recursion.out b/tests/expectations/parser/functions/bounded_recursion.out index f67ac6d1d0..4c63f1599a 100644 --- a/tests/expectations/parser/functions/bounded_recursion.out +++ b/tests/expectations/parser/functions/bounded_recursion.out @@ -11,7 +11,7 @@ outputs: functions: x: annotations: [] - call_type: Standard + variant: Standard identifier: "{\"name\":\"x\",\"span\":\"{\\\"lo\\\":39,\\\"hi\\\":40}\"}" input: - Internal: @@ -97,7 +97,7 @@ outputs: hi: 126 main: annotations: [] - call_type: Standard + variant: Standard identifier: "{\"name\":\"main\",\"span\":\"{\\\"lo\\\":145,\\\"hi\\\":149}\"}" input: - Internal: diff --git a/tests/expectations/parser/functions/const_input.out b/tests/expectations/parser/functions/const_input.out index 7d84c7e28e..332a085fe7 100644 --- a/tests/expectations/parser/functions/const_input.out +++ b/tests/expectations/parser/functions/const_input.out @@ -11,7 +11,7 @@ outputs: functions: x: annotations: [] - call_type: Standard + variant: Standard identifier: "{\"name\":\"x\",\"span\":\"{\\\"lo\\\":39,\\\"hi\\\":40}\"}" input: - Internal: @@ -43,7 +43,7 @@ outputs: hi: 62 y: annotations: [] - call_type: Standard + variant: Standard identifier: "{\"name\":\"y\",\"span\":\"{\\\"lo\\\":81,\\\"hi\\\":82}\"}" input: - Internal: diff --git a/tests/expectations/parser/functions/const_param.out b/tests/expectations/parser/functions/const_param.out index e39693ff52..682239c72c 100644 --- a/tests/expectations/parser/functions/const_param.out +++ b/tests/expectations/parser/functions/const_param.out @@ -11,7 +11,7 @@ outputs: functions: x: annotations: [] - call_type: Standard + variant: Standard identifier: "{\"name\":\"x\",\"span\":\"{\\\"lo\\\":118,\\\"hi\\\":119}\"}" input: - Internal: diff --git a/tests/expectations/parser/functions/danling_annotations_fail.out b/tests/expectations/parser/functions/danling_annotations_fail.out index 3336b2186c..77bcf9de86 100644 --- a/tests/expectations/parser/functions/danling_annotations_fail.out +++ b/tests/expectations/parser/functions/danling_annotations_fail.out @@ -15,7 +15,7 @@ outputs: span: lo: 110 hi: 115 - call_type: Standard + variant: Standard identifier: "{\"name\":\"test\",\"span\":\"{\\\"lo\\\":134,\\\"hi\\\":138}\"}" input: [] output: diff --git a/tests/expectations/parser/functions/empty2.out b/tests/expectations/parser/functions/empty2.out index b034b2eca4..4f2e131c08 100644 --- a/tests/expectations/parser/functions/empty2.out +++ b/tests/expectations/parser/functions/empty2.out @@ -11,7 +11,7 @@ outputs: functions: x: annotations: [] - call_type: Standard + variant: Standard identifier: "{\"name\":\"x\",\"span\":\"{\\\"lo\\\":39,\\\"hi\\\":40}\"}" input: [] output: diff --git a/tests/expectations/parser/functions/ident_token_fail.out b/tests/expectations/parser/functions/ident_token_fail.out index 9cdcbac4c4..a034d20dc4 100644 --- a/tests/expectations/parser/functions/ident_token_fail.out +++ b/tests/expectations/parser/functions/ident_token_fail.out @@ -2,4 +2,4 @@ namespace: Parse expectation: Fail outputs: - - "Error [EPAR0370005]: expected 'struct', 'record', 'mapping', '@', 'function', 'transition' -- found '1'\n --> test:4:5\n |\n 4 | 1 main() {}}\n | ^" + - "Error [EPAR0370005]: expected 'struct', 'record', 'mapping', '@', 'function', 'transition', 'inline' -- found '1'\n --> test:4:5\n |\n 4 | 1 main() {}}\n | ^" diff --git a/tests/expectations/parser/functions/infinite_recursion.out b/tests/expectations/parser/functions/infinite_recursion.out index 3a1f828dd7..522b18bb24 100644 --- a/tests/expectations/parser/functions/infinite_recursion.out +++ b/tests/expectations/parser/functions/infinite_recursion.out @@ -11,7 +11,7 @@ outputs: functions: "inf": annotations: [] - call_type: Standard + variant: Standard identifier: "{\"name\":\"inf\",\"span\":\"{\\\"lo\\\":39,\\\"hi\\\":42}\"}" input: [] output: @@ -48,7 +48,7 @@ outputs: hi: 73 main: annotations: [] - call_type: Standard + variant: Standard identifier: "{\"name\":\"main\",\"span\":\"{\\\"lo\\\":92,\\\"hi\\\":96}\"}" input: - Internal: diff --git a/tests/expectations/parser/functions/inline_function.out b/tests/expectations/parser/functions/inline_function.out new file mode 100644 index 0000000000..fe8fb63620 --- /dev/null +++ b/tests/expectations/parser/functions/inline_function.out @@ -0,0 +1,67 @@ +--- +namespace: Parse +expectation: Pass +outputs: + - imports: {} + program_scopes: + "{\"name\":\"test\",\"network\":\"\\\"{\\\\\\\"name\\\\\\\":\\\\\\\"aleo\\\\\\\",\\\\\\\"span\\\\\\\":\\\\\\\"{\\\\\\\\\\\\\\\"lo\\\\\\\\\\\\\\\":15,\\\\\\\\\\\\\\\"hi\\\\\\\\\\\\\\\":19}\\\\\\\"}\\\"\"}": + program_id: "{\"name\":\"test\",\"network\":\"\\\"{\\\\\\\"name\\\\\\\":\\\\\\\"aleo\\\\\\\",\\\\\\\"span\\\\\\\":\\\\\\\"{\\\\\\\\\\\\\\\"lo\\\\\\\\\\\\\\\":15,\\\\\\\\\\\\\\\"hi\\\\\\\\\\\\\\\":19}\\\\\\\"}\\\"\"}" + structs: {} + mappings: {} + functions: + foo: + annotations: [] + variant: Inline + identifier: "{\"name\":\"foo\",\"span\":\"{\\\"lo\\\":33,\\\"hi\\\":36}\"}" + input: + - Internal: + identifier: "{\"name\":\"x\",\"span\":\"{\\\"lo\\\":37,\\\"hi\\\":38}\"}" + mode: None + type_: + Integer: U32 + span: + lo: 37 + hi: 38 + - Internal: + identifier: "{\"name\":\"y\",\"span\":\"{\\\"lo\\\":45,\\\"hi\\\":46}\"}" + mode: None + type_: + Integer: I32 + span: + lo: 45 + hi: 46 + output: + - Internal: + mode: None + type_: + Integer: U32 + span: + lo: 56 + hi: 59 + output_type: + Integer: U32 + block: + statements: + - Return: + expression: + Literal: + Integer: + - U32 + - "0" + - span: + lo: 77 + hi: 81 + finalize_arguments: ~ + span: + lo: 70 + hi: 82 + span: + lo: 60 + hi: 88 + finalize: ~ + span: + lo: 26 + hi: 88 + span: + lo: 2 + hi: 90 diff --git a/tests/expectations/parser/functions/params.out b/tests/expectations/parser/functions/params.out index e54af22638..4b66764727 100644 --- a/tests/expectations/parser/functions/params.out +++ b/tests/expectations/parser/functions/params.out @@ -11,7 +11,7 @@ outputs: functions: x: annotations: [] - call_type: Standard + variant: Standard identifier: "{\"name\":\"x\",\"span\":\"{\\\"lo\\\":39,\\\"hi\\\":40}\"}" input: - Internal: diff --git a/tests/expectations/parser/functions/params_return.out b/tests/expectations/parser/functions/params_return.out index df716ecee8..64db40d337 100644 --- a/tests/expectations/parser/functions/params_return.out +++ b/tests/expectations/parser/functions/params_return.out @@ -11,7 +11,7 @@ outputs: functions: x: annotations: [] - call_type: Standard + variant: Standard identifier: "{\"name\":\"x\",\"span\":\"{\\\"lo\\\":39,\\\"hi\\\":40}\"}" input: - Internal: diff --git a/tests/expectations/parser/functions/public_param.out b/tests/expectations/parser/functions/public_param.out index 1fcd4ad4bb..63bfab39b0 100644 --- a/tests/expectations/parser/functions/public_param.out +++ b/tests/expectations/parser/functions/public_param.out @@ -11,7 +11,7 @@ outputs: functions: x: annotations: [] - call_type: Standard + variant: Standard identifier: "{\"name\":\"x\",\"span\":\"{\\\"lo\\\":116,\\\"hi\\\":117}\"}" input: - Internal: diff --git a/tests/expectations/parser/functions/return.out b/tests/expectations/parser/functions/return.out index c1527a77aa..efcc95a596 100644 --- a/tests/expectations/parser/functions/return.out +++ b/tests/expectations/parser/functions/return.out @@ -11,7 +11,7 @@ outputs: functions: x: annotations: [] - call_type: Standard + variant: Standard identifier: "{\"name\":\"x\",\"span\":\"{\\\"lo\\\":39,\\\"hi\\\":40}\"}" input: [] output: diff --git a/tests/expectations/parser/functions/test_keyword_fail.out b/tests/expectations/parser/functions/test_keyword_fail.out index 0f84dd4df6..b4e98eef56 100644 --- a/tests/expectations/parser/functions/test_keyword_fail.out +++ b/tests/expectations/parser/functions/test_keyword_fail.out @@ -2,4 +2,4 @@ namespace: Parse expectation: Fail outputs: - - "Error [EPAR0370005]: expected 'struct', 'record', 'mapping', '@', 'function', 'transition' -- found 'test'\n --> test:4:5\n |\n 4 | test main() {}}\n | ^^^^" + - "Error [EPAR0370005]: expected 'struct', 'record', 'mapping', '@', 'function', 'transition', 'inline' -- found 'test'\n --> test:4:5\n |\n 4 | test main() {}}\n | ^^^^" diff --git a/tests/expectations/parser/functions/transition_function.out b/tests/expectations/parser/functions/transition_function.out new file mode 100644 index 0000000000..e1b85812a1 --- /dev/null +++ b/tests/expectations/parser/functions/transition_function.out @@ -0,0 +1,67 @@ +--- +namespace: Parse +expectation: Pass +outputs: + - imports: {} + program_scopes: + "{\"name\":\"test\",\"network\":\"\\\"{\\\\\\\"name\\\\\\\":\\\\\\\"aleo\\\\\\\",\\\\\\\"span\\\\\\\":\\\\\\\"{\\\\\\\\\\\\\\\"lo\\\\\\\\\\\\\\\":15,\\\\\\\\\\\\\\\"hi\\\\\\\\\\\\\\\":19}\\\\\\\"}\\\"\"}": + program_id: "{\"name\":\"test\",\"network\":\"\\\"{\\\\\\\"name\\\\\\\":\\\\\\\"aleo\\\\\\\",\\\\\\\"span\\\\\\\":\\\\\\\"{\\\\\\\\\\\\\\\"lo\\\\\\\\\\\\\\\":15,\\\\\\\\\\\\\\\"hi\\\\\\\\\\\\\\\":19}\\\\\\\"}\\\"\"}" + structs: {} + mappings: {} + functions: + foo: + annotations: [] + variant: Transition + identifier: "{\"name\":\"foo\",\"span\":\"{\\\"lo\\\":37,\\\"hi\\\":40}\"}" + input: + - Internal: + identifier: "{\"name\":\"x\",\"span\":\"{\\\"lo\\\":41,\\\"hi\\\":42}\"}" + mode: None + type_: + Integer: U32 + span: + lo: 41 + hi: 42 + - Internal: + identifier: "{\"name\":\"y\",\"span\":\"{\\\"lo\\\":49,\\\"hi\\\":50}\"}" + mode: None + type_: + Integer: I32 + span: + lo: 49 + hi: 50 + output: + - Internal: + mode: None + type_: + Integer: U32 + span: + lo: 60 + hi: 63 + output_type: + Integer: U32 + block: + statements: + - Return: + expression: + Literal: + Integer: + - U32 + - "0" + - span: + lo: 81 + hi: 85 + finalize_arguments: ~ + span: + lo: 74 + hi: 86 + span: + lo: 64 + hi: 92 + finalize: ~ + span: + lo: 26 + hi: 92 + span: + lo: 2 + hi: 94 diff --git a/tests/expectations/parser/program/mapping_fail.out b/tests/expectations/parser/program/mapping_fail.out index c5baba5e44..233b09e314 100644 --- a/tests/expectations/parser/program/mapping_fail.out +++ b/tests/expectations/parser/program/mapping_fail.out @@ -2,4 +2,4 @@ namespace: Parse expectation: Fail outputs: - - "Error [EPAR0370005]: expected 'struct', 'record', 'mapping', '@', 'function', 'transition' -- found 'mappin'\n --> test:4:5\n |\n 4 | mappin balances: address => u128;\n | ^^^^^^" + - "Error [EPAR0370005]: expected 'struct', 'record', 'mapping', '@', 'function', 'transition', 'inline' -- found 'mappin'\n --> test:4:5\n |\n 4 | mappin balances: address => u128;\n | ^^^^^^" diff --git a/tests/expectations/parser/serialize/one_plus_one.out b/tests/expectations/parser/serialize/one_plus_one.out index 8e326b3c53..6d3555361d 100644 --- a/tests/expectations/parser/serialize/one_plus_one.out +++ b/tests/expectations/parser/serialize/one_plus_one.out @@ -11,7 +11,7 @@ outputs: functions: main: annotations: [] - call_type: Standard + variant: Standard identifier: "{\"name\":\"main\",\"span\":\"{\\\"lo\\\":35,\\\"hi\\\":39}\"}" input: [] output: diff --git a/tests/test-framework/benches/leo_compiler.rs b/tests/test-framework/benches/leo_compiler.rs index dc5634f46a..0dc20f5c47 100644 --- a/tests/test-framework/benches/leo_compiler.rs +++ b/tests/test-framework/benches/leo_compiler.rs @@ -41,6 +41,8 @@ enum BenchMode { Ssa, /// Benchmarks flattening. Flatten, + /// Benchmarks function inlining. + Inline, // TODO: Benchmark code generation /// Benchmarks all the above stages. Full, @@ -107,6 +109,7 @@ impl Sample { BenchMode::Unroll => self.bench_loop_unroller(c), BenchMode::Ssa => self.bench_ssa(c), BenchMode::Flatten => self.bench_flattener(c), + BenchMode::Inline => self.bench_inline(c), BenchMode::Full => self.bench_full(c), } } @@ -219,15 +222,10 @@ impl Sample { }); } - fn bench_full(&self, c: &mut Criterion) { - self.bencher(c, "full", |mut compiler| { - let (input, name) = self.data(); - let start = Instant::now(); - compiler - .parse_program_from_string(input, name) - .expect("Failed to parse program"); + fn bench_inline(&self, c: &mut Criterion) { + self.bencher_after_parse(c, "inliner pass", |mut compiler| { let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); - let (symbol_table, _struct_graph, _call_graph) = compiler + let (symbol_table, _struct_graph, call_graph) = compiler .type_checker_pass(symbol_table) .expect("failed to run type check pass"); let symbol_table = compiler @@ -236,9 +234,40 @@ impl Sample { let assigner = compiler .static_single_assignment_pass(&symbol_table) .expect("failed to run ssa pass"); + let assigner = compiler + .flattening_pass(&symbol_table, assigner) + .expect("failed to run flattener pass"); + let start = Instant::now(); + let out = compiler.function_inlining_pass(&call_graph, assigner); + let time = start.elapsed(); + out.expect("failed to run inliner pass"); + time + }); + } + + fn bench_full(&self, c: &mut Criterion) { + self.bencher(c, "full", |mut compiler| { + let (input, name) = self.data(); + let start = Instant::now(); compiler + .parse_program_from_string(input, name) + .expect("Failed to parse program"); + let symbol_table = compiler.symbol_table_pass().expect("failed to generate symbol table"); + let (symbol_table, _struct_graph, call_graph) = compiler + .type_checker_pass(symbol_table) + .expect("failed to run type check pass"); + let symbol_table = compiler + .loop_unrolling_pass(symbol_table) + .expect("failed to run loop unrolling pass"); + let assigner = compiler + .static_single_assignment_pass(&symbol_table) + .expect("failed to run ssa pass"); + let assigner = compiler .flattening_pass(&symbol_table, assigner) .expect("failed to run flattening pass"); + compiler + .function_inlining_pass(&call_graph, assigner) + .expect("failed to run function inlining pass"); start.elapsed() }) } @@ -258,6 +287,7 @@ bench!(bench_type, BenchMode::Type); bench!(bench_unroll, BenchMode::Unroll); bench!(bench_ssa, BenchMode::Ssa); bench!(bench_flatten, BenchMode::Flatten); +bench!(bench_inline, BenchMode::Inline); bench!(bench_full, BenchMode::Full); criterion_group!( @@ -270,6 +300,7 @@ criterion_group!( bench_unroll, bench_ssa, bench_flatten, + bench_inline, bench_full ); criterion_main!(benches); diff --git a/tests/tests/compiler/finalize/increment_decrement_in_inline_fail.leo b/tests/tests/compiler/finalize/increment_decrement_in_inline_fail.leo new file mode 100644 index 0000000000..e946544348 --- /dev/null +++ b/tests/tests/compiler/finalize/increment_decrement_in_inline_fail.leo @@ -0,0 +1,24 @@ +/* +namespace: Compile +expectation: Fail +*/ + +program test.aleo { + mapping account: address => u64; + mapping values: u8 => u8; + + inline foo() { + increment(values, 0u8, 1u8); + increment(account, self.caller, 1u64); + } + + inline bar() { + decrement(values, 0u8, 1u8); + decrement(account, self.caller, 1u64); + } + + finalize finalize_no_params() { + foo(); + bar(); + } +} diff --git a/tests/tests/compiler/finalize/inline_in_finalize.leo b/tests/tests/compiler/finalize/inline_in_finalize.leo new file mode 100644 index 0000000000..51f841447b --- /dev/null +++ b/tests/tests/compiler/finalize/inline_in_finalize.leo @@ -0,0 +1,18 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + + inline foo(a: u8, b: u8) -> u8 { + return a + b; + } + + transition public_adder(public a: u8, public b: u8) { + return then finalize(a, b); + } finalize public_adder(a: u8, b: u8) -> public u8 { + return foo(a, b); + } + +} diff --git a/tests/tests/compiler/function/flatten_inlined_tuples_of_structs.leo b/tests/tests/compiler/function/flatten_inlined_tuples_of_structs.leo new file mode 100644 index 0000000000..0994490a73 --- /dev/null +++ b/tests/tests/compiler/function/flatten_inlined_tuples_of_structs.leo @@ -0,0 +1,44 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + struct Extra { + c: u8, + } + + struct Data { + a: u8, + b: u8, + c: Extra, + } + + inline foo(a: u8, b: u8) -> (u8, u8, Data) { + let extra: Extra = Extra { c: a }; + let data: Data = Data { a: a, b: b, c: extra }; + if (a == b) { + return (a, b, data); + } + let c: u8 = a + b; + let d: u8 = a - b; + + return (c, d, data); + } + + transition bar(flag1: bool, flag2: bool, a: u8, b: u8) -> (u8, u8, Data) { + let start: (u8, u8, Data) = foo(a, b); + if flag1 { + start = foo(start.0, start.2.c.c); + } else { + + if flag2 { + start = foo(start.1, start.2.b); + } else { + start = foo(start.2.a, start.1); + } + + } + return start; + } +} diff --git a/tests/tests/compiler/function/function_call_inline.leo b/tests/tests/compiler/function/function_call_inline.leo new file mode 100644 index 0000000000..35a11863b4 --- /dev/null +++ b/tests/tests/compiler/function/function_call_inline.leo @@ -0,0 +1,27 @@ +/* +namespace: Compile +expectation: Pass +*/ + +program test.aleo { + transition main(a: u32, b: u32, y: bool) -> u32 { + check_not_eq(a, b); + if y { + return adder(a, b); + } else { + return subber(a, b); + } + } + + inline check_not_eq(a: u32, b: u32) { + assert(a != b); + } + + inline adder(a: u32, b: u32) -> u32 { + return a + b; + } + + inline subber(a: u32, b: u32) -> u32 { + return a - b; + } +} diff --git a/tests/tests/execution/flattened_function_and_inline_matches.leo b/tests/tests/execution/flattened_function_and_inline_matches.leo new file mode 100644 index 0000000000..1713215422 --- /dev/null +++ b/tests/tests/execution/flattened_function_and_inline_matches.leo @@ -0,0 +1,82 @@ +/* +namespace: Execute +expectation: Pass +cases: + bar: + - input: ["true", "true", "1u8", "0u8"] + - input: ["true", "false", "1u8", "1u8"] + - input: ["false", "true", "2u8", "1u8"] + - input: ["false", "false", "2u8", "2u8"] + blar: + - input: ["true", "true", "1u8", "0u8"] + - input: ["true", "false", "1u8", "1u8"] + - input: ["false", "true", "2u8", "1u8"] + - input: ["false", "false", "2u8", "2u8"] +*/ + +// In this test, we expect bar and blar to produce the same result for all inputs. + +program test.aleo { + struct Extra { + c: u8, + } + + struct Data { + a: u8, + b: u8, + c: Extra, + } + + inline foo(a: u8, b: u8) -> (u8, u8, Data) { + let extra: Extra = Extra { c: a }; + let data: Data = Data { a: a, b: b, c: extra }; + if (a == b) { + return (a, b, data); + } + let c: u8 = a + b; + let d: u8 = a - b; + + return (c, d, data); + } + + function floo(a: u8, b: u8) -> (u8, u8, Data) { + let extra: Extra = Extra { c: a }; + let data: Data = Data { a: a, b: b, c: extra }; + if (a == b) { + return (a, b, data); + } + let c: u8 = a + b; + let d: u8 = a - b; + + return (c, d, data); + } + + transition bar(flag1: bool, flag2: bool, a: u8, b: u8) -> (u8, u8, Data) { + let start: (u8, u8, Data) = foo(a, b); + if flag1 { + start = foo(start.0, start.2.c.c); + } else { + if flag2 { + start = foo(start.1, start.2.b); + } else { + start = foo(start.2.a, start.1); + } + } + return start; + } + + transition blar(flag1: bool, flag2: bool, a: u8, b: u8) -> (u8, u8, Data) { + let start: (u8, u8, Data) = floo(a, b); + if flag1 { + start = floo(start.0, start.2.c.c); + } else { + if flag2 { + start = floo(start.1, start.2.b); + } else { + start = floo(start.2.a, start.1); + } + } + return start; + } + +} diff --git a/tests/tests/parser/functions/inline_function.leo b/tests/tests/parser/functions/inline_function.leo new file mode 100644 index 0000000000..d9380ef118 --- /dev/null +++ b/tests/tests/parser/functions/inline_function.leo @@ -0,0 +1,10 @@ +/* +namespace: Parse +expectation: Pass +*/ + +program test.aleo { + inline foo(x: u32, y: i32) -> u32 { + return 0u32; + } +} diff --git a/tests/tests/parser/functions/transition_function.leo b/tests/tests/parser/functions/transition_function.leo new file mode 100644 index 0000000000..b54eae1801 --- /dev/null +++ b/tests/tests/parser/functions/transition_function.leo @@ -0,0 +1,10 @@ +/* +namespace: Parse +expectation: Pass +*/ + +program test.aleo { + transition foo(x: u32, y: i32) -> u32 { + return 0u32; + } +}