feat(path): Improve error messages for path parser

Author: zaneduffield

src/path/parser.rs

@@ -2,13 +2,15 @@ use std::str::FromStr;
 
 use winnow::ascii::digit1;
 use winnow::ascii::space0;
+use winnow::combinator::cut_err;
 use winnow::combinator::dispatch;
-use winnow::combinator::eof;
 use winnow::combinator::fail;
 use winnow::combinator::opt;
 use winnow::combinator::repeat;
 use winnow::combinator::seq;
 use winnow::error::ContextError;
+use winnow::error::StrContext;
+use winnow::error::StrContextValue;
 use winnow::prelude::*;
 use winnow::token::any;
 use winnow::token::take_while;
@@ -17,7 +19,7 @@ use crate::path::Expression;
 
 pub(crate) fn from_str(mut input: &str) -> Result<Expression, ContextError> {
     let input = &mut input;
-    path(input).map_err(|e| e.into_inner().unwrap())
+    path.parse(input).map_err(|e| e.into_inner())
 }
 
 fn path(i: &mut &str) -> PResult<Expression> {
@@ -31,7 +33,6 @@ fn path(i: &mut &str) -> PResult<Expression> {
             },
         )
         .parse_next(i)?;
-    eof.parse_next(i)?;
     Ok(expr)
 }
 
@@ -41,9 +42,21 @@ fn ident(i: &mut &str) -> PResult<Expression> {
 
 fn postfix(i: &mut &str) -> PResult<Child> {
     dispatch! {any;
-        '[' => seq!(integer.map(Child::Index), _: ']').map(|(i,)| i),
-        '.' => raw_ident.map(Child::Key),
-        _ => fail,
+        '[' => cut_err(
+            seq!(
+                integer.map(Child::Index),
+                _: ']'.context(StrContext::Expected(StrContextValue::CharLiteral(']'))),
+            )
+                .map(|(i,)| i)
+                .context(StrContext::Label("subscript"))
+        ),
+        '.' => cut_err(raw_ident.map(Child::Key)),
+        _ => cut_err(
+            fail
+                .context(StrContext::Label("postfix"))
+                .context(StrContext::Expected(StrContextValue::CharLiteral('[')))
+                .context(StrContext::Expected(StrContextValue::CharLiteral('.')))
+        ),
     }
     .parse_next(i)
 }
@@ -56,6 +69,12 @@ enum Child {
 fn raw_ident(i: &mut &str) -> PResult<String> {
     take_while(1.., ('a'..='z', 'A'..='Z', '0'..='9', '_', '-'))
         .map(ToString::to_string)
+        .context(StrContext::Label("identifier"))
+        .context(StrContext::Expected(StrContextValue::Description(
+            "ASCII alphanumeric",
+        )))
+        .context(StrContext::Expected(StrContextValue::CharLiteral('_')))
+        .context(StrContext::Expected(StrContextValue::CharLiteral('-')))
         .parse_next(i)
 }
 
@@ -65,6 +84,9 @@ fn integer(i: &mut &str) -> PResult<isize> {
         (opt('-'), digit1).take().try_map(FromStr::from_str),
         _: space0
     )
+    .context(StrContext::Expected(StrContextValue::Description(
+        "integer",
+    )))
     .map(|(i,)| i)
     .parse_next(i)
 }
@@ -121,30 +143,36 @@ mod test {
     #[test]
     fn test_invalid_identifier() {
         let err = from_str("!").unwrap_err();
-        assert_eq!("", err.to_string());
+        assert_eq!(
+            "invalid identifier\nexpected ASCII alphanumeric, `_`, `-`",
+            err.to_string()
+        );
     }
 
     #[test]
     fn test_invalid_child() {
         let err = from_str("a..").unwrap_err();
-        assert_eq!("", err.to_string());
+        assert_eq!(
+            "invalid identifier\nexpected ASCII alphanumeric, `_`, `-`",
+            err.to_string()
+        );
     }
 
     #[test]
     fn test_invalid_subscript() {
         let err = from_str("a[b]").unwrap_err();
-        assert_eq!("", err.to_string());
+        assert_eq!("invalid subscript\nexpected integer", err.to_string());
     }
 
     #[test]
     fn test_incomplete_subscript() {
         let err = from_str("a[0").unwrap_err();
-        assert_eq!("", err.to_string());
+        assert_eq!("invalid subscript\nexpected `]`", err.to_string());
     }
 
     #[test]
     fn test_invalid_postfix() {
         let err = from_str("a!b").unwrap_err();
-        assert_eq!("", err.to_string());
+        assert_eq!("invalid postfix\nexpected `[`, `.`", err.to_string());
     }
 }