[WIP] Implemented a Code Formatting Codegen Module

contracts/BadDemo.sol

@@ -0,0 +1,45 @@
+pragma solidity ^0.4.25;
+
+contract 
+
+
+
+Demo                
+
+
+    is 
+
+
+
+    A, 
+                        B, 
+
+
+          C, 
+
+
+      D  
+
+
+
+
+
+
+      {
+    event Transfer(
+        address 
+        indexed 
+                 owner, 
+                 address indexed recipient,
+                 uint256 indexed value);
+    address public 
+    constant a = 103414;
+
+
+    address 
+    public constant b = 0x103414;
+
+    modifier empty  {
+
+                }
+            }

contracts/BadEmpty.sol

@@ -0,0 +1,15 @@
+pragma   solidity            ^0.4.25
+
+
+; 
+
+
+
+
+
+
+
+contract            Empty {
+
+
+}

contracts/BadOwnable.sol

@@ -0,0 +1,84 @@
+ pragma           solidity 
+
+
+
+ ^0.4.25            
+
+
+
+                                                                    ;
+
+
+contract Ownable   
+
+
+
+
+
+{
+
+    address 
+
+    public owner;
+
+    modifier 
+
+
+    onlyOwner {
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+        require(
+
+            msg.sender  
+
+
+
+            == owner
+
+               )                                             ;
+        _;
+
+                                                                                                                } }

contracts/BadValue.sol

@@ -0,0 +1,9 @@
+pragma 
+
+
+               solidity  
+
+
+   ^0.4.25;
+
+contract                       Value {         uint256  b = 351231; }        

contracts/Demo.sol

@@ -0,0 +1,16 @@
+pragma solidity ^0.4.25;
+
+
+contract Demo is 
+    A, 
+    B, 
+    C, 
+    D 
+{
+
+    event Transfer(address indexed owner, address indexed recipient, uint256 indexed value);
+
+    address public constant a = 103414;
+
+    address public constant b = 0x103414;
+}

contracts/Empty.sol

@@ -0,0 +1,4 @@
+pragma solidity ^0.4.25;
+
+
+contract Empty {}

contracts/Ownable.sol

@@ -1,6 +1,8 @@
 pragma solidity ^0.4.25;
 
