How to get try_map to cut?

[viridia]

I have a parser which parses keys and values in a map. After the key and value are parsed, I have a try_map which checks to see if the type of the value matches the key. If not, it returns an error.

The problem I have is that when an error is printed, it shows an error location at the start of the file. In other words, when try_map fails, it backtracks all the way up to the root of the grammar and reports the error there.

What I want, instead, is to have the error shown at the location of the key / value.

Here's an example:

fn style_prop(input: &mut &str) -> PResult<StyleProp> {
    (
        prop_name,
        multispace0,
        ':',
        multispace0,
        alt((color, ident, length_list, length)).context(StrContext::Label("property value")),
    )
        .try_map(|(name, _, _, _, value)| match name {
            "background_color" => Ok(StyleProp::BackgroundColor(value.coerce()?)),
            "border_color" => Ok(StyleProp::BackgroundColor(value.coerce()?)),
            "color" => Ok(StyleProp::Color(value.coerce()?)),
            _ => Err(StyleParsingError::InvalidProperty),
        })
        .parse_next(input)
}

Wrapping this rule in cut_err doesn't work, since that prevents the parser from detecting the end of the property list ('}').
Wrapping just the property value part (the 'alt') in cut_err doesn't work either, since try_map is failing the whole rule.

[epage]

This is not directly supported at this time. Composability is a known issue and is being tracked in #180. Some parsers solve this by creating a lot of combinations of these functions and I'd like to avoid that.

This is easier to workaround when you are only applying it to one parser, like prop_name.try_map as you could do prop_name.and_then(...) and do the cut_err inside the and_then.

You could solve this by being less declarative.

fn style_prop(input: &mut &str) -> PResult<StyleProp> {
    let (name, _, _, _, value) = (
        prop_name,
        multispace0,
        ':',
        multispace0,
        alt((color, ident, length_list, length)).context(StrContext::Label("property value")),
    ).parse_next(input)?;

    match name {
            "background_color" => Ok(StyleProp::BackgroundColor(value.coerce()?)),
            "border_color" => Ok(StyleProp::BackgroundColor(value.coerce()?)),
            "color" => Ok(StyleProp::Color(value.coerce()?)),
            _ => ErrMode::Cut(StyleParsingError::InvalidProperty),
    }
}

(error construction details left as an exercise for the reader ;) )

[epage]

That is odd. I'd need a reproduction case to tell what is happening.

[viridia]

Here's a small sample which demonstrates the issues I am having:

parse_err.rs.zip

There are 5 unit tests in the example, only 2 of them pass. I'd like to get all of them to pass.

The more general question is, what is the right technique for reporting semantic (not syntactic) errors in a way that prints both the source location and a reasonable error message.

[viridia]

Also, I think that I really don't understand cut_err(). Is cut_err((a, b, c, d)) the same as (cut_err(a), b, c, d) or is it the same as (a, b, c, cut_err(d)). Or neither? The docs say that it "commits" the parse result, but does that happen before, during, or after the subrule?

[epage]

What I overlooked in my message and yours is that ErrMode::from_external_error creates a backtracking error by default. You need to append .cut() to it to make it work.

Couple of tips

• Put #[track_caller] on run_parser_err and run_parser so you can more easily tell what failed
• Change assert!(err.contains("invalid property name:")); to assert!(err.contains("invalid property name:"), "{err}"); so you have context on the failures.
• Something that can help a lot is if you wrap your parsers in trace parsers, like:

fn style_prop(input: &mut &str) -> PResult<StyleProp> {
    winnow::trace::trace("style_prop", |input: &mut _| {
    let (name, _, _, (_, value, _, _, _)) = (
        prop_name,
        multispace0,
        ':',
        cut_err((
            multispace0,
            alt((ident, number)).context(StrContext::Label("property value")),
            multispace0,
            ';'.context(StrContext::Expected(StrContextValue::Description(
                "semicolon",
            ))),
            multispace0,
        )),
    )
        .parse_next(input)?;
    create_prop(name, &value)
        .map_err(|err| ErrMode::from_external_error(input, ErrorKind::Fail, err).cut())
    }).parse_next(input)
}

(note my formatting is way off)

You can then run that one test with --features winnow/debug and see:

