fix: map_err loses some of what is expected in error when used sequentially (#835) (#836)

Author: Hedgehogo

src/combinator.rs

@@ -2867,10 +2867,16 @@ where
         let start = inp.cursor();
         let old_alt = inp.take_alt();
         let res = self.parser.go::<M>(inp);
+        let new_alt = inp.take_alt();
 
-        if res.is_err() {
+        if res.is_ok() {
+            inp.errors.alt = old_alt;
+            if let Some(new_alt) = new_alt {
+                inp.add_alt_err(&new_alt.pos, new_alt.err);
+            }
+        } else {
             // Can't fail!
-            let mut new_alt = inp.take_alt().unwrap();
+            let mut new_alt = new_alt.unwrap();
             let span = inp.span_since(&start);
             new_alt.err = (self.mapper)(new_alt.err, span, inp.state());
 

src/lib.rs

@@ -3761,30 +3761,53 @@ mod tests {
     #[test]
     #[allow(dead_code)]
     fn map_err_missed_info() {
-        use crate::LabelError;
+        use crate::{extra::Err, LabelError};
 
-        fn zero<'src>() -> impl Parser<'src, &'src str, (), extra::Err<Rich<'src, char>>> {
-            just("-")
-                .or_not()
-                .then(just("0").map_err(move |e: Rich<_>| {
-                    LabelError::<&str, char>::expected_found(
-                        ['n'],
-                        e.found().map(|i| From::from(*i)),
-                        *e.span(),
-                    )
-                }))
-                .ignored()
+        fn erroneous_map_err<'src>() -> impl Parser<'src, &'src str, (), Err<Rich<'src, char>>> {
+            group((
+                just("a").or_not(),
+                just("b").map_err(|mut err| {
+                    LabelError::<&str, _>::label_with(&mut err, 'l');
+                    err
+                }),
+            ))
+            .ignored()
         }
 
         assert_eq!(
-            zero().parse("_0").into_result(),
-            Err(vec![
-                <Rich<char> as LabelError::<&str, char>>::expected_found(
-                    ['-', 'n'],
+            erroneous_map_err().parse("_").into_output_errors(),
+            (
+                None,
+                vec![LabelError::<&str, _>::expected_found(
+                    ['a', 'l'],
                     Some('_'.into()),
-                    (0..1).into(),
-                )
-            ]),
+                    SimpleSpan::new((), 0..1),
+                )]
+            ),
+        );
+
+        fn erroneous_then<'src>() -> impl Parser<'src, &'src str, (), Err<Rich<'src, char>>> {
+            group((
+                just("a").or_not(),
+                empty().map_err(|mut err| {
+                    LabelError::<&str, _>::label_with(&mut err, 'l');
+                    err
+                }),
+                just("c"),
+            ))
+            .ignored()
+        }
+
+        assert_eq!(
+            erroneous_then().parse("_").into_output_errors(),
+            (
+                None,
+                vec![LabelError::<&str, _>::expected_found(
+                    ['a', 'c'],
+                    Some('_'.into()),
+                    SimpleSpan::new((), 0..1),
+                )]
+            ),
         );
     }