mist-parser 0.1.1

use std::fmt::Debug;

use pest::iterators::Pair;

use crate::Rule;

pub type AstResult<'a, T, ET = T> = Result<T, AstError<'a, ET>>;

#[derive(Debug, Clone)]
pub enum ParseError<'a, T> {
    PreAst(pest::error::Error<Rule>),
    Ast(AstError<'a, T>),
}

#[derive(Debug, Clone)]
pub struct AstError<'a, T> {
    pub span: pest::Span<'a>,
    pub error_code: ErrorCode,
    pub error_message: String,
    pub recovered: Option<T>,
}

#[derive(Debug, Clone)]
pub enum ErrorCode {
    InvalidStatement,
    AstGenBug,
}

impl<T> From<pest::error::Error<Rule>> for ParseError<'_, T> {
    fn from(value: pest::error::Error<Rule>) -> Self {
        Self::PreAst(value)
    }
}

impl<'a, T> From<AstError<'a, T>> for ParseError<'a, T> {
    fn from(value: AstError<'a, T>) -> Self {
        Self::Ast(value)
    }
}

impl<'a, F> AstError<'a, F> {
    pub fn get<T>(self) -> AstError<'a, T> {
        AstError {
            span: self.span,
            error_code: self.error_code,
            error_message: self.error_message,
            recovered: None,
        }
    }

    pub fn bug_unimplemented<T>(pair: Pair<'a, Rule>) -> AstResult<'a, T, F> {
        Err(Self {
            span: pair.as_span(),
            error_code: ErrorCode::AstGenBug,
            error_message: format!("Possible bug, unimplemented: {:#?}", pair.as_rule()),
            recovered: None,
        })
    }
}

pub trait IntoErr<T, FA, FR> {
    fn get(self) -> T;
    fn get_map(self, m: impl Fn(FA) -> FR) -> T;
}

impl<'a, T, TE, TE2> IntoErr<AstResult<'a, T, TE2>, TE, TE2> for AstResult<'a, T, TE> {
    fn get(self) -> AstResult<'a, T, TE2> {
        self.map_err(AstError::get)
    }

    fn get_map(self, m: impl Fn(TE) -> TE2) -> AstResult<'a, T, TE2> {
        self.map_err(|e| AstError {
            span: e.span,
            error_code: e.error_code,
            error_message: e.error_message,
            recovered: e.recovered.map(m),
        })
    }
}

pub trait GetLength {
    fn len(&self) -> usize;
}

impl<T, E> GetLength for Result<Vec<T>, E> {
    fn len(&self) -> usize {
        if let Ok(v) = self { v.len() } else { 0 }
    }
}

pub fn collect_recovered<'a, T: Debug, ET>(
    pairs: impl Iterator<Item = pest::iterators::Pair<'a, Rule>>,
) -> AstResult<'a, Vec<T>, Vec<T>>
where
    T: TryFrom<pest::iterators::Pair<'a, Rule>, Error = AstError<'a, ET>>,
{
    collect_recovered_map(pairs, T::try_from)
}

pub fn collect_recovered_map<'a, T: Debug, F, ET>(
    pairs: impl Iterator<Item = pest::iterators::Pair<'a, Rule>>,
    f: F,
) -> AstResult<'a, Vec<T>, Vec<T>>
where
    F: Fn(pest::iterators::Pair<'a, Rule>) -> AstResult<'a, T, ET>,
{
    let mut items = Vec::new();
    let mut last_error: Option<AstError<'a, ET>> = None;

    for pair in pairs {
        match f(pair) {
            Ok(item) => items.push(item),
            Err(e) => {
                last_error = Some(e);
            }
        }
    }

    match last_error {
        Some(ast_err) => Err(AstError {
            span: ast_err.span,
            error_code: ast_err.error_code,
            error_message: ast_err.error_message,
            recovered: Some(items),
        }),
        None => Ok(items),
    }
}

pub struct AstErrorAnalyzer<'a, T>(pub Option<AstError<'a, T>>);

impl<'a, T> AstErrorAnalyzer<'a, T> {
    pub fn get<V: Clone, V2: Clone + Into<V>>(
        &mut self,
        r: AstResult<'a, V, V2>,
    ) -> AstResult<'a, V, V2> {
        if let Err(e) = r {
            self.0 = Some(e.clone().get());

            if let Some(recovered) = e.recovered {
                Ok(recovered.into())
            } else {
                Err(e)
            }
        } else {
            r
        }
    }

    pub fn build(self, v: T) -> AstResult<'a, T> {
        if let Some(mut e) = self.0 {
            e.recovered = Some(v);

            Err(e)
        } else {
            Ok(v)
        }
    }
}