Skip to content

[WIP] Virag tests #22

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Open
wadealexc wants to merge 3 commits into
base: master
Choose a base branch
from
Open

[WIP] Virag tests #22

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
cd2bce7
Merge pull request #15 from jalextowle/lexer-refactor
Jun 13, 2019
a48f945
Test Commit
viragmody Jun 14, 2019
8665ce6
Integration tests added for IACLOracle.sol - Contains errors
viragmody Jun 14, 2019
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
9 changes: 9 additions & 0 deletions Git_Command_Directory.txt
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -0,0 +1,9 @@
git status /git diff - shows any changes made to local files relative to repo
Copy link
Member

@jalextowle jalextowle Jun 16, 2019

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

This file needs to be removed before this PR can be merged.

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
5 changes: 5 additions & 0 deletions contracts/IACLOracle.sol
View file
Open in desktop
Original file line number Diff line number Diff line change
@@ -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);
Copy link
Member

@jalextowle jalextowle Jun 16, 2019

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

Let's space out the parameters like so:

interface IACLOracle {
    function canPerform(
        address who,
        address where,
        bytes32 what,
        uint256[] how
    )
        external
        view returns (bool);
}

This way, our Solidity code will follow the 0x style guide. (which will hopefully be defined by our style rules one day!).

}
88 changes: 44 additions & 44 deletions src/parse_4_25.rs
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -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) {
Copy link
Member

@jalextowle jalextowle Jun 16, 2019

Choose a reason for hiding this comment

The reason will be displayed to describe this comment to others. Learn more.

To recap on our conversation the other day, I don't think these changes should be included because it muddles the "path of blame" for these lines. Since you didn't actually touch the code, you shouldn't be on the "path of blame".

This comment applies to all such changes. I may reevaluate this in the future, but I think this restriction makes sense for now.

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<ParseNode> { self.children.remove(0) }
Expand Down Expand Up @@ -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::<Vec<char>>();
let input_chars = &mut input.chars().collect::<Vec<char>>();
while *cur < input_chars.len() {
match lex_4_25::peek_token(input_chars, cur) {
lex_4_25::Token::Pragma => {
Expand Down Expand Up @@ -83,12 +83,12 @@ pub fn parse(input: String) -> ParseTree {

/*** Pragma ***/

pub fn parse_pragma(chars: &Vec<char>, cur: &mut usize) -> ParseNode {
pub fn parse_pragma(chars: &Vec<char>, 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" {
Expand All @@ -113,11 +113,11 @@ pub fn parse_pragma(chars: &Vec<char>, 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 ***/

Expand All @@ -143,7 +143,7 @@ fn parse_contract(chars: &Vec<char>, 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) {
Expand All @@ -169,7 +169,7 @@ fn parse_contract(chars: &Vec<char>, cur: &mut usize) -> ParseNode {
result
}

fn parse_inheritance_specifier(chars: &Vec<char>, cur: &mut usize) -> ParseNode {
fn parse_inheritance_specifier(chars: &Vec<char>, 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) {
Expand All @@ -184,7 +184,7 @@ fn parse_inheritance_specifier(chars: &Vec<char>, cur: &mut usize) -> ParseNode
}

fn parse_contract_part(chars: &Vec<char>, 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) {
Expand All @@ -203,7 +203,7 @@ fn parse_contract_part(chars: &Vec<char>, cur: &mut usize) -> ParseNode {

fn parse_struct_definition(chars: &Vec<char>, cur: &mut usize) -> ParseNode { ParseNode::empty() }

fn parse_state_variable_declaration(chars: &Vec<char>, cur: &mut usize) -> ParseNode {
fn parse_state_variable_declaration(chars: &Vec<char>, 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;
Expand Down Expand Up @@ -330,7 +330,7 @@ fn parse_event_parameter_list(chars: &Vec<char>, 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,
Expand Down Expand Up @@ -376,7 +376,7 @@ fn parse_modifier_definition(chars: &Vec<char>, 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
}

Expand Down Expand Up @@ -409,7 +409,7 @@ fn parse_function_definition(chars: &Vec<char>, 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
Expand All @@ -432,7 +432,7 @@ fn parse_parameter_list(chars: &Vec<char>, cur: &mut usize) -> ParseNode {

fn parse_parameter(chars: &Vec<char>, cur: &mut usize) -> ParseNode { ParseNode::empty() }

fn parse_block(chars: &Vec<char>, cur: &mut usize) -> ParseNode {
fn parse_block(chars: &Vec<char>, 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 => (),
Expand All @@ -454,10 +454,10 @@ fn parse_block(chars: &Vec<char>, 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<char>, cur: &mut usize) -> ParseNode {
return match lex_4_25::peek_token(chars, cur) {
Expand Down Expand Up @@ -565,7 +565,7 @@ fn parse_operation(chars: &Vec<char>, 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) {
Expand All @@ -574,7 +574,7 @@ fn parse_operation(chars: &Vec<char>, 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 {
Expand Down Expand Up @@ -618,7 +618,7 @@ fn parse_operation(chars: &Vec<char>, 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))
}
Expand Down Expand Up @@ -657,12 +657,12 @@ fn parse_operation(chars: &Vec<char>, 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));
Expand Down Expand Up @@ -696,12 +696,12 @@ fn parse_operation(chars: &Vec<char>, 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 {
Expand Down Expand Up @@ -730,7 +730,7 @@ fn parse_operation(chars: &Vec<char>, 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))
}
}
Expand Down Expand Up @@ -762,7 +762,7 @@ fn parse_operation(chars: &Vec<char>, 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))
}
}
Expand Down Expand Up @@ -792,7 +792,7 @@ fn parse_operation(chars: &Vec<char>, 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))
}
}
Expand Down Expand Up @@ -821,7 +821,7 @@ fn parse_operation(chars: &Vec<char>, 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))
}
}
Expand Down Expand Up @@ -850,7 +850,7 @@ fn parse_operation(chars: &Vec<char>, 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))
}
}
Expand Down Expand Up @@ -880,7 +880,7 @@ fn parse_operation(chars: &Vec<char>, 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))
}
}
Expand All @@ -903,7 +903,7 @@ fn parse_operation(chars: &Vec<char>, 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))
}
}
Expand All @@ -912,7 +912,7 @@ fn parse_operation(chars: &Vec<char>, 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 |
Expand All @@ -923,7 +923,7 @@ fn parse_operation(chars: &Vec<char>, 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))
}
}
Expand All @@ -944,7 +944,7 @@ fn parse_operation(chars: &Vec<char>, 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))
}
}
Expand Down Expand Up @@ -973,7 +973,7 @@ fn parse_operation(chars: &Vec<char>, 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))
}
}
Expand Down Expand Up @@ -1045,7 +1045,7 @@ pub fn parse_expression(chars: &Vec<char>, 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);
}
Expand All @@ -1070,10 +1070,10 @@ pub fn parse_expression(chars: &Vec<char>, 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 => {
Expand Down Expand Up @@ -1149,7 +1149,7 @@ fn parse_user_defined_type_name(chars: &Vec<char>, cur: &mut usize) -> ParseNode
result
}

fn parse_mapping(chars: &Vec<char>, cur: &mut usize) -> ParseNode {
fn parse_mapping(chars: &Vec<char>, 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 => (),
Expand Down Expand Up @@ -1268,4 +1268,4 @@ fn parse_function_type_parameter(chars: &Vec<char>, cur: &mut usize) -> ParseNod
_ => ()
}
result
}
}
Loading