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

remove uuid dependency

Browse Source
This commit is contained in:
Protryon 2021-02-25 07:40:47 -08:00
parent d85a057ddc
commit ed8d2fb11d
55 changed files with 427 additions and 460 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
Cargo.lock generated
View File

@ -955,17 +955,6 @@ dependencies = [
"wasi 0.9.0+wasi-snapshot-preview1",
]
[[package]]
name = "getrandom"
version = "0.2.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c9495705279e7140bf035dde1f6e750c162df8b625267cd52cc44e0b156732c8"
dependencies = [
"cfg-if 1.0.0",
"libc",
"wasi 0.10.0+wasi-snapshot-preview1",
]
[[package]]
name = "gimli"
version = "0.23.0"
@ -1290,7 +1279,6 @@ dependencies = [
"serde_json",
"thiserror",
"typed-arena",
"uuid",
]
[[package]]
@ -1338,7 +1326,6 @@ dependencies = [
"snarkvm-utilities",
"thiserror",
"tracing",
"uuid",
]
[[package]]
@ -2148,7 +2135,7 @@ version = "0.7.3"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "6a6b1679d49b24bbfe0c803429aa1874472f50d9b363131f0e89fc356b544d03"
dependencies = [
"getrandom 0.1.15",
"getrandom",
"libc",
"rand_chacha",
"rand_core 0.5.1",
@ -2171,7 +2158,7 @@ version = "0.5.1"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "90bde5296fc891b0cef12a6d03ddccc162ce7b2aff54160af9338f8d40df6d19"
dependencies = [
"getrandom 0.1.15",
"getrandom",
]
[[package]]
@ -2235,7 +2222,7 @@ version = "0.3.5"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "de0737333e7a9502c789a36d7c7fa6092a49895d4faa31ca5df163857ded2e9d"
dependencies = [
"getrandom 0.1.15",
"getrandom",
"redox_syscall",
"rust-argon2",
]
@ -3231,16 +3218,6 @@ dependencies = [
"percent-encoding",
]
[[package]]
name = "uuid"
version = "0.8.2"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "bc5cf98d8186244414c848017f0e2676b3fcb46807f6668a97dfe67359a3c4b7"
dependencies = [
"getrandom 0.2.2",
"serde",
]
[[package]]
name = "vcpkg"
version = "0.2.11"

4
asg/Cargo.toml
View File

@ -37,10 +37,6 @@ path = "../ast"
version = "1.2.2"
path = "../grammar"
[dependencies.uuid]
version = "0.8"
features = [ "v4", "serde" ]
[dependencies.num-bigint]
version = "0.3"

46
asg/src/context.rs Normal file
View File

@ -0,0 +1,46 @@
// Copyright (C) 2019-2021 Aleo Systems Inc.
// This file is part of the Leo library.
// The Leo library is free software: you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
// The Leo library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use std::{cell::Cell, unimplemented};
use typed_arena::Arena;
use crate::ArenaNode;
pub struct AsgContextInner<'a> {
pub arena: &'a Arena<ArenaNode<'a>>,
pub next_id: Cell<u32>,
}
impl<'a> AsgContextInner<'a> {
pub fn new(arena: &'a Arena<ArenaNode<'a>>) -> &'a Self {
match arena.alloc(ArenaNode::Inner(AsgContextInner {
arena,
next_id: Cell::new(0),
})) {
ArenaNode::Inner(x) => x,
_ => unimplemented!(),
}
}
pub fn get_id(&self) -> u32 {
let next_id = self.next_id.get();
self.next_id.replace(next_id + 1);
next_id
}
}
pub type AsgContext<'a> = &'a AsgContextInner<'a>;

6
asg/src/input.rs
View File

