github-mig/ZoKrates
github-mig/ZoKrates
1
0
Fork 0
mirror of synced 2025-09-23 12:18:44 +00:00
Code Issues Projects Releases Wiki Activity

fix tests

Browse source
This commit is contained in:
schaeff 2022-06-15 14:28:40 +02:00
parent 241447a09c
commit aad6622488
8 changed files with 239 additions and 243 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

21
zokrates_core/src/absy/from_ast.rs
View file

@ -249,9 +249,7 @@ impl<'ast> From<pest::Parameter<'ast>> for absy::ParameterNode<'ast> {
)
.span(param.id.span);
absy::Parameter::new(variable)
.is_private(is_private)
.span(param.span)
absy::Parameter::new(variable, is_private).span(param.span)
}
}
@ -970,7 +968,7 @@ mod tests {
#[test]
fn arguments() {
let source = "def main(private field a, bool b) -> field: return 42";
let source = "def main(private field a, bool mut b) -> field: return 42";
let ast = pest::generate_ast(source).unwrap();
let expected: absy::Module = absy::Module {
@ -980,19 +978,12 @@ mod tests {
absy::Function {
arguments: vec![
absy::Parameter::private(
absy::Variable::new(
&source[23..24],
UnresolvedType::FieldElement.mock(),
)
.into(),
absy::Variable::immutable("a", UnresolvedType::FieldElement.mock())
.into(),
)
.into(),
absy::Parameter::public(
absy::Variable::new(
&source[31..32],
UnresolvedType::Boolean.mock(),
)
.into(),
absy::Variable::mutable("b", UnresolvedType::Boolean.mock()).into(),
)
.into(),
],
@ -1032,7 +1023,7 @@ mod tests {
symbol: absy::Symbol::Here(absy::SymbolDefinition::Function(
absy::Function {
arguments: vec![absy::Parameter::private(
absy::Variable::new("a", ty.clone().mock()).into(),
absy::Variable::new("a", ty.clone().mock(), false).into(),
)
.into()],
statements: vec![absy::Statement::Return(

16
zokrates_core/src/absy/parameter.rs
View file

@ -8,16 +8,16 @@ pub struct Parameter<'ast> {
}
impl<'ast> Parameter<'ast> {
pub fn new(v: VariableNode<'ast>) -> Self {
Parameter {
id: v,
is_private: true,
}
pub fn new(v: VariableNode<'ast>, is_private: bool) -> Self {
Parameter { id: v, is_private }
}
pub fn is_private(mut self, is_private: bool) -> Self {
self.is_private = is_private;
self
pub fn private(v: VariableNode<'ast>) -> Self {
Self::new(v, true)
}
pub fn public(v: VariableNode<'ast>) -> Self {
Self::new(v, false)
}
}

8
zokrates_core/src/absy/variable.rs
View file

@ -26,6 +26,14 @@ impl<'ast> Variable<'ast> {
}
}
pub fn immutable<S: Into<&'ast str>>(id: S, t: UnresolvedTypeNode<'ast>) -> Self {
Self::new(id, t, false)
}
pub fn mutable<S: Into<&'ast str>>(id: S, t: UnresolvedTypeNode<'ast>) -> Self {
Self::new(id, t, true)
}
pub fn get_type(&self) -> &UnresolvedType<'ast> {
&self._type.value
}

352
zokrates_core/src/semantics.rs
View file

@ -716,13 +716,12 @@ impl<'ast, T: Field> Checker<'ast, T> {
)
.into(),
);
self.insert_into_scope(Variable::new(
self.insert_into_scope(Variable::immutable(
CoreIdentifier::Constant(CanonicalConstantIdentifier::new(
declaration.id,
module_id.into(),
)),
c.get_type(),
false,
));
assert!(state
.constants
@ -908,10 +907,10 @@ impl<'ast, T: Field> Checker<'ast, T> {
id.clone(),
TypedConstantSymbol::There(imported_id)
).into());
self.insert_into_scope(Variable::new(CoreIdentifier::Constant(CanonicalConstantIdentifier::new(
self.insert_into_scope(Variable::immutable(CoreIdentifier::Constant(CanonicalConstantIdentifier::new(
declaration.id,
module_id.into(),
)), crate::typed_absy::types::try_from_g_type(ty.clone()).unwrap(), false));
)), crate::typed_absy::types::try_from_g_type(ty.clone()).unwrap()));
state
.constants
@ -1137,7 +1136,7 @@ impl<'ast, T: Field> Checker<'ast, T> {
// for declaration signatures, generics cannot be ignored
let v = Variable::new(generic.name(), Type::Uint(UBitwidth::B32), false);
let v = Variable::immutable(generic.name(), Type::Uint(UBitwidth::B32));
generics.0.insert(
generic.clone(),
@ -3820,7 +3819,7 @@ mod tests {
.mock()];
let arguments = vec![absy::Parameter {
id: absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(),
id: absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
is_private: true,
}
.mock()];
@ -4023,7 +4022,7 @@ mod tests {
let mut f0 = function0();
f0.value.arguments = vec![absy::Parameter::private(
absy::Variable::new(
absy::Variable::immutable(
"a",
UnresolvedType::array(
UnresolvedType::FieldElement.mock(),
@ -4044,7 +4043,7 @@ mod tests {
let mut f1 = function0();
f1.value.arguments = vec![absy::Parameter::private(
absy::Variable::new(
absy::Variable::immutable(
"a",
UnresolvedType::array(
UnresolvedType::FieldElement.mock(),
@ -4132,7 +4131,7 @@ mod tests {
let mut foo = function0();
foo.value.arguments = vec![absy::Parameter::private(
absy::Variable::new(
absy::Variable::immutable(
"a",
UnresolvedType::array(
UnresolvedType::FieldElement.mock(),
@ -4494,8 +4493,7 @@ mod tests {
// field a = b
// b undefined
let statement: StatementNode = Statement::Definition(
absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(),
false,
absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
Expression::Identifier("b").mock(),
)
.mock();
@ -4514,25 +4512,15 @@ mod tests {
#[test]
fn defined_variable_in_statement() {
// a = b
// field a = b
// b defined
let statement: StatementNode = Statement::Assignment(
Assignee::Identifier("a").mock(),
let statement: StatementNode = Statement::Definition(
absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
Expression::Identifier("b").mock(),
)
.mock();
let mut scope = Scope::default();
scope.insert(
ScopedIdentifier {
id: CoreIdentifier::Source("a"),
level: 1,
},
IdentifierInfo {
ty: Type::FieldElement,
is_mutable: true,
},
);
scope.insert(
ScopedIdentifier {
id: CoreIdentifier::Source("b"),
@ -4565,8 +4553,7 @@ mod tests {
let foo_args = vec![];
let foo_statements = vec![
Statement::Definition(
absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(),
false,
absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
Expression::IntConstant(1usize.into()).mock(),
)
.mock(),
@ -4647,8 +4634,7 @@ mod tests {
let foo_args = vec![];
let foo_statements = vec![
Statement::Definition(
absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(),
false,
absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
Expression::IntConstant(1usize.into()).mock(),
)
.mock(),
@ -4671,8 +4657,7 @@ mod tests {
let bar_args = vec![];
let bar_statements = vec![
Statement::Definition(
absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(),
false,
absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
Expression::IntConstant(2usize.into()).mock(),
)
.mock(),
@ -4744,7 +4729,7 @@ mod tests {
// should fail
let foo_statements: Vec<StatementNode> = vec![
Statement::For(
absy::Variable::new("i", UnresolvedType::Uint(32).mock()).mock(),
absy::Variable::immutable("i", UnresolvedType::Uint(32).mock()).mock(),
Expression::IntConstant(0usize.into()).mock(),
Expression::IntConstant(10usize.into()).mock(),
vec![],
@ -4790,15 +4775,14 @@ mod tests {
// should pass
let for_statements = vec![Statement::Definition(
absy::Variable::new("a", UnresolvedType::Uint(32).mock()).mock(),
false,
absy::Variable::immutable("a", UnresolvedType::Uint(32).mock()).mock(),
Expression::Identifier("i").mock(),
)
.mock()];
let foo_statements = vec![
Statement::For(
absy::Variable::new("i", UnresolvedType::Uint(32).mock()).mock(),
absy::Variable::immutable("i", UnresolvedType::Uint(32).mock()).mock(),
Expression::IntConstant(0usize.into()).mock(),
Expression::IntConstant(10usize.into()).mock(),
for_statements,
@ -4863,7 +4847,7 @@ mod tests {
let bar_statements: Vec<StatementNode> = vec![
Statement::MultipleDefinition(
vec![
absy::Variable::new("a", UnresolvedType::FieldElement.mock())
absy::Variable::immutable("a", UnresolvedType::FieldElement.mock())
.mock()
.into(),
],
@ -4986,7 +4970,7 @@ mod tests {
let bar_statements: Vec<StatementNode> = vec![
Statement::MultipleDefinition(
vec![
absy::Variable::new("a", UnresolvedType::FieldElement.mock())
absy::Variable::immutable("a", UnresolvedType::FieldElement.mock())
.mock()
.into(),
],
@ -5048,7 +5032,7 @@ mod tests {
let foo = Function {
arguments: vec![crate::absy::Parameter {
id: absy::Variable::new("x", UnresolvedType::FieldElement.mock()).mock(),
id: absy::Variable::immutable("x", UnresolvedType::FieldElement.mock()).mock(),
is_private: false,
}
.mock()],
@ -5065,10 +5049,10 @@ mod tests {
let main_statements: Vec<StatementNode> = vec![
Statement::MultipleDefinition(
vec![
absy::Variable::new("a", UnresolvedType::FieldElement.mock())
absy::Variable::immutable("a", UnresolvedType::FieldElement.mock())
.mock()
.into(),
absy::Variable::new("b", UnresolvedType::FieldElement.mock())
absy::Variable::immutable("b", UnresolvedType::FieldElement.mock())
.mock()
.into(),
],
@ -5254,7 +5238,7 @@ mod tests {
let main_statements: Vec<StatementNode> = vec![
Statement::Definition(
absy::Variable::new(
absy::Variable::mutable(
"a",
UnresolvedType::array(
UnresolvedType::FieldElement.mock(),
@ -5263,7 +5247,6 @@ mod tests {
.mock(),
)
.mock(),
true,
Expression::InlineArray(vec![absy::SpreadOrExpression::Expression(
Expression::IntConstant(0usize.into()).mock(),
)])
@ -5425,10 +5408,10 @@ mod tests {
let bar_statements: Vec<StatementNode> = vec![
Statement::MultipleDefinition(
vec![
absy::Variable::new("a", UnresolvedType::FieldElement.mock())
absy::Variable::immutable("a", UnresolvedType::FieldElement.mock())
.mock()
.into(),
absy::Variable::new("b", UnresolvedType::FieldElement.mock())
absy::Variable::immutable("b", UnresolvedType::FieldElement.mock())
.mock()
.into(),
],
@ -5523,11 +5506,11 @@ mod tests {
let mut f = function0();
f.value.arguments = vec![
absy::Parameter::private(
absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(),
absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
)
.mock(),
absy::Parameter::private(
absy::Variable::new("a", UnresolvedType::Boolean.mock()).mock(),
absy::Variable::immutable("a", UnresolvedType::Boolean.mock()).mock(),
)
.mock(),
];
@ -5566,7 +5549,7 @@ mod tests {
.mock()];
let main1_arguments = vec![crate::absy::Parameter {
id: absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(),
id: absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
is_private: false,
}
.mock()];
@ -5644,7 +5627,7 @@ mod tests {
// let mut checker: Checker<Bn128Field> = Checker::default();
// let _: Result<TypedStatement<Bn128Field>, Vec<ErrorInner>> = checker.check_statement(
// Statement::Definition(
// absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(),
// absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
// false,
// )
// .mock(),
@ -5654,7 +5637,7 @@ mod tests {
// let s2_checked: Result<TypedStatement<Bn128Field>, Vec<ErrorInner>> = checker
// .check_statement(
// Statement::Definition(
// absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(),
// absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
// false,
// )
// .mock(),
@ -5680,7 +5663,7 @@ mod tests {
// let mut checker: Checker<Bn128Field> = Checker::default();
// let _: Result<TypedStatement<Bn128Field>, Vec<ErrorInner>> = checker.check_statement(
// Statement::Definition(
// absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(),
// absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
// false,
// )
// .mock(),
@ -5690,7 +5673,7 @@ mod tests {
// let s2_checked: Result<TypedStatement<Bn128Field>, Vec<ErrorInner>> = checker
// .check_statement(
// Statement::Definition(
// absy::Variable::new("a", UnresolvedType::Boolean.mock()).mock(),
// absy::Variable::immutable("a", UnresolvedType::Boolean.mock()).mock(),
// false,
// )
// .mock(),
@ -6445,11 +6428,7 @@ mod tests {
let mut foo_field = function0();
foo_field.value.arguments = vec![absy::Parameter::private(
absy::Variable {
id: "a",
_type: UnresolvedType::FieldElement.mock(),
}
.mock(),
absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
)
.mock()];
foo_field.value.statements = vec![Statement::Return(
@ -6466,11 +6445,7 @@ mod tests {
let mut foo_u32 = function0();
foo_u32.value.arguments = vec![absy::Parameter::private(
absy::Variable {
id: "a",
_type: UnresolvedType::Uint(32).mock(),
}
.mock(),
absy::Variable::immutable("a", UnresolvedType::Uint(32).mock()).mock(),
)
.mock()];
foo_u32.value.statements = vec![Statement::Return(
@ -6540,136 +6515,153 @@ mod tests {
mod assignee {
use super::*;
// #[test]
// fn identifier() {
// // a = 42
// let a = Assignee::Identifier("a").mock();
#[test]
fn identifier() {
// a = 42
let a = Assignee::Identifier("a").mock();
// let mut checker: Checker<Bn128Field> = Checker::default();
// checker.enter_scope();
let mut checker: Checker<Bn128Field> = Checker::default();
checker.enter_scope();
// checker
// .check_statement(
// Statement::Definition(
// absy::Variable::new("a", UnresolvedType::FieldElement.mock()).mock(),
// false,
// )
// .mock(),
// &*MODULE_ID,
// &TypeMap::new(),
// )
// .unwrap();
checker
.check_statement(
Statement::Definition(
absy::Variable::mutable("a", UnresolvedType::FieldElement.mock()).mock(),
Expression::FieldConstant(42u32.into()).mock(),
)
.mock(),
&*MODULE_ID,
&TypeMap::new(),
)
.unwrap();
// assert_eq!(
// checker.check_assignee(a, &*MODULE_ID, &TypeMap::new()),
// Ok(TypedAssignee::Identifier(
// typed_absy::Variable::field_element("a")
// ))
// );
// }
assert_eq!(
checker.check_assignee(a, &*MODULE_ID, &TypeMap::new()),
Ok(TypedAssignee::Identifier(typed_absy::Variable::new(
"a",
Type::FieldElement,
true
)))
);
}
// #[test]
// fn array_element() {
// // field[33] a
// // a[2] = 42
// let a = Assignee::Select(
// box Assignee::Identifier("a").mock(),
// box RangeOrExpression::Expression(Expression::IntConstant(2usize.into()).mock()),
// )
// .mock();
#[test]
fn array_element() {
// field[3] a = [1, 2, 3]
// a[2] = 42
let a = Assignee::Select(
box Assignee::Identifier("a").mock(),
box RangeOrExpression::Expression(Expression::IntConstant(2usize.into()).mock()),
)
.mock();
// let mut checker: Checker<Bn128Field> = Checker::default();
// checker.enter_scope();
let mut checker: Checker<Bn128Field> = Checker::default();
checker.enter_scope();
// checker
// .check_statement(
// Statement::Definition(
// absy::Variable::new(
// "a",
// UnresolvedType::array(
// UnresolvedType::FieldElement.mock(),
// Expression::IntConstant(33usize.into()).mock(),
// )
// .mock(),
// )
// .mock(),
// false,
// )
// .mock(),
// &*MODULE_ID,
// &TypeMap::new(),
// )
// .unwrap();
checker
.check_statement(
Statement::Definition(
absy::Variable::mutable(
"a",
UnresolvedType::array(
UnresolvedType::FieldElement.mock(),
Expression::IntConstant(3usize.into()).mock(),
)
.mock(),
)
.mock(),
Expression::InlineArray(
(1..4)
.map(|i| {
Expression::FieldConstant(BigUint::from(i as u32))
.mock()
.into()
})
.collect(),
)
.mock(),
)
.mock(),
&*MODULE_ID,
&TypeMap::new(),
)
.unwrap();
// assert_eq!(
// checker.check_assignee(a, &*MODULE_ID, &TypeMap::new()),
// Ok(TypedAssignee::Select(
// box TypedAssignee::Identifier(typed_absy::Variable::field_array(
// "a",
// 33u32.into()
// )),
// box 2u32.into()
// ))
// );
// }
assert_eq!(
checker.check_assignee(a, &*MODULE_ID, &TypeMap::new()),
Ok(TypedAssignee::Select(
box TypedAssignee::Identifier(typed_absy::Variable::new(
"a",
Type::array((Type::FieldElement, 3u32)),
true,
)),
box 2u32.into()
))
);
}
// #[test]
// fn array_of_array_element() {
// // field[33][42] a
// // a[1][2]
// let a: AssigneeNode = Assignee::Select(
// box Assignee::Select(
// box Assignee::Identifier("a").mock(),
// box RangeOrExpression::Expression(
// Expression::IntConstant(1usize.into()).mock(),
// ),
// )
// .mock(),
// box RangeOrExpression::Expression(Expression::IntConstant(2usize.into()).mock()),
// )
// .mock();
#[test]
fn array_of_array_element() {
// field[1][1] a = [[1]]
// a[0][0]
let a: AssigneeNode = Assignee::Select(
box Assignee::Select(
box Assignee::Identifier("a").mock(),
box RangeOrExpression::Expression(
Expression::IntConstant(0usize.into()).mock(),
),
)
.mock(),
box RangeOrExpression::Expression(Expression::IntConstant(0usize.into()).mock()),
)
.mock();
// let mut checker: Checker<Bn128Field> = Checker::default();
// checker.enter_scope();
let mut checker: Checker<Bn128Field> = Checker::default();
checker.enter_scope();
// checker
// .check_statement(
// Statement::Definition(
// absy::Variable::new(
// "a",
// UnresolvedType::array(
// UnresolvedType::array(
// UnresolvedType::FieldElement.mock(),
// Expression::IntConstant(33usize.into()).mock(),
// )
// .mock(),
// Expression::IntConstant(42usize.into()).mock(),
// )
// .mock(),
// )
// .mock(),
// false,
// )
// .mock(),
// &*MODULE_ID,
// &TypeMap::new(),
// )
// .unwrap();
checker
.check_statement(
Statement::Definition(
absy::Variable::mutable(
"a",
UnresolvedType::array(
UnresolvedType::array(
UnresolvedType::FieldElement.mock(),
Expression::IntConstant(1usize.into()).mock(),
)
.mock(),
Expression::IntConstant(1usize.into()).mock(),
)
.mock(),
)
.mock(),
Expression::InlineArray(vec![Expression::InlineArray(vec![
Expression::IntConstant(1usize.into()).mock().into(),
])
.mock()
.into()])
.mock(),
)
.mock(),
&*MODULE_ID,
&TypeMap::new(),
)
.unwrap();
// assert_eq!(
// checker.check_assignee(a, &*MODULE_ID, &TypeMap::new()),
// Ok(TypedAssignee::Select(
// box TypedAssignee::Select(
// box TypedAssignee::Identifier(typed_absy::Variable::array(
// "a",
// Type::array((Type::FieldElement, 33u32)),
// 42u32,
// )),
// box 1u32.into()
// ),
// box 2u32.into()
// ))
// );
// }
assert_eq!(
checker.check_assignee(a, &*MODULE_ID, &TypeMap::new()),
Ok(TypedAssignee::Select(
box TypedAssignee::Select(
box TypedAssignee::Identifier(typed_absy::Variable::new(
"a",
Type::array((Type::array((Type::FieldElement, 1u32)), 1u32)),
true,
)),
box 0u32.into()
),
box 0u32.into()
))
);
}
}
}

20
zokrates_core/src/static_analysis/condition_redefiner.rs
View file

@ -1,7 +1,7 @@
use crate::typed_absy::{
folder::*, BlockExpression, BooleanExpression, Conditional, ConditionalExpression,
ConditionalOrExpression, CoreIdentifier, DeclarationType, Expr, Identifier, Type, TypedProgram,
TypedStatement, Variable,
ConditionalOrExpression, CoreIdentifier, Expr, Identifier, Type, TypedProgram, TypedStatement,
Variable,
};
use zokrates_field::Field;
@ -66,7 +66,7 @@ impl<'ast, T: Field> Folder<'ast, T> for ConditionRedefiner<'ast, T> {
condition => {
let condition_id = Identifier::from(CoreIdentifier::Condition(self.index));
self.buffer.push(TypedStatement::Definition(
Variable::new(condition_id.clone(), Type::Boolean, false).into(),
Variable::immutable(condition_id.clone(), Type::Boolean).into(),
condition.into(),
));
self.index += 1;
@ -164,7 +164,7 @@ mod tests {
let expected = vec![
// define condition
TypedStatement::Definition(
Variable::new(CoreIdentifier::Condition(0), Type::Boolean).into(),
Variable::immutable(CoreIdentifier::Condition(0), Type::Boolean).into(),
condition.into(),
),
// rewrite statement
@ -224,11 +224,11 @@ mod tests {
let expected = vec![
// define conditions
TypedStatement::Definition(
Variable::new(CoreIdentifier::Condition(0), Type::Boolean).into(),
Variable::immutable(CoreIdentifier::Condition(0), Type::Boolean).into(),
condition_0.into(),
),
TypedStatement::Definition(
Variable::new(CoreIdentifier::Condition(1), Type::Boolean).into(),
Variable::immutable(CoreIdentifier::Condition(1), Type::Boolean).into(),
condition_1.into(),
),
// rewrite statement
@ -332,7 +332,7 @@ mod tests {
let expected = vec![
// define conditions
TypedStatement::Definition(
Variable::new(CoreIdentifier::Condition(0), Type::Boolean).into(),
Variable::immutable(CoreIdentifier::Condition(0), Type::Boolean).into(),
condition_0.into(),
),
// rewrite statement
@ -347,7 +347,8 @@ mod tests {
FieldElementExpression::Number(Bn128Field::from(1)).into(),
),
TypedStatement::Definition(
Variable::new(CoreIdentifier::Condition(1), Type::Boolean).into(),
Variable::immutable(CoreIdentifier::Condition(1), Type::Boolean)
.into(),
condition_1.into(),
),
],
@ -365,7 +366,8 @@ mod tests {
FieldElementExpression::Number(Bn128Field::from(2)).into(),
),
TypedStatement::Definition(
Variable::new(CoreIdentifier::Condition(2), Type::Boolean).into(),
Variable::immutable(CoreIdentifier::Condition(2), Type::Boolean)
.into(),
condition_2.into(),
),
],

11
zokrates_core/src/static_analysis/reducer/shallow_ssa.rs
View file

@ -200,7 +200,7 @@ mod tests {
#[test]
fn detect_non_constant_bound() {
let loops: Vec<TypedStatement<Bn128Field>> = vec![TypedStatement::For(
Variable::uint("i", UBitwidth::B32),
Variable::new("i", Type::Uint(UBitwidth::B32), false),
UExpressionInner::Identifier("i".into()).annotate(UBitwidth::B32),
2u32.into(),
vec![],
@ -464,7 +464,7 @@ mod tests {
let array_of_array_ty = Type::array((Type::array((Type::FieldElement, 2u32)), 2u32));
let s = TypedStatement::Definition(
TypedAssignee::Identifier(Variable::new("a", array_of_array_ty.clone())),
TypedAssignee::Identifier(Variable::new("a", array_of_array_ty.clone(), true)),
ArrayExpressionInner::Value(
vec![
ArrayExpressionInner::Value(
@ -498,6 +498,7 @@ mod tests {
TypedAssignee::Identifier(Variable::new(
Identifier::from("a").version(0),
array_of_array_ty.clone(),
true,
)),
ArrayExpressionInner::Value(
vec![
@ -529,7 +530,11 @@ mod tests {
let s: TypedStatement<Bn128Field> = TypedStatement::Definition(
TypedAssignee::Select(
box TypedAssignee::Identifier(Variable::new("a", array_of_array_ty.clone())),
box TypedAssignee::Identifier(Variable::new(
"a",
array_of_array_ty.clone(),
true,
)),
box UExpression::from(1u32),
),
ArrayExpressionInner::Value(

5
zokrates_core/src/typed_absy/abi.rs
View file

@ -33,6 +33,7 @@ mod tests {
use crate::typed_absy::types::{
ConcreteArrayType, ConcreteFunctionKey, ConcreteStructMember, ConcreteStructType, UBitwidth,
};
use crate::typed_absy::DeclarationType;
use crate::typed_absy::{
parameter::DeclarationParameter, variable::DeclarationVariable, ConcreteTupleType,
ConcreteType, TypedFunction, TypedFunctionSymbol, TypedFunctionSymbolDeclaration,
@ -48,11 +49,11 @@ mod tests {
TypedFunctionSymbol::Here(TypedFunction {
arguments: vec![
DeclarationParameter {
id: DeclarationVariable::field_element("a"),
id: DeclarationVariable::new("a", DeclarationType::FieldElement, true),
private: true,
},
DeclarationParameter {
id: DeclarationVariable::boolean("b"),
id: DeclarationVariable::new("b", DeclarationType::Boolean, false),
private: false,
},
],

49
zokrates_core/src/typed_absy/variable.rs
View file

@ -5,7 +5,7 @@ use crate::typed_absy::UExpression;
use crate::typed_absy::{TryFrom, TryInto};
use std::fmt;
#[derive(Clone, PartialEq, Hash, Eq, PartialOrd, Ord)]
#[derive(Clone, PartialEq, Hash, Eq, PartialOrd, Ord, Debug)]
pub struct GVariable<'ast, S> {
pub id: Identifier<'ast>,
pub _type: GType<S>,
@ -55,30 +55,33 @@ pub fn try_from_g_variable<T: TryInto<U>, U>(
}
impl<'ast, S: Clone> GVariable<'ast, S> {
// pub fn field_element<I: Into<Identifier<'ast>>>(id: I) -> Self {
// Self::new(id, GType::FieldElement)
// }
pub fn field_element<I: Into<Identifier<'ast>>>(id: I) -> Self {
Self::immutable(id, GType::FieldElement)
}
// pub fn boolean<I: Into<Identifier<'ast>>>(id: I) -> Self {
// Self::new(id, GType::Boolean)
// }
pub fn boolean<I: Into<Identifier<'ast>>>(id: I) -> Self {
Self::immutable(id, GType::Boolean)
}
// pub fn uint<I: Into<Identifier<'ast>>, W: Into<UBitwidth>>(id: I, bitwidth: W) -> Self {
// Self::new(id, GType::uint(bitwidth))
// }
pub fn uint<I: Into<Identifier<'ast>>, W: Into<UBitwidth>>(id: I, bitwidth: W) -> Self {
Self::immutable(id, GType::uint(bitwidth))
}
// #[cfg(test)]
// pub fn field_array<I: Into<Identifier<'ast>>>(id: I, size: S) -> Self {
// Self::array(id, GType::FieldElement, size)
// }
pub fn array<I: Into<Identifier<'ast>>, U: Into<S>>(id: I, ty: GType<S>, size: U) -> Self {
Self::immutable(id, GType::array((ty, size.into())))
}
// pub fn array<I: Into<Identifier<'ast>>, U: Into<S>>(id: I, ty: GType<S>, size: U) -> Self {
// Self::new(id, GType::array((ty, size.into())))
// }
pub fn struc<I: Into<Identifier<'ast>>>(id: I, ty: GStructType<S>) -> Self {
Self::immutable(id, GType::Struct(ty))
}
// pub fn struc<I: Into<Identifier<'ast>>>(id: I, ty: GStructType<S>) -> Self {
// Self::new(id, GType::Struct(ty))
// }
pub fn immutable<I: Into<Identifier<'ast>>>(id: I, _type: GType<S>) -> Self {
Self::new(id, _type, false)
}
pub fn mutable<I: Into<Identifier<'ast>>>(id: I, _type: GType<S>) -> Self {
Self::new(id, _type, true)
}
pub fn new<I: Into<Identifier<'ast>>>(id: I, _type: GType<S>, is_mutable: bool) -> Self {
GVariable {
@ -98,9 +101,3 @@ impl<'ast, S: fmt::Display> fmt::Display for GVariable<'ast, S> {
write!(f, "{} {}", self._type, self.id,)
}
}
impl<'ast, S: fmt::Debug> fmt::Debug for GVariable<'ast, S> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
write!(f, "Variable(type: {:?}, id: {:?})", self._type, self.id,)
}
}