Remove eq on LexErrorKind add private is_same_kind.

Author: ratmice

lrlex/src/lib/mod.rs

@@ -65,8 +65,8 @@ pub enum LexErrorKind {
     VerbatimNotSupported,
 }
 
-impl PartialEq for LexErrorKind {
-    fn eq(&self, other: &Self) -> bool {
+impl LexErrorKind {
+    fn is_same_kind(&self, other: &Self) -> bool {
         use LexErrorKind as EK;
         match (self, other) {
             (EK::PrematureEnd, EK::PrematureEnd)
@@ -82,16 +82,13 @@ impl PartialEq for LexErrorKind {
             | (EK::InvalidGrmtoolsSectionValue, EK::InvalidGrmtoolsSectionValue)
             | (EK::InvalidNumber, EK::InvalidNumber)
             | (EK::DuplicateGrmtoolsSectionValue, EK::DuplicateGrmtoolsSectionValue)
+            | (EK::RegexError(_), EK::RegexError(_))
             | (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()

lrlex/src/lib/parser.rs

@@ -113,7 +113,7 @@ fn add_duplicate_occurrence(
     dup_span: Span,
 ) {
     if !errs.iter_mut().any(|e| {
-        if e.kind == kind && e.spans[0] == orig_span {
+        if e.kind.is_same_kind(&kind) && e.spans[0] == orig_span {
             e.spans.push(dup_span);
             true
         } else {
@@ -852,7 +852,7 @@ mod test {
                 .expect_err("Parsed ok while expecting error");
             assert_eq!(errs.len(), 1);
             let e = &errs[0];
-            assert_eq!(e.kind, kind);
+            assert!(e.kind.is_same_kind(&kind));
             assert_eq!(
                 e.spans()
                     .iter()
@@ -880,20 +880,22 @@ mod test {
                 }
             }
 
-            assert_eq!(
-                errs.iter()
-                    .map(|e| {
-                        (
-                            e.kind.clone(),
-                            e.spans()
-                                .iter()
-                                .map(|span| line_col!(src, span))
-                                .collect::<Vec<_>>(),
-                        )
-                    })
-                    .collect::<Vec<_>>(),
-                expected.collect::<Vec<_>>()
-            );
+            for ((ek1, es1), (ek2, es2)) in errs
+                .iter()
+                .map(|e| {
+                    (
+                        e.kind.clone(),
+                        e.spans()
+                            .iter()
+                            .map(|span| line_col!(src, span))
+                            .collect::<Vec<_>>(),
+                    )
+                })
+                .zip(expected)
+            {
+                assert!(ek1.is_same_kind(&ek2));
+                assert_eq!(es1, es2);
+            }
         }
     }