github-mig/ZoKrates
github-mig/ZoKrates
1
0
Fork 0
mirror of synced 2025-09-24 04:40:05 +00:00
Code Issues Projects Releases Wiki Activity

clean

Browse source
This commit is contained in:
schaeff 2022-06-15 17:46:06 +02:00
parent 15dcee9978
commit 4a593664e3
2 changed files with 141 additions and 144 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

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

@ -201,11 +201,7 @@ impl<'ast> From<pest::FunctionDefinition<'ast>> for absy::SymbolDeclarationNode<
.into_iter() .into_iter()
.map(absy::ParameterNode::from) .map(absy::ParameterNode::from)
.collect(), .collect(),
statements: function statements: function.statements.into_iter().map(|s| s.into()).collect(),
.statements
.into_iter()
.flat_map(statements_from_statement)
.collect(),
signature, signature,
} }
.span(span.clone()); .span(span.clone());
@ -266,77 +262,81 @@ impl<'ast> From<pest::TypedIdentifier<'ast>> for absy::VariableNode<'ast> {
} }
} }
fn statements_from_statement(statement: pest::Statement) -> Vec<absy::StatementNode> { impl<'ast> From<pest::Statement<'ast>> for absy::StatementNode<'ast> {
match statement { fn from(statement: pest::Statement<'ast>) -> Self {
pest::Statement::Definition(s) => vec![statement_from_definition(s)], match statement {
pest::Statement::Iteration(s) => vec![absy::StatementNode::from(s)], pest::Statement::Definition(s) => absy::StatementNode::from(s),
pest::Statement::Assertion(s) => vec![absy::StatementNode::from(s)], pest::Statement::Iteration(s) => absy::StatementNode::from(s),
pest::Statement::Return(s) => vec![absy::StatementNode::from(s)], pest::Statement::Assertion(s) => absy::StatementNode::from(s),
pest::Statement::Return(s) => absy::StatementNode::from(s),
}
} }
} }
fn statement_from_definition(definition: pest::DefinitionStatement) -> absy::StatementNode { impl<'ast> From<pest::DefinitionStatement<'ast>> for absy::StatementNode<'ast> {
use crate::absy::NodeValue; fn from(definition: pest::DefinitionStatement<'ast>) -> Self {
use crate::absy::NodeValue;
let lhs = definition.lhs; let lhs = definition.lhs;
match lhs.len() { match lhs.len() {
1 => { 1 => {
// Definition or assignment // Definition or assignment
let a = lhs[0].clone(); let a = lhs[0].clone();
let e: absy::ExpressionNode = absy::ExpressionNode::from(definition.expression); let e: absy::ExpressionNode = absy::ExpressionNode::from(definition.expression);
match a { match a {
pest::TypedIdentifierOrAssignee::TypedIdentifier(i) => match e.value { pest::TypedIdentifierOrAssignee::TypedIdentifier(i) => match e.value {
absy::Expression::FunctionCall(..) => absy::Statement::MultipleDefinition( absy::Expression::FunctionCall(..) => absy::Statement::MultipleDefinition(
vec![absy::Variable::new( vec![absy::Variable::new(
i.identifier.span.as_str(), i.identifier.span.as_str(),
absy::UnresolvedTypeNode::from(i.ty), absy::UnresolvedTypeNode::from(i.ty),
i.mutable.is_some(), i.mutable.is_some(),
) )
.span(i.span.clone()) .span(i.span.clone())
.into()], .into()],
e, e,
), ),
_ => absy::Statement::Definition( _ => absy::Statement::Definition(
absy::Variable::new( absy::Variable::new(
i.identifier.span.as_str(), i.identifier.span.as_str(),
absy::UnresolvedTypeNode::from(i.ty), absy::UnresolvedTypeNode::from(i.ty),
i.mutable.is_some(), i.mutable.is_some(),
) )
.span(i.span.clone()), .span(i.span.clone()),
e, e,
), ),
}, },
pest::TypedIdentifierOrAssignee::Assignee(a) => match e.value { pest::TypedIdentifierOrAssignee::Assignee(a) => match e.value {
absy::Expression::FunctionCall(..) => absy::Statement::MultipleDefinition( absy::Expression::FunctionCall(..) => absy::Statement::MultipleDefinition(
vec![VariableOrAssignee::Assignee(absy::AssigneeNode::from(a))], vec![VariableOrAssignee::Assignee(absy::AssigneeNode::from(a))],
e, e,
), ),
_ => absy::Statement::Assignment(absy::AssigneeNode::from(a), e), _ => absy::Statement::Assignment(absy::AssigneeNode::from(a), e),
}, },
}
.span(definition.span.clone())
} }
.span(definition.span.clone()) _ => {
} let lhs = lhs
_ => { .into_iter()
let lhs = lhs .map(|i| match i {
.into_iter() pest::TypedIdentifierOrAssignee::TypedIdentifier(i) => {
.map(|i| match i { absy::VariableOrAssignee::Variable(absy::VariableNode::from(i))
pest::TypedIdentifierOrAssignee::TypedIdentifier(i) => { }
absy::VariableOrAssignee::Variable(absy::VariableNode::from(i)) pest::TypedIdentifierOrAssignee::Assignee(a) => {
} absy::VariableOrAssignee::Assignee(absy::AssigneeNode::from(a))
pest::TypedIdentifierOrAssignee::Assignee(a) => { }
absy::VariableOrAssignee::Assignee(absy::AssigneeNode::from(a)) })
} .collect();
})
.collect();
absy::Statement::MultipleDefinition( absy::Statement::MultipleDefinition(
lhs, lhs,
absy::ExpressionNode::from(definition.expression), absy::ExpressionNode::from(definition.expression),
) )
.span(definition.span) .span(definition.span)
}
} }
} }
} }
@ -377,11 +377,8 @@ impl<'ast> From<pest::IterationStatement<'ast>> for absy::StatementNode<'ast> {
let index = absy::VariableNode::from(statement.index); let index = absy::VariableNode::from(statement.index);
let from = absy::ExpressionNode::from(statement.from); let from = absy::ExpressionNode::from(statement.from);
let to = absy::ExpressionNode::from(statement.to); let to = absy::ExpressionNode::from(statement.to);
let statements: Vec<absy::StatementNode<'ast>> = statement let statements: Vec<absy::StatementNode<'ast>> =
.statements statement.statements.into_iter().map(|s| s.into()).collect();
.into_iter()
.flat_map(statements_from_statement)
.collect();
absy::Statement::For(index, from, to, statements).span(statement.span) absy::Statement::For(index, from, to, statements).span(statement.span)
} }
@ -1260,7 +1257,7 @@ mod tests {
span: span.clone(), span: span.clone(),
}; };
let statement = statement_from_definition(definition); let statement = absy::StatementNode::from(definition);
match statement.value { match statement.value {
absy::Statement::Assignment(..) => {} absy::Statement::Assignment(..) => {}
@ -1299,7 +1296,7 @@ mod tests {
span: span.clone(), span: span.clone(),
}; };
let statement = statement_from_definition(definition); let statement = absy::StatementNode::from(definition);
match statement.value { match statement.value {
absy::Statement::MultipleDefinition(..) => {} absy::Statement::MultipleDefinition(..) => {}
@ -1352,9 +1349,9 @@ mod tests {
span: span.clone(), span: span.clone(),
}; };
let statements = statement_from_definition(definition); let statement = absy::StatementNode::from(definition);
match statements.value { match statement.value {
absy::Statement::MultipleDefinition(..) => {} absy::Statement::MultipleDefinition(..) => {}
s => { s => {
panic!("should be a Definition, found {}", s); panic!("should be a Definition, found {}", s);

136
zokrates_core/src/semantics.rs
View file

@ -5617,77 +5617,77 @@ mod tests {
); );
} }
// #[test] #[test]
// fn shadowing_with_same_type() { fn shadowing_with_same_type() {
// // field a // field a = 2
// // field a // field a = 2
// // //
// // should fail // should fail
// let mut checker: Checker<Bn128Field> = Checker::default(); let mut checker: Checker<Bn128Field> = Checker::default();
// let _: Result<TypedStatement<Bn128Field>, Vec<ErrorInner>> = checker.check_statement( let _: Result<TypedStatement<Bn128Field>, Vec<ErrorInner>> = checker.check_statement(
// Statement::Definition( Statement::Definition(
// absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(), absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
// false, absy::Expression::IntConstant(2usize.into()).mock(),
// ) )
// .mock(), .mock(),
// &*MODULE_ID, &*MODULE_ID,
// &TypeMap::new(), &TypeMap::new(),
// ); );
// let s2_checked: Result<TypedStatement<Bn128Field>, Vec<ErrorInner>> = checker let s2_checked: Result<TypedStatement<Bn128Field>, Vec<ErrorInner>> = checker
// .check_statement( .check_statement(
// Statement::Definition( Statement::Definition(
// absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(), absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
// false, absy::Expression::IntConstant(2usize.into()).mock(),
// ) )
// .mock(), .mock(),
// &*MODULE_ID, &*MODULE_ID,
// &TypeMap::new(), &TypeMap::new(),
// ); );
// assert_eq!( assert_eq!(
// s2_checked, s2_checked,
// Err(vec![ErrorInner { Err(vec![ErrorInner {
// pos: Some((Position::mock(), Position::mock())), pos: Some((Position::mock(), Position::mock())),
// message: "Duplicate declaration for variable named a".into() message: "Duplicate declaration for variable named a".into()
// }]) }])
// ); );
// } }
// #[test] #[test]
// fn shadowing_with_different_type() { fn shadowing_with_different_type() {
// // field a // field a = 2
// // bool a // bool a = true
// // //
// // should fail // should fail
// let mut checker: Checker<Bn128Field> = Checker::default(); let mut checker: Checker<Bn128Field> = Checker::default();
// let _: Result<TypedStatement<Bn128Field>, Vec<ErrorInner>> = checker.check_statement( let _: Result<TypedStatement<Bn128Field>, Vec<ErrorInner>> = checker.check_statement(
// Statement::Definition( Statement::Definition(
// absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(), absy::Variable::immutable("a", UnresolvedType::FieldElement.mock()).mock(),
// false, absy::Expression::IntConstant(2usize.into()).mock(),
// ) )
// .mock(), .mock(),
// &*MODULE_ID, &*MODULE_ID,
// &TypeMap::new(), &TypeMap::new(),
// ); );
// let s2_checked: Result<TypedStatement<Bn128Field>, Vec<ErrorInner>> = checker let s2_checked: Result<TypedStatement<Bn128Field>, Vec<ErrorInner>> = checker
// .check_statement( .check_statement(
// Statement::Definition( Statement::Definition(
// absy::Variable::immutable("a", UnresolvedType::Boolean.mock()).mock(), absy::Variable::immutable("a", UnresolvedType::Boolean.mock()).mock(),
// false, absy::Expression::BooleanConstant(true).mock(),
// ) )
// .mock(), .mock(),
// &*MODULE_ID, &*MODULE_ID,
// &TypeMap::new(), &TypeMap::new(),
// ); );
// assert_eq!( assert_eq!(
// s2_checked, s2_checked,
// Err(vec![ErrorInner { Err(vec![ErrorInner {
// pos: Some((Position::mock(), Position::mock())), pos: Some((Position::mock(), Position::mock())),
// message: "Duplicate declaration for variable named a".into() message: "Duplicate declaration for variable named a".into()
// }]) }])
// ); );
// } }
mod structs { mod structs {
use super::*; use super::*;