> repeat                                            | "foo: 1;"∅
 > style_prop                                       | "foo: 1;"∅
  > one_of                                          | "foo: 1;"∅
   > any                                            | "foo: 1;"∅
   < any                                            | +1
   | verify                                         | 
  < one_of                                          | +1
  > take_while                                      | "oo: 1;"∅
  < take_while                                      | +2
  > multispace0                                     | ": 1;"∅
   > take_while                                     | ": 1;"∅
   < take_while                                     | +0
  < multispace0                                     | +0
  > one_of                                          | ": 1;"∅
   > any                                            | ": 1;"∅
   < any                                            | +1
   | verify                                         | 
  < one_of                                          | +1
  > cut_err                                         | " 1;"∅
   > multispace0                                    | " 1;"∅
    > take_while                                    | " 1;"∅
    < take_while                                    | +1
   < multispace0                                    | +1
   > context=Label("property value")                | "1;"∅
    > alt                                           | "1;"∅
     > one_of                                       | "1;"∅
      > any                                         | "1;"∅
      < any                                         | +1
      | verify                                      | backtrack
     < one_of                                       | backtrack
     > float                                        | "1;"∅
      > alt                                         | "1;"∅
       > opt                                        | "1;"∅
        > one_of                                    | "1;"∅
         > any                                      | "1;"∅
         < any                                      | +1
         | verify                                   | backtrack
        < one_of                                    | backtrack
       < opt                                        | +0
       > alt                                        | "1;"∅
        > digit1                                    | "1;"∅
         > take_while                               | "1;"∅
         < take_while                               | +1
        < digit1                                    | +1
        > opt                                       | ";"∅
         > one_of                                   | ";"∅
          > any                                     | ";"∅
          < any                                     | +1
          | verify                                  | backtrack
         < one_of                                   | backtrack
        < opt                                       | +0
       < alt                                        | +1
       > opt                                        | ";"∅
        > one_of                                    | ";"∅
         > any                                      | ";"∅
         < any                                      | +1
         | verify                                   | backtrack
        < one_of                                    | backtrack
       < opt                                        | +0
      < alt                                         | +1
     < float                                        | +1
    < alt                                           | +1
   < context=Label("property value")                | +1
   > multispace0                                    | ";"∅
    > take_while                                    | ";"∅
    < take_while                                    | +0
   < multispace0                                    | +0
   > context=Expected(Description("semicolon"))     | ";"∅
    > one_of                                        | ";"∅
     > any                                          | ";"∅
     < any                                          | +1
     | verify                                       | 
    < one_of                                        | +1
   < context=Expected(Description("semicolon"))     | +1
   > multispace0                                    | ""∅
    > take_while                                    | ""∅
    < take_while                                    | +0
   < multispace0                                    | +0
  < cut_err                                         | +3
 < style_prop                                       | backtrack
< repeat                                            | +0
> eof                                               | "foo: 1;"∅
< eof                                               | backtrack
error: test failed, to rerun pass `--bin winnow-435`

and you know that that function backtracked and can look deeper into what to do.

[epage]

Also, I think that I really don't understand cut_err(). Is cut_err((a, b, c, d)) the same as (cut_err(a), b, c, d) or is it the same as (a, b, c, cut_err(d)). Or neither? The docs say that it "commits" the parse result, but does that happen before, during, or after the subrule?

When the inner parse operation errors out, it is transformed from a Backtrack to a Cut.

Normally, if you are using cut_err, you apply it on an entire expression or on the tail end of it as the first part of the expression is what you would use to decide whether you want to "commit" to that parse result or allow a alt to try something else or a repeat to end. You'll see me do this a lot in toml_edit.

[epage]

The more general question is, what is the right technique for reporting semantic (not syntactic) errors in a way that prints both the source location and a reasonable error message.

For toml_edit, we report more semantic errors (like duplicate table definitions) through the same mechanism you are. Higher level semantic errors, like the data doesn't match a schema, we report that by keeping a copy of the original string and tracking the location of every node so we can report an error that looks the same as a syntax error.

[viridia]

Aha! Yes, that works nicely. Thanks!

And thanks for the tips.

BTW, what I am doing is writing a macro which lets me import "css-like" stylesheets directly into Rust as Rust code (this is for Bevy UI).

import_stylesheet!(test_styles, "path/to/styles.pss");

[epage]

btw I've been working some more on error recovery which allows you to report multiple errors at once.

However, for toml, I want to experiment with a zero-copy parser which parses and reports errors as you walk and automatically recovers.