Implemented with_expected_message in pc

Author: ngeor

rusty_parser/src/core/dim_name.rs

@@ -172,13 +172,12 @@ mod type_definition {
                     Box::new(built_in_numeric_type()),
                     Box::new(built_in_string()),
                 ];
-                let mut expected_message =
-                    "Expected: INTEGER or LONG or SINGLE or DOUBLE or STRING";
+                let mut expected_message = "INTEGER or LONG or SINGLE or DOUBLE or STRING";
 
                 if allow_user_defined {
                     parsers.push(Box::new(user_defined_type()));
                     expected_message =
-                        "Expected: INTEGER or LONG or SINGLE or DOUBLE or STRING or identifier";
+                        "INTEGER or LONG or SINGLE or DOUBLE or STRING or identifier";
                 }
 
                 OrParser::new(parsers).with_expected_message(expected_message)

rusty_parser/src/core/param_name.rs

@@ -101,9 +101,7 @@ fn extended_type() -> impl Parser<StringView, VarNameCtx, Output = ParamType, Er
         // allow user defined
         built_in_extended_type()
             .or(user_defined_type())
-            .with_expected_message(
-                "Expected: INTEGER or LONG or SINGLE or DOUBLE or STRING or identifier",
-            ),
+            .with_expected_message("INTEGER or LONG or SINGLE or DOUBLE or STRING or identifier"),
         // do not allow user defined
         built_in_extended_type(),
     )

rusty_parser/src/error.rs

@@ -63,7 +63,7 @@ impl ParserError {
     /// Creates a syntax error that starts with "Expected: "
     /// followed by the given string.
     pub fn expected(expectation: &str) -> Self {
-        Self::Expected(format!("Expected: {}", expectation))
+        Self::from(expectation)
     }
 }
 
@@ -98,3 +98,17 @@ impl From<std::num::ParseIntError> for ParserError {
         Self::ParseNumError(e.to_string())
     }
 }
+
+// Needed in order to support with_expected_message
+
+impl From<String> for ParserError {
+    fn from(e: String) -> Self {
+        Self::Expected(format!("Expected: {}", e))
+    }
+}
+
+impl From<&str> for ParserError {
+    fn from(e: &str) -> Self {
+        Self::Expected(format!("Expected: {}", e))
+    }
+}

rusty_parser/src/pc_specific/keyword.rs

@@ -4,7 +4,7 @@ use rusty_pc::and::IgnoringBothCombiner;
 use rusty_pc::*;
 
 use crate::input::StringView;
-use crate::pc_specific::{WithExpected, whitespace_ignoring};
+use crate::pc_specific::whitespace_ignoring;
 use crate::tokens::{TokenMatcher, TokenType, any_token};
 use crate::{Keyword, ParserError};
 
@@ -42,7 +42,7 @@ pub fn keyword_ignoring(k: Keyword) -> impl Parser<StringView, Output = (), Erro
     any_token()
         .filter(move |t| k.matches_token(t))
         .map_to_unit()
-        .with_expected_message(format!("Expected: {}", k))
+        .with_expected_message(format!("{}", k))
 }
 
 /// Parses the given keyword, followed by mandatory whitespace.

rusty_parser/src/pc_specific/mod.rs

@@ -8,7 +8,6 @@ mod whitespace;
 pub mod logging;
 
 mod or_expected;
-mod with_expected_message;
 mod with_pos;
 
 pub use self::csv::*;
@@ -17,5 +16,4 @@ pub use self::keyword::*;
 pub use self::keyword_map::*;
 pub use self::or_expected::*;
 pub use self::whitespace::*;
-pub use self::with_expected_message::*;
 pub use self::with_pos::*;

rusty_parser/src/pc_specific/with_expected_message.rs

@@ -4,7 +4,6 @@ use rusty_pc::text::{many_str, many_str_with_combiner, one_char_to_str};
 use rusty_pc::*;
 
 use crate::input::StringView;
-use crate::pc_specific::WithExpected;
 use crate::tokens::TokenType;
 use crate::tokens::any_symbol::any_symbol;
 use crate::{Keyword, ParserError};

rusty_parser/src/tokens/any_token.rs

@@ -318,6 +318,17 @@ where
         MapSoftErrParser::new(self, err)
     }
 
+    /// If this parser returns a soft error, the soft error will be replaced
+    /// by transforming the given message into an error.
+    /// The parameter will be converted with the standard `From` trait.
+    fn with_expected_message<E>(self, msg: E) -> MapSoftErrParser<Self, Self::Error>
+    where
+        Self: Sized,
+        Self::Error: From<E>,
+    {
+        self.with_soft_err(Self::Error::from(msg))
+    }
+
     /// If this parser returns a soft error, the soft error will be replaced by
     /// the given error, which must be fatal.
     fn or_fail(self, err: Self::Error) -> MapSoftErrParser<Self, Self::Error>