From a48f945e264a9c8d95f03a51b3c3b2d98ba1c083 Mon Sep 17 00:00:00 2001 From: frogmonkee <51428047+frogmonkee@users.noreply.github.com> Date: Fri, 14 Jun 2019 16:35:56 -0400 Subject: [PATCH 1/2] Test Commit --- tests/parser_integration_tests.rs | 8 +++++--- 1 file changed, 5 insertions(+), 3 deletions(-) diff --git a/tests/parser_integration_tests.rs b/tests/parser_integration_tests.rs index 7149090..e370dc8 100644 --- a/tests/parser_integration_tests.rs +++ b/tests/parser_integration_tests.rs @@ -1,5 +1,7 @@ extern crate solfix; +//Solfix + #[cfg(test)] mod parser_integration_tests { use solfix::lex_4_25; @@ -28,7 +30,7 @@ mod parser_integration_tests { Box::new(ParseNode { node: lex_4_25::Token::OpenBrace, children: vec![ - Box::new(ParseNode { + Box::new(ParseNode { node: lex_4_25::Token::StateVariable, children: vec![ Box::new(lex_4_25::Token::Address.to_leaf()), @@ -36,7 +38,7 @@ mod parser_integration_tests { Box::new(lex_4_25::Token::Identifier("owner".to_string()).to_leaf()) ] }), - Box::new(ParseNode { + Box::new(ParseNode { node: lex_4_25::Token::Modifier, children: vec![ Box::new(lex_4_25::Token::Identifier("onlyOwner".to_string()).to_leaf()), @@ -195,4 +197,4 @@ mod parser_integration_tests { assert_eq!(expected_tree, actual_tree); } */ -} +} From 8665ce6e7c758ba8f544e06983c1bb9ad846cd86 Mon Sep 17 00:00:00 2001 From: frogmonkee <51428047+frogmonkee@users.noreply.github.com> Date: Fri, 14 Jun 2019 18:28:56 -0400 Subject: [PATCH 2/2] Integration tests added for IACLOracle.sol - Contains errors --- Git_Command_Directory.txt | 9 ++++ contracts/IACLOracle.sol | 5 ++ src/parse_4_25.rs | 88 +++++++++++++++--------------- tests/parser_integration_tests.rs | 89 +++++++++++++++++++++++++++++++ 4 files changed, 147 insertions(+), 44 deletions(-) create mode 100644 Git_Command_Directory.txt create mode 100644 contracts/IACLOracle.sol diff --git a/Git_Command_Directory.txt b/Git_Command_Directory.txt new file mode 100644 index 0000000..31c1574 --- /dev/null +++ b/Git_Command_Directory.txt @@ -0,0 +1,9 @@ +git status /git diff - shows any changes made to local files relative to repo +git pull - pulls latest changes to repo (by branch) +git checkout -b '...' - Creates a separate branch +git add . - Prepares changes to be made to repo, LOCALLY (for all files) (draft -> final copy) +git commit -m "[Message]" - Creates new version of file system based on what was 'git add'ed after the previous commit +git push origin 'Branch' - Pushes commit to Github + +cargo test = Runs all tests +pwd = print working director \ No newline at end of file diff --git a/contracts/IACLOracle.sol b/contracts/IACLOracle.sol new file mode 100644 index 0000000..4486df2 --- /dev/null +++ b/contracts/IACLOracle.sol @@ -0,0 +1,5 @@ +pragma solidity ^0.4.25; + +interface IACLOracle { + function canPerform(address who, address where, bytes32 what, uint256[] how) external view returns (bool); +} diff --git a/src/parse_4_25.rs b/src/parse_4_25.rs index 1530f1f..a876cf6 100644 --- a/src/parse_4_25.rs +++ b/src/parse_4_25.rs @@ -13,8 +13,8 @@ pub struct ParseNode { impl ParseNode { // Add a token to this node's children - fn add_child(&mut self, token: lex_4_25::Token) { - self.children.push(Box::new(ParseNode{ node: token, children: vec![] })); + fn add_child(&mut self, token: lex_4_25::Token) { + self.children.push(Box::new(ParseNode{ node: token, children: vec![] })); } fn remove_left_child(&mut self) -> Box { self.children.remove(0) } @@ -50,7 +50,7 @@ pub fn parse(input: String) -> ParseTree { let current_node = &mut ParseNode::empty(); let mut tree = ParseTree{ children: vec![] }; let cur = &mut 0; - let input_chars = &mut input.chars().collect::>(); + let input_chars = &mut input.chars().collect::>(); while *cur < input_chars.len() { match lex_4_25::peek_token(input_chars, cur) { lex_4_25::Token::Pragma => { @@ -83,12 +83,12 @@ pub fn parse(input: String) -> ParseTree { /*** Pragma ***/ -pub fn parse_pragma(chars: &Vec, cur: &mut usize) -> ParseNode { +pub fn parse_pragma(chars: &Vec, cur: &mut usize) -> ParseNode { let mut result = ParseNode::empty(); - match lex_4_25::next_token(chars, cur) { + match lex_4_25::next_token(chars, cur) { lex_4_25::Token::Pragma => result.node = lex_4_25::Token::Pragma, _ => panic!("Invalid pragma declaration") - } + } match lex_4_25::next_token(chars, cur) { lex_4_25::Token::Identifier(name) => { if name != "solidity" { @@ -113,11 +113,11 @@ pub fn parse_pragma(chars: &Vec, cur: &mut usize) -> ParseNode { _ => panic!("Invalid pragma declaration") } match lex_4_25::next_token(&chars, cur) { - lex_4_25::Token::Semicolon => (), + lex_4_25::Token::Semicolon => (), _ => panic!("Invalid pragma declaration") } result -} +} /*** Import ***/ @@ -143,7 +143,7 @@ fn parse_contract(chars: &Vec, cur: &mut usize) -> ParseNode { } if is { let mut stop = false; - let mut is_node = lex_4_25::Token::Is.to_leaf(); + let mut is_node = lex_4_25::Token::Is.to_leaf(); while !stop { is_node.children.push(Box::new(parse_inheritance_specifier(chars, cur))); if let lex_4_25::Token::Comma = lex_4_25::peek_token(chars, cur) { @@ -169,7 +169,7 @@ fn parse_contract(chars: &Vec, cur: &mut usize) -> ParseNode { result } -fn parse_inheritance_specifier(chars: &Vec, cur: &mut usize) -> ParseNode { +fn parse_inheritance_specifier(chars: &Vec, cur: &mut usize) -> ParseNode { let mut result = lex_4_25::Token::OpenParenthesis.to_leaf(); result.children.push(Box::new(parse_user_defined_type_name(chars, cur))); if let lex_4_25::Token::OpenParenthesis = lex_4_25::peek_token(chars, cur) { @@ -184,7 +184,7 @@ fn parse_inheritance_specifier(chars: &Vec, cur: &mut usize) -> ParseNode } fn parse_contract_part(chars: &Vec, cur: &mut usize) -> ParseNode { - let mut result = lex_4_25::Token::OpenBrace.to_leaf(); + let mut result = lex_4_25::Token::OpenBrace.to_leaf(); let mut stop = false; while !stop { match lex_4_25::peek_token(chars, cur) { @@ -203,7 +203,7 @@ fn parse_contract_part(chars: &Vec, cur: &mut usize) -> ParseNode { fn parse_struct_definition(chars: &Vec, cur: &mut usize) -> ParseNode { ParseNode::empty() } -fn parse_state_variable_declaration(chars: &Vec, cur: &mut usize) -> ParseNode { +fn parse_state_variable_declaration(chars: &Vec, cur: &mut usize) -> ParseNode { let mut result = lex_4_25::Token::StateVariable.to_leaf(); result.children.push(Box::new(parse_type_name(chars, cur))); let mut stop = false; @@ -330,7 +330,7 @@ fn parse_event_parameter_list(chars: &Vec, cur: &mut usize) -> ParseNode { _ => result.children.push(Box::new(parse_event_parameter(chars, cur))) } match lex_4_25::peek_token(chars, cur) { - lex_4_25::Token::Comma => { + lex_4_25::Token::Comma => { lex_4_25::next_token(chars, cur); } lex_4_25::Token::CloseParenthesis => stop = true, @@ -376,7 +376,7 @@ fn parse_modifier_definition(chars: &Vec, cur: &mut usize) -> ParseNode { lex_4_25::Token::OpenParenthesis => result.children.push(Box::new(parse_parameter_list(chars, cur))), _ => () } - result.children.push(Box::new(parse_block(chars, cur))); + result.children.push(Box::new(parse_block(chars, cur))); result } @@ -409,7 +409,7 @@ fn parse_function_definition(chars: &Vec, cur: &mut usize) -> ParseNode { result.add_child(lex_4_25::next_token(chars, cur)); result.children.push(Box::new(parse_parameter_list(chars, cur))); } - _ => (), + _ => (), } result.children.push(Box::new(parse_block(chars, cur))); result @@ -432,7 +432,7 @@ fn parse_parameter_list(chars: &Vec, cur: &mut usize) -> ParseNode { fn parse_parameter(chars: &Vec, cur: &mut usize) -> ParseNode { ParseNode::empty() } -fn parse_block(chars: &Vec, cur: &mut usize) -> ParseNode { +fn parse_block(chars: &Vec, cur: &mut usize) -> ParseNode { let mut result = lex_4_25::Token::OpenBrace.to_leaf(); match lex_4_25::next_token(chars, cur) { lex_4_25::Token::OpenBrace => (), @@ -454,10 +454,10 @@ fn parse_block(chars: &Vec, cur: &mut usize) -> ParseNode { /*** Statements ***/ -// This functions parses the input text for statements. Statements are used in contracts, +// This functions parses the input text for statements. Statements are used in contracts, // and the grammar for statements specifies how many fundamental constructs must be written. -// Statements include: if statements, while statments, for statements, blocks, inline assembly -// statements, *do while statements, *placeholder statements, *continue, *break, *return, +// Statements include: if statements, while statments, for statements, blocks, inline assembly +// statements, *do while statements, *placeholder statements, *continue, *break, *return, // *throw, *emit statements, *simple statments (* - must be followed by a semicolon). fn parse_statement(chars: &Vec, cur: &mut usize) -> ParseNode { return match lex_4_25::peek_token(chars, cur) { @@ -565,7 +565,7 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse lex_4_25::Token::MinusEquals | lex_4_25::Token::MultiplyEquals | lex_4_25::Token::DivideEquals | - lex_4_25::Token::ModEquals => result = result.merge_expressions(right), + lex_4_25::Token::ModEquals => result = result.merge_expressions(right), _ => result.children.push(Box::new(right)) } match lex_4_25::next_token(&chars, cur) { @@ -574,7 +574,7 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse } } lex_4_25::Token::Dot => { - result.node = lex_4_25::next_token(&chars, cur); + result.node = lex_4_25::next_token(&chars, cur); result.children.push(Box::new(left)); let right = lex_4_25::next_token(&chars, cur); match right { @@ -618,7 +618,7 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse lex_4_25::Token::MinusEquals | lex_4_25::Token::MultiplyEquals | lex_4_25::Token::DivideEquals | - lex_4_25::Token::ModEquals => result = result.merge_expressions(right), + lex_4_25::Token::ModEquals => result = result.merge_expressions(right), lex_4_25::Token::NoMatch => (), _ => result.children.push(Box::new(right)) } @@ -657,12 +657,12 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse lex_4_25::Token::MinusEquals | lex_4_25::Token::MultiplyEquals | lex_4_25::Token::DivideEquals | - lex_4_25::Token::ModEquals => result = result.merge_expressions(right), + lex_4_25::Token::ModEquals => result = result.merge_expressions(right), _ => result.children.push(Box::new(right)) } } lex_4_25::Token::Divide | - lex_4_25::Token::Multiply | + lex_4_25::Token::Multiply | lex_4_25::Token::Modulus => { result.node = lex_4_25::next_token(&chars, cur); result.children.push(Box::new(left)); @@ -696,12 +696,12 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse lex_4_25::Token::MinusEquals | lex_4_25::Token::MultiplyEquals | lex_4_25::Token::DivideEquals | - lex_4_25::Token::ModEquals => result = result.merge_expressions(right), + lex_4_25::Token::ModEquals => result = result.merge_expressions(right), _ => result.children.push(Box::new(right)) } } lex_4_25::Token::Plus | lex_4_25::Token::Minus => { - result.node = lex_4_25::next_token(&chars, cur); + result.node = lex_4_25::next_token(&chars, cur); result.children.push(Box::new(left)); let right = parse_expression(&chars, cur); match right.node { @@ -730,7 +730,7 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse lex_4_25::Token::MinusEquals | lex_4_25::Token::MultiplyEquals | lex_4_25::Token::DivideEquals | - lex_4_25::Token::ModEquals => result = result.merge_expressions(right), + lex_4_25::Token::ModEquals => result = result.merge_expressions(right), _ => result.children.push(Box::new(right)) } } @@ -762,7 +762,7 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse lex_4_25::Token::MinusEquals | lex_4_25::Token::MultiplyEquals | lex_4_25::Token::DivideEquals | - lex_4_25::Token::ModEquals => result = result.merge_expressions(right), + lex_4_25::Token::ModEquals => result = result.merge_expressions(right), _ => result.children.push(Box::new(right)) } } @@ -792,7 +792,7 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse lex_4_25::Token::MinusEquals | lex_4_25::Token::MultiplyEquals | lex_4_25::Token::DivideEquals | - lex_4_25::Token::ModEquals => result = result.merge_expressions(right), + lex_4_25::Token::ModEquals => result = result.merge_expressions(right), _ => result.children.push(Box::new(right)) } } @@ -821,7 +821,7 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse lex_4_25::Token::MinusEquals | lex_4_25::Token::MultiplyEquals | lex_4_25::Token::DivideEquals | - lex_4_25::Token::ModEquals => result = result.merge_expressions(right), + lex_4_25::Token::ModEquals => result = result.merge_expressions(right), _ => result.children.push(Box::new(right)) } } @@ -850,7 +850,7 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse lex_4_25::Token::MinusEquals | lex_4_25::Token::MultiplyEquals | lex_4_25::Token::DivideEquals | - lex_4_25::Token::ModEquals => result = result.merge_expressions(right), + lex_4_25::Token::ModEquals => result = result.merge_expressions(right), _ => result.children.push(Box::new(right)) } } @@ -880,7 +880,7 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse lex_4_25::Token::MinusEquals | lex_4_25::Token::MultiplyEquals | lex_4_25::Token::DivideEquals | - lex_4_25::Token::ModEquals => result = result.merge_expressions(right), + lex_4_25::Token::ModEquals => result = result.merge_expressions(right), _ => result.children.push(Box::new(right)) } } @@ -903,7 +903,7 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse lex_4_25::Token::MinusEquals | lex_4_25::Token::MultiplyEquals | lex_4_25::Token::DivideEquals | - lex_4_25::Token::ModEquals => result = result.merge_expressions(right), + lex_4_25::Token::ModEquals => result = result.merge_expressions(right), _ => result.children.push(Box::new(right)) } } @@ -912,7 +912,7 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse result.children.push(Box::new(left)); let right = parse_expression(&chars, cur); match right.node { - lex_4_25::Token::LogicalOr | + lex_4_25::Token::LogicalOr | lex_4_25::Token::Assignment | lex_4_25::Token::OrEquals | lex_4_25::Token::XorEquals | @@ -923,7 +923,7 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse lex_4_25::Token::MinusEquals | lex_4_25::Token::MultiplyEquals | lex_4_25::Token::DivideEquals | - lex_4_25::Token::ModEquals => result = result.merge_expressions(right), + lex_4_25::Token::ModEquals => result = result.merge_expressions(right), _ => result.children.push(Box::new(right)) } } @@ -944,7 +944,7 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse lex_4_25::Token::MinusEquals | lex_4_25::Token::MultiplyEquals | lex_4_25::Token::DivideEquals | - lex_4_25::Token::ModEquals => result = result.merge_expressions(right), + lex_4_25::Token::ModEquals => result = result.merge_expressions(right), _ => result.children.push(Box::new(right)) } } @@ -973,7 +973,7 @@ fn parse_operation(chars: &Vec, cur: &mut usize, left: ParseNode) -> Parse lex_4_25::Token::MinusEquals | lex_4_25::Token::MultiplyEquals | lex_4_25::Token::DivideEquals | - lex_4_25::Token::ModEquals => result = result.merge_expressions(right), + lex_4_25::Token::ModEquals => result = result.merge_expressions(right), _ => result.children.push(Box::new(right)) } } @@ -1045,7 +1045,7 @@ pub fn parse_expression(chars: &Vec, cur: &mut usize) -> ParseNode { let mut left = lex_4_25::next_token(&chars, cur).to_leaf(); let peek = lex_4_25::peek_token(&chars, cur); if peek.is_number_unit() { - left.add_child(lex_4_25::next_token(&chars, cur)); + left.add_child(lex_4_25::next_token(&chars, cur)); } result = parse_operation(&chars, cur, left); } @@ -1070,10 +1070,10 @@ pub fn parse_expression(chars: &Vec, cur: &mut usize) -> ParseNode { result = parse_operation(&chars, cur, result); } } - lex_4_25::Token::Exclamation | - lex_4_25::Token::Tilda | - lex_4_25::Token::Delete | - lex_4_25::Token::Increment | + lex_4_25::Token::Exclamation | + lex_4_25::Token::Tilda | + lex_4_25::Token::Delete | + lex_4_25::Token::Increment | lex_4_25::Token::Decrement | lex_4_25::Token::Plus | lex_4_25::Token::Minus => { @@ -1149,7 +1149,7 @@ fn parse_user_defined_type_name(chars: &Vec, cur: &mut usize) -> ParseNode result } -fn parse_mapping(chars: &Vec, cur: &mut usize) -> ParseNode { +fn parse_mapping(chars: &Vec, cur: &mut usize) -> ParseNode { let mut result = lex_4_25::Token::Mapping.to_leaf(); match lex_4_25::next_token(chars, cur) { lex_4_25::Token::Mapping => (), @@ -1268,4 +1268,4 @@ fn parse_function_type_parameter(chars: &Vec, cur: &mut usize) -> ParseNod _ => () } result -} \ No newline at end of file +} diff --git a/tests/parser_integration_tests.rs b/tests/parser_integration_tests.rs index e370dc8..1fec00d 100644 --- a/tests/parser_integration_tests.rs +++ b/tests/parser_integration_tests.rs @@ -198,3 +198,92 @@ mod parser_integration_tests { } */ } + #[test] + fn IACLOracle_test() { + let input = fs::read_to_string("./contracts/IACLOracle.sol") + .expect("Test file not found: ./contracts/IACLOracle.sol"); + let actual_tree = parse(input); + let expected_tree = ParseTree { + children: vec![ + ParseNode { + node: lex_4_25::Token::Pragma, + children: vec![ + Box::new(lex_4_25::Token::Identifier("solidity".to_string()).to_leaf()), + Box::new(lex_4_25::Token::BitwiseXor.to_leaf()), + Box::new(lex_4_25::Token::Version("0.4.25".to_string()).to_leaf()) + ] + }, + ParseNode { + node: lex_4_25::Token::Interface, + children: vec![ + Box::new(lex_4_25::Token::Identifier("IACLOracle".to_string()).to_leaf()), + Box::new(ParseNode { + node: lex_4_25::Token::OpenBrace, + children: vec![ + Box::new(ParseNode { + node: lex_4_25::Token::Function, + children: vec![ + Box::new(lex_4_25::Token::Identifier("canPerform".to_string()).to_leaf()), + Box::new(ParseNode { + node: lex_4_25::Token::OpenParenthesis, + children: vec![ + Box::new(ParseNode { + node: lex_4_25::Token::StateVariable, + children: vec![ + Box::new(lex_4_25::Token::Address.to_leaf()), + Box::new(lex_4_25::Token::Identifier("who".to_string()).to_leaf()) + ] + }), + Box::new(ParseNode { + node: lex_4_25::Token::StateVariable, + children: vec![ + Box::new(lex_4_25::Token::Address.to_leaf()), + Box::new(lex_4_25::Token::Identifier("where".to_string()).to_leaf()) + ] + }), + Box::new(ParseNode { + node: lex_4_25::Token::StateVariable, + children: vec![ + Box::new(lex_4_25::Token::Bytes32.to_leaf()), + Box::new(lex_4_25::Token::Identifier("what".to_string()).to_leaf()) + ] + }), + Box::new(ParseNode { + node: lex_4_25::Token::StateVariable, + children: vec![ + Box::new(lex_4_25::Token::Uint256.to_leaf()), + Box::new(ParseNode { + node: lex_4_25::Token::OpenBracket + children: vec![] + }] + Box::new(lex_4_25::Token::Identifier("who".to_string()).to_leaf()) + }), + ] + }) + ] + }) + Box::new(ParseNode { + node: lex_4_25::Token::External, + children: vec![ + Box::new(lex_4_25::Token::Identifier("view".to_string()).to_leaf()) + ] + }) + Box::new(ParseNode { + node: lex_4_25::Token::Returns, + children: vec![ + Box::new(ParseNode { + node: lex_4_25::Token::OpenBracket + children: vec![ + Box::new(lex_4_25::Token::bool.to_leaf()), + ] + }) + ] + }) + ] + }) + ] + } + ] + }; + assert_eq!(expected_tree, actual_tree); + }