Add regex error source to RegexError

Author: ratmice

lrlex/src/lib/mod.rs

@@ -46,7 +46,7 @@ pub struct LexBuildError {
 impl Error for LexBuildError {}
 
 /// The various different possible Lex parser errors.
-#[derive(Debug, PartialEq, Eq, Clone)]
+#[derive(Debug, Clone)]
 pub enum LexErrorKind {
     PrematureEnd,
     RoutinesNotSupported,
@@ -58,13 +58,40 @@ pub enum LexErrorKind {
     InvalidStartState,
     InvalidStartStateName,
     DuplicateName,
-    RegexError,
+    RegexError(regex::Error),
     InvalidGrmtoolsSectionValue,
     InvalidNumber,
     DuplicateGrmtoolsSectionValue,
     VerbatimNotSupported,
 }
 
+impl PartialEq for LexErrorKind {
+    fn eq(&self, other: &Self) -> bool {
+        use LexErrorKind as EK;
+        match (self, other) {
+            (EK::PrematureEnd, EK::PrematureEnd)
+            | (EK::RoutinesNotSupported, EK::RoutinesNotSupported)
+            | (EK::UnknownDeclaration, EK::UnknownDeclaration)
+            | (EK::MissingSpace, EK::MissingSpace)
+            | (EK::InvalidName, EK::InvalidName)
+            | (EK::UnknownStartState, EK::UnknownStartState)
+            | (EK::DuplicateStartState, EK::DuplicateStartState)
+            | (EK::InvalidStartState, EK::InvalidStartState)
+            | (EK::InvalidStartStateName, EK::InvalidStartStateName)
+            | (EK::DuplicateName, EK::DuplicateName)
+            | (EK::InvalidGrmtoolsSectionValue, EK::InvalidGrmtoolsSectionValue)
+            | (EK::InvalidNumber, EK::InvalidNumber)
+            | (EK::DuplicateGrmtoolsSectionValue, EK::DuplicateGrmtoolsSectionValue)
+            | (EK::VerbatimNotSupported, EK::VerbatimNotSupported) => true,
+            (EK::RegexError(e1), EK::RegexError(e2)) => e1.to_string() == e2.to_string(),
+
+            _ => false,
+        }
+    }
+}
+
+impl Eq for LexErrorKind {}
+
 impl Spanned for LexBuildError {
     fn spans(&self) -> &[Span] {
         self.spans.as_slice()
@@ -83,7 +110,7 @@ impl Spanned for LexBuildError {
             | LexErrorKind::InvalidGrmtoolsSectionValue
             | LexErrorKind::InvalidNumber
             | LexErrorKind::VerbatimNotSupported
-            | LexErrorKind::RegexError => SpansKind::Error,
+            | LexErrorKind::RegexError(_) => SpansKind::Error,
             LexErrorKind::DuplicateName
             | LexErrorKind::DuplicateStartState
             | LexErrorKind::DuplicateGrmtoolsSectionValue => SpansKind::DuplicationError,
@@ -93,7 +120,7 @@ impl Spanned for LexBuildError {
 
 impl fmt::Display for LexBuildError {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let s = match self.kind {
+        let s = match &self.kind {
             LexErrorKind::VerbatimNotSupported => "Verbatim code not supported",
             LexErrorKind::PrematureEnd => "File ends prematurely",
             LexErrorKind::RoutinesNotSupported => "Routines not currently supported",
@@ -108,7 +135,7 @@ impl fmt::Display for LexBuildError {
             LexErrorKind::InvalidNumber => "Invalid number",
             LexErrorKind::DuplicateGrmtoolsSectionValue => "Duplicate grmtools section value",
             LexErrorKind::DuplicateName => "Rule name already exists",
-            LexErrorKind::RegexError => "Invalid regular expression",
+            LexErrorKind::RegexError(e) => return write!(f, "Invalid regular expression: {e}"),
         };
         write!(f, "{s}")
     }

lrlex/src/lib/parser.rs

@@ -606,7 +606,7 @@ where
                 target_state,
                 &self.lex_flags,
             )
-            .map_err(|_| self.mk_error(LexErrorKind::RegexError, i))?;
+            .map_err(|e| self.mk_error(LexErrorKind::RegexError(e), i))?;
             self.rules.push(rule);
         }
         Ok(i + line_len)