ProvableHQ/leo
1
1
Fork 0
mirror of https://github.com/ProvableHQ/leo.git synced 2024-11-23 23:23:50 +03:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #1911 from AleoHQ/feat/redesign-symbol-table

Browse Source 
Redesign SymbolTable
This commit is contained in:
d0cd 2022-07-08 12:10:48 -07:00 committed by GitHub
commit 9b9db978ef
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
340 changed files with 369 additions and 632 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

13
build.rs
View File

@ -43,16 +43,17 @@ fn compare_license_text(path: &Path, expected_lines: &[&str]) {
let reader = BufReader::new(file);
for (i, (file_line, expected_line)) in reader.lines().zip(expected_lines).enumerate() {
let file_line = file_line.expect(&format!("Can't read line {} in file \"{}\"!", i + 1, path.display()));
assert!(
&file_line == expected_line,
let file_line =
file_line.unwrap_or_else(|_| panic!("Can't read line {} in file \"{}\"!", i + 1, path.display()));
assert_eq!(
&file_line,
expected_line,
"Line {} in file \"{}\" was expected to contain the license text \"{}\", but contains \"{}\" instead! \
Consult the expected license text in \".resources/license_header\"",
i + 1,
path.display(),
expected_line,
file_line,
file_line
);
}
}
@ -75,7 +76,7 @@ fn check_file_licenses<P: AsRef<Path>>(path: P) {
// Check all files with the ".rs" extension.
if entry_type.is_file() && entry.file_name().to_str().unwrap_or("").ends_with(".rs") {
compare_license_text(&entry.path(), &license_lines);
compare_license_text(entry.path(), &license_lines);
}
}

14
compiler/compiler/src/compiler.rs
View File

@ -146,30 +146,30 @@ impl<'a> Compiler<'a> {
///
/// Runs the symbol table pass.
///
pub fn symbol_table_pass(&self) -> Result<SymbolTable<'_>> {
pub fn symbol_table_pass(&self) -> Result<SymbolTable> {
CreateSymbolTable::do_pass((&self.ast, self.handler))
}
///
/// Runs the type checker pass.
///
pub fn type_checker_pass(&'a self, symbol_table: &mut SymbolTable<'_>) -> Result<()> {
TypeChecker::do_pass((&self.ast, &mut symbol_table.clone(), self.handler))
pub fn type_checker_pass(&'a self, symbol_table: SymbolTable) -> Result<SymbolTable> {
TypeChecker::do_pass((&self.ast, self.handler, symbol_table))
}
///
/// Runs the compiler stages.
///
pub fn compiler_stages(&self) -> Result<SymbolTable<'_>> {
let mut st = self.symbol_table_pass()?;
self.type_checker_pass(&mut st)?;
pub fn compiler_stages(&self) -> Result<SymbolTable> {
let st = self.symbol_table_pass()?;
let st = self.type_checker_pass(st)?;
Ok(st)
}
///
/// Returns a compiled Leo program.
///
pub fn compile(&mut self) -> Result<SymbolTable<'_>> {
pub fn compile(&mut self) -> Result<SymbolTable> {
self.parse_program()?;
self.compiler_stages()
}

12
compiler/compiler/src/test.rs
View File

@ -102,7 +102,6 @@ struct OutputItem {
struct CompileOutput {
pub output: Vec<OutputItem>,
pub initial_ast: String,
pub symbol_table: String,
}
/// Get the path of the `input_file` given in `input` into `list`.
@ -132,9 +131,9 @@ fn collect_all_inputs(test: &Test) -> Result<Vec<PathBuf>, String> {
Ok(list)
}
fn compile_and_process<'a>(parsed: &'a mut Compiler<'a>) -> Result<SymbolTable<'_>, LeoError> {
let mut st = parsed.symbol_table_pass()?;
parsed.type_checker_pass(&mut st)?;
fn compile_and_process<'a>(parsed: &'a mut Compiler<'a>) -> Result<SymbolTable, LeoError> {
let st = parsed.symbol_table_pass()?;
let st = parsed.type_checker_pass(st)?;
Ok(st)
}
@ -198,6 +197,7 @@ fn run_test(test: Test, handler: &Handler, err_buf: &BufferEmitter) -> Result<Va
let mut output_items = Vec::with_capacity(inputs.len());
if inputs.is_empty() {
handler.extend_if_error(compile_and_process(&mut parsed))?;
output_items.push(OutputItem {
initial_input_ast: "no input".to_string(),
});
@ -205,14 +205,13 @@ fn run_test(test: Test, handler: &Handler, err_buf: &BufferEmitter) -> Result<Va
for input in inputs {
let mut parsed = parsed.clone();
handler.extend_if_error(parsed.parse_input(input))?;
handler.extend_if_error(compile_and_process(&mut parsed))?;
let initial_input_ast = hash_file("/tmp/output/initial_input_ast.json");
output_items.push(OutputItem { initial_input_ast });
}
}
let symbol_table = handler.extend_if_error(compile_and_process(&mut parsed))?;
let initial_ast = hash_file("/tmp/output/initial_ast.json");
if fs::read_dir("/tmp/output").is_ok() {
@ -222,7 +221,6 @@ fn run_test(test: Test, handler: &Handler, err_buf: &BufferEmitter) -> Result<Va
let final_output = CompileOutput {
output: output_items,
initial_ast,
symbol_table: hash_content(&symbol_table.to_string()),
};
Ok(serde_yaml::to_value(&final_output).expect("serialization failed"))
}

3
compiler/passes/src/pass.rs
View File

@ -14,10 +14,11 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
/// A pass consuming a `Program` and possibly returning an `Ast`.
/// A compiler pass consuming `Self::Input` and returning `Self::Output`.
pub trait Pass {
type Input;
type Output;
/// Runs the compiler pass.
fn do_pass(input: Self::Input) -> Self::Output;
}

12
compiler/passes/src/symbol_table/create.rs
View File

@ -19,21 +19,23 @@ use leo_errors::emitter::Handler;
use crate::SymbolTable;
/// A compiler pass during which the `SymbolTable` is created.
/// Note that this pass only creates the initial entries for functions and circuits.
/// The table is populated further during the type checking pass.
pub struct CreateSymbolTable<'a> {
symbol_table: SymbolTable<'a>,
/// The `SymbolTable` constructed by this compiler pass.
pub(crate) symbol_table: SymbolTable,
/// The error handler.
handler: &'a Handler,
}
impl<'a> CreateSymbolTable<'a> {
pub fn new(handler: &'a Handler) -> Self {
Self {
symbol_table: SymbolTable::default(),
symbol_table: Default::default(),
handler,
}
}
pub fn symbol_table(self) -> SymbolTable<'a> {
self.symbol_table
}
}
impl<'a> ExpressionVisitor<'a> for CreateSymbolTable<'a> {

44
compiler/passes/src/symbol_table/function_symbol.rs Normal file
View File

@ -0,0 +1,44 @@
// Copyright (C) 2019-2022 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use leo_ast::{Function, FunctionInput, Type};
use leo_span::Span;
use crate::SymbolTable;
/// An entry for a function in the symbol table.
#[derive(Clone, Debug)]
pub struct FunctionSymbol {
/// The index associated with the scope in the parent symbol table.
pub(crate) id: usize,
/// The output type of the function.
pub(crate) output: Type,
/// The `Span` associated with the function.
pub(crate) span: Span,
/// The inputs to the function.
pub(crate) input: Vec<FunctionInput>,
}
impl SymbolTable {
pub(crate) fn new_function_symbol(id: usize, func: &Function) -> FunctionSymbol {
FunctionSymbol {
id,
output: func.output,
span: func.span,
input: func.input.clone(),
}
}
}

11
compiler/passes/src/symbol_table/mod.rs
View File

@ -17,12 +17,12 @@
pub mod create;
pub use create::*;
pub mod function_symbol;
pub use function_symbol::*;
pub mod table;
pub use table::*;
pub mod variable_scope;
pub use variable_scope::*;
pub mod variable_symbol;
pub use variable_symbol::*;
@ -33,13 +33,14 @@ use leo_errors::{emitter::Handler, Result};
impl<'a> Pass for CreateSymbolTable<'a> {
type Input = (&'a Ast, &'a Handler);
type Output = Result<SymbolTable<'a>>;
type Output = Result<SymbolTable>;
/// Runs the compiler pass.
fn do_pass((ast, handler): Self::Input) -> Self::Output {
let mut visitor = CreateSymbolTable::new(handler);
visitor.visit_program(ast.as_repr());
handler.last_err()?;
Ok(visitor.symbol_table())
Ok(visitor.symbol_table)
}
}

198
compiler/passes/src/symbol_table/table.rs
View File

@ -14,7 +14,7 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use std::fmt::Display;
use std::cell::RefCell;
use leo_ast::{Circuit, Function};
use leo_errors::{AstError, Result};
@ -22,100 +22,160 @@ use leo_span::{Span, Symbol};
use indexmap::IndexMap;
use crate::{VariableScope, VariableSymbol};
use crate::{FunctionSymbol, VariableSymbol};
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct SymbolTable<'a> {
/// Maps function names to function definitions.
#[derive(Clone, Debug, Default)]
pub struct SymbolTable {
/// The parent scope if it exists.
/// For example if we are in a if block inside a function.
pub(crate) parent: Option<Box<SymbolTable>>,
/// Functions represents the name of each function mapped to the AST's function definition.
/// This field is populated at a first pass.
functions: IndexMap<Symbol, &'a Function>,
pub functions: IndexMap<Symbol, FunctionSymbol>,
/// Maps circuit names to circuit definitions.
/// This field is populated at a first pass.
circuits: IndexMap<Symbol, &'a Circuit>,
/// Variables represents functions variable definitions and input variables.
/// This field is not populated till necessary.
pub(crate) variables: VariableScope<'a>,
pub circuits: IndexMap<Symbol, Circuit>,
/// The variables defined in a scope.
/// This field is populated as necessary.
pub(crate) variables: IndexMap<Symbol, VariableSymbol>,
/// The index of the current scope.
pub(crate) scope_index: usize,
/// The sub-scopes of this scope.
pub(crate) scopes: Vec<RefCell<SymbolTable>>,
}
impl<'a> SymbolTable<'a> {
impl SymbolTable {
/// Recursively checks if the symbol table contains an entry for the given symbol.
/// Leo does not allow any variable shadowing or overlap between different symbols.
pub fn check_shadowing(&self, symbol: Symbol, span: Span) -> Result<()> {
if self.functions.contains_key(&symbol) {
if self.variables.contains_key(&symbol) {
Err(AstError::shadowed_variable(symbol, span).into())
} else if self.functions.contains_key(&symbol) {
Err(AstError::shadowed_function(symbol, span).into())
} else if let Some(existing) = self.circuits.get(&symbol) {
match existing.is_record {
true => Err(AstError::shadowed_record(symbol, span).into()),
false => Err(AstError::shadowed_circuit(symbol, span).into()),
}
} else if let Some(parent) = self.parent.as_ref() {
parent.check_shadowing(symbol, span)
} else {
self.variables.check_shadowing(symbol, span)?;
Ok(())
}
}
pub fn clear_variables(&mut self) {
self.variables.clear();
/// Returns the current scope index.
/// Increments the scope index.
pub fn scope_index(&mut self) -> usize {
let index = self.scope_index;
self.scope_index += 1;
index
}
pub fn insert_fn(&mut self, symbol: Symbol, insert: &'a Function) -> Result<()> {
/// Inserts a function into the symbol table.
pub fn insert_fn(&mut self, symbol: Symbol, insert: &Function) -> Result<()> {
self.check_shadowing(symbol, insert.span)?;
self.functions.insert(symbol, insert);
let id = self.scope_index();
self.functions.insert(symbol, Self::new_function_symbol(id, insert));
self.scopes.push(Default::default());
Ok(())
}
pub fn insert_circuit(&mut self, symbol: Symbol, insert: &'a Circuit) -> Result<()> {
if let Some(existing) = self.circuits.get(&symbol) {
// Error if the circuit or record already exists.
let err = if existing.is_record {
AstError::shadowed_record(symbol, insert.span).into()
/// Inserts a circuit into the symbol table.
pub fn insert_circuit(&mut self, symbol: Symbol, insert: &Circuit) -> Result<()> {
self.check_shadowing(symbol, insert.span)?;
self.circuits.insert(symbol, insert.clone());
Ok(())
}
/// Inserts a variable into the symbol table.
pub fn insert_variable(&mut self, symbol: Symbol, insert: VariableSymbol) -> Result<()> {
self.check_shadowing(symbol, insert.span)?;
self.variables.insert(symbol, insert);
Ok(())
}
/// Creates a new scope for the block and stores it in the symbol table.
pub fn insert_block(&mut self) -> usize {
self.scopes.push(RefCell::new(Default::default()));
self.scope_index()
}
/// Attempts to lookup a function in the symbol table.
pub fn lookup_fn(&self, symbol: &Symbol) -> Option<&FunctionSymbol> {
if let Some(func) = self.functions.get(symbol) {
Some(func)
} else if let Some(parent) = self.parent.as_ref() {
parent.lookup_fn(symbol)
} else {
None
}
}
/// Attempts to lookup a circuit in the symbol table.
pub fn lookup_circuit(&self, symbol: &Symbol) -> Option<&Circuit> {
if let Some(circ) = self.circuits.get(symbol) {
Some(circ)
} else if let Some(parent) = self.parent.as_ref() {
parent.lookup_circuit(symbol)
} else {
None
}
}
/// Attempts to lookup a variable in the symbol table.
pub fn lookup_variable(&self, symbol: &Symbol) -> Option<&VariableSymbol> {
if let Some(var) = self.variables.get(symbol) {
Some(var)
} else if let Some(parent) = self.parent.as_ref() {
parent.lookup_variable(symbol)
} else {
None
}
}
/// Returns true if the variable exists in the local scope
pub fn variable_in_local_scope(&self, symbol: &Symbol) -> bool {
self.variables.contains_key(symbol)
}
/// Returns true if the variable exists in any parent scope
pub fn variable_in_parent_scope(&self, symbol: &Symbol) -> bool {
if let Some(parent) = self.parent.as_ref() {
if parent.variables.contains_key(symbol) {
true
} else {
AstError::shadowed_circuit(symbol, insert.span).into()
};
return Err(err);
parent.variable_in_parent_scope(symbol)
}
} else {
false
}
self.circuits.insert(symbol, insert);
Ok(())
}
pub fn insert_variable(&mut self, symbol: Symbol, insert: VariableSymbol<'a>) -> Result<()> {
self.check_shadowing(symbol, insert.span)?;
self.variables.variables.insert(symbol, insert);
Ok(())
/// Returns a mutable reference to the `VariableSymbol` if it exists in the symbol table.
pub fn lookup_variable_mut(&mut self, symbol: &Symbol) -> Option<&mut VariableSymbol> {
if let Some(var) = self.variables.get_mut(symbol) {
Some(var)
} else if let Some(parent) = self.parent.as_mut() {
parent.lookup_variable_mut(symbol)
} else {
None
}
}
pub fn lookup_fn(&self, symbol: Symbol) -> Option<&&'a Function> {
self.functions.get(&symbol)
/// Returns the scope associated with the function symbol, if it exists in the symbol table.
pub fn get_fn_scope(&self, symbol: &Symbol) -> Option<&RefCell<Self>> {
if let Some(func) = self.functions.get(symbol) {
self.scopes.get(func.id)
} else if let Some(parent) = self.parent.as_ref() {
parent.get_fn_scope(symbol)
} else {
None
}
}
pub fn lookup_circuit(&self, symbol: &Symbol) -> Option<&&'a Circuit> {
self.circuits.get(symbol)
}
pub fn lookup_variable(&self, symbol: &Symbol) -> Option<&VariableSymbol<'a>> {
self.variables.lookup_variable(symbol)
}
pub fn push_variable_scope(&mut self) {
let current_scope = self.variables.clone();
self.variables = VariableScope {
parent: Some(Box::new(current_scope)),
variables: Default::default(),
};
}
pub fn pop_variable_scope(&mut self) {
let parent = self.variables.parent.clone().unwrap();
self.variables = *parent;
}
}
impl Display for SymbolTable<'_> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "SymbolTable")?;
for func in self.functions.values() {
write!(f, "{func}")?;
}
for circ in self.circuits.values() {
write!(f, "{circ}")?;
}
write!(f, "{}", self.variables)
/// Returns the scope associated with `index`, if it exists in the symbol table.
pub fn get_block_scope(&self, index: usize) -> Option<&RefCell<Self>> {
self.scopes.get(index)
}
}

78
compiler/passes/src/symbol_table/variable_scope.rs
View File

@ -1,78 +0,0 @@
// Copyright (C) 2019-2022 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use std::fmt::Display;
use indexmap::IndexMap;
use leo_errors::{AstError, Result};
use leo_span::{Span, Symbol};
use crate::VariableSymbol;
#[derive(Clone, Debug, Default, Eq, PartialEq)]
pub struct VariableScope<'a> {
/// The parent scope of variables if it exists.
/// For example if we are in a if block inside a function.
/// The parent would be the functions variables and inputs.
/// This field is populated as necessary.
pub(crate) parent: Option<Box<VariableScope<'a>>>,
/// The variables defined in a scope.
/// This field is populated as necessary.
pub(crate) variables: IndexMap<Symbol, VariableSymbol<'a>>,
}
impl<'a> VariableScope<'a> {
pub fn check_shadowing(&self, symbol: Symbol, span: Span) -> Result<()> {
if self.variables.contains_key(&symbol) {
Err(AstError::shadowed_variable(symbol, span).into())
} else if let Some(parent) = &self.parent {
parent.check_shadowing(symbol, span)
} else {
Ok(())
}
}
pub fn clear(&mut self) {
self.parent = None;
self.variables.clear();
}
pub fn lookup_variable(&self, symbol: &Symbol) -> Option<&VariableSymbol<'a>> {
if let Some(var) = self.variables.get(symbol) {
Some(var)
} else if let Some(parent) = &self.parent {
parent.lookup_variable(symbol)
} else {
None
}
}
}
impl<'a> Display for VariableScope<'a> {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "VariableScope")?;
self.parent
.as_ref()
.map(|parent| write!(f, "parent {parent}"))
.transpose()?;
for (sym, var) in self.variables.iter() {
write!(f, "{sym} {var}")?;
}
Ok(())
}
}

11
compiler/passes/src/symbol_table/variable_symbol.rs
View File

@ -19,6 +19,7 @@ use std::fmt::Display;
use leo_ast::{ParamMode, Type};
use leo_span::Span;
/// An enumeration of the different types of declarations.
#[derive(Clone, Debug, Eq, PartialEq)]
pub enum Declaration {
Const,
@ -38,14 +39,18 @@ impl Display for Declaration {
}
}
/// An entry for a variable in the symbol table.
#[derive(Clone, Debug, Eq, PartialEq)]
pub struct VariableSymbol<'a> {
pub type_: &'a Type,
pub struct VariableSymbol {
/// The `Type` of the variable.
pub type_: Type,
/// The `Span` associated with the variable.
pub span: Span,
/// The type of declaration for the variable.
pub declaration: Declaration,
}
impl<'a> Display for VariableSymbol<'a> {
impl Display for VariableSymbol {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
write!(f, "{}: {}", self.declaration, self.type_)?;
Ok(())

188
compiler/passes/src/type_checker/check_expressions.rs
View File

@ -55,11 +55,99 @@ impl<'a> ExpressionVisitor<'a> for TypeChecker<'a> {
}
}
fn visit_access(&mut self, input: &'a AccessExpression, expected: &Self::AdditionalInput) -> Self::Output {
// CAUTION: This implementation only allows access to core circuits.
match input {
AccessExpression::AssociatedFunction(access) => {
// Check core circuit name and function.
if let Some(core_instruction) = self.check_core_circuit_call(&access.ty, &access.name) {
// Check num input arguments.
if core_instruction.num_args() != access.args.len() {
self.handler.emit_err(
TypeCheckerError::incorrect_num_args_to_call(
core_instruction.num_args(),
access.args.len(),
input.span(),
)
.into(),
);
}
// Check first argument type.
if let Some(first_arg) = access.args.get(0usize) {
let first_arg_type = self.visit_expression(first_arg, &None);
self.assert_one_of_types(&first_arg_type, core_instruction.first_arg_types(), access.span());
}
// Check second argument type.
if let Some(second_arg) = access.args.get(1usize) {
let second_arg_type = self.visit_expression(second_arg, &None);
self.assert_one_of_types(&second_arg_type, core_instruction.second_arg_types(), access.span());
}
// Check return type.
Some(self.assert_and_return_type(core_instruction.return_type(), expected, access.span()))
} else {
self.handler
.emit_err(TypeCheckerError::invalid_access_expression(access, access.span()).into());
None
}
}
_expr => None, // todo: Add support for associated constants (u8::MAX).
}
}
fn visit_circuit_init(
&mut self,
input: &'a CircuitInitExpression,
additional: &Self::AdditionalInput,
) -> Self::Output {
let circ = self.symbol_table.borrow().lookup_circuit(&input.name.name).cloned();
if let Some(circ) = circ {
// Check circuit type name.
let ret = self.check_expected_circuit(circ.identifier, additional, input.name.span());
// Check number of circuit members.
if circ.members.len() != input.members.len() {
self.handler.emit_err(
TypeCheckerError::incorrect_num_circuit_members(
circ.members.len(),
input.members.len(),
input.span(),
)
.into(),
);
}
// Check circuit member types.
circ.members
.iter()
.for_each(|CircuitMember::CircuitVariable(name, ty)| {
// Lookup circuit variable name.
if let Some(actual) = input.members.iter().find(|member| member.identifier.name == name.name) {
if let Some(expr) = &actual.expression {
self.visit_expression(expr, &Some(*ty));
}
} else {
self.handler.emit_err(
TypeCheckerError::unknown_sym("circuit member variable", name, name.span()).into(),
);
};
});
Some(ret)
} else {
self.handler
.emit_err(TypeCheckerError::unknown_sym("circuit", &input.name.name, input.name.span()).into());
None
}
}
fn visit_identifier(&mut self, var: &'a Identifier, expected: &Self::AdditionalInput) -> Self::Output {
if let Some(circuit) = self.symbol_table.clone().lookup_circuit(&var.name) {
Some(self.assert_and_return_type(Type::Identifier(circuit.identifier), expected, circuit.span()))
} else if let Some(var) = self.symbol_table.clone().lookup_variable(&var.name) {
Some(self.assert_and_return_type(*var.type_, expected, var.span))
if let Some(circuit) = self.symbol_table.borrow().lookup_circuit(&var.name) {
Some(self.assert_and_return_type(Type::Identifier(circuit.identifier), expected, var.span))
} else if let Some(var) = self.symbol_table.borrow().lookup_variable(&var.name) {
Some(self.assert_and_return_type(var.type_, expected, var.span))
} else {
self.handler
.emit_err(TypeCheckerError::unknown_sym("variable", var.name, var.span()).into());
@ -159,48 +247,6 @@ impl<'a> ExpressionVisitor<'a> for TypeChecker<'a> {
})
}
fn visit_access(&mut self, input: &'a AccessExpression, expected: &Self::AdditionalInput) -> Self::Output {
// CAUTION: This implementation only allows access to core circuits.
match input {
AccessExpression::AssociatedFunction(access) => {
// Check core circuit name and function.
if let Some(core_instruction) = self.check_core_circuit_call(&access.ty, &access.name) {
// Check num input arguments.
if core_instruction.num_args() != access.args.len() {
self.handler.emit_err(
TypeCheckerError::incorrect_num_args_to_call(
core_instruction.num_args(),
access.args.len(),
input.span(),
)
.into(),
);
}
// Check first argument type.
if let Some(first_arg) = access.args.get(0usize) {
let first_arg_type = self.visit_expression(first_arg, &None);
self.assert_one_of_types(&first_arg_type, core_instruction.first_arg_types(), access.span());
}
// Check second argument type.
if let Some(second_arg) = access.args.get(1usize) {
let second_arg_type = self.visit_expression(second_arg, &None);
self.assert_one_of_types(&second_arg_type, core_instruction.second_arg_types(), access.span());
}
// Check return type.
Some(self.assert_and_return_type(core_instruction.return_type(), expected, access.span()))
} else {
self.handler
.emit_err(TypeCheckerError::invalid_access_expression(access, access.span()).into());
None
}
}
_expr => None, // todo: Add support for associated constants (u8::MAX).
}
}
fn visit_binary(&mut self, input: &'a BinaryExpression, destination: &Self::AdditionalInput) -> Self::Output {
match input.op {
BinaryOperation::And | BinaryOperation::Or | BinaryOperation::Nand | BinaryOperation::Nor => {
@ -487,8 +533,9 @@ impl<'a> ExpressionVisitor<'a> for TypeChecker<'a> {
fn visit_call(&mut self, input: &'a CallExpression, expected: &Self::AdditionalInput) -> Self::Output {
match &*input.function {
Expression::Identifier(ident) => {
if let Some(func) = self.symbol_table.clone().lookup_fn(ident.name) {
let ret = self.assert_and_return_type(func.output, expected, func.span());
let func = self.symbol_table.borrow().lookup_fn(&ident.name).cloned();
if let Some(func) = func {
let ret = self.assert_and_return_type(func.output, expected, func.span);
// Check number of function arguments.
if func.input.len() != input.arguments.len() {
@ -520,49 +567,4 @@ impl<'a> ExpressionVisitor<'a> for TypeChecker<'a> {
expr => self.visit_expression(expr, expected),
}
}
fn visit_circuit_init(
&mut self,
input: &'a CircuitInitExpression,
additional: &Self::AdditionalInput,
) -> Self::Output {
if let Some(circ) = self.symbol_table.clone().lookup_circuit(&input.name.name) {
// Check circuit type name.
let ret = self.check_expected_circuit(circ.identifier, additional, input.name.span());
// Check number of circuit members.
if circ.members.len() != input.members.len() {
self.handler.emit_err(
TypeCheckerError::incorrect_num_circuit_members(
circ.members.len(),
input.members.len(),
input.span(),
)
.into(),
);
}
// Check circuit member types.
circ.members
.iter()
.for_each(|CircuitMember::CircuitVariable(name, ty)| {
// Lookup circuit variable name.
if let Some(actual) = input.members.iter().find(|member| member.identifier.name == name.name) {
if let Some(expr) = &actual.expression {
self.visit_expression(expr, &Some(*ty));
}
} else {
self.handler.emit_err(
TypeCheckerError::unknown_sym("circuit member variable", name, name.span()).into(),
);
};
});
Some(ret)
} else {
self.handler
.emit_err(TypeCheckerError::unknown_sym("circuit", &input.name.name, input.name.span()).into());
None
}
}
}

19
compiler/passes/src/type_checker/check_program.rs
View File

@ -15,26 +15,33 @@
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use crate::{Declaration, TypeChecker, VariableSymbol};
use leo_ast::*;
use leo_errors::TypeCheckerError;
use leo_span::sym;
use std::cell::RefCell;
use std::collections::HashSet;
impl<'a> ProgramVisitor<'a> for TypeChecker<'a> {
fn visit_function(&mut self, input: &'a Function) {
let prev_st = std::mem::take(&mut self.symbol_table);
self.symbol_table
.swap(prev_st.borrow().get_fn_scope(&input.name()).unwrap());
self.symbol_table.borrow_mut().parent = Some(Box::new(prev_st.into_inner()));
self.has_return = false;
self.symbol_table.clear_variables();
self.parent = Some(input.name());
input.input.iter().for_each(|i| {
let input_var = i.get_variable();
self.check_ident_type(&Some(input_var.type_));
// Check for conflicting variable names.
if let Err(err) = self.symbol_table.insert_variable(
if let Err(err) = self.symbol_table.borrow_mut().insert_variable(
input_var.identifier.name,
VariableSymbol {
type_: &input_var.type_,
type_: input_var.type_,
span: input_var.identifier.span(),
declaration: Declaration::Input(input_var.mode()),
},
@ -48,10 +55,14 @@ impl<'a> ProgramVisitor<'a> for TypeChecker<'a> {
self.handler
.emit_err(TypeCheckerError::function_has_no_return(input.name(), input.span()).into());
}
let prev_st = *self.symbol_table.borrow_mut().parent.take().unwrap();
self.symbol_table.swap(prev_st.get_fn_scope(&input.name()).unwrap());
self.symbol_table = RefCell::new(prev_st);
}
fn visit_circuit(&mut self, input: &'a Circuit) {
// Check for conflicting circuit member names.
// Check for conflicting circuit/record member names.
let mut used = HashSet::new();
if !input.members.iter().all(|member| used.insert(member.name())) {
self.handler.emit_err(if input.is_record {

38
compiler/passes/src/type_checker/check_statements.rs
View File

@ -14,10 +14,12 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use crate::{Declaration, TypeChecker, VariableSymbol};
use leo_ast::*;
use leo_errors::TypeCheckerError;
use crate::{Declaration, TypeChecker, VariableSymbol};
use std::cell::RefCell;
impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
fn visit_return(&mut self, input: &'a ReturnStatement) {
@ -25,7 +27,7 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
// statements should always have some parent block
let parent = self.parent.unwrap();
let return_type = &self.symbol_table.lookup_fn(parent).map(|f| f.output);
let return_type = &self.symbol_table.borrow().lookup_fn(&parent).map(|f| f.output);
self.check_ident_type(return_type);
self.has_return = true;
@ -44,10 +46,10 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
self.visit_expression(&input.value, &Some(input.type_));
if let Err(err) = self.symbol_table.insert_variable(
if let Err(err) = self.symbol_table.borrow_mut().insert_variable(
v.identifier.name,
VariableSymbol {
type_: &input.type_,
type_: input.type_,
span: input.span(),
declaration: declaration.clone(),
},
@ -67,7 +69,8 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
}
};
let var_type = if let Some(var) = self.symbol_table.lookup_variable(&var_name.name) {
let var_type = if let Some(var) = self.symbol_table.borrow_mut().lookup_variable(&var_name.name) {
// TODO: Check where this check is moved to in `improved-flattening`.
match &var.declaration {
Declaration::Const => self
.handler
@ -78,7 +81,7 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
_ => {}
}
Some(*var.type_)
Some(var.type_)
} else {
self.handler
.emit_err(TypeCheckerError::unknown_sym("variable", var_name.name, var_name.span).into());
@ -101,10 +104,13 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
}
fn visit_iteration(&mut self, input: &'a IterationStatement) {
if let Err(err) = self.symbol_table.insert_variable(
let iter_type = &Some(input.type_);
self.check_ident_type(iter_type);
if let Err(err) = self.symbol_table.borrow_mut().insert_variable(
input.variable.name,
VariableSymbol {
type_: &input.type_,
type_: input.type_,
span: input.span(),
declaration: Declaration::Const,
},
@ -112,8 +118,6 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
self.handler.emit_err(err);
}
let iter_type = &Some(input.type_);
self.check_ident_type(iter_type);
self.visit_expression(&input.start, iter_type);
self.visit_expression(&input.stop, iter_type);
}
@ -130,8 +134,13 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
}
fn visit_block(&mut self, input: &'a Block) {
// creates a new sub-scope since we are in a block.
self.symbol_table.push_variable_scope();
// Creates a new sub-scope since we are in a block.
let scope_index = self.symbol_table.borrow_mut().insert_block();
let prev_st = std::mem::take(&mut self.symbol_table);
self.symbol_table
.swap(prev_st.borrow().get_block_scope(scope_index).unwrap());
self.symbol_table.borrow_mut().parent = Some(Box::new(prev_st.into_inner()));
input.statements.iter().for_each(|stmt| {
match stmt {
Statement::Return(stmt) => self.visit_return(stmt),
@ -143,6 +152,9 @@ impl<'a> StatementVisitor<'a> for TypeChecker<'a> {
Statement::Block(stmt) => self.visit_block(stmt),
};
});
self.symbol_table.pop_variable_scope();
let prev_st = *self.symbol_table.borrow_mut().parent.take().unwrap();
self.symbol_table.swap(prev_st.get_block_scope(scope_index).unwrap());
self.symbol_table = RefCell::new(prev_st);
}
}

10
compiler/passes/src/type_checker/checker.rs
View File

@ -15,6 +15,7 @@
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use crate::SymbolTable;
use leo_ast::{Identifier, IntegerType, Node, Type};
use leo_core::*;
use leo_errors::{emitter::Handler, TypeCheckerError};
@ -22,9 +23,10 @@ use leo_span::{Span, Symbol};
use indexmap::IndexSet;
use itertools::Itertools;
use std::cell::RefCell;
pub struct TypeChecker<'a> {
pub(crate) symbol_table: &'a mut SymbolTable<'a>,
pub(crate) symbol_table: RefCell<SymbolTable>,
pub(crate) handler: &'a Handler,
pub(crate) parent: Option<Symbol>,
pub(crate) has_return: bool,
@ -70,9 +72,9 @@ const MAGNITUDE_TYPES: [Type; 3] = [
impl<'a> TypeChecker<'a> {
/// Returns a new type checker given a symbol table and error handler.
pub fn new(symbol_table: &'a mut SymbolTable<'a>, handler: &'a Handler) -> Self {
pub fn new(symbol_table: SymbolTable, handler: &'a Handler) -> Self {
Self {
symbol_table,
symbol_table: RefCell::new(symbol_table),
handler,
parent: None,
has_return: false,
@ -100,7 +102,7 @@ impl<'a> TypeChecker<'a> {
/// Use this method when you know the actual type.
/// Emits an error to the handler if the `actual` type is not equal to the `expected` type.
pub(crate) fn assert_and_return_type(&mut self, actual: Type, expected: &Option<Type>, span: Span) -> Type {
pub(crate) fn assert_and_return_type(&self, actual: Type, expected: &Option<Type>, span: Span) -> Type {
if let Some(expected) = expected {
if !actual.eq_flat(expected) {
self.emit_err(TypeCheckerError::type_should_be(actual, expected, span));

11
compiler/passes/src/type_checker/mod.rs
View File

@ -15,6 +15,7 @@
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
pub mod check_expressions;
pub use check_expressions::*;
pub mod check_program;
@ -32,14 +33,14 @@ use leo_ast::{Ast, ProgramVisitor};
use leo_errors::{emitter::Handler, Result};
impl<'a> Pass for TypeChecker<'a> {
type Input = (&'a Ast, &'a mut SymbolTable<'a>, &'a Handler);
type Output = Result<()>;
type Input = (&'a Ast, &'a Handler, SymbolTable);
type Output = Result<SymbolTable>;
fn do_pass((ast, symbol_table, handler): Self::Input) -> Self::Output {
let mut visitor = TypeChecker::new(symbol_table, handler);
fn do_pass((ast, handler, st): Self::Input) -> Self::Output {
let mut visitor = TypeChecker::new(st, handler);
visitor.visit_program(ast.as_repr());
handler.last_err()?;
Ok(())
Ok(visitor.symbol_table.take())
}
}

2
tests/compiler/circuits/duplicate_name_context.leo
View File

@ -1,6 +1,6 @@
/*
namespace: Compile
expectation: Pass
expectation: Fail
input_file: input/dummy.in
*/

1
tests/expectations/compiler/compiler/address/binary.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: fe880c907d0257c9fc8314b8b98cabd8a8282b587d2d618408cc3cd8e528fda5
initial_ast: d2bf8199011f00bef93c6cec36528966c69908982ea4a6f2e515c98c258edf25
symbol_table: dc40d8435dfe2399cda1bb0c53eb941b4719e40a7e9a2f038b98d7613d538b4e

1
tests/expectations/compiler/compiler/address/branch.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 00f5aba05e4efae5a125eb52f02f16400132085b8a34919d910aa40c6c405a22
initial_ast: d9baeb1448040c61f5e7f779270eb767a29b5f2fd23a60a680aad138327999e7
symbol_table: e8029086f943767e4f98014b3991bff8336cb6472c2d2dc3d51b4b13e5c72ea5

1
tests/expectations/compiler/compiler/address/equal.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 03e9df3bd1409f4af9e2a7f55130bc52f27d41f32a624ffa27f0ab114bf6fbf4
initial_ast: ea3c9a73110ccc7684863543cf563ec78349402c460a75317b776af11d46f781
symbol_table: 25f09247dfa86534ff321b8e1b2ca1666c92751d37a611d62e56b8cfac96261d

1
tests/expectations/compiler/compiler/address/ternary.out
View File

@ -6,4 +6,3 @@ outputs:
- initial_input_ast: ec3cfeb93ea66a530150a5c5e2bd396688b3ef9b9fb0bcb961c62dac4daa064e
- initial_input_ast: cb1d48114c10b2b732ad47a46fc8d05bf7a3e783da89e7f00065244bfc8d15c8
initial_ast: 1bbe35b9a1a767668b4ff0d689873caded5d92ea7886aad2355a404511d76199
symbol_table: 5fddde57167344769d00e423fb56692291d57ac8c953c512b82a4626bbdcb6c9

1
tests/expectations/compiler/compiler/boolean/and.out
View File

@ -8,4 +8,3 @@ outputs:
- initial_input_ast: 4c5eeffd0306b20c8deece509782b81ea8583245f650e40a4a300d517f6ed5f4
- initial_input_ast: a56b3f9908dec2acaed302691d4fe0c2cf046f0deb8f188f617e042e75502f71
initial_ast: 8e4ab3450ec4ffbdba78fc0e1450c319bf538fd716af967419c8ce116ccd3d0e
symbol_table: f36863240edb9fb5fb852c212a9ae1db491ee8243d0469fc155592964595e7d0

1
tests/expectations/compiler/compiler/boolean/conditional.out
View File

@ -8,4 +8,3 @@ outputs:
- initial_input_ast: 7a1c39dec2388ab801496ceb17ca85665d2f515269929925b7cc9018e14297ea
- initial_input_ast: 650984ca5077d11a815889421656b7735b4c6bd320bdf68b4deb87dfc0f49388
initial_ast: d84cf01e1fddeb09983dc4f7e868ae999b7b9ab4dff9d4286108f81aefe80677
symbol_table: 4fd4e476609947028fbffe357ffb9d962e96c30a9abe3677d75675ae37b12587

1
tests/expectations/compiler/compiler/boolean/equal.out
View File

@ -8,4 +8,3 @@ outputs:
- initial_input_ast: 4c5eeffd0306b20c8deece509782b81ea8583245f650e40a4a300d517f6ed5f4
- initial_input_ast: a56b3f9908dec2acaed302691d4fe0c2cf046f0deb8f188f617e042e75502f71
initial_ast: d135ca0877ca63f6c31be572178a69508de9cfb81e258c4aec425861241f84c3
symbol_table: c8dd46774e298ef70fc87f89ecb8b5f23f63b1f2401f337fc97ad83b54e85871

1
tests/expectations/compiler/compiler/boolean/not_equal.out
View File

@ -8,4 +8,3 @@ outputs:
- initial_input_ast: 4c5eeffd0306b20c8deece509782b81ea8583245f650e40a4a300d517f6ed5f4
- initial_input_ast: a56b3f9908dec2acaed302691d4fe0c2cf046f0deb8f188f617e042e75502f71
initial_ast: 42cf44d6821d7bd9d2c0222d2a673df9ff9c199f583e79a8b15b8eec53e2aea0
symbol_table: 8ed9a73e996562abfe75837cfbf2103a4d9213291298206f4f63a7dac808cbc1

1
tests/expectations/compiler/compiler/boolean/operator_methods.out
View File

@ -8,4 +8,3 @@ outputs:
- initial_input_ast: 19f1be52a19445695f23724e1979b362dd3fcf31aace997c829e2206dc1cccbe
- initial_input_ast: d2fc1992beaf062678bbf6c3e862820dbbea39926589afcdc46c19c8669f0e37
initial_ast: b8707d1d3f6c111db2515d4093d15b4739765bfb9e114ed345ebedce0c04024d
symbol_table: e73ad99357809180c0f1290a435d566d56110b8599a1ef2ec2a17d78b21628a8

1
tests/expectations/compiler/compiler/boolean/or.out
View File

@ -8,4 +8,3 @@ outputs:
- initial_input_ast: 4c5eeffd0306b20c8deece509782b81ea8583245f650e40a4a300d517f6ed5f4
- initial_input_ast: a56b3f9908dec2acaed302691d4fe0c2cf046f0deb8f188f617e042e75502f71
initial_ast: 6738dda9dfa2cce86f92f9d28e0e0750870156f6b5d6146d063baa221f88df3f
symbol_table: 91630eda77eaf1e355744e663ceba26a0c3f860d3f69e8e46b03f5464d16950f

1
tests/expectations/compiler/compiler/char/string.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: f1af7e79dff9ede0d2a1c88d5d22801cb3dfe3a9fb34e93bca646e29a61e9f65
initial_ast: 80124fe1a7297907bc27330cfe87117bee204a9f2b8acce053b0778568415a31
symbol_table: 4a29c4b5af2ad1879798454b95b7dd04ae7ecd48289c5f3e7a1e19eaf3921c3b

7
tests/expectations/compiler/compiler/circuits/duplicate_name_context.out
View File

@ -1,8 +1,5 @@
---
namespace: Compile
expectation: Pass
expectation: Fail
outputs:
- output:
- initial_input_ast: acb54d555ee391d519919827f5949bf1600d18004ce461097d062f91108563ba
initial_ast: 2fd04130d93c29b06f1288c682dd1ce37731ef0762f8e8d70d994aa97fa55c1e
symbol_table: 862016bdb0f3f5516b1c9311b674207d4fc2a533066ef43e2a80e413119eeab7
- "Error [EAST0372015]: circuit `Bar` shadowed by\n --> compiler-test:8:5\n |\n 8 | const Bar: u32 = 66u32;\n | ^^^^^^^^^^^^^^^^^^^^^^\n"

1
tests/expectations/compiler/compiler/circuits/inline.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 8507cd1753f4d2a835fa34d3d784487d89d595ea415d51145dd7291a839159c2
symbol_table: e6f85704fccd0ca0f0461ae54cb604159a5f41a2175aad6b76bd534166f1bc6b

1
tests/expectations/compiler/compiler/circuits/inline_member_pass.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 9489ab9b78bd31ac516e1674a83c6b35708238174df88374a7b19cef3d4a8e8a
symbol_table: 53d31f0d39f8ceb7cf079812e6e3a00e0bdb507ca9c11a1c0158433d8d25a476

1
tests/expectations/compiler/compiler/circuits/member_variable.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 29f6139d908d390f890f04d8ee620757d29b7f71cd48c46ff65bc1e70aae840c
initial_ast: 630995cc22fb6ec613f02e3aaa18392770158b2bbaf5aa1736c0bf71dd7357ce
symbol_table: dc48ad542739351f7ab87e4add0f0a3e3fcc500195bdfa7d2eb3e79e29ef0916

1
tests/expectations/compiler/compiler/console/assert.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 15a1f00a6c0ca8141202e45e534b7afd196e9391c184a4efd94f0d0ccf04a59d
initial_ast: 0ef8a9cfc447ad3fd1cb0275e91b1d005b7f230a02bf87e0f8ad56be86daa23e
symbol_table: f8c971e501487f7a368a50fd1941c3fb70684b041478fe615a91f088796e301b

1
tests/expectations/compiler/compiler/console/conditional_assert.out
View File

@ -6,4 +6,3 @@ outputs:
- initial_input_ast: 8b94c0dbc84f44bd29c614b87947e625ad136549ea29ff18233ba5b01ce63c9b
- initial_input_ast: a62874e75304ab81d487909be1c6b1efa2e5756a2980b46e3bb1368586c3ee83
initial_ast: 487dcbee6a433329c15b3cd0b23ecc259d4df455906438f3e6cf348ebd63ee02
symbol_table: f4e056be00b25dfd854a5be8197aeb205436bb0ee11cfe06701531ea086e038c

1
tests/expectations/compiler/compiler/console/error.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 14cd2c781b154a9037de84e945cfb348e9c587cef94d3e1f3be83e4306f92a0e
initial_ast: d718de3086bc78a00a392e3c2b46dfa8f76084909bad3c98a5a6759df73efb27
symbol_table: d46f6eb98259f34d32a60788aa178efa34166bcc6ba1058e2ff5f8327a129b9c

1
tests/expectations/compiler/compiler/console/log.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: fd19d82c3aba921f01b37174e3eb7fb603438506fe511657e21235b9fb3647d2
initial_ast: 2a99ef2515c58607e4b617f93c74838b6f2afed28e9e2c2eed658cea6d729b2d
symbol_table: 559484bc163178bf54b169f5dd573167771566aa993055b6a28f0c1a759339bc

1
tests/expectations/compiler/compiler/console/log_conditional.out
View File

@ -6,4 +6,3 @@ outputs:
- initial_input_ast: 06fad995841b833ef5074920ae270b93bf82ad60b6c8b440c66b8bc5018aaa72
- initial_input_ast: 34bd981451bdeb915a2de749b969c8804c06e44a9f4473f36d6efac7617baead
initial_ast: f8315b82b0a05e0e69fb8b0342b46cbee976ec20d62e0edd2f066bf51acd81d6
symbol_table: 560afbb790df70bfc770d5c2f966428a37baf94a5c0f5312ad445456d33a2cd9

1
tests/expectations/compiler/compiler/console/log_input.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 0961f603812e241567b6e3ef5adb458309f1829eb2c08a216efccb17bea89faf
initial_ast: 3602c929b2256f4ed5cec2ba9d3e967b029a7dc9717a371b32a356425cf9892b
symbol_table: 720c2aafae77c261ed1640d4080f9a73657638baa30e54a5e10e2323b6f6eca0

1
tests/expectations/compiler/compiler/console/log_parameter.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: f18a0e019ca4719c4c4ef5b7313f562c3bc9581819d161d84566e706f3765249
initial_ast: f319125731635279a198fb2df8c0446475024c70829e9de32fa5f43c38079862
symbol_table: e5159343ab03573032873783b28058a482dd401d534a0d3af03790a5286ba470

1
tests/expectations/compiler/compiler/console/log_parameter_many.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 16910a94cf1f803ae6425ae6bee9422b01651c2c243b5e46807dc3191d169e64
initial_ast: 52824ac2e84097578faf0ff92f7ca840d2de30e8454a540886123a2cf79192ae
symbol_table: 757bb967973b87466c01be1a9dc78d30701964e0d234e0e65d1bbcbd3072370f

1
tests/expectations/compiler/compiler/core/algorithms/bhp.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: fc0f2558100be5c1216c0d56e8be51be6ad4f51e47e42f89b96d1b9bae0ae34d
symbol_table: 00e1ab10d05676c51e65671158712d7041de760ca226f74a2314f1cef9740402

1
tests/expectations/compiler/compiler/core/algorithms/pedersen.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 8c3b9cf2aad8ba67eb351b67ed4642caa64a7ff83a2dcdc48f05413bba7ba81f
symbol_table: 4a439652db94447b85f87bdd262953b6b6233e2d5f22c562215fd792f59f04d3

1
tests/expectations/compiler/compiler/core/algorithms/poseidon.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 0a7abaad3d4eb543b09e8664f8b274714f742bec62c45fe56dd6bece0a19161e
symbol_table: 43835e3ddb0a6a15f6ace2186576a1a51de6ad7251d29ff13302546bf1b46a42

1
tests/expectations/compiler/compiler/definition/out_of_order.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: b649852fa2fd7eda05bd0ba261f01dcee93b6b825d5d30fddb8dd5c5710081ca
initial_ast: 13b0f0680422f4f647cb4da2fef412662f35b745ba788ce147add5eeccb2edaa
symbol_table: 66779461e33acc9c5c732509637db91bd72aff3e9dae6aee0c137d0537446878

1
tests/expectations/compiler/compiler/field/add.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 3f35e74d282a1e5281e7f283d1e572a3dc75dea1a5ef1a0f8c7f46412ef946a7
initial_ast: 0aebc18388f6ceed8c1d813152ec6392bf687a814d3ae6d63ae10b50420c1a43
symbol_table: d666098c1c0d7c670730cfa6548d47fa89d9a1dd33642f8021b0622f9abc0e5e

1
tests/expectations/compiler/compiler/field/div.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 4e3882d83c8044e40258f8414966b09c715b00e08bc3383030cecf2c4a825c60
initial_ast: 924a3905b44bfea2a10118e4c0336a596b6981a7b06ea39f71daac7000e5cf9c
symbol_table: 38cbfecf35fb5189618a9767d3245d02e133d59ce2a0fc0f3aba37a8fa14fe8e

1
tests/expectations/compiler/compiler/field/eq.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: eeba130bda3ee24f2a4bf92f67fb555ab849173910a647096e28729c2ebd71c2
initial_ast: 3546a10b24a6a53ee07d298e7dbbed5122bd9d0c973613296a94189d9e57f246
symbol_table: 0879cd6e4cc609ecdbdfc87ff0f08b4f3ae54367e0a1c02116304eb1411d2c23

1
tests/expectations/compiler/compiler/field/field.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 3a510480221eb323713b4b10cc374ba357f130e8ac2b07bf1c69ad5d8c936f12
initial_ast: ff341146cdbb78e4a5bffd47c109cc9987dd3b7cea8224e0ef3668394d1c7a90
symbol_table: 7e1d351a3c008868527f780c7d643e848c26b786b786ba24dd5771c8639416da

1
tests/expectations/compiler/compiler/field/mul.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 3f35e74d282a1e5281e7f283d1e572a3dc75dea1a5ef1a0f8c7f46412ef946a7
initial_ast: c05e588dae9e5f6e7e1c2d16d08629af8d287b453796b21de89b25d40970ec1b
symbol_table: 47782aad84b54a835bead341b6113b471712ddd6d19005040d16c5d199a0920a

1
tests/expectations/compiler/compiler/field/negate.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 9206742d7f18345efbd4d9077cd1aca0855d43a2436be0697ec22954650e3737
initial_ast: c2122be4da96294b4ce4bca5d239176c6bb98765248c767dd41352b6b95888c8
symbol_table: c1972a6cda7ceae22c2efcf9fbb23065899f6ded0f295d2ca52789ccfb916e75

1
tests/expectations/compiler/compiler/field/operator_methods.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 047866515f4dc74cd9966242734984b53e72f87afc21f7171b118e6defa1f166
initial_ast: 49b4956c647eb7f6e1ae496ce2e5c4ff238493d9cbc9d20d6f0f3fee09dee4f4
symbol_table: d2086bca43b5a4ee965064ad79ef70496bfc2e89d6cb76f0d68d3e29c515af0a

1
tests/expectations/compiler/compiler/field/pow.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 5e0a61d909d2e94dfbc95775e4c5c356adb61375ceef2d583a5ab927b3b6342e
initial_ast: ecf60185d2eda458885b00f1daa586132dfbfc560b0565c1659bb4bfed3cb19d
symbol_table: 2aef6303c5f4e1c08e7ef101bb47063e28bda7e17a320ae2ce73c4859fa62a19

1
tests/expectations/compiler/compiler/field/sub.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 4e3882d83c8044e40258f8414966b09c715b00e08bc3383030cecf2c4a825c60
initial_ast: 44033abf4e0e2d174cc770b32f903b8a1d4505ee4cbfdcfca3ad1f885071123e
symbol_table: f601b6a1652f79ac2853737ecf09f4e5f23c05873e2bb3967137a7b2b0085b04

1
tests/expectations/compiler/compiler/field/ternary.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: e19dcac0064fed4ec8293b9b40ec70cb94b5fdb05f1081fc29f46a023bf79b09
initial_ast: 8efd26ef8db8c5c793450a368ec66d7a3fe3b363145655192344af4a8c2b4d81
symbol_table: 5bb0a34e488683807eef29093f204fb2f1cfe8da3c2e2370d61e427a109a2d4a

1
tests/expectations/compiler/compiler/function/conditional_return.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: f4c81e7647e3b7cb29e8faf5456878989cbc81cb49097acf5bc9aaafc9092b6b
initial_ast: ed69198e934ac7f6a604adb37a4b27ad593909930029904db802c1895d7269c9
symbol_table: 577abb859b2f33b9e81c5e94c82b559601f44025143fa7a6757561b47e78efa5

1
tests/expectations/compiler/compiler/function/iteration.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 1febcc333f69e7f5ea2e8b9e915c66a23f4e195c6106a31cffb1adb81b90f0e4
initial_ast: 7df50863de140cd6033391d929212b91180ff90737c536e631f977ddf9eb9d91
symbol_table: 6754c028b1d3793f022a7da93be8510a6844da8a2e45f5dcaa9566252e418ee2

1
tests/expectations/compiler/compiler/function/iteration_repeated.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: ae87aca959c3d818c9259be6ca73eca6ada9633312e81a4df172d833f40c78e9
initial_ast: 24bdae47f1154abc4c7f8dbe30dde72ae25779e4464e8942968c7fd36f602d42
symbol_table: c45d23aa877641cbf1853709cc103d389f3e3105b5c873f8bb90c3a0c48bd2ff

1
tests/expectations/compiler/compiler/function/repeated.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 6b8596d250b3c42a0ff9856eb4a94d28c72b2953313d594f13a5d3f1de6f072f
initial_ast: a21fe86230689152fbfcf3529c818c0ef25fe9f3117de260f85ae84cc535c503
symbol_table: 7c82d098d4b483b968c5b928f68a4a6f040bf961bbf5192bf323ddabbe592da8

1
tests/expectations/compiler/compiler/function/return.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: d11a4218606717322234d8ea4c4786d6edce90f07abde9e120d597cb0e838ce0
initial_ast: 9a7092fce407db3067a8ed1a90dbd5613dff7d581d2df73ce7f6701ff64e5e0b
symbol_table: 8bddbedba52c66dc7a86530a2df470eb3222992c10b75842431a82afc7e936d4

1
tests/expectations/compiler/compiler/group/add.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: a28b88dc36ace78ed0de93b56db7274f16521597ccf1e820a17fdb60a1e3d92a
initial_ast: 7109d173cdd239abf5f0f717e669e300cf7bd4b3bde2158a17d1f16c1b154276
symbol_table: b10964224747af7f8ba12f1b3c0dfa228842b3e08b9b82d785b71def31387144

1
tests/expectations/compiler/compiler/group/assert_eq.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 00c3cc87ce3c30894ad6b6874ce6dacfa02c9f2bc171615ff627f06f2e201997
initial_ast: b6e75e27703bf6b6af69de95f9c22ef2033db46227f5658a9f2e88c33a169b1d
symbol_table: 584d3ba9f7908f1b2e0c918710e78d0a483c12aa3f4644edada2eac31ac689ca

1
tests/expectations/compiler/compiler/group/both_sign_high.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 7631f3258e3f0f288fd21a0470c43f636b96bbe0f3643dad29353e9b48c63ee6
symbol_table: 9a61702119ebc681917d7cb7e40ecafa00354849326bf1182635f27a28da35e9

1
tests/expectations/compiler/compiler/group/both_sign_inferred.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 97c27f26fd8d201623b1cbb19474a2cb6934c6bda8d4b363c831b0a3193e75ec
symbol_table: e4a96223c049893c904a90f24d069592b33fc137de0f4816cf92089e63663693

1
tests/expectations/compiler/compiler/group/both_sign_low.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 772357946f6febbf75a72e8f706975abc242cc805368babdac1e3d047a1d0dc8
symbol_table: 1817d91b99941ddc2590c6a2777ad8f7d4ba26a8b2a3baa3932f1a08eb540206

1
tests/expectations/compiler/compiler/group/eq.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 00c3cc87ce3c30894ad6b6874ce6dacfa02c9f2bc171615ff627f06f2e201997
initial_ast: b6e75e27703bf6b6af69de95f9c22ef2033db46227f5658a9f2e88c33a169b1d
symbol_table: 584d3ba9f7908f1b2e0c918710e78d0a483c12aa3f4644edada2eac31ac689ca

1
tests/expectations/compiler/compiler/group/input.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: c93f9fd667509aa0aa3896c261cb48c7d579d9856d0a14b96e9b2c7e04566a0a
initial_ast: b6e75e27703bf6b6af69de95f9c22ef2033db46227f5658a9f2e88c33a169b1d
symbol_table: 584d3ba9f7908f1b2e0c918710e78d0a483c12aa3f4644edada2eac31ac689ca

1
tests/expectations/compiler/compiler/group/mult_by_scalar.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 7b0236b04ad9caa4039a989b91e7f49021a9daf09a495a9cdad7c371ee196761
initial_ast: 99e25dcd781ee8514ca93fdb34430f05caf429ed46dafa3189c3d835d680d7df
symbol_table: ac787ea8268badd26320c55d7d1b808ca7bfdaac3994570a28e605d637f1cdaf

1
tests/expectations/compiler/compiler/group/negate.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 5e1e23855cb6841ee210c8a24e11cc819e91ce3b087a8c961035c574baa1784b
initial_ast: 491aa1b9665527f07687444cb882f1ae5d363ca3b024f9cc3de36027ec37fce4
symbol_table: 0884500a6ca9407b647feb8c0257cf2785412a051f1d0e0fad5ca54e40008243

1
tests/expectations/compiler/compiler/group/one.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 5a4b6b18074e63ba98467539a224838675ea3f08b945b554c23df2f22f730181
symbol_table: 1459210791fd0aae2827b2b7c3fd438e7a8315b290e23cbfe365b4214d5cd284

1
tests/expectations/compiler/compiler/group/operator_methods.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: a60503e3f83fbee658d02fb3806b3a3326fc6d4f4e43ac05bce7b16ac0552edb
initial_ast: 07af6f05d46a6cd91085fb1aaf8a0fcb9cb2c05ccf60fd5fad5449e9fbf079b4
symbol_table: 411b2d036a4603e77f6fe4479d6d35cbe7d82a718010b1a759e4bf6ac24687fd

1
tests/expectations/compiler/compiler/group/point.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 7031bc0fd844a95ff14f558d113c6c5701834489713c2e9050d42b80e32fa2d0
symbol_table: ac8c4425959cf548f2f0edc8aa637b1d827394f11fe2c10ecef366a803fe30a2

1
tests/expectations/compiler/compiler/group/point_input.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 1b5330a3356c437ddc09afc027d1365eedb24c56777772fd83b9167cfebb4435
initial_ast: c90971ebee1da3c277fef3288af860eeca4997ba9807a8038a3d1bd03200d277
symbol_table: 0db35c4a8548b1c37607ad3a7d67be41b7949f6219107f4d5ef8442a75dd2a7a

1
tests/expectations/compiler/compiler/group/positive_and_negative.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 32f2a58463cce89611be1ef90aa7f109f3c86c8c2ad87b11c4ab62127ac8c969
symbol_table: 7e69e6875d7b047f525e435533e6b299da0779cd28edbf4190f2b701c79d74fb

1
tests/expectations/compiler/compiler/group/sub.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: a28b88dc36ace78ed0de93b56db7274f16521597ccf1e820a17fdb60a1e3d92a
initial_ast: 97ab784d4cdbb80329f8284003c821fa956e5b4913277813136217849815200d
symbol_table: 8d7179908ac5272f4892b2e374ad5c5401332d4d12d7d0505ba1e51a98ef0d6d

1
tests/expectations/compiler/compiler/group/ternary.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: d12e492b73a208051457ad2ce9ed8dbbb5a8096f32f52d697c41972ba8b88d35
initial_ast: 5d6e9ede195a3cfc06f7a91b47937247e6ffc237b57e37859a6d0e5cc966b762
symbol_table: 35465ba1d734747d0265a3b89c9cee8fe0beda4cfb42b477010c902472e57cc1

1
tests/expectations/compiler/compiler/group/x_and_y.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 3cf73b90d40fce8273b69ccf99424ad3b5f8fce2999d06bb1413428280f17f7d
symbol_table: f33f5b0c84aac58327880b146c570d74ed3118e93247b4a05680ae2c451db5b1

1
tests/expectations/compiler/compiler/group/x_sign_high.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 0ae122eb2bd121db2f072a8d79afbe3d0ad1023e7a4aaee2e4e9f4ba5c1a3c36
symbol_table: 2d0db26fa84f8daad71afd4420718043de1c97757ae4fe4fa78e9874891d1d80

1
tests/expectations/compiler/compiler/group/x_sign_inferred.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 81f062d4ca72bbfb62d447cfe23d0658b3b40a4caf3ca1fd37db833a3a6ba9f5
symbol_table: c20979f64468655131a488980c1de31384fd7ff35561ed569c3db6f2d0bc19cc

1
tests/expectations/compiler/compiler/group/x_sign_low.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 2b60be6820f8dc537b2ab9ec70e4981d93d0c68ebdc71d9437345e57c66505bf
symbol_table: f450d14b0bb862b0bec4a5f8d41eb92f7cf951dee469505fb20dbfa25972eb7b

1
tests/expectations/compiler/compiler/group/y_sign_high.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: c92281b28b5166cfa0cb458bb6f21dcc71d67dfe1f8bb757945c575cbb92a549
symbol_table: 52760622da95d189f6e707df97fc6bba4216fa59022a4ae79d840b9c05fdf5b1

1
tests/expectations/compiler/compiler/group/y_sign_inferred.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: b5c2ab86061f7dcae809f6a707559c1738a0f0a2352270ca3ff91a3242d70af3
symbol_table: d3bf69e78619e63bc1c56c1efe49712b226f5d477e1c42491d0b31e24d5a98a7

1
tests/expectations/compiler/compiler/group/y_sign_low.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 1d5f67161857e1ef3195099a1a04370ddf33dc3eebade9e1a5e0f6266c495a75
symbol_table: 026430e928e2236167d6587cb1885784f30bbc916f75d3a0f42fa7a3f2c6978b

1
tests/expectations/compiler/compiler/group/zero.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: no input
initial_ast: 31edb6eef4b9fa47acfb94f0f8f7ec9f50667501c7dc6bb5c643a65be90cbfb7
symbol_table: b181fa2d3c50419dbdaadbe2e91aa4a3e17baa614b0635f9ce6fa7367ead48eb

1
tests/expectations/compiler/compiler/input_files/program_input/main.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 23e62412d2a9377334d90aaeb6629b73c77e045ce87f23bd6ae2e2cd242e70f0
initial_ast: 62a908a53573e228fec4b308f637909227856abaf327f527c23dd63e739d77d7
symbol_table: 00f652a7b8e969478d433c749951ee63b97343691ff9ade7e1e9288757814ef6

1
tests/expectations/compiler/compiler/input_files/program_input/main_field.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 2b6bc4ade2305a65746066befacf6a0a18382f754d4d7911d0c6e0abef682114
initial_ast: 4d5c44da11b6644f95211ba6ebac1a6ca45ffbc63248fbc42a92a26e109cb63f
symbol_table: a3dad989c81fa120b3092919ca6bd0cc90221424459f5691b7f172e5564ba1ae

1
tests/expectations/compiler/compiler/input_files/program_input/main_group.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 4001f721e97052bdea8fafe39846356011e335e40281e0082c0b406cd6a85947
initial_ast: 947309cb1c78f8b954bd55ccb34e84ce39f7988991c9f6c2ae6408257c979665
symbol_table: 3b68eff86b45e4f940b0a1031e19a64178b0bf802acb59f3b743e664f3010876

1
tests/expectations/compiler/compiler/input_files/program_input_constants/main.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: e626f055978f5125bc292065d74aab5b679229a5364f150ccbe1f07d0c167c3d
initial_ast: 22df0e8dcc96e127df94438ebdd1111070afb5f2fede13534a9aeb0d20885246
symbol_table: 0c159f2d4019e8ce09298ed85f51214a307e72e2e0cbfae36ff844e54221f6f3

1
tests/expectations/compiler/compiler/input_files/program_input_constants/main_field.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 3eaa98274698edacf455de40418ea012234a1355d5b50b9063ee0e06d3d26709
initial_ast: b1647dfd919968219b01ee5ff48ba97b155d8d40702498a69ff712b59c4a908f
symbol_table: 876b01cb4c834949c3a9bae4d6ebc2a675c5c6d8f0d44738ad3624be693169d5

1
tests/expectations/compiler/compiler/input_files/program_input_constants/main_group.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 4efe3ae5f2d6a95663ca302b60d4e430b63bcb7c5a19d638ec7613b7dc099825
initial_ast: f88e91c98500ea74503f284eb75e2e25857d9092257166716025bc9a95584b9d
symbol_table: 5b4e625f4a8684ff3dbfce2fb03cd8e64d1f22f1397b8106aee9e13034bef0ac

1
tests/expectations/compiler/compiler/input_files/program_input_constants/main_multiple.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: e7173f6b8aa8aa40bcb167fa4de0b5d5a7f1b6d245a78dcb5ad70a73b53ef7de
initial_ast: 314c2343d15bc5676eb5669e9a7a193936ce32ea4f2c7a1ab10719202314e4ee
symbol_table: cbab89bb481942bafb0524e8228ea50c64926bdec2bb8c75a13f1733515459f4

1
tests/expectations/compiler/compiler/integers/i128/add.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: ca7500628480432228743b9eff2cac69e433bc0a9da6ce007cae38ef9c2b57a6
initial_ast: 07374055a6d078ecbf9f3c76a3c63cef7b529a583333afc655d1f7b22c8fd054
symbol_table: 26e29ab43161625435a7de57fba18feffa2ca86b908d3720a652c8fabc1a6adf

1
tests/expectations/compiler/compiler/integers/i128/and.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: ca7500628480432228743b9eff2cac69e433bc0a9da6ce007cae38ef9c2b57a6
initial_ast: 210dcc0f1e9522a7a7ada3b633f1ce0401f8c53ad0acf3e59f60772b51f35899
symbol_table: f398fd041dc330aa49abf58328dd175e5bb927bf3e36e16559e79eb0d4461a77

1
tests/expectations/compiler/compiler/integers/i128/console_assert.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 86fc147511a8405918da9d9f5e40b2daccb441e80b793287203d30b21bb5600a
initial_ast: e684deb39dd4d7d41b1d5062f5f025df84d1998d16a59871d53f211dd9d9cce2
symbol_table: 6f25f2987af24695b2fb70fb856a108c3d185a98289e796f5af4cb60c0de946a

1
tests/expectations/compiler/compiler/integers/i128/div.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 8562aec00f8be8367748af8197e2add488cbae2e0931674b68581744dbaafe61
initial_ast: ae2ef5614de8c31c25df7bb8cea87eb00ac8c154fb4a0ead71dfc306dc836b66
symbol_table: 13298cf22dc30ccc0e18f787e657068fd0531e71e9b29155541503bf7209801b

1
tests/expectations/compiler/compiler/integers/i128/eq.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: a4d1618b78d6f649f06d5f58f5ae0bb45135717abf3feea0541698ddb0212ec6
initial_ast: 44bd05c77cfb936ae6363fd532803e6939b0893d887d4e85b205ab3517ecfefa
symbol_table: e354ff29052ba6cf646dc2a940fb2489c740245554aa81f4a9b71c314f431618

1
tests/expectations/compiler/compiler/integers/i128/ge.out
View File

@ -6,4 +6,3 @@ outputs:
- initial_input_ast: 14e51b70ecee1d7bbdd5c37abf0d03f2c620fc9d31d68135108e241d78f738a6
- initial_input_ast: d5462c67471a54461a3e8bdca815ec0700534c47e89ee9adc34f1243c53d1f11
initial_ast: 190357900b121a5278ca1cd8174bc13a092dd3babf9727c03fd27ab51066ba29
symbol_table: a0b9f85aee4a145dd4f5a8f6488b4d50a627e317601a523b63b13cc969325401

1
tests/expectations/compiler/compiler/integers/i128/gt.out
View File

@ -6,4 +6,3 @@ outputs:
- initial_input_ast: dfdb458d96c001da809b9b656e1f32b1b3936303033136bb8fd8c99d9732dde3
- initial_input_ast: 8687bd99746f218264adc45a810fb6e16cf8ead9f64d63faa7b376e4e3907f84
initial_ast: 1b01fc5c167c9957c4f631fcf1e494444822f748f3abcc977d13263a0a74cb9f
symbol_table: 96ff00c92d164363ceb1fee06485b451062e76798f4381afa4141d60b2e88c96

1
tests/expectations/compiler/compiler/integers/i128/le.out
View File

@ -6,4 +6,3 @@ outputs:
- initial_input_ast: 14e51b70ecee1d7bbdd5c37abf0d03f2c620fc9d31d68135108e241d78f738a6
- initial_input_ast: e34798d157f456fecf7ceed2e406c6b76e0b1bcda3a7110f56de0df10472b3c4
initial_ast: 3396a4771011467bf2f248f6346e7c2c5dae8dc8b14eddc39a58d180538a506d
symbol_table: 4beca34f91e3bb4fbb997a1851b3fefb933c47d1e24f6a2e6258d4075c01918a

1
tests/expectations/compiler/compiler/integers/i128/lt.out
View File

@ -6,4 +6,3 @@ outputs:
- initial_input_ast: 8ed1bfd98e5df545f33dfc3b622573a028950b9f44a6038d84d903839ce6b226
- initial_input_ast: bc33c98fd9b5eba7bd68ca76eea533e137e786f4b75b79421de10134b56585df
initial_ast: 66cb035a3d249a394e8dbbe19cbc02f5cddb844a78bc80c838c7cab191fe9701
symbol_table: ad21c0cb65fd2f4f2360ed81da1bf608b83a0865801d2b569035eb1e36a7676a

1
tests/expectations/compiler/compiler/integers/i128/max.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: a2ab6a89c5952a113fbecdeb630917b4699c38dcda5971528ab35cdd5e92c216
initial_ast: 76fb816766ffe11700b4c2a7ebf8502f09b7a5ca9f616fcfb1fbfc083d70b91e
symbol_table: b9f23cb88072c4321465b95ec69bba96f8fb225616244266e05a9e6eeb99da5b

1
tests/expectations/compiler/compiler/integers/i128/min.out
View File

@ -5,4 +5,3 @@ outputs:
- output:
- initial_input_ast: 1480b753150538db3f133e6491506ee264d39be8d1c0dab484cd81a20f24cdd8
initial_ast: 03f31393c00a98648f946675297b0c1bcefb2660ec10f96a955eec09fcdefecb
symbol_table: 9738fdb5ac2d311d0ad30f5e9fad6752b6a938c5d92fde015da71f5d57a90ed7

Some files were not shown because too many files have changed in this diff Show More