Simplify ParseResult struct

src/codegen/binding.rs

@@ -13,7 +13,10 @@ impl Transpilable for Binding<'_> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{lexic::token::{Token, TokenType}, syntax::ast::{var_binding::Binding, Expression}};
+    use crate::{
+        lexic::token::{Token, TokenType},
+        syntax::ast::{var_binding::Binding, Expression},
+    };
 
     #[test]
     fn binding_should_transpile() {

src/codegen/function_declaration.rs

@@ -34,6 +34,7 @@ mod tests {
 
                 assert_eq!("function id() {\n\n}", transpiled);
             }
+            _ => panic!("Not implemented: Expression at top level"),
         }
     }
 }

src/codegen/module_ast.rs

@@ -18,7 +18,10 @@ impl Transpilable for ModuleAST<'_> {
 #[cfg(test)]
 mod tests {
     use super::*;
-    use crate::{lexic::token::{Token, TokenType}, syntax::ast::{var_binding::Binding, Expression, TopLevelDeclaration}};
+    use crate::{
+        lexic::token::{Token, TokenType},
+        syntax::ast::{var_binding::Binding, Expression, TopLevelDeclaration},
+    };
 
     #[test]
     fn module_ast_should_transpile() {

src/codegen/top_level_construct.rs

@@ -7,6 +7,7 @@ impl Transpilable for TopLevelDeclaration<'_> {
         match self {
             TopLevelDeclaration::Binding(binding) => binding.transpile(),
             TopLevelDeclaration::FunctionDeclaration(fun) => fun.transpile(),
+            _ => panic!("Not implemented: Expression at top level"),
         }
     }
 }

src/lexic/token.rs

@@ -22,7 +22,7 @@ pub enum TokenType {
     FUN,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Clone)]
 pub struct Token {
     pub token_type: TokenType,
     // The token as a raw string

src/semantic/impls.rs

@@ -51,12 +51,15 @@ impl SemanticCheck for TopLevelDeclaration<'_> {
                                 binding_name
                             ),
                         };
-    
+
                         return Err(MistiError::Semantic(error));
                     }
                 };
 
-                scope.insert(binding_name.clone(), SymbolEntry::new_variable(datatype.value.clone()));
+                scope.insert(
+                    binding_name.clone(),
+                    SymbolEntry::new_variable(datatype.value.clone()),
+                );
 
                 Ok(())
             }
@@ -77,10 +80,14 @@ impl SemanticCheck for TopLevelDeclaration<'_> {
                     return Err(MistiError::Semantic(error));
                 }
 
-                scope.insert(function_name, SymbolEntry::new_function(vec![], "Unit".into()));
+                scope.insert(
+                    function_name,
+                    SymbolEntry::new_function(vec![], "Unit".into()),
+                );
 
                 Ok(())
             }
+            _ => panic!("Not implemented"),
         }
     }
 }

src/syntax/ast/mod.rs

