mango 0.4.0

The Mango programming language (UNDER CONSTRUCTION)
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

use ::std::fmt;

use crate::io::source::SourceSlice;
use crate::common::error::MangoErrType::Read;

pub type MangoResult<T> = Result<T, MangoErr>;
pub type MsgResult<T> = Result<T, ErrMsg>;

#[derive(Debug, Clone, Eq, PartialEq)]
pub enum Severity {
    Error,
    Warning,
    Debug,
}

/// This is for errors that are related to specific problems with the source.
/// This is the type that should eventually be returned and reported.
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct MangoErr {
    typ: MangoErrType,
    message: ErrMsg,
    severity: Severity,
}

#[derive(Debug, Clone, Eq, PartialEq)]
pub enum MangoErrType {
    Read,
    Syntax { src: SourceSlice },
}

impl MangoErr {
    pub fn new(msg: impl Into<String>, severity: Severity, typ: MangoErrType) -> Self {
        MangoErr {
            typ: MangoErrType::Read,
            message: ErrMsg::new(msg),
            severity: Severity::Error,
        }
    }

    pub fn new_debug(msg: impl Into<String>, debug: impl Into<String>, severity: Severity, typ: MangoErrType) -> Self {
        MangoErr {
            typ: MangoErrType::Read,
            message: ErrMsg::new_debug(msg, debug),
            severity: Severity::Error,
        }
    }

    pub fn read(msg: impl Into<String>) -> Self {
        MangoErr::new(msg, Severity::Error, MangoErrType::Read)
    }

    pub fn syntax(msg: impl Into<String>, slice: SourceSlice) -> Self {
        MangoErr::new(msg, Severity::Error, MangoErrType::Syntax { src: slice })
    }

    fn msg(&self) -> &ErrMsg {
        &self.message
    }

    pub fn as_str(&self) -> &str {
        &self.msg().friendly
    }
}

/// This is for a plain text error, possibly with debug version.
/// This can be returned initially, in code that is removed from the source handling. It
/// should eventually be turned into `MangoErr`.
#[derive(Debug, Clone, Eq, PartialEq)]
pub struct ErrMsg {
    pub friendly: String,
    pub debug: Option<String>,
}

impl ErrMsg {
    pub fn new(friendly: impl Into<String>) -> Self {
        ErrMsg { friendly: friendly.into(), debug: None }
    }

    pub fn new_debug(friendly: impl Into<String>, debug: impl Into<String>) -> Self {
        ErrMsg { friendly: friendly.into(), debug: Some(debug.into()) }
    }

    pub fn as_str(&self) -> &str {
        &self.friendly
    }
}

impl From<String> for ErrMsg {
    fn from(text: String) -> Self {
        ErrMsg { friendly: text, debug: None }
    }
}

impl From<&str> for ErrMsg {
    fn from(text: &str) -> Self {
        ErrMsg { friendly: text.to_owned(), debug: None }
    }
}

impl fmt::Display for ErrMsg {
    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
        write!(f, "{}", &self.friendly)
    }
}