refactor(pc): Introduce ParserErrorTrait trait

Introducing a `ParserErrorTrait` trait that describes an error.

An important change is that that trait now determines
if the error is fatal or not, which changes the error
returned in `ParseResult` (the fatal part was specified
as a boolean in a tuple, now that is gone).

Regarding naming, settling on this naming:

- soft errors, errors that are not fatal and just indicate a miss
- fatal errors, unrecoverable errors

Renamed the `ParseError` struct to `ParserError`
and the old enum is now called `ParserErrorKind`.

Author: ngeor

rusty_linter/src/core/error.rs

@@ -1,5 +1,5 @@
 use rusty_common::{AtPos, HasPos, Positioned};
-use rusty_parser::ParseError;
+use rusty_parser::{ParserError, ParserErrorKind};
 use rusty_variant::VariantError;
 
 #[derive(Clone, Debug, PartialEq)]
@@ -26,7 +26,7 @@ pub enum LintError {
     TypeNotDefined,
     VariableRequired,
     WrongNumberOfDimensions,
-    ParserError(ParseError),
+    ParserError(ParserErrorKind),
 
     // custom
     NotFiniteNumber,
@@ -44,13 +44,13 @@ impl From<VariantError> for LintError {
     }
 }
 
-impl From<ParseError> for LintError {
-    fn from(e: ParseError) -> Self {
-        match e {
-            ParseError::NextWithoutFor => Self::NextWithoutFor,
-            ParseError::Overflow => Self::Overflow,
-            ParseError::ElementNotDefined => Self::ElementNotDefined,
-            _ => Self::ParserError(e),
+impl From<ParserError> for LintError {
+    fn from(e: ParserError) -> Self {
+        match e.kind() {
+            ParserErrorKind::NextWithoutFor => Self::NextWithoutFor,
+            ParserErrorKind::Overflow => Self::Overflow,
+            ParserErrorKind::ElementNotDefined => Self::ElementNotDefined,
+            _ => Self::ParserError(e.to_kind()),
         }
     }
 }

rusty_parser/src/built_ins/close.rs

@@ -4,23 +4,23 @@ use crate::input::RcStringView;
 use crate::pc_specific::*;
 use crate::tokens::comma_ws;
 use crate::{
-    BuiltInSub, ParseError, file_handle_as_expression_pos_p, guarded_file_handle_or_expression_p, *
+    BuiltInSub, ParserError, file_handle_as_expression_pos_p, guarded_file_handle_or_expression_p, *
 };
 
 // <result> ::= <CLOSE> | <CLOSE><file_handles>
 // file_handles ::= <first_file_handle> | <first_file_handle> <opt-ws> "," <opt-ws> <next_file_handles>
 // next_file_handles ::= <file_handle> | <file_handle> <opt-ws> "," <opt-ws> <next_file_handles>
 // first_file_handle ::= "(" <file_handle> ")" | <ws> <file_handle>
 // file_handle ::= "#" <digits> | <expr>
-pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParseError> {
+pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParserError> {
     seq2(
         keyword(Keyword::Close),
         file_handles(),
         |_, file_handles| Statement::built_in_sub_call(BuiltInSub::Close, file_handles),
     )
 }
 
-fn file_handles() -> impl Parser<RcStringView, Output = Expressions, Error = ParseError> {
+fn file_handles() -> impl Parser<RcStringView, Output = Expressions, Error = ParserError> {
     guarded_file_handle_or_expression_p()
         .map(|first| vec![first])
         .and(
@@ -33,7 +33,7 @@ fn file_handles() -> impl Parser<RcStringView, Output = Expressions, Error = Par
 }
 
 fn file_handle_or_expression_p()
--> impl Parser<RcStringView, Output = ExpressionPos, Error = ParseError> {
+-> impl Parser<RcStringView, Output = ExpressionPos, Error = ParserError> {
     OrParser::new(vec![
         Box::new(file_handle_as_expression_pos_p()),
         Box::new(expression_pos_p()),
@@ -44,7 +44,6 @@ fn file_handle_or_expression_p()
 mod tests {
     use rusty_common::*;
 
-    use crate::error::ParseError;
     use crate::test_utils::*;
     use crate::{BuiltInSub, assert_parser_err, *};
 
@@ -114,15 +113,15 @@ mod tests {
     #[test]
     fn test_one_file_number_with_hash_no_leading_space() {
         let input = "CLOSE#1";
-        assert_parser_err!(input, ParseError::expected("end-of-statement"), 1, 7);
+        assert_parser_err!(input, ParserErrorKind::expected("end-of-statement"), 1, 7);
     }
 
     #[test]
     fn test_one_file_number_with_hash_parenthesis_leading_space() {
         let input = "CLOSE (#1)";
         assert_parser_err!(
             input,
-            ParseError::expected("expression inside parenthesis"),
+            ParserErrorKind::expected("expression inside parenthesis"),
             1,
             8
         );
@@ -133,7 +132,7 @@ mod tests {
         let input = "CLOSE(#1)";
         assert_parser_err!(
             input,
-            ParseError::expected("expression inside parenthesis"),
+            ParserErrorKind::expected("expression inside parenthesis"),
             1,
             7
         );

rusty_parser/src/built_ins/color.rs

@@ -2,17 +2,16 @@ use rusty_pc::*;
 
 use crate::built_ins::common::parse_built_in_sub_with_opt_args;
 use crate::input::RcStringView;
-use crate::{BuiltInSub, ParseError, *};
+use crate::{BuiltInSub, ParserError, *};
 
-pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParseError> {
+pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParserError> {
     parse_built_in_sub_with_opt_args(Keyword::Color, BuiltInSub::Color)
 }
 
 #[cfg(test)]
 mod tests {
-    use crate::error::ParseError;
     use crate::test_utils::*;
-    use crate::{BuiltInSub, Statement, assert_parser_err, parse};
+    use crate::{BuiltInSub, ParserErrorKind, Statement, assert_parser_err, parse};
 
     #[test]
     fn parse_foreground_only() {
@@ -60,6 +59,6 @@ mod tests {
     #[test]
     fn parse_no_args() {
         let input = "COLOR";
-        assert_parser_err!(input, ParseError::expected("whitespace"), 1, 6);
+        assert_parser_err!(input, ParserErrorKind::expected("whitespace"), 1, 6);
     }
 }

rusty_parser/src/built_ins/common.rs

@@ -4,14 +4,14 @@ use rusty_pc::*;
 use crate::input::RcStringView;
 use crate::pc_specific::*;
 use crate::tokens::comma_ws;
-use crate::{BuiltInSub, ParseError, *};
+use crate::{BuiltInSub, ParserError, *};
 
 /// Parses built-in subs with optional arguments.
 /// Used only by `COLOR` and `LOCATE`.
 pub fn parse_built_in_sub_with_opt_args(
     k: Keyword,
     built_in_sub: BuiltInSub,
-) -> impl Parser<RcStringView, Output = Statement, Error = ParseError> {
+) -> impl Parser<RcStringView, Output = Statement, Error = ParserError> {
     keyword_ws_p(k)
         .and_keep_right(csv_allow_missing())
         .map(move |opt_args| {
@@ -41,15 +41,15 @@ fn map_opt_args_to_flags(args: Vec<Option<ExpressionPos>>) -> Expressions {
 
 /// Comma separated list of items, allowing items to be missing between commas.
 pub fn csv_allow_missing()
--> impl Parser<RcStringView, Output = Vec<Option<ExpressionPos>>, Error = ParseError> {
+-> impl Parser<RcStringView, Output = Vec<Option<ExpressionPos>>, Error = ParserError> {
     expression_pos_p()
         .delimited_by_allow_missing(comma_ws(), trailing_comma_error())
         .or_default()
 }
 
 /// Used in `INPUT` and `LINE INPUT`, parsing an optional file number.
 pub fn opt_file_handle_comma_p()
--> impl Parser<RcStringView, Output = Option<Positioned<FileHandle>>, Error = ParseError> {
+-> impl Parser<RcStringView, Output = Option<Positioned<FileHandle>>, Error = ParserError> {
     seq2(file_handle_p(), comma_ws(), |l, _| l).to_option()
 }
 

rusty_parser/src/built_ins/data.rs

@@ -2,9 +2,9 @@ use rusty_pc::*;
 
 use crate::input::RcStringView;
 use crate::pc_specific::*;
-use crate::{BuiltInSub, ParseError, *};
+use crate::{BuiltInSub, ParserError, *};
 
-pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParseError> {
+pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParserError> {
     seq2(
         keyword(Keyword::Data),
         csv_expressions_first_guarded().or_default(),

rusty_parser/src/built_ins/def_seg.rs

@@ -3,10 +3,10 @@ use rusty_pc::*;
 use crate::input::RcStringView;
 use crate::pc_specific::*;
 use crate::tokens::equal_sign_ws;
-use crate::{BuiltInSub, ParseError, *};
+use crate::{BuiltInSub, ParserError, *};
 
 // DEF SEG(=expr)?
-pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParseError> {
+pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParserError> {
     seq2(
         keyword_pair(Keyword::Def, Keyword::Seg),
         equal_sign_and_expression().to_option(),
@@ -17,7 +17,7 @@ pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParseErr
 }
 
 fn equal_sign_and_expression()
--> impl Parser<RcStringView, Output = ExpressionPos, Error = ParseError> {
+-> impl Parser<RcStringView, Output = ExpressionPos, Error = ParserError> {
     equal_sign_ws().and_keep_right(expression_pos_p().or_expected("Expression after equal sign"))
 }
 

rusty_parser/src/built_ins/field.rs

@@ -4,10 +4,10 @@ use rusty_pc::*;
 use crate::input::RcStringView;
 use crate::pc_specific::*;
 use crate::tokens::comma_ws;
-use crate::{BuiltInSub, ParseError, *};
+use crate::{BuiltInSub, ParserError, *};
 
 /// Example: FIELD #1, 10 AS FirstName$, 20 AS LastName$
-pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParseError> {
+pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParserError> {
     seq4(
         keyword_ws_p(Keyword::Field),
         file_handle_p().or_expected("file-number"),
@@ -19,8 +19,8 @@ pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParseErr
     )
 }
 
-fn field_item_p() -> impl Parser<RcStringView, Output = (ExpressionPos, NamePos), Error = ParseError>
-{
+fn field_item_p()
+-> impl Parser<RcStringView, Output = (ExpressionPos, NamePos), Error = ParserError> {
     seq3(
         expr_pos_ws_p(),
         keyword_ws_p(Keyword::As),

rusty_parser/src/built_ins/get.rs

@@ -3,16 +3,16 @@ use rusty_pc::*;
 use crate::input::RcStringView;
 use crate::pc_specific::*;
 use crate::tokens::comma_ws;
-use crate::{BuiltInSub, ParseError, *};
+use crate::{BuiltInSub, ParserError, *};
 
-pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParseError> {
+pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParserError> {
     parse_get_or_put(Keyword::Get, BuiltInSub::Get)
 }
 
 pub fn parse_get_or_put(
     k: Keyword,
     built_in_sub: BuiltInSub,
-) -> impl Parser<RcStringView, Output = Statement, Error = ParseError> {
+) -> impl Parser<RcStringView, Output = Statement, Error = ParserError> {
     seq4(
         keyword_ws_p(k),
         file_handle_p().or_expected("file-number"),

rusty_parser/src/built_ins/input.rs

@@ -3,11 +3,11 @@ use rusty_pc::*;
 use crate::built_ins::common::{encode_opt_file_handle_arg, opt_file_handle_comma_p};
 use crate::input::RcStringView;
 use crate::pc_specific::*;
-use crate::{BuiltInSub, ParseError, *};
+use crate::{BuiltInSub, ParserError, *};
 
 // INPUT variable-list
 // INPUT #file-number%, variable-list
-pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParseError> {
+pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParserError> {
     seq3(
         keyword_ws_p(Keyword::Input),
         opt_file_handle_comma_p(),
@@ -22,7 +22,6 @@ pub fn parse() -> impl Parser<RcStringView, Output = Statement, Error = ParseErr
 
 #[cfg(test)]
 mod tests {
-    use crate::error::ParseError;
     use crate::test_utils::*;
     use crate::{BuiltInSub, assert_built_in_sub_call, assert_parser_err, *};
 
@@ -52,13 +51,13 @@ mod tests {
     #[test]
     fn test_no_whitespace_ignoring_after_input() {
         let input = "INPUT";
-        assert_parser_err!(input, ParseError::expected("whitespace"));
+        assert_parser_err!(input, ParserErrorKind::expected("whitespace"));
     }
 
     #[test]
     fn test_no_variable() {
         let input = "INPUT ";
-        assert_parser_err!(input, ParseError::expected("#file-number or variable"));
+        assert_parser_err!(input, ParserErrorKind::expected("#file-number or variable"));
     }
 
     #[test]

rusty_parser/src/built_ins/len.rs

@@ -2,9 +2,9 @@ use rusty_pc::*;
 
 use crate::input::RcStringView;
 use crate::pc_specific::*;
-use crate::{BuiltInFunction, ParseError, *};
+use crate::{BuiltInFunction, ParserError, *};
 
-pub fn parse() -> impl Parser<RcStringView, Output = Expression, Error = ParseError> {
+pub fn parse() -> impl Parser<RcStringView, Output = Expression, Error = ParserError> {
     keyword(Keyword::Len)
         .and_keep_right(in_parenthesis_csv_expressions_non_opt("variable"))
         .map(|v| Expression::BuiltInFunctionCall(BuiltInFunction::Len, v))