Move parser util functions into separate module

src/compiler/parser.rs

@@ -1,5 +1,6 @@
 use crate::compiler::{
     ast::Expression::{self, *},
+    parser::parser_utilities::*,
     token::{Token, TokenType},
 };
 
@@ -131,69 +132,73 @@ fn parse_identifier<'source>(pos: &mut usize, tokens: &[Token<'source>]) -> Expr
     Identifier(token.text)
 }
 
-fn consume_string<'source>(
+mod parser_utilities {
-    pos: &mut usize,
+    use super::*;
-    tokens: &[Token<'source>],
-    expected_string: &str,
-) -> Token<'source> {
-    consume_strings(pos, tokens, &[expected_string])
-}
 
-fn consume_strings<'source>(
+    pub fn consume_string<'source>(
-    pos: &mut usize,
+        pos: &mut usize,
-    tokens: &[Token<'source>],
+        tokens: &[Token<'source>],
-    strings: &[&str],
+        expected_string: &str,
-) -> Token<'source> {
+    ) -> Token<'source> {
-    let token = consume(pos, tokens);
+        consume_strings(pos, tokens, &[expected_string])
-
-    if strings.contains(&token.text) {
-        token
-    } else {
-        panic!(
-            "Parsing error: expected one of {:?} but found {}",
-            strings, token
-        );
     }
-}
 
-fn consume_type<'source>(
+    pub fn consume_strings<'source>(
-    pos: &mut usize,
+        pos: &mut usize,
-    tokens: &[Token<'source>],
+        tokens: &[Token<'source>],
-    expected_type: TokenType,
+        strings: &[&str],
-) -> Token<'source> {
+    ) -> Token<'source> {
-    consume_types(pos, tokens, &[expected_type])
+        let token = consume(pos, tokens);
-}
 
-fn consume_types<'source>(
+        if strings.contains(&token.text) {
-    pos: &mut usize,
+            token
-    tokens: &[Token<'source>],
+        } else {
-    types: &[TokenType],
+            panic!(
-) -> Token<'source> {
+                "Parsing error: expected one of {:?} but found {}",
-    let token = consume(pos, tokens);
+                strings, token
-
+            );
-    if types.contains(&token.token_type) {
+        }
-        token
-    } else {
-        panic!(
-            "Parsing error: expected one of {:?} but found {}",
-            types, token
-        );
     }
-}
 
-fn consume<'source>(pos: &mut usize, tokens: &[Token<'source>]) -> Token<'source> {
+    pub fn consume_type<'source>(
-    let token = peek(pos, tokens);
+        pos: &mut usize,
-    *pos += 1;
+        tokens: &[Token<'source>],
-    token
+        expected_type: TokenType,
-}
+    ) -> Token<'source> {
+        consume_types(pos, tokens, &[expected_type])
+    }
 
-fn peek<'source>(pos: &mut usize, tokens: &[Token<'source>]) -> Token<'source> {
+    pub fn consume_types<'source>(
-    if let Some(token) = tokens.get(*pos) {
+        pos: &mut usize,
-        token.clone()
+        tokens: &[Token<'source>],
-    } else if let Some(last_token) = tokens.get(*pos - 1) {
+        types: &[TokenType],
-        Token::new("", TokenType::End, last_token.loc)
+    ) -> Token<'source> {
-    } else {
+        let token = consume(pos, tokens);
-        panic!("Input to parser appears to be empty!");
+
+        if types.contains(&token.token_type) {
+            token
+        } else {
+            panic!(
+                "Parsing error: expected one of {:?} but found {}",
+                types, token
+            );
+        }
+    }
+
+    pub fn consume<'source>(pos: &mut usize, tokens: &[Token<'source>]) -> Token<'source> {
+        let token = peek(pos, tokens);
+        *pos += 1;
+        token
+    }
+
+    pub fn peek<'source>(pos: &mut usize, tokens: &[Token<'source>]) -> Token<'source> {
+        if let Some(token) = tokens.get(*pos) {
+            token.clone()
+        } else if let Some(last_token) = tokens.get(*pos - 1) {
+            Token::new("", TokenType::End, last_token.loc)
+        } else {
+            panic!("Input to parser appears to be empty!");
+        }
     }
 }