parser: track ErrorKind in ErrorContext

Author: djc

askama_parser/src/expr.rs

@@ -115,6 +115,7 @@ impl<'a> Expr<'a> {
                                 message: Some(Cow::Borrowed(
                                     "named arguments must always be passed last",
                                 )),
+                                kind: ErrorKind::Fail,
                             }))
                         } else {
                             Ok((i, expr))
@@ -150,6 +151,7 @@ impl<'a> Expr<'a> {
                 message: Some(Cow::Owned(format!(
                     "named argument `{argument}` was passed more than once"
                 ))),
+                kind: ErrorKind::Count,
             }))
         }
     }

askama_parser/src/lib.rs

@@ -140,13 +140,15 @@ pub(crate) type ParseResult<'a, T = &'a str> = Result<(&'a str, T), nom::Err<Err
 pub(crate) struct ErrorContext<'a> {
     pub(crate) input: &'a str,
     pub(crate) message: Option<Cow<'static, str>>,
+    pub(crate) kind: ErrorKind,
 }
 
 impl<'a> nom::error::ParseError<&'a str> for ErrorContext<'a> {
-    fn from_error_kind(input: &'a str, _code: ErrorKind) -> Self {
+    fn from_error_kind(input: &'a str, kind: ErrorKind) -> Self {
         Self {
             input,
             message: None,
+            kind,
         }
     }
 
@@ -156,10 +158,11 @@ impl<'a> nom::error::ParseError<&'a str> for ErrorContext<'a> {
 }
 
 impl<'a, E: std::fmt::Display> FromExternalError<&'a str, E> for ErrorContext<'a> {
-    fn from_external_error(input: &'a str, _kind: ErrorKind, e: E) -> Self {
+    fn from_external_error(input: &'a str, kind: ErrorKind, e: E) -> Self {
         Self {
             input,
             message: Some(Cow::Owned(e.to_string())),
+            kind,
         }
     }
 }
@@ -168,13 +171,15 @@ impl<'a> ErrorContext<'a> {
     pub(crate) fn from_err(error: nom::Err<Error<&'a str>>) -> nom::Err<Self> {
         match error {
             nom::Err::Incomplete(i) => nom::Err::Incomplete(i),
-            nom::Err::Failure(Error { input, .. }) => nom::Err::Failure(Self {
+            nom::Err::Failure(Error { input, code }) => nom::Err::Failure(Self {
                 input,
                 message: None,
+                kind: code,
             }),
-            nom::Err::Error(Error { input, .. }) => nom::Err::Error(Self {
+            nom::Err::Error(Error { input, code }) => nom::Err::Error(Self {
                 input,
                 message: None,
+                kind: code,
             }),
         }
     }

askama_parser/src/node.rs

@@ -263,6 +263,7 @@ impl<'a> Target<'a> {
             "self" | "writer" => Err(nom::Err::Failure(ErrorContext {
                 input,
                 message: Some(Cow::Owned(format!("Cannot use `{name}` as a name"))),
+                kind: ErrorKind::NoneOf,
             })),
             _ => Ok(Self::Name(name)),
         }
@@ -343,6 +344,7 @@ impl<'a> Cond<'a> {
                     message: Some(Cow::Borrowed(
                         "unknown `elif` keyword; did you mean `else if`?",
                     )),
+                    kind: ErrorKind::Tag,
                 }))
             }))),
             cut(tuple((
@@ -789,6 +791,7 @@ fn check_end_name<'a>(
     Err(nom::Err::Failure(ErrorContext {
         input: before,
         message: Some(Cow::Owned(message)),
+        kind: ErrorKind::Tag,
     }))
 }
 
@@ -991,6 +994,7 @@ impl<'a> Extends<'a> {
                 message: Some(Cow::Borrowed(
                     "whitespace control is not allowed on `extends`",
                 )),
+                kind: ErrorKind::NoneOf,
             })),
         }
     }