@ -39,7 +39,7 @@ pub const STATE_LEAF_PSEUDO_CIRCUIT: &str = "$InputStateLeaf";
impl<'a> Input<'a> {
fn make_header(scope: &'a Scope<'a>, name: &str) -> &'a Circuit<'a> {
scope.alloc_circuit(Circuit {
id: uuid::Uuid::new_v4(),
id: scope.context.get_id(),
name: RefCell::new(Identifier::new(name.to_string())),
members: RefCell::new(IndexMap::new()),
core_mapping: RefCell::new(None),
@ -68,7 +68,7 @@ impl<'a> Input<'a> {
);
let container_circuit = input_scope.alloc_circuit(Circuit {
id: uuid::Uuid::new_v4(),
id: scope.context.get_id(),
name: RefCell::new(Identifier::new(CONTAINER_PSEUDO_CIRCUIT.to_string())),
members: RefCell::new(container_members),
core_mapping: RefCell::new(None),
@ -83,7 +83,7 @@ impl<'a> Input<'a> {
state_leaf,
container_circuit,
container: input_scope.alloc_variable(RefCell::new(crate::InnerVariable {
id: uuid::Uuid::new_v4(),
id: scope.context.get_id(),
name: Identifier::new("input".to_string()),
type_: Type::Circuit(container_circuit),
mutable: false,

11
asg/src/lib.rs
View File

@ -71,9 +71,10 @@ pub use variable::*;
pub mod pass;
pub use pass::*;
pub use leo_ast::{Ast, Identifier, Span};
pub mod context;
pub use context::*;
pub type AsgContext<'a> = &'a Arena<ArenaNode<'a>>;
pub use leo_ast::{Ast, Identifier, Span};
use std::path::Path;
@ -132,6 +133,10 @@ pub fn load_asg<'a, T: ImportResolver<'a>>(
InternalProgram::new(context, leo_ast::Ast::new("load_ast", &ast)?.as_repr(), resolver)
}
pub fn new_context<'a>() -> Arena<ArenaNode<'a>> {
pub fn new_alloc_context<'a>() -> Arena<ArenaNode<'a>> {
Arena::new()
}
pub fn new_context<'a>(arena: &'a Arena<ArenaNode<'a>>) -> AsgContext<'a> {
AsgContextInner::new(arena)
}

14
asg/src/node.rs
View File

@ -14,7 +14,18 @@
// 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::{AsgConvertError, Circuit, Expression, Function, PartialType, Scope, Span, Statement, Variable};
use crate::{
AsgContextInner,
AsgConvertError,
Circuit,
Expression,
Function,
PartialType,
Scope,
Span,
Statement,
Variable,
};
/// A node in the abstract semantic graph.
pub trait Node {
@ -38,4 +49,5 @@ pub enum ArenaNode<'a> {
Variable(Variable<'a>),
Circuit(Circuit<'a>),
Function(Function<'a>),
Inner(AsgContextInner<'a>),
}

5
asg/src/program/circuit.rs
View File

@ -18,7 +18,6 @@ use crate::{AsgConvertError, Function, Identifier, Node, Scope, Span, Type};
use indexmap::IndexMap;
use std::cell::RefCell;
use uuid::Uuid;
#[derive(Clone)]
pub enum CircuitMember<'a> {
@ -28,7 +27,7 @@ pub enum CircuitMember<'a> {
#[derive(Clone)]
pub struct Circuit<'a> {
pub id: Uuid,
pub id: u32,
pub name: RefCell<Identifier>,
pub core_mapping: RefCell<Option<String>>,
pub scope: &'a Scope<'a>,
@ -58,7 +57,7 @@ impl<'a> Circuit<'a> {
let new_scope = scope.make_subscope();
let circuit = scope.alloc_circuit(Circuit {
id: Uuid::new_v4(),
id: scope.context.get_id(),
name: RefCell::new(value.circuit_name.clone()),
members: RefCell::new(IndexMap::new()),
core_mapping: RefCell::new(None),

9
asg/src/program/function.rs
View File

@ -32,7 +32,6 @@ use indexmap::IndexMap;
use leo_ast::FunctionInput;
use std::cell::{Cell, RefCell};
use uuid::Uuid;
#[derive(Clone, Copy, PartialEq)]
pub enum FunctionQualifier {
@ -43,7 +42,7 @@ pub enum FunctionQualifier {
#[derive(Clone)]
pub struct Function<'a> {
pub id: Uuid,
pub id: u32,
pub name: RefCell<Identifier>,
pub output: Type<'a>,
pub has_input: bool,
@ -99,7 +98,7 @@ impl<'a> Function<'a> {
..
}) => {
let variable = scope.alloc_variable(RefCell::new(crate::InnerVariable {
id: Uuid::new_v4(),
id: scope.context.get_id(),
name: identifier.clone(),
type_: scope.resolve_ast_type(&type_)?,
mutable: *mutable,
@ -117,7 +116,7 @@ impl<'a> Function<'a> {
return Err(AsgConvertError::invalid_self_in_global(&value.span));
}
let function = scope.alloc_function(Function {
id: Uuid::new_v4(),
id: scope.context.get_id(),
name: RefCell::new(value.identifier.clone()),
output,
has_input,
@ -137,7 +136,7 @@ impl<'a> Function<'a> {
if self.qualifier != FunctionQualifier::Static {
let circuit = self.circuit.get();
let self_variable = self.scope.alloc_variable(RefCell::new(crate::InnerVariable {
id: Uuid::new_v4(),
id: self.scope.context.get_id(),
name: Identifier::new("self".to_string()),
type_: Type::Circuit(circuit.as_ref().unwrap()),
mutable: self.qualifier == FunctionQualifier::MutSelfRef,

21
asg/src/program/mod.rs
View File

@ -29,7 +29,6 @@ use leo_ast::{Identifier, PackageAccess, PackageOrPackages, Span};
use indexmap::IndexMap;
use std::cell::{Cell, RefCell};
use uuid::Uuid;
/// Stores the Leo program abstract semantic graph (ASG).
#[derive(Clone)]
@ -37,7 +36,7 @@ pub struct InternalProgram<'a> {
pub context: AsgContext<'a>,
/// The unique id of the program.
pub id: Uuid,
pub id: u32,
/// The program file name.
pub name: String,
@ -137,7 +136,7 @@ impl<'a> InternalProgram<'a> {
/// 4. resolve all asg nodes
///
pub fn new<T: ImportResolver<'a>>(
arena: AsgContext<'a>,
context: AsgContext<'a>,
program: &leo_ast::Program,
import_resolver: &mut T,
) -> Result<Program<'a>, AsgConvertError> {
@ -161,7 +160,7 @@ impl<'a> InternalProgram<'a> {
let pretty_package = package.join(".");
let resolved_package = match wrapped_resolver.resolve_package(
arena,
context,
&package.iter().map(|x| &**x).collect::<Vec<_>>()[..],
span,
)? {
@ -214,9 +213,9 @@ impl<'a> InternalProgram<'a> {
}
}
let import_scope = match arena.alloc(ArenaNode::Scope(Scope {
arena,
id: uuid::Uuid::new_v4(),
let import_scope = match context.arena.alloc(ArenaNode::Scope(Scope {
context,
id: context.get_id(),
parent_scope: Cell::new(None),
circuit_self: Cell::new(None),
variables: RefCell::new(IndexMap::new()),
@ -230,9 +229,9 @@ impl<'a> InternalProgram<'a> {
};
let scope = import_scope.alloc_scope(Scope {
arena,
context,
input: Cell::new(Some(Input::new(import_scope))), // we use import_scope to avoid recursive scope ref here
id: uuid::Uuid::new_v4(),
id: context.get_id(),
parent_scope: Cell::new(Some(import_scope)),
circuit_self: Cell::new(None),
variables: RefCell::new(IndexMap::new()),
@ -296,8 +295,8 @@ impl<'a> InternalProgram<'a> {
}
Ok(InternalProgram {
context: arena,
id: Uuid::new_v4(),
context,
id: context.get_id(),
name: program.name.clone(),
test_functions,
functions,

24
asg/src/scope.rs
View File

@ -14,20 +14,18 @@
// 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::{ArenaNode, AsgConvertError, Circuit, Expression, Function, Input, Statement, Type, Variable};
use crate::{ArenaNode, AsgContext, AsgConvertError, Circuit, Expression, Function, Input, Statement, Type, Variable};
use indexmap::IndexMap;
use std::cell::{Cell, RefCell};
use typed_arena::Arena;
use uuid::Uuid;
/// An abstract data type that track the current bindings for variables, functions, and circuits.
#[derive(Clone)]
pub struct Scope<'a> {
pub arena: &'a Arena<ArenaNode<'a>>,
pub context: AsgContext<'a>,
/// The unique id of the scope.
pub id: Uuid,
pub id: u32,
/// The parent scope that this scope inherits.
pub parent_scope: Cell<Option<&'a Scope<'a>>>,
@ -54,42 +52,42 @@ pub struct Scope<'a> {
#[allow(clippy::mut_from_ref)]
impl<'a> Scope<'a> {
pub fn alloc_expression(&'a self, expr: Expression<'a>) -> &'a mut Expression<'a> {
match self.arena.alloc(ArenaNode::Expression(expr)) {
match self.context.arena.alloc(ArenaNode::Expression(expr)) {
ArenaNode::Expression(e) => e,
_ => unimplemented!(),
}
}
pub fn alloc_statement(&'a self, statement: Statement<'a>) -> &'a mut Statement<'a> {
match self.arena.alloc(ArenaNode::Statement(statement)) {
match self.context.arena.alloc(ArenaNode::Statement(statement)) {
ArenaNode::Statement(e) => e,
_ => unimplemented!(),
}
}
pub fn alloc_variable(&'a self, variable: Variable<'a>) -> &'a mut Variable<'a> {
match self.arena.alloc(ArenaNode::Variable(variable)) {
match self.context.arena.alloc(ArenaNode::Variable(variable)) {
ArenaNode::Variable(e) => e,
_ => unimplemented!(),
}
}
pub fn alloc_scope(&'a self, scope: Scope<'a>) -> &'a mut Scope<'a> {
match self.arena.alloc(ArenaNode::Scope(scope)) {
match self.context.arena.alloc(ArenaNode::Scope(scope)) {
ArenaNode::Scope(e) => e,
_ => unimplemented!(),
}
}
pub fn alloc_circuit(&'a self, circuit: Circuit<'a>) -> &'a mut Circuit<'a> {
match self.arena.alloc(ArenaNode::Circuit(circuit)) {
match self.context.arena.alloc(ArenaNode::Circuit(circuit)) {
ArenaNode::Circuit(e) => e,
_ => unimplemented!(),
}
}
pub fn alloc_function(&'a self, function: Function<'a>) -> &'a mut Function<'a> {
match self.arena.alloc(ArenaNode::Function(function)) {
match self.context.arena.alloc(ArenaNode::Function(function)) {
ArenaNode::Function(e) => e,
_ => unimplemented!(),
}
@ -198,8 +196,8 @@ impl<'a> Scope<'a> {
///
pub fn make_subscope(self: &'a Scope<'a>) -> &'a Scope<'a> {
self.alloc_scope(Scope::<'a> {
arena: self.arena,
id: Uuid::new_v4(),
context: self.context,
id: self.context.get_id(),
parent_scope: Cell::new(Some(self)),
circuit_self: Cell::new(None),
variables: RefCell::new(IndexMap::new()),

2
asg/src/statement/definition.rs
View File

@ -96,7 +96,7 @@ impl<'a> FromAst<'a, leo_ast::DefinitionStatement> for &'a Statement<'a> {
)));
}
variables.push(&*scope.alloc_variable(RefCell::new(InnerVariable {
id: uuid::Uuid::new_v4(),
id: scope.context.get_id(),
name: variable.identifier.clone(),
type_:
type_.ok_or_else(|| AsgConvertError::unresolved_type(&variable.identifier.name, &statement.span))?,

2
asg/src/statement/iteration.rs
View File

@ -58,7 +58,7 @@ impl<'a> FromAst<'a, leo_ast::IterationStatement> for &'a Statement<'a> {
let start = <&Expression<'a>>::from_ast(scope, &statement.start, expected_index_type.clone())?;
let stop = <&Expression<'a>>::from_ast(scope, &statement.stop, expected_index_type)?;
let variable = scope.alloc_variable(RefCell::new(InnerVariable {
id: uuid::Uuid::new_v4(),
id: scope.context.get_id(),
name: statement.variable.clone(),
type_: start
.get_type()

4
asg/src/variable.rs
View File

@ -19,8 +19,6 @@ use std::cell::RefCell;
use crate::{Expression, Statement, Type};
use leo_ast::Identifier;
use uuid::Uuid;
/// Specifies how a program variable was declared.
#[derive(Clone, Copy, PartialEq)]
pub enum VariableDeclaration {
@ -33,7 +31,7 @@ pub enum VariableDeclaration {
/// Stores information on a program variable.
#[derive(Clone)]
pub struct InnerVariable<'a> {
pub id: Uuid,
pub id: u32,
pub name: Identifier,
pub type_: Type<'a>,
pub mutable: bool,

4
asg/tests/fail/address/mod.rs
View File

@ -14,12 +14,10 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_implicit_invalid() {
let program_string = include_str!("implicit_invalid.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}

40
asg/tests/fail/array/mod.rs
View File

@ -14,8 +14,6 @@
// 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_asg::new_context;
use crate::load_asg;
// Expressions
@ -23,49 +21,49 @@ use crate::load_asg;
#[test]
fn test_initializer_fail() {
let program_string = include_str!("initializer_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_input_nested_3x2_fail() {
let program_string = include_str!("input_nested_3x2_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_input_tuple_3x2_fail() {
let program_string = include_str!("input_tuple_3x2_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_multi_fail_initializer() {
let program_string = include_str!("multi_fail_initializer.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_multi_inline_fail() {
let program_string = include_str!("multi_fail_inline.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_multi_initializer_fail() {
let program_string = include_str!("multi_initializer_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_nested_3x2_value_fail() {
let program_string = include_str!("nested_3x2_value_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_tuple_3x2_value_fail() {
let program_string = include_str!("tuple_3x2_value_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
// Array type tests
@ -73,65 +71,65 @@ fn test_tuple_3x2_value_fail() {
#[test]
fn test_type_fail() {
let program_string = include_str!("type_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_type_nested_value_nested_3x2_fail() {
let program_string = include_str!("type_nested_value_nested_3x2_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_type_nested_value_nested_4x3x2_fail() {
let program_string = include_str!("type_nested_value_nested_4x3x2_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_type_nested_value_tuple_3x2_fail() {
let program_string = include_str!("type_nested_value_tuple_3x2_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_type_nested_value_tuple_4x3x2_fail() {
let program_string = include_str!("type_nested_value_tuple_4x3x2_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_type_tuple_value_nested_3x2_fail() {
let program_string = include_str!("type_tuple_value_nested_3x2_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_type_tuple_value_nested_3x2_swap_fail() {
let program_string = include_str!("type_tuple_value_nested_3x2_swap_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_type_tuple_value_nested_4x3x2_fail() {
let program_string = include_str!("type_tuple_value_nested_4x3x2_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_type_tuple_value_tuple_3x2_fail() {
let program_string = include_str!("type_tuple_value_tuple_3x2_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_type_tuple_value_tuple_3x2_swap_fail() {
let program_string = include_str!("type_tuple_value_tuple_3x2_swap_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_type_tuple_value_tuple_4x3x2_fail() {
let program_string = include_str!("type_tuple_value_tuple_4x3x2_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}

8
asg/tests/fail/boolean/mod.rs
View File

@ -14,24 +14,22 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_not_u32() {
let program_string = include_str!("not_u32.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_true_or_u32() {
let program_string = include_str!("true_or_u32.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_true_and_u32() {
let program_string = include_str!("true_and_u32.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}

36
asg/tests/fail/circuits/mod.rs
View File

@ -14,8 +14,6 @@
// 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_asg::new_context;
use crate::load_asg;
// Expressions
@ -23,13 +21,13 @@ use crate::load_asg;
#[test]
fn test_inline_fail() {
let program_string = include_str!("inline_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_inline_undefined() {
let program_string = include_str!("inline_undefined.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
// Members
@ -37,19 +35,19 @@ fn test_inline_undefined() {
#[test]
fn test_member_variable_fail() {
let program_string = include_str!("member_variable_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_member_function_fail() {
let program_string = include_str!("member_function_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_member_function_invalid() {
let program_string = include_str!("member_function_invalid.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
@ -66,19 +64,19 @@ fn test_mut_member_function_fail() {
console.assert(a.echo(1u32) == 1u32);
}"#;
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_member_static_function_invalid() {
let program_string = include_str!("member_static_function_invalid.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_member_static_function_undefined() {
let program_string = include_str!("member_static_function_undefined.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
// Mutability
@ -86,37 +84,37 @@ fn test_member_static_function_undefined() {
#[test]
fn test_mutate_function_fail() {
let program_string = include_str!("mut_function_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_mutate_self_variable_fail() {
let program_string = include_str!("mut_self_variable_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_mutate_self_function_fail() {
let program_string = include_str!("mut_self_function_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_mutate_self_static_function_fail() {
let program_string = include_str!("mut_self_static_function_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_mutate_static_function_fail() {
let program_string = include_str!("mut_static_function_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_mutate_variable_fail() {
let program_string = include_str!("mut_variable_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
// Self
@ -124,17 +122,17 @@ fn test_mutate_variable_fail() {
#[test]
fn test_self_fail() {
let program_string = include_str!("self_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_self_member_invalid() {
let program_string = include_str!("self_member_invalid.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_self_member_undefined() {
let program_string = include_str!("self_member_undefined.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}

10
asg/tests/fail/console/mod.rs
View File

@ -14,30 +14,28 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_log_fail() {
let program_string = include_str!("log_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_log_parameter_fail_unknown() {
let program_string = include_str!("log_parameter_fail_unknown.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_log_parameter_fail_empty() {
let program_string = include_str!("log_parameter_fail_empty.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_log_parameter_fail_none() {
let program_string = include_str!("log_parameter_fail_empty.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}

10
asg/tests/fail/core/mod.rs
View File

@ -14,30 +14,28 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_core_circuit_invalid() {
let program_string = include_str!("core_package_invalid.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_core_circuit_star_fail() {
let program_string = include_str!("core_circuit_star_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_core_package_invalid() {
let program_string = include_str!("core_package_invalid.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_core_unstable_package_invalid() {
let program_string = include_str!("core_unstable_package_invalid.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}

18
asg/tests/fail/function/mod.rs
View File

@ -14,44 +14,42 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_multiple_returns_fail() {
let program_string = include_str!("multiple_returns_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_multiple_returns_input_ambiguous() {
let program_string = include_str!("multiple_returns_input_ambiguous.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_multiple_returns_fail_conditional() {
let program_string = include_str!("multiple_returns_fail_conditional.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_scope_fail() {
let program_string = include_str!("scope_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_undefined() {
let program_string = include_str!("undefined.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_array_input() {
let program_string = include_str!("array_input.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
// Test return multidimensional arrays
@ -59,11 +57,11 @@ fn test_array_input() {
#[test]
fn test_return_array_nested_fail() {
let program_string = include_str!("return_array_nested_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_return_array_tuple_fail() {
let program_string = include_str!("return_array_tuple_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}

6
asg/tests/fail/group/mod.rs
View File

@ -19,17 +19,17 @@ use crate::load_asg;
#[test]
fn test_both_sign_high() {
let program_string = include_str!("both_sign_high.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_both_sign_low() {
let program_string = include_str!("both_sign_low.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_both_sign_inferred() {
let program_string = include_str!("both_sign_inferred.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}

8
asg/tests/fail/integers/int_macro.rs
View File

@ -16,27 +16,25 @@
macro_rules! test_int {
($name: ident) => {
use leo_asg::new_context;
pub struct $name {}
// we are not doing constant folding here, so asg doesnt catch this
// impl $name {
// fn test_negate_min_fail() {
// let program_string = include_str!("negate_min.leo");
// crate::load_asg(&new_context(), program_string).err().unwrap();
// crate::load_asg(program_string).err().unwrap();
// }
// }
impl super::IntegerTester for $name {
fn test_min_fail() {
let program_string = include_str!("min_fail.leo");
crate::load_asg(&new_context(), program_string).err().unwrap();
crate::load_asg(program_string).err().unwrap();
}
fn test_max_fail() {
let program_string = include_str!("max_fail.leo");
crate::load_asg(&new_context(), program_string).err().unwrap();
crate::load_asg(program_string).err().unwrap();
}
}
};

6
asg/tests/fail/integers/uint_macro.rs
View File

@ -16,19 +16,17 @@
macro_rules! test_uint {
($name: ident) => {
use leo_asg::new_context;
pub struct $name {}
impl super::IntegerTester for $name {
fn test_min_fail() {
let program_string = include_str!("min_fail.leo");
crate::load_asg(&new_context(), program_string).err().unwrap();
crate::load_asg(program_string).err().unwrap();
}
fn test_max_fail() {
let program_string = include_str!("max_fail.leo");
crate::load_asg(&new_context(), program_string).err().unwrap();
crate::load_asg(program_string).err().unwrap();
}
}
};

16
asg/tests/fail/mutability/mod.rs
View File

@ -14,48 +14,46 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_let() {
let program_string = include_str!("let.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_const_fail() {
let program_string = include_str!("const.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_array() {
let program_string = include_str!("array.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_circuit() {
let program_string = include_str!("circuit.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_circuit_function_mut() {
let program_string = include_str!("circuit_function_mut.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_circuit_static_function_mut() {
let program_string = include_str!("circuit_static_function_mut.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_function_input() {
let program_string = include_str!("function_input.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}

6
asg/tests/fail/statements/mod.rs
View File

@ -14,18 +14,16 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use leo_asg::new_context;
use crate::load_asg;
#[test]
fn test_num_returns_fail() {
let program_string = include_str!("num_returns_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_const_declaration_fail() {
let program_string = include_str!("const_declaration_fail.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}

10
asg/tests/mod.rs
View File

@ -26,8 +26,8 @@ mod pass;
const TESTING_FILEPATH: &str = "input.leo";
const TESTING_PROGRAM_NAME: &str = "test_program";
fn load_asg<'a>(context: AsgContext<'a>, program_string: &str) -> Result<Program<'a>, AsgConvertError> {
load_asg_imports(context, program_string, &mut NullImportResolver)
fn load_asg(program_string: &str) -> Result<Program<'static>, AsgConvertError> {
load_asg_imports(make_test_context(), program_string, &mut NullImportResolver)
}
fn load_asg_imports<'a, T: ImportResolver<'a>>(
@ -44,3 +44,9 @@ fn mocked_resolver<'a>(_context: AsgContext<'a>) -> MockedImportResolver<'a> {
let packages = indexmap::IndexMap::new();
MockedImportResolver { packages }
}
//convenience function for tests, leaks memory
pub(crate) fn make_test_context() -> AsgContext<'static> {
let allocator = Box::leak(Box::new(new_alloc_context()));
new_context(allocator)
}

12
asg/tests/pass/address/mod.rs
View File

@ -14,37 +14,35 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_valid() {
let program_string = include_str!("valid.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_implicit_valid() {
let program_string = include_str!("implicit_valid.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_console_assert_pass() {
let program_string = include_str!("console_assert_pass.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_ternary() {
let program_string = include_str!("ternary.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_equal() {
let program_string = include_str!("equal.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

62
asg/tests/pass/array/mod.rs
View File

@ -14,8 +14,6 @@
// 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_asg::new_context;
use crate::load_asg;
// Registers
@ -23,7 +21,7 @@ use crate::load_asg;
#[test]
fn test_registers() {
let program_string = include_str!("registers.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// Expressions
@ -31,173 +29,173 @@ fn test_registers() {
#[test]
fn test_inline() {
let program_string = include_str!("inline.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_initializer() {
let program_string = include_str!("initializer.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_initializer_input() {
let program_string = include_str!("initializer_input.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_input_nested_3x2() {
let program_string = include_str!("input_nested_3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_input_tuple_3x2() {
let program_string = include_str!("input_tuple_3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_multi_initializer() {
let program_string = include_str!("multi_initializer.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_nested_3x2_value() {
let program_string = include_str!("nested_3x2_value.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_tuple_3x2_value() {
let program_string = include_str!("tuple_3x2_value.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_spread() {
let program_string = include_str!("spread.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_slice() {
let program_string = include_str!("slice.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_index_u8() {
let program_string = include_str!("index_u8.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_slice_i8() {
let program_string = include_str!("slice_i8.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_slice_lower() {
let program_string = include_str!("slice_lower.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_type_nested_value_nested_3x2() {
let program_string = include_str!("type_nested_value_nested_3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_type_nested_value_nested_4x3x2() {
let program_string = include_str!("type_nested_value_nested_4x3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_type_nested_value_tuple_3x2() {
let program_string = include_str!("type_nested_value_tuple_3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_type_nested_value_tuple_4x3x2() {
let program_string = include_str!("type_nested_value_tuple_4x3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_type_tuple_value_nested_3x2() {
let program_string = include_str!("type_tuple_value_nested_3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_type_tuple_value_nested_4x3x2() {
let program_string = include_str!("type_tuple_value_nested_4x3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_type_tuple_value_tuple_3x2() {
let program_string = include_str!("type_tuple_value_tuple_3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_type_tuple_value_tuple_4x3x2() {
let program_string = include_str!("type_tuple_value_tuple_4x3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_input_type_nested_value_nested_3x2() {
let program_string = include_str!("type_input_3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_input_type_nested_value_nested_4x3x2() {
let program_string = include_str!("type_input_4x3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_input_type_nested_value_tuple_3x2() {
let program_string = include_str!("type_input_3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_input_type_nested_value_tuple_4x3x2() {
let program_string = include_str!("type_input_4x3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_input_type_tuple_value_nested_3x2() {
let program_string = include_str!("type_input_3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_input_type_tuple_value_nested_4x3x2() {
let program_string = include_str!("type_input_4x3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_input_type_tuple_value_tuple_3x2() {
let program_string = include_str!("type_input_3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_input_type_tuple_value_tuple_4x3x2() {
let program_string = include_str!("type_input_4x3x2.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

26
asg/tests/pass/boolean/mod.rs
View File

@ -14,20 +14,18 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_input_pass() {
let program_string = include_str!("assert_eq_input.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_registers() {
let program_string = include_str!("output_register.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// Boolean not !
@ -35,19 +33,19 @@ fn test_registers() {
#[test]
fn test_not_true() {
let program_string = include_str!("not_true.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_not_false() {
let program_string = include_str!("not_false.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_not_mutable() {
let program_string = include_str!("not_mutable.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// Boolean or ||
@ -55,19 +53,19 @@ fn test_not_mutable() {
#[test]
fn test_true_or_true() {
let program_string = include_str!("true_or_true.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_true_or_false() {
let program_string = include_str!("true_or_false.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_false_or_false() {
let program_string = include_str!("false_or_false.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// Boolean and &&
@ -75,19 +73,19 @@ fn test_false_or_false() {
#[test]
fn test_true_and_true() {
let program_string = include_str!("true_and_true.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_true_and_false() {
let program_string = include_str!("true_and_false.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_false_and_false() {
let program_string = include_str!("false_and_false.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// All
@ -95,5 +93,5 @@ fn test_false_and_false() {
#[test]
fn test_all() {
let program_string = include_str!("all.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

32
asg/tests/pass/circuits/mod.rs
View File

@ -14,8 +14,6 @@
// 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_asg::new_context;
use crate::load_asg;
// Expressions
@ -23,7 +21,7 @@ use crate::load_asg;
#[test]
fn test_inline() {
let program_string = include_str!("inline.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// Members
@ -31,19 +29,19 @@ fn test_inline() {
#[test]
fn test_member_variable() {
let program_string = include_str!("member_variable.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_member_variable_and_function() {
let program_string = include_str!("member_variable_and_function.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_member_function() {
let program_string = include_str!("member_function.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
@ -60,25 +58,25 @@ fn test_mut_member_function() {
console.assert(a.echo(1u32) == 1u32);
}"#;
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_member_function_nested() {
let program_string = include_str!("member_function_nested.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_member_static_function() {
let program_string = include_str!("member_static_function.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_member_static_function_nested() {
let program_string = include_str!("member_static_function_nested.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// Mutability
@ -86,19 +84,19 @@ fn test_member_static_function_nested() {
#[test]
fn test_mutate_self_variable() {
let program_string = include_str!("mut_self_variable.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_mutate_self_variable_conditional() {
let program_string = include_str!("mut_self_variable_conditional.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_mutate_variable() {
let program_string = include_str!("mut_variable.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// Self
@ -106,7 +104,7 @@ fn test_mutate_variable() {
#[test]
fn test_self_member_pass() {
let program_string = include_str!("self_member.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// All
@ -114,13 +112,13 @@ fn test_self_member_pass() {
#[test]
fn test_pedersen_mock() {
let program_string = include_str!("pedersen_mock.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_define_circuit_inside_circuit_function() {
let program_string = include_str!("define_circuit_inside_circuit_function.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
@ -133,5 +131,5 @@ fn test_circuit_explicit_define() {
let x: One = One {x: 5};
}
"#;
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

18
asg/tests/pass/console/mod.rs
View File

@ -14,32 +14,30 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_log() {
let program_string = include_str!("log.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_log_parameter() {
let program_string = include_str!("log_parameter.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_log_parameter_many() {
let program_string = include_str!("log_parameter_many.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_log_input() {
let program_string = include_str!("log_input.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// Debug
@ -47,7 +45,7 @@ fn test_log_input() {
#[test]
fn test_debug() {
let program_string = include_str!("debug.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// Error
@ -55,7 +53,7 @@ fn test_debug() {
#[test]
fn test_error() {
let program_string = include_str!("error.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// Assertion
@ -63,11 +61,11 @@ fn test_error() {
#[test]
fn test_assert() {
let program_string = include_str!("assert.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_conditional_assert() {
let program_string = include_str!("conditional_assert.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

8
asg/tests/pass/core/mod.rs
View File

@ -14,24 +14,22 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_unstable_blake2s() {
let program_string = include_str!("unstable_blake2s.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_blake2s_input() {
let program_string = include_str!("blake2s_input.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_blake2s_random() {
let program_string = include_str!("blake2s_random.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

6
asg/tests/pass/definition/mod.rs
View File

@ -14,19 +14,17 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_out_of_order() {
let program_string = include_str!("out_of_order.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// #[test]
// #[ignore]
// fn test_out_of_order_with_import() {
// let program_string = include_str!("out_of_order_with_import.leo");
// load_asg(&new_context(), program_string).unwrap();
// load_asg(program_string).unwrap();
// }

20
asg/tests/pass/field/mod.rs
View File

@ -14,20 +14,18 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_negate() {
let program_string = include_str!("negate.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_add() {
let program_string = include_str!("add.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
@ -37,41 +35,41 @@ fn test_add_explicit() {
let c: field = 0field + 1field;
}
"#;
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_sub() {
let program_string = include_str!("sub.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_div() {
let program_string = include_str!("div.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_mul() {
let program_string = include_str!("mul.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_eq() {
let program_string = include_str!("eq.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_console_assert_pass() {
let program_string = include_str!("console_assert.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_ternary() {
let program_string = include_str!("ternary.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

14
asg/tests/pass/form_ast.rs
View File

@ -14,9 +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 leo_asg::new_context;
use crate::load_asg;
use crate::{load_asg, make_test_context};
use leo_ast::Ast;
use leo_grammar::Grammar;
@ -25,8 +23,7 @@ use std::path::Path;
#[test]
fn test_basic() {
let program_string = include_str!("./circuits/pedersen_mock.leo");
let context = new_context();
let asg = load_asg(&context, program_string).unwrap();
let asg = load_asg(program_string).unwrap();
let reformed_ast = leo_asg::reform_ast(&asg);
println!("{}", reformed_ast);
// panic!();
@ -51,8 +48,7 @@ fn test_function_rename() {
console.assert(total == 20);
}
"#;
let context = new_context();
let asg = load_asg(&context, program_string).unwrap();
let asg = load_asg(program_string).unwrap();
let reformed_ast = leo_asg::reform_ast(&asg);
println!("{}", reformed_ast);
// panic!();
@ -60,7 +56,7 @@ fn test_function_rename() {
#[test]
fn test_imports() {
let context = new_context();
let context = make_test_context();
let mut imports = crate::mocked_resolver(&context);
let test_import = r#"
circuit Point {
@ -74,7 +70,7 @@ fn test_imports() {
"#;
imports
.packages
.insert("test-import".to_string(), load_asg(&context, test_import).unwrap());
.insert("test-import".to_string(), load_asg(test_import).unwrap());
let program_string = r#"
import test-import.foo;

38
asg/tests/pass/function/mod.rs
View File

@ -14,20 +14,18 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_empty() {
let program_string = include_str!("empty.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_iteration() {
let program_string = include_str!("iteration.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
@ -47,7 +45,7 @@ fn test_const_args() {
console.assert(a == 20u32);
}
"#;
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
@ -68,7 +66,7 @@ fn test_const_args_used() {
console.assert(a == 6u8);
}
"#;
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
@ -87,61 +85,61 @@ fn test_const_args_fail() {
console.assert(a == 1u8);
}
"#;
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_iteration_repeated() {
let program_string = include_str!("iteration_repeated.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_newlines() {
let program_string = include_str!("newlines.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_multiple_returns() {
let program_string = include_str!("multiple_returns.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_multiple_returns_main() {
let program_string = include_str!("multiple_returns_main.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_repeated_function_call() {
let program_string = include_str!("repeated.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_return() {
let program_string = include_str!("return.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_undefined() {
let program_string = include_str!("undefined.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
#[test]
fn test_value_unchanged() {
let program_string = include_str!("value_unchanged.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_array_input() {
let program_string = include_str!("array_input.leo");
load_asg(&new_context(), program_string).err().unwrap();
load_asg(program_string).err().unwrap();
}
// Test return multidimensional arrays
@ -149,13 +147,13 @@ fn test_array_input() {
#[test]
fn test_return_array_nested_pass() {
let program_string = include_str!("return_array_nested_pass.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_return_array_tuple_pass() {
let program_string = include_str!("return_array_tuple_pass.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// Test return tuples
@ -163,11 +161,11 @@ fn test_return_array_tuple_pass() {
#[test]
fn test_return_tuple() {
let program_string = include_str!("return_tuple.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_return_tuple_conditional() {
let program_string = include_str!("return_tuple_conditional.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

40
asg/tests/pass/group/mod.rs
View File

@ -14,14 +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 leo_asg::new_context;
use crate::load_asg;
#[test]
fn test_one() {
let program_string = include_str!("one.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
@ -31,79 +29,79 @@ fn test_implicit() {
let element: group = 0;
}
"#;
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_zero() {
let program_string = include_str!("zero.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_point() {
let program_string = include_str!("point.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_x_sign_high() {
let program_string = include_str!("x_sign_high.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_x_sign_low() {
let program_string = include_str!("x_sign_low.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_x_sign_inferred() {
let program_string = include_str!("x_sign_inferred.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_y_sign_high() {
let program_string = include_str!("y_sign_high.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_y_sign_low() {
let program_string = include_str!("y_sign_low.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_y_sign_inferred() {
let program_string = include_str!("y_sign_inferred.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_point_input() {
let program_string = include_str!("point_input.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_input() {
let program_string = include_str!("input.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_negate() {
let program_string = include_str!("negate.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_add() {
let program_string = include_str!("add.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
@ -113,29 +111,29 @@ fn test_add_explicit() {
let c: group = 0group + 1group;
}
"#;
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_sub() {
let program_string = include_str!("sub.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_console_assert_pass() {
let program_string = include_str!("assert_eq.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_eq() {
let program_string = include_str!("eq.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_ternary() {
let program_string = include_str!("ternary.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

66
asg/tests/pass/import/mod.rs
View File

@ -14,17 +14,15 @@
// 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_asg::new_context;
use crate::{load_asg, load_asg_imports, mocked_resolver};
use crate::{load_asg, load_asg_imports, make_test_context, mocked_resolver};
#[test]
fn test_basic() {
let context = new_context();
let context = make_test_context();
let mut imports = mocked_resolver(&context);
imports.packages.insert(
"test-import".to_string(),
load_asg(&context, include_str!("src/test-import.leo")).unwrap(),
load_asg(include_str!("src/test-import.leo")).unwrap(),
);
let program_string = include_str!("basic.leo");
load_asg_imports(&context, program_string, &mut imports).unwrap();
@ -32,11 +30,11 @@ fn test_basic() {
#[test]
fn test_multiple() {
let context = new_context();
let context = make_test_context();
let mut imports = mocked_resolver(&context);
imports.packages.insert(
"test-import".to_string(),
load_asg(&context, include_str!("src/test-import.leo")).unwrap(),
load_asg(include_str!("src/test-import.leo")).unwrap(),
);
let program_string = include_str!("multiple.leo");
load_asg_imports(&context, program_string, &mut imports).unwrap();
@ -44,11 +42,11 @@ fn test_multiple() {
#[test]
fn test_star() {
let context = new_context();
let context = make_test_context();
let mut imports = mocked_resolver(&context);
imports.packages.insert(
"test-import".to_string(),
load_asg(&context, include_str!("src/test-import.leo")).unwrap(),
load_asg(include_str!("src/test-import.leo")).unwrap(),
);
let program_string = include_str!("star.leo");
@ -57,11 +55,11 @@ fn test_star() {
#[test]
fn test_alias() {
let context = new_context();
let context = make_test_context();
let mut imports = mocked_resolver(&context);
imports.packages.insert(
"test-import".to_string(),
load_asg(&context, include_str!("src/test-import.leo")).unwrap(),
load_asg(include_str!("src/test-import.leo")).unwrap(),
);
let program_string = include_str!("alias.leo");
@ -71,20 +69,18 @@ fn test_alias() {
// naming tests
#[test]
fn test_name() {
let context = new_context();
let context = make_test_context();
let mut imports = mocked_resolver(&context);
imports.packages.insert(
"hello-world".to_string(),
load_asg(&context, include_str!("src/hello-world.leo")).unwrap(),
);
imports.packages.insert(
"a0-f".to_string(),
load_asg(&context, include_str!("src/a0-f.leo")).unwrap(),
);
imports.packages.insert(
"a-9".to_string(),
load_asg(&context, include_str!("src/a-9.leo")).unwrap(),
load_asg(include_str!("src/hello-world.leo")).unwrap(),
);
imports
.packages
.insert("a0-f".to_string(), load_asg(include_str!("src/a0-f.leo")).unwrap());
imports
.packages
.insert("a-9".to_string(), load_asg(include_str!("src/a-9.leo")).unwrap());
let program_string = include_str!("names.leo");
load_asg_imports(&context, program_string, &mut imports).unwrap();
@ -93,31 +89,31 @@ fn test_name() {
// more complex tests
#[test]
fn test_many_import() {
let context = new_context();
let context = make_test_context();
let mut imports = mocked_resolver(&context);
imports.packages.insert(
"test-import".to_string(),
load_asg(&context, include_str!("src/test-import.leo")).unwrap(),
load_asg(include_str!("src/test-import.leo")).unwrap(),
);
imports.packages.insert(
"bar".to_string(),
load_asg(&context, include_str!("imports/bar/src/lib.leo")).unwrap(),
load_asg(include_str!("imports/bar/src/lib.leo")).unwrap(),
);
imports.packages.insert(
"bar.baz".to_string(),
load_asg(&context, include_str!("imports/bar/src/baz.leo")).unwrap(),
load_asg(include_str!("imports/bar/src/baz.leo")).unwrap(),
);
imports.packages.insert(
"bar.baz".to_string(),
load_asg(&context, include_str!("imports/bar/src/baz.leo")).unwrap(),
load_asg(include_str!("imports/bar/src/baz.leo")).unwrap(),
);
imports.packages.insert(
"bar.bat.bat".to_string(),
load_asg(&context, include_str!("imports/bar/src/bat/bat.leo")).unwrap(),
load_asg(include_str!("imports/bar/src/bat/bat.leo")).unwrap(),
);
imports.packages.insert(
"car".to_string(),
load_asg(&context, include_str!("imports/car/src/lib.leo")).unwrap(),
load_asg(include_str!("imports/car/src/lib.leo")).unwrap(),
);
let program_string = include_str!("many_import.leo");
@ -126,31 +122,31 @@ fn test_many_import() {
#[test]
fn test_many_import_star() {
let context = new_context();
let context = make_test_context();
let mut imports = mocked_resolver(&context);
imports.packages.insert(
"test-import".to_string(),
load_asg(&context, include_str!("src/test-import.leo")).unwrap(),
load_asg(include_str!("src/test-import.leo")).unwrap(),
);
imports.packages.insert(
"bar".to_string(),
load_asg(&context, include_str!("imports/bar/src/lib.leo")).unwrap(),
load_asg(include_str!("imports/bar/src/lib.leo")).unwrap(),
);
imports.packages.insert(
"bar.baz".to_string(),
load_asg(&context, include_str!("imports/bar/src/baz.leo")).unwrap(),
load_asg(include_str!("imports/bar/src/baz.leo")).unwrap(),
);
imports.packages.insert(
"bar.baz".to_string(),
load_asg(&context, include_str!("imports/bar/src/baz.leo")).unwrap(),
load_asg(include_str!("imports/bar/src/baz.leo")).unwrap(),
);
imports.packages.insert(
"bar.bat.bat".to_string(),
load_asg(&context, include_str!("imports/bar/src/bat/bat.leo")).unwrap(),
load_asg(include_str!("imports/bar/src/bat/bat.leo")).unwrap(),
);
imports.packages.insert(
"car".to_string(),
load_asg(&context, include_str!("imports/car/src/lib.leo")).unwrap(),
load_asg(include_str!("imports/car/src/lib.leo")).unwrap(),
);
let program_string = include_str!("many_import_star.leo");

6
asg/tests/pass/input_files/program_input/mod.rs
View File

@ -14,18 +14,16 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use leo_asg::new_context;
use crate::load_asg;
#[test]
fn test_input_pass() {
let program_string = include_str!("main.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_input_multiple() {
let program_string = include_str!("main_multiple.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

4
asg/tests/pass/input_files/program_input_and_program_state/mod.rs
View File

@ -14,12 +14,10 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_access() {
let program_string = include_str!("access.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

6
asg/tests/pass/input_files/program_state/mod.rs
View File

@ -14,18 +14,16 @@
// You should have received a copy of the GNU General Public License
// along with the Leo library. If not, see <https://www.gnu.org/licenses/>.
use leo_asg::new_context;
use crate::load_asg;
#[test]
fn test_access_state() {
let program_string = include_str!("access_state.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_access_all() {
let program_string = include_str!("access_all.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

36
asg/tests/pass/integers/int_macro.rs
View File

@ -16,96 +16,94 @@
macro_rules! test_int {
($name: ident) => {
use leo_asg::new_context;
pub struct $name {}
impl $name {
fn test_negate() {
let program_string = include_str!("negate.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_negate_zero() {
let program_string = include_str!("negate_zero.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
}
impl super::IntegerTester for $name {
fn test_min() {
let program_string = include_str!("min.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_max() {
let program_string = include_str!("max.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_add() {
let program_string = include_str!("add.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_sub() {
let program_string = include_str!("sub.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_mul() {
let program_string = include_str!("mul.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_div() {
let program_string = include_str!("div.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_pow() {
let program_string = include_str!("pow.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_eq() {
let program_string = include_str!("eq.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_ne() {
let program_string = include_str!("ne.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_ge() {
let program_string = include_str!("ge.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_gt() {
let program_string = include_str!("gt.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_le() {
let program_string = include_str!("le.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_lt() {
let program_string = include_str!("lt.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_console_assert() {
let program_string = include_str!("console_assert.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_ternary() {
let program_string = include_str!("ternary.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
}
};

32
asg/tests/pass/integers/uint_macro.rs
View File

@ -16,84 +16,82 @@
macro_rules! test_uint {
($name: ident) => {
use leo_asg::new_context;
pub struct $name {}
impl super::IntegerTester for $name {
fn test_min() {
let program_string = include_str!("min.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_max() {
let program_string = include_str!("max.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_add() {
let program_string = include_str!("add.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_sub() {
let program_string = include_str!("sub.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_mul() {
let program_string = include_str!("mul.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_div() {
let program_string = include_str!("div.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_pow() {
let program_string = include_str!("pow.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_eq() {
let program_string = include_str!("eq.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_ne() {
let program_string = include_str!("ne.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_ge() {
let program_string = include_str!("ge.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_gt() {
let program_string = include_str!("gt.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_le() {
let program_string = include_str!("le.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_lt() {
let program_string = include_str!("lt.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_console_assert() {
let program_string = include_str!("console_assert.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
fn test_ternary() {
let program_string = include_str!("ternary.leo");
crate::load_asg(&new_context(), program_string).unwrap();
crate::load_asg(program_string).unwrap();
}
}
};

20
asg/tests/pass/mutability/mod.rs
View File

@ -14,60 +14,58 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_let_mut() {
let program_string = include_str!("let_mut.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_let_mut_nested() {
let program_string = include_str!("let_mut_nested.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_array_mut() {
let program_string = include_str!("array_mut.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_array_tuple_mut() {
let program_string = include_str!("array_tuple_mut.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_array_splice_mut() {
let program_string = include_str!("array_splice_mut.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_circuit_mut() {
let program_string = include_str!("circuit_mut.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_circuit_variable_mut() {
let program_string = include_str!("circuit_variable_mut.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_function_input_mut() {
let program_string = include_str!("function_input_mut.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_swap() {
let program_string = include_str!("swap.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

14
asg/tests/pass/statements/conditional/mod.rs
View File

@ -14,42 +14,40 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_assert() {
let program_string = include_str!("assert.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_mutate() {
let program_string = include_str!("mutate.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_for_loop() {
let program_string = include_str!("for_loop.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_chain() {
let program_string = include_str!("chain.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_nested() {
let program_string = include_str!("nested.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_multiple_returns() {
let program_string = include_str!("multiple_returns.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

8
asg/tests/pass/statements/mod.rs
View File

@ -14,8 +14,6 @@
// 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_asg::new_context;
use crate::load_asg;
pub mod conditional;
@ -25,7 +23,7 @@ pub mod conditional;
#[test]
fn test_ternary_basic() {
let program_string = include_str!("ternary_basic.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
// Iteration for i {start}..{stop} { statements }
@ -33,11 +31,11 @@ fn test_ternary_basic() {
#[test]
fn test_iteration_basic() {
let program_string = include_str!("iteration_basic.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_block() {
let program_string = include_str!("block.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

24
asg/tests/pass/tuples/mod.rs
View File

@ -14,72 +14,70 @@
// 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_asg::new_context;
use crate::load_asg;
#[test]
fn test_tuple_basic() {
let program_string = include_str!("basic.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_tuple_access() {
let program_string = include_str!("access.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_tuple_typed() {
let program_string = include_str!("typed.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_multiple() {
let program_string = include_str!("multiple.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_multiple_typed() {
let program_string = include_str!("multiple_typed.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_function() {
let program_string = include_str!("function.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_function_typed() {
let program_string = include_str!("function_typed.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_function_multiple() {
let program_string = include_str!("function_multiple.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_nested() {
let program_string = include_str!("nested.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_nested_access() {
let program_string = include_str!("nested_access.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}
#[test]
fn test_nested_typed() {
let program_string = include_str!("nested_typed.leo");
load_asg(&new_context(), program_string).unwrap();
load_asg(program_string).unwrap();
}

4
compiler/Cargo.toml
View File

@ -108,10 +108,6 @@ version = "1.0"
[dependencies.tracing]
version = "0.1"
[dependencies.uuid]
version = "0.8"
features = [ "v4", "serde" ]
[dev-dependencies.num-bigint]
version = "0.3"

5
compiler/src/compiler.rs
View File

@ -47,7 +47,10 @@ use std::{
pub use leo_asg::{new_context, AsgContext as Context, AsgContext};
thread_local! {
static THREAD_GLOBAL_CONTEXT: AsgContext<'static> = Box::leak(Box::new(new_context()));
static THREAD_GLOBAL_CONTEXT: AsgContext<'static> = {
let leaked = Box::leak(Box::new(leo_asg::new_alloc_context()));
leo_asg::new_context(leaked)
}
}
/// Conventience function to return a leaked thread-local global context. Should only be used for transient programs (like cli).

5
compiler/src/expression/variable_ref/variable_ref.rs
View File

@ -26,10 +26,11 @@ impl<'a, F: PrimeField, G: GroupType<F>> ConstrainedProgram<'a, F, G> {
pub fn evaluate_ref(&mut self, variable_ref: &VariableRef) -> Result<ConstrainedValue<'a, F, G>, ExpressionError> {
// Evaluate the identifier name in the current function scope
let variable = variable_ref.variable.borrow();
let result_value = if let Some(value) = self.get(&variable.id) {
let result_value = if let Some(value) = self.get(variable.id) {
value.clone()
} else {
return Err(ExpressionError::undefined_identifier(variable.name.clone())); // todo: probably can be a panic here instead
return Err(ExpressionError::undefined_identifier(variable.name.clone()));
// todo: probably can be a panic here instead
};
Ok(result_value)

2
compiler/src/function/function.rs
View File

@ -83,7 +83,7 @@ impl<'a, F: PrimeField, G: GroupType<F>> ConstrainedProgram<'a, F, G> {
if function.qualifier == FunctionQualifier::MutSelfRef {
if let (Some(self_var), Some(target)) = (self_var, target) {
let new_self = self
.get(&self_var.borrow().id)
.get(self_var.borrow().id)
.expect("no self variable found in mut self context")
.clone();
if let Some(assignable_target) = self.resolve_mut_ref(cs, target)? {

2
compiler/src/function/mut_target.rs
View File

@ -104,7 +104,7 @@ impl<'a, F: PrimeField, G: GroupType<F>> ConstrainedProgram<'a, F, G> {
let variable = target.unwrap();
let variable = variable.borrow();
let mut result = vec![match self.get_mut(&variable.id) {
let mut result = vec![match self.get_mut(variable.id) {
Some(value) => value,
None => return Err(StatementError::undefined_variable(variable.name.to_string(), span)),
}];

15
compiler/src/program/program.rs
View File

@ -22,11 +22,10 @@ use leo_asg::Program;
use snarkvm_models::curves::PrimeField;
use indexmap::IndexMap;
use uuid::Uuid;
pub struct ConstrainedProgram<'a, F: PrimeField, G: GroupType<F>> {
pub asg: Program<'a>,
identifiers: IndexMap<Uuid, ConstrainedValue<'a, F, G>>,
identifiers: IndexMap<u32, ConstrainedValue<'a, F, G>>,
}
impl<'a, F: PrimeField, G: GroupType<F>> ConstrainedProgram<'a, F, G> {
@ -37,15 +36,15 @@ impl<'a, F: PrimeField, G: GroupType<F>> ConstrainedProgram<'a, F, G> {
}
}
pub(crate) fn store(&mut self, name: Uuid, value: ConstrainedValue<'a, F, G>) {
self.identifiers.insert(name, value);
pub(crate) fn store(&mut self, id: u32, value: ConstrainedValue<'a, F, G>) {
self.identifiers.insert(id, value);
}
pub(crate) fn get(&self, name: &Uuid) -> Option<&ConstrainedValue<'a, F, G>> {
self.identifiers.get(name)
pub(crate) fn get(&self, id: u32) -> Option<&ConstrainedValue<'a, F, G>> {
self.identifiers.get(&id)
}
pub(crate) fn get_mut(&mut self, name: &Uuid) -> Option<&mut ConstrainedValue<'a, F, G>> {
self.identifiers.get_mut(name)
pub(crate) fn get_mut(&mut self, id: u32) -> Option<&mut ConstrainedValue<'a, F, G>> {
self.identifiers.get_mut(&id)
}
}

2
compiler/src/statement/assign/assignee.rs
View File

@ -60,7 +60,7 @@ impl<'a, F: PrimeField, G: GroupType<F>> ConstrainedProgram<'a, F, G> {
let variable = assignee.target_variable.get().borrow();
let mut result = vec![match self.get_mut(&variable.id) {
let mut result = vec![match self.get_mut(variable.id) {
Some(value) => value,
None => return Err(StatementError::undefined_variable(variable.name.to_string(), span)),
}];

5
compiler/tests/mod.rs
View File

@ -36,7 +36,7 @@ pub mod statements;
pub mod syntax;
pub mod tuples;
use leo_asg::{new_context, AsgContext};
use leo_asg::{new_alloc_context, new_context, AsgContext};
use leo_ast::{InputValue, MainInput};
use leo_compiler::{
compiler::Compiler,
@ -60,7 +60,8 @@ pub type EdwardsConstrainedValue = ConstrainedValue<'static, Fq, EdwardsGroupTyp
//convenience function for tests, leaks memory
pub(crate) fn make_test_context() -> AsgContext<'static> {
Box::leak(Box::new(new_context()))
let allocator = Box::leak(Box::new(new_alloc_context()));
new_context(allocator)
}
fn new_compiler() -> EdwardsTestCompiler {