@@ -14,6 +14,7 @@ pub struct ModuleAST<'a> {
 pub enum TopLevelDeclaration<'a> {
     Binding(var_binding::Binding<'a>),
     FunctionDeclaration(FunctionDeclaration<'a>),
+    Expression(Expression<'a>),
 }
 
 #[derive(Debug)]

src/syntax/binding.rs

@@ -5,7 +5,7 @@ use crate::error_handling::SyntaxError;
 use crate::lexic::token::{Token, TokenType};
 use crate::utils::Result3;
 
-pub fn try_parse<'a>(tokens: &'a Vec<Token>, pos: usize) -> ParseResult<Binding, ()> {
+pub fn try_parse<'a>(tokens: &'a Vec<Token>, pos: usize) -> ParseResult<Binding> {
     let mut current_pos = pos;
 
     // TODO: Detect if the binding starts with a datatype

src/syntax/block.rs

@@ -6,7 +6,7 @@ use crate::{
 use super::{ast::Block, utils::parse_token_type, ParseResult};
 
 // Assumes that the token at `pos` is a {
-pub fn parse_block<'a>(tokens: &'a Vec<Token>, pos: usize) -> ParseResult<Block, &Token> {
+pub fn parse_block<'a>(tokens: &'a Vec<Token>, pos: usize) -> ParseResult<Block> {
     let mut current_pos = pos;
 
     let (opening_brace, next_pos) =

src/syntax/expression/comparison.rs

@@ -8,7 +8,7 @@ use crate::{
 /// ```ebnf
 /// comparison = term, ((">" | ">=" | "<" | "<="), term)*;
 /// ```
-pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression, ()> {
+pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression> {
     let (term, next_pos) = match super::term::try_parse(tokens, pos) {
         ParseResult::Ok(expr, next_pos) => (expr, next_pos),
         _ => return ParseResult::Unmatched,
@@ -21,7 +21,7 @@ fn parse_many<'a>(
     tokens: &'a Vec<Token>,
     pos: usize,
     prev_expr: Expression<'a>,
-) -> ParseResult<Expression<'a>, ()> {
+) -> ParseResult<Expression<'a>> {
     // comparison = term, ((">" | ">=" | "<" | "<="), term)*;
 
     match tokens.get(pos) {

src/syntax/expression/equality.rs

@@ -8,7 +8,7 @@ use crate::{
 /// ```ebnf
 /// equality = comparison, (("==" | "!="), comparison )*;
 /// ```
-pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression, ()> {
+pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression> {
     let (comparison, next_pos) = match super::comparison::try_parse(tokens, pos) {
         ParseResult::Ok(expr, next_pos) => (expr, next_pos),
         _ => return ParseResult::Unmatched,
@@ -21,7 +21,7 @@ fn parse_many<'a>(
     tokens: &'a Vec<Token>,
     pos: usize,
     prev_expr: Expression<'a>,
-) -> ParseResult<Expression<'a>, ()> {
+) -> ParseResult<Expression<'a>> {
     // equality = comparison, (("==" | "!="), comparison )*;
 
     match tokens.get(pos) {

src/syntax/expression/factor.rs

@@ -8,7 +8,7 @@ use crate::{
 /// ```ebnf
 /// factor = unary, (("/" | "*"), unary)*;
 /// ```
-pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression, ()> {
+pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression> {
     let (unary, next_pos) = match super::unary::try_parse(tokens, pos) {
         ParseResult::Ok(expr, next_pos) => (expr, next_pos),
         _ => return ParseResult::Unmatched,
@@ -21,7 +21,7 @@ fn parse_many<'a>(
     tokens: &'a Vec<Token>,
     pos: usize,
     prev_expr: Expression<'a>,
-) -> ParseResult<Expression<'a>, ()> {
+) -> ParseResult<Expression<'a>> {
     // (("/" | "*"), unary)*
 
     match tokens.get(pos) {

src/syntax/expression/function_call_expr.rs

@@ -13,7 +13,7 @@ use crate::{
 /// function call expr = primary, "(", (arguments list)?, ")"
 ///                    | primary;
 /// ```
-pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression, ()> {
+pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression> {
     let (primary_expr, next_pos) = match super::primary::try_parse(tokens, pos) {
         ParseResult::Ok(expr, next_pos) => (expr, next_pos),
         _ => return ParseResult::Unmatched,

src/syntax/expression/mod.rs

@@ -10,7 +10,7 @@ mod term;
 mod unary;
 
 /// Expression is defined in the grammar.
-pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression, ()> {
+pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression> {
     return equality::try_parse(tokens, pos);
 }
 

src/syntax/expression/primary.rs

@@ -9,7 +9,7 @@ use crate::{
 /// ```ebnf
 /// primary = number | string | boolean | identifier | ("(", expression, ")");
 /// ```
-pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression, ()> {
+pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression> {
     match tokens.get_significant(pos) {
         Some((token, token_pos)) => match token.token_type {
             TokenType::Number => ParseResult::Ok(Expression::Number(&token.value), token_pos + 1),
@@ -27,7 +27,7 @@ pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression, ()>
     }
 }
 
-fn parse_parenthesized_expression(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression, ()> {
+fn parse_parenthesized_expression(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression> {
     let expression = super::try_parse(tokens, pos + 1);
     match expression {
         ParseResult::Ok(expression, next_pos) => match tokens.get(next_pos) {

src/syntax/expression/term.rs

@@ -8,7 +8,7 @@ use crate::{
 /// ```ebnf
 /// term = factor, (("-" | "+"), factor)*;
 /// ```
-pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression, ()> {
+pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression> {
     let (factor, next_pos) = match super::factor::try_parse(tokens, pos) {
         ParseResult::Ok(expr, next_pos) => (expr, next_pos),
         _ => return ParseResult::Unmatched,
@@ -21,7 +21,7 @@ fn parse_many<'a>(
     tokens: &'a Vec<Token>,
     pos: usize,
     prev_expr: Expression<'a>,
-) -> ParseResult<Expression<'a>, ()> {
+) -> ParseResult<Expression<'a>> {
     // term = factor, (("-" | "+"), factor)*;
 
     match tokens.get(pos) {

src/syntax/expression/unary.rs

@@ -11,7 +11,7 @@ use super::function_call_expr;
 /// unary = ("!" | "-"), expression
 ///       | function call expr;
 /// ```
-pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression, ()> {
+pub fn try_parse(tokens: &Vec<Token>, pos: usize) -> ParseResult<Expression> {
     match tokens.get(pos) {
         Some(token) if token.value == "!" || token.value == "-" => {
             match super::try_parse(tokens, pos + 1) {

src/syntax/functions/arguments_list.rs

@@ -8,7 +8,7 @@ use crate::{
     },
 };
 
-pub fn try_parse<'a>(tokens: &'a Vec<Token>, pos: usize) -> ParseResult<ArgumentsList, &Token> {
+pub fn try_parse<'a>(tokens: &'a Vec<Token>, pos: usize) -> ParseResult<ArgumentsList> {
     let mut current_pos = pos;
 
     let (opening_paren, next_pos) =

src/syntax/functions/function_declaration.rs

@@ -14,7 +14,7 @@ use super::{
     params_list::parse_params_list,
 };
 
-pub fn try_parse<'a>(tokens: &'a Vec<Token>, pos: usize) -> ParseResult<FunctionDeclaration, ()> {
+pub fn try_parse<'a>(tokens: &'a Vec<Token>, pos: usize) -> ParseResult<FunctionDeclaration> {
     let mut current_pos = pos;
 
     // `fun` keyword

src/syntax/functions/params_list.rs

@@ -9,10 +9,7 @@ use super::super::{
     utils, ParseResult,
 };
 
-pub fn parse_params_list<'a>(
+pub fn parse_params_list<'a>(tokens: &'a Vec<Token>, pos: usize) -> ParseResult<ParamsList> {
-    tokens: &'a Vec<Token>,
-    pos: usize,
-) -> ParseResult<ParamsList, &Token> {
     let mut current_pos = pos;
 
     let (opening_paren, next_pos) =
@@ -24,6 +21,14 @@ pub fn parse_params_list<'a>(
         };
     current_pos = next_pos;
 
+    /*
+    val (opening_paren, next_pos) = try parse_token_type(...)
+
+    val (next_parameter, next_pos) = try parse_param_definition(...) catch
+    case ::Err(e) { return ::Err(e) }
+    else { break }
+     */
+
     // Parse parameters definitions, separated by commas
     let mut parameters = Vec::<Parameter>::new();
     loop {
@@ -79,10 +84,7 @@ pub fn parse_params_list<'a>(
     ParseResult::Ok(ParamsList {}, current_pos)
 }
 
-fn parse_param_definition<'a>(
+fn parse_param_definition<'a>(tokens: &'a Vec<Token>, pos: usize) -> ParseResult<Parameter> {
-    tokens: &'a Vec<Token>,
-    pos: usize,
-) -> ParseResult<Parameter, &Token> {
     // Parse a single parameter definition of the form:
     // - Type identifier
     // There will be more constructs in the future, like:

src/syntax/grammar.md

@@ -1,19 +1,21 @@
 # Grammar
 
 
-## Module
+## Source file
-
-A module is (commonly) a single source file.
 
 ```ebnf
-module = top level declaration*
+source file = top level statement*
 ```
 
 
-## Top level declaration
+## Top level statement
+
+Current focus: Have a mvp compiler (w lexical/syntactic/semantic analysis + codegen) for
+simple function calls, and then implement other features top down
 
 ```ebnf
-top level declaration = function declaration
+top level statement = expression
+                    | function declaration
 ```
 
 

src/syntax/mod.rs

@@ -15,7 +15,7 @@ use ast::ModuleAST;
 use self::ast::TopLevelDeclaration;
 
 #[derive(Debug)]
-pub enum ParseResult<A, B> {
+pub enum ParseResult<A> {
     /// The parsing was a success. The first element is the parsed construct,
     /// the second element is the position of the next token to parse
     Ok(A, usize),
@@ -26,11 +26,19 @@ pub enum ParseResult<A, B> {
     Err(SyntaxError),
     /// Some special value was expected, but something else was found.
     /// The inside element is the something else found.
-    Mismatch(B),
+    Mismatch(Token),
     /// This parsing didn't succeed, but it's not a fatal error.
     Unmatched,
 }
 
+enum ParsingError {
+    Mismatch(Token),
+    Unmatch,
+    Error(SyntaxError),
+}
+
+type ParsingResult<A> = Result<(A, usize), ParsingError>;
+
 /// Constructs the Misti AST from a vector of tokens
 pub fn construct_ast<'a>(tokens: &'a Vec<Token>) -> Result<ModuleAST, MistiError> {
     let mut top_level_declarations = Vec::new();
@@ -70,7 +78,7 @@ pub fn construct_ast<'a>(tokens: &'a Vec<Token>) -> Result<ModuleAST, MistiError
 fn next_construct<'a>(
     tokens: &'a Vec<Token>,
     current_pos: usize,
-) -> ParseResult<TopLevelDeclaration, ()> {
+) -> ParseResult<TopLevelDeclaration> {
     None.or_else(
         || match functions::function_declaration::try_parse(tokens, current_pos) {
             ParseResult::Ok(declaration, next_pos) => Some(ParseResult::Ok(
@@ -81,6 +89,15 @@ fn next_construct<'a>(
             _ => None,
         },
     )
+    .or_else(|| match expression::try_parse(tokens, current_pos) {
+        ParseResult::Ok(expression, next_pos) => Some(ParseResult::Ok(
+            TopLevelDeclaration::Expression(expression),
+            next_pos,
+        )),
+        ParseResult::Err(_) => todo!(),
+        ParseResult::Mismatch(_) => todo!(),
+        ParseResult::Unmatched => todo!(),
+    })
     .unwrap_or_else(|| ParseResult::Unmatched)
 }
 
@@ -101,6 +118,7 @@ mod tests {
             TopLevelDeclaration::FunctionDeclaration(_f) => {
                 assert!(true)
             }
+            _ => panic!("Not implemented: Expression at top level"),
         }
     }
 
@@ -117,6 +135,7 @@ mod tests {
             TopLevelDeclaration::FunctionDeclaration(_f) => {
                 assert!(true)
             }
+            _ => panic!("Not implemented: Expression at top level"),
         }
 
         match declarations.get(1).unwrap() {
@@ -124,6 +143,7 @@ mod tests {
             TopLevelDeclaration::FunctionDeclaration(_f) => {
                 assert!(true)
             }
+            _ => panic!("Not implemented: Expression at top level"),
         }
     }
 }

src/syntax/statement.rs

@@ -7,7 +7,7 @@ use super::{
     ParseResult,
 };
 
-pub fn try_parse<'a>(tokens: &'a Vec<Token>, pos: usize) -> ParseResult<Statement, ()> {
+pub fn try_parse<'a>(tokens: &'a Vec<Token>, pos: usize) -> ParseResult<Statement> {
     None.or_else(|| match binding::try_parse(tokens, pos) {
         ParseResult::Ok(b, next) => Some(ParseResult::Ok(Statement::Binding(b), next)),
         ParseResult::Err(err) => Some(ParseResult::Err(err)),

src/syntax/utils.rs

@@ -33,7 +33,7 @@ impl Tokenizer for Vec<Token> {
     }
 }
 
-/// Expects the token at `pos` to be of type `token_type`
+/// Expects the token at `pos` to be of type `token_type`. Doesn't ignore whitespace or newlines
 pub fn try_token_type(tokens: &Vec<Token>, pos: usize, token_type: TokenType) -> Result3<&Token> {
     match tokens.get(pos) {
         Some(t) if t.token_type == token_type => Result3::Ok(t),
@@ -45,6 +45,7 @@ pub fn try_token_type(tokens: &Vec<Token>, pos: usize, token_type: TokenType) ->
     }
 }
 
+/// Expects the token at `pos` to be an operator of value `operator`. Doesn't ignore whitespace or newlines
 pub fn try_operator(tokens: &Vec<Token>, pos: usize, operator: String) -> Result3<&Token> {
     match tokens.get(pos) {
         Some(t) if t.token_type == TokenType::Operator && t.value == operator => Result3::Ok(t),
@@ -56,12 +57,12 @@ pub fn try_operator(tokens: &Vec<Token>, pos: usize, operator: String) -> Result
     }
 }
 
-/// Expects the token at `pos` to be of type `token_type`
+/// Expects the token at `pos` to be of type `token_type`, ignoring all whitespace & newlines
 pub fn parse_token_type(
     tokens: &Vec<Token>,
     pos: usize,
     token_type: TokenType,
-) -> ParseResult<&Token, &Token> {
+) -> ParseResult<&Token> {
     let mut current_pos = pos;
 
     // Ignore all whitespace and newlines
@@ -81,7 +82,7 @@ pub fn parse_token_type(
         Some(t) if t.token_type == TokenType::EOF || t.token_type == TokenType::NewLine => {
             ParseResult::Unmatched
         }
-        Some(t) => ParseResult::Mismatch(t),
+        Some(t) => ParseResult::Mismatch(t.clone()),
         None => ParseResult::Unmatched,
     }
 }