ackerman 0.1.1

Yggdrasil Shared Structure
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118

use std::{
    error::Error,
    fmt::{self, Debug, Display, Formatter},
    ops::Range,
};

use url::Url;

use crate::Diagnostic;

use self::YggdrasilErrorKind::*;

pub mod diagnostic;
pub mod error_std;

pub type YggdrasilResult<T = ()> = Result<Diagnostic<T>, YggdrasilError>;

#[derive(Debug)]
pub struct YggdrasilError {
    pub kind: Box<YggdrasilErrorKind>,
    pub file: Option<Url>,
    pub range: Option<Range<usize>>,
}

#[derive(Debug)]
pub enum YggdrasilErrorKind {
    IOError(std::io::Error),
    FormatError(std::fmt::Error),
    // PestError { #[from] source: pest::error::Error<crate::as_peg::Rule> },
    LanguageError(String),
    StructureError(String),
    UnexpectedToken(String),
    InfoMissing(String),
    /// Some nodes failed to resolve and are being rolled back
    Unwinding,
    /// A forbidden cst_node encountered
    Unreachable,
}

impl YggdrasilError {
    pub fn set_url(mut self, url: Url) -> Self {
        self.file = Some(url);
        return self;
    }
    pub fn set_path() {}
    pub fn set_range(mut self, range: Range<usize>) -> Self {
        self.range = Some(range);
        return self;
    }
    #[inline]
    pub fn is_unwinding(&self) -> bool {
        matches!(*self.kind, Unwinding)
    }
}

impl YggdrasilError {
    #[inline]
    pub fn structure_error(msg: impl Into<String>) -> Self {
        Self { kind: Box::new(StructureError(msg.into())), file: None, range: None }
    }
    ///
    #[inline]
    pub fn unexpected_token(msg: impl Into<String>) -> Self {
        Self { kind: Box::new(UnexpectedToken(msg.into())), file: None, range: None }
    }
    ///
    #[inline]
    pub fn language_error(msg: impl Into<String>) -> Self {
        Self { kind: Box::new(LanguageError(msg.into())), file: None, range: None }
    }
    #[inline]
    pub fn unreachable() -> Self {
        Self { kind: Box::new(Unreachable), file: None, range: None }
    }
    #[inline]
    pub fn unwinding() -> Self {
        Self { kind: Box::new(Unwinding), file: None, range: None }
    }
}

impl Error for YggdrasilError {}

impl Display for YggdrasilError {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        let path = match &self.file {
            Some(s) => s.path(),
            None => "<Anonymous>",
        };
        match &self.range {
            Some(s) => {
                writeln!(f, "at ({}, {}) of {}", s.start, s.end, path)?;
            }
            None => {
                writeln!(f, "at {}", path)?;
            }
        }
        write!(f, "{indent:indent$}{kind}", indent = 4, kind = self.kind)
    }
}

impl Display for YggdrasilErrorKind {
    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
        match self {
            IOError(e) => f.write_str(&e.to_string()),
            FormatError(e) => f.write_str(&e.to_string()),
            LanguageError(e) => f.write_str(e),
            StructureError(e) => f.write_str(e),
            UnexpectedToken(e) => f.write_str(e),
            InfoMissing(e) => f.write_str(e),
            Unwinding => {
                unimplemented!()
            }
            Unreachable => {
                unimplemented!()
            }
        }
    }
}