+
 contract Ownable {
+
     address public owner;
 
     modifier onlyOwner {

contracts/Value.sol

@@ -0,0 +1,7 @@
+pragma solidity ^0.4.25;
+
+
+contract Value {
+
+    uint256 b = 351231;
+}

contracts/library.sol

@@ -0,0 +1,3 @@
+pragma solidity ^0.4.25;
+
+library A {}

src/lex_4_25.rs

@@ -219,6 +219,7 @@ pub enum Token {
     UserDefinedTypeName,
     Using,
     Var,
+    VariableDeclaration,
     Version(String),
     View,
     Weeks,

src/lib.rs

@@ -1,2 +1,3 @@
 pub mod lex_4_25;
 pub mod parse_4_25;
+pub mod style;

src/main.rs

@@ -1,9 +1,26 @@
 use std::env;
 use std::fs;
 use solfix::parse_4_25::parse;
+use solfix::style::stylize;
 
 fn main() {
-    let name = env::args().nth(1).expect("Usage: solidity-fix FILE_NAME");
-    let input = fs::read_to_string(name).expect("Unable to open input file");
-    println!("{:?}", parse(input));
+    let usage = "Usage: solfix style SOURCE [TARGET]\n              ast SOURCE [TARGET]";
+    match env::args().nth(1) {
+        Some(ref style) if style == "style" => {
+            let source = env::args().nth(2).expect(usage);
+            let input = fs::read_to_string(source).expect("Unable to find SOURCE");
+            match env::args().nth(3) {
+                Some(target) => fs::write(target, stylize(parse(input))).expect("Unable to write file to TARGET"),
+                None => println!("{}", stylize(parse(input)))
+            }
+        }
+        Some(ref ast) if ast == "ast" => {
+            let source = env::args().nth(2).expect(usage);
+            let input = fs::read_to_string(source).expect("Unable to find SOURCE");
+            match env::args().nth(3) {
+                _ => println!("{:?}", parse(input))
+            }
+        }
+        _ => println!("{}", usage)
+    }
 }

src/parse_4_25.rs

@@ -201,9 +201,61 @@ fn parse_contract_part(chars: &Vec<char>, cur: &mut usize) -> ParseNode {
     result
 }
 
-fn parse_struct_definition(chars: &Vec<char>, cur: &mut usize) -> ParseNode { ParseNode::empty() }
+fn parse_struct_definition(chars: &Vec<char>, cur: &mut usize) -> ParseNode { 
+    let mut result = lex_4_25::Token::Struct.to_leaf();
+    match lex_4_25::next_token(chars, cur) {
+        lex_4_25::Token::Struct => (),
+        _ => panic!("Invalid struct definition")
+    }
+    match lex_4_25::next_token(chars, cur) {
+        id @ lex_4_25::Token::Identifier(..) => result.add_child(id),
+        _ => panic!("Invalid struct definition")
+    }
+    match lex_4_25::next_token(chars, cur) {
+        lex_4_25::Token::OpenBrace => result.add_child(lex_4_25::Token::OpenBrace),
+        _ => panic!("Invalid struct definition")
+    }
+    result.children.push(Box::new(parse_variable_declaration(chars, cur)));
+    match lex_4_25::next_token(chars, cur) {
+        lex_4_25::Token::Semicolon => (),
+        _ => panic!("Invalid struct definition")
+    }
+    let mut stop = false;
+    while !stop {
+        match lex_4_25::peek_token(chars, cur) {
+            lex_4_25::Token::CloseBrace => stop = true,
+            _ => result.children.push(Box::new(parse_variable_declaration(chars, cur)))
+        }
+        if !stop {
+            match lex_4_25::next_token(chars, cur) {
+                lex_4_25::Token::Semicolon => (),
+                _ => panic!("Invalid struct definition")
+            }
+        }
+    }
+    match lex_4_25::next_token(chars, cur) {
+        lex_4_25::Token::CloseBrace => (),
+        _ => panic!("Invalid struct definition")
+    }
+    result
+}
 
-fn parse_state_variable_declaration(chars: &Vec<char>, cur: &mut usize) -> ParseNode {  
+fn parse_variable_declaration(chars: &Vec<char>, cur: &mut usize) -> ParseNode {
+    let mut result = lex_4_25::Token::VariableDeclaration.to_leaf();
+    result.children.push(Box::new(parse_type_name(chars, cur)));
+    match lex_4_25::peek_token(chars, cur) {
+        lex_4_25::Token::Memory  |
+        lex_4_25::Token::Storage => result.add_child(lex_4_25::next_token(chars, cur)),
+        _ => panic!("Invalid variable declaration")
+    }
+    match lex_4_25::next_token(chars, cur) {
+        id @ lex_4_25::Token::Identifier(..) => result.add_child(id),
+        _ => panic!("Invalid variable declaration")
+    }
+    result
+}
+
+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;
@@ -423,14 +475,42 @@ fn parse_parameter_list(chars: &Vec<char>, cur: &mut usize) -> ParseNode {
         lex_4_25::Token::OpenParenthesis => (),
         _ => panic!("Invalid parameter list")
     }
+    let mut stop = false;
+    while !stop {
+        /*
+        match lex_4_25::peek_token(chars, cur) {
+            lex_4_25::Token::CloseParenthesis => stop = true,
+            _ => result.children.push(Box::new(parse_parameter(chars, cur)))
+        }
+        */
+        if !stop {
+            match lex_4_25::peek_token(chars, cur) {
+                lex_4_25::Token::Comma => (),
+                _ => stop = true
+            }
+        }
+    }
     match lex_4_25::next_token(chars, cur) {
         lex_4_25::Token::CloseParenthesis => (),
         _ => panic!("Invalid parameter list")
     }
     result
 }
 
-fn parse_parameter(chars: &Vec<char>, cur: &mut usize) -> ParseNode { ParseNode::empty() }
+fn parse_parameter(chars: &Vec<char>, cur: &mut usize) -> ParseNode {
+    let mut result = lex_4_25::Token::Parameter.to_leaf();
+    result.children.push(Box::new(parse_type_name(chars, cur)));
+    match lex_4_25::peek_token(chars, cur) {
+        lex_4_25::Token::Memory  |
+        lex_4_25::Token::Storage => result.add_child(lex_4_25::next_token(chars, cur)),
+        _ => ()
+    }
+    match lex_4_25::peek_token(chars, cur) {
+        lex_4_25::Token::Identifier(..) => result.add_child(lex_4_25::next_token(chars, cur)),
+        _ => ()
+    }
+    result
+}
 
 fn parse_block(chars: &Vec<char>, cur: &mut usize) -> ParseNode { 
     let mut result = lex_4_25::Token::OpenBrace.to_leaf();
@@ -1268,4 +1348,4 @@ fn parse_function_type_parameter(chars: &Vec<char>, cur: &mut usize) -> ParseNod
         _ => ()
     }
     result
-}
+}