Idiomatic way to generate custom errors

[skittishdev]

Hi,

I'm curious what the idiomatic way of converting pest::error::Error<R> into a custom error type is.

My crates are organized such that I have MyError as a custom type defined in a common crate (C1), and my parser using pest is defined in a totally separate crate (C2) in the same workspace. This is something I don't want to move away from, because the common error type will be used in other crates which will be added to my workspace that have nothing to do with the parser.

Here is what I'm doing right now.

#[derive(Parser)]
#[grammar = "grammars/my_grammar.pest"]
pub struct MyParser {}

impl MyParser {
    pub fn generate_ast(&self, input: &str) -> Result<TypedAST, MyError> {
        match MyParser::parse(Rule::main_program, input) {
            Ok(_pairs) => {
                Ok(TypedAST::MyType(AST::Program))
            },
            Err(err) => {
                Err(Self::convert_error(err))
            }
        }
    }

    fn convert_error<R>(value: Error<R>) -> MyError where R: RuleType {
        let (line_num, col_num) = match value.line_col {
            LineColLocation::Pos(x) => {
                (x.0, x.1)
            },
            LineColLocation::Span(start, end) => {
                (start.0, end.0)
            }
        };
        MyError::ParseError {
            line: value.line().to_string(),
            line_num,
            col_num,
            error_message: value.to_string(),
        }
    }
}

What I already tried:

• Defining a wrapper type (WrapperError) for pest::error::Error in C2, and trying to implement the From trait for MyError <-> WrapperError
  • This fails because I added the type constraint <R: RuleType> and it appears that Rule's do not end up implementing this trait somehow? It looks like they should, but I get an error saying From trait bounds for Rule are not satisfied (even though I have it defined for RuleType.

pub(crate) struct WrapperError<R: RuleType> {
    err: Error<R>
}

impl <R: RuleType> WrapperError<R> {
    pub fn new(err: Error<R>) -> Self {
        Self { err }
    }
}

impl <R: RuleType> From<Error<R>> for WrapperError<R> {
    fn from(value: Error<R>) -> Self {
        Self { err: value }
    }
}

impl <R: RuleType> From<WrapperError<R>> for MyError {
    fn from(value: WrapperError<R>) -> Self {
        // same logic as `convert_error` above
        // I have to add the `R: RuleType` trait bound because I need access to the `line()` method.
    }
}

[skittishdev]

I'd like to be able to use the ? operator is what all of this boils down to. I don't want to write these match statements in a bunch of places if I can help it. But then again, maybe I don't have to because as far as I can tell, once the parse method works, I think pest/PEG assures that my input is valid and fully parsed, and I don't have to worry about encountering a pest::error::Error<R> again.

[skittishdev]

@tomtau, sorry for the direct ping, but any suggestions here?

[tomtau]

If you use thiserror, you can have it generated by annotating #[from] in your wrapper

[skittishdev]

I can't implement the From trait because MyError is in a different crate than where the parser lives. Same for thiserror (I'd have to take a dependency on pest in my common crate in the above example). In fact, I am already using thiserror in this cargo workspace.

[skittishdev]

That's why I created the WrapperError in the crate which does have a dependency on pest, and WrapperError implements From for pest::error::Error<R>.

[tomtau]

Oh, I missed it was MyError, not WrapperError... maybe you can have a helper (private) function generate_ast_helper that returns WrapperError as the error type that's called by generate_ast... in that way, you can use ? in both?

[skittishdev]

Ah, of course. This worked. Awesome! Thank you so much!

pub fn generate_ast(input: &str) -> Result<CSVAST, MyError> {
    Ok(generate_ast_helper(input)?)
}

fn generate_ast_helper(input: &str) -> Result<CSVAST, WrapperError<Rule>> {
    let field = CSVParser::parse(Rule::field, input)?;
    Ok(CSVAST::Field{ value: str::parse(field.as_str()).unwrap()})
}