Function rich_error_to_error

prqlc/prqlc-parser/src/parser/perror.rs:10–83

Helper function to convert Rich errors to our Error type

(
    span: Span,
    reason: &chumsky::error::RichReason<T>,
    token_to_string: impl Fn(&T) -> String,
    is_whitespace_token: impl Fn(&T) -> bool,
)

// Helper function to convert Rich errors to our Error type
fn rich_error_to_error<T>(
    span: Span,
    reason: &chumsky::error::RichReason<T>,
    token_to_string: impl Fn(&T) -> String,
    is_whitespace_token: impl Fn(&T) -> bool,
) -> Error
where
    T: std::fmt::Debug,
{
    use chumsky::error::RichReason;

    let error = match reason {
        RichReason::ExpectedFound { expected, found } => {
            use chumsky::error::RichPattern;
            let expected_strs: Vec<String> = expected
                .iter()
                .filter(|p| {
                    // Filter out whitespace tokens unless that's all we're expecting
                    let is_whitespace = match p {
                        RichPattern::EndOfInput => true,
                        RichPattern::Token(t) => is_whitespace_token(t),
                        _ => false,
                    };
                    !is_whitespace
                        || expected.iter().all(|p| match p {
                            RichPattern::EndOfInput => true,
                            RichPattern::Token(t) => is_whitespace_token(t),
                            _ => false,
                        })
                })
                .map(|p| match p {
                    RichPattern::Token(t) => token_to_string(t),
                    RichPattern::EndOfInput => "end of input".to_string(),
                    _ => format!("{:?}", p),
                })
                .collect();

            let found_str = match found {
                Some(t) => token_to_string(t),
                None => "end of input".to_string(),
            };

            if expected_strs.is_empty() || expected_strs.len() > 10 {
                Error::new_simple(format!("unexpected {found_str}"))
            } else {
                let mut expected_strs = expected_strs;
                expected_strs.sort();

                let expected_str = match expected_strs.len() {
                    1 => expected_strs[0].clone(),
                    2 => expected_strs.join(" or "),
                    _ => {
                        let last = expected_strs.pop().unwrap();
                        format!("one of {} or {last}", expected_strs.join(", "))
                    }
                };

                match found {