Turn helpers into functions of ParseSession (#199)

Closes #191 

* replace consume_or_report! macro with ParseSession method

* replace allow() helper function with ParseSession method

* replace slice_and_advance() helper function with method in ParseSession

* replace is_end_of_stream() helper with method in ParseSession

* parser.rs: cleanup imports

* replace helpers with member functions of Diagnostic

* improve unexpected_token_found()

* replace expect! macro with ParseSession method

* improve coverage by removing unidentified_token()

* get rid of duplicate unexpected_token() function

* add test for unexpected token in ACTIONS block

* remove unnecessary Option, improve error messages

Co-authored-by: Ghaith Hachem <ghaith.hachem@gmail.com>

Author: ulmer-a

src/lexer.rs

@@ -37,6 +37,47 @@ impl<'a> ParseSession<'a> {
         lexer
     }
 
+    pub fn expect(&self, token: Token) -> Result<(), Diagnostic> {
+        if self.token != token {
+            Err(Diagnostic::unexpected_token_found(
+                format!("{:?}", token),
+                self.slice().to_string(),
+                self.location(),
+            ))
+        } else {
+            Ok(())
+        }
+    }
+
+    /// consumes an optional token and returns true if it was consumed.
+    pub fn allow(&mut self, token: &Token) -> bool {
+        if self.token == *token {
+            self.advance();
+            true
+        } else {
+            false
+        }
+    }
+
+    pub fn consume_or_report(&mut self, token: Token) {
+        if !self.allow(&token) {
+            self.accept_diagnostic(Diagnostic::missing_token(
+                format!("{:?}", token),
+                self.location(),
+            ));
+        }
+    }
+
+    pub fn slice_and_advance(&mut self) -> String {
+        let slice = self.slice().to_string();
+        self.advance();
+        slice
+    }
+
+    pub fn is_end_of_stream(&self) -> bool {
+        self.token == Token::End || self.token == Token::Error
+    }
+
     pub fn slice_region(&self, range: Range<usize>) -> &str {
         &self.lexer.source()[range]
     }

src/lib.rs

@@ -60,13 +60,13 @@ impl Diagnostic {
         found: String,
         range: SourceRange,
     ) -> Diagnostic {
-        Diagnostic::SyntaxError {
-            message: format!(
+        Diagnostic::syntax_error(
+            format!(
                 "Unexpected token: expected {} but found {}",
                 expected, found
             ),
             range,
-        }
+        )
     }
 
     pub fn return_type_not_supported(pou_type: &PouType, range: SourceRange) -> Diagnostic {