Clean up expression parsing

examples/hello_world.sb

@@ -1,3 +1,3 @@
-fn main(n) {
+fn main() {
-    return 2 * n;
+    return 2 * 5 / 3;
 }

examples_out/out.js

@@ -1,4 +1,4 @@
-function main(n) {
+function main() {
-return 2 * n
+return 2 * 5 / 3
 }
 console.log(main())

src/parser/mod.rs

@@ -195,33 +195,25 @@ impl Parser {
     }
 
     fn parse_statement(&mut self) -> Result<Statement, String> {
-        let token = self.next_token();
+        let token = self.peek().ok_or_else(|| "Expected token")?;
-        match &token.kind {
+        let state = match &token.kind {
-            TokenKind::Keyword(Keyword::Let) => {
+            TokenKind::Keyword(Keyword::Let) => self.parse_declare(),
-                let state = self.parse_declare();
+            TokenKind::Keyword(Keyword::Return) => self.parse_return(),
-                self.match_token(TokenKind::SemiColon)?;
+            TokenKind::Identifier(_) => {
-
+                let ident = self.match_identifier()?;
-                state
-            }
-            TokenKind::Keyword(Keyword::Return) => {
-                let state = self.parse_return()?;
-                self.match_token(TokenKind::SemiColon)?;
-
-                Ok(state)
-            }
-            TokenKind::Identifier(name) => {
                 if let Ok(_) = self.peek_token(TokenKind::BraceOpen) {
                     let state = self.parse_function_call()?;
-                    self.match_token(TokenKind::SemiColon)?;
                     Ok(Statement::Exp(state))
                 } else {
-                    let state = Statement::Exp(Expression::Variable(name.into()));
+                    let state = Statement::Exp(Expression::Variable(ident.into()));
                     Ok(state)
                 }
             }
-
+            TokenKind::Literal(_) => Ok(Statement::Exp(self.parse_expression()?)),
             _ => return Err(self.make_error(TokenKind::Unknown, token)),
-        }
+        };
+        self.match_token(TokenKind::SemiColon)?;
+        state
     }
 
     /// Parses a function call from tokens.
@@ -262,6 +254,7 @@ impl Parser {
     }
 
     fn parse_return(&mut self) -> Result<Statement, String> {
+        self.match_keyword(Keyword::Return)?;
         // TODO: Replace unwrap with make_error
         let peeked = self.peek().unwrap();
         match peeked.kind {
@@ -338,6 +331,7 @@ impl Parser {
     }
 
     fn parse_declare(&mut self) -> Result<Statement, String> {
+        self.match_keyword(Keyword::Let)?;
         match (
             self.next_token().kind,
             self.peek().ok_or("Expected ; or =")?.kind,

src/parser/tests.rs

@@ -163,7 +163,6 @@ fn test_parse_basic_ops() {
 }
 
 #[test]
-#[ignore]
 fn test_parse_compound_ops() {
     let raw = "
     fn main() {