lua_parser 0.10.0

syntax parser for lua language
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
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147

use lua_tokenizer::Token;
pub use lua_tokenizer::TokenizeError;

/// error when tokenizing & parsing lua source code
#[non_exhaustive]
#[derive(Debug)]
pub enum ParseError {
    /// error when tokenizing lua source code
    TokenizeError(TokenizeError),
    /// error when feeding token to parser
    InvalidToken(InvalidToken),
    /// when there are multiple possible paths to parse (in GLR parser).
    /// normally, this should not happen
    Ambiguous,

    /// unknown attribute in local variable definition
    UnknownAttribute(SpannedString),
}

impl std::fmt::Display for ParseError {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        match self {
            ParseError::TokenizeError(e) => write!(f, "{}", e),
            ParseError::InvalidToken(e) => write!(f, "{}", e),
            ParseError::Ambiguous => write!(
                f,
                "Ambiguous Grammar: I guess the source code is not complete"
            ),
            ParseError::UnknownAttribute(attr) => {
                write!(
                    f,
                    "Unknown attribute in local variable definition: {}",
                    attr
                )
            }
        }
    }
}
impl std::error::Error for ParseError
where
    TokenizeError: 'static,
    InvalidToken: 'static,
{
    fn source(&self) -> Option<&(dyn std::error::Error + 'static)> {
        match self {
            ParseError::TokenizeError(e) => Some(e),
            ParseError::InvalidToken(e) => Some(e),
            ParseError::Ambiguous => None,
            ParseError::UnknownAttribute(_) => None,
        }
    }
}

#[derive(Debug)]
pub struct InvalidToken {
    /// the token that caused the error
    pub token: Option<Token>,
    /// expected tokens
    pub expected: Vec<&'static str>,
    /// expected nonterminal tokens
    pub expected_nonterm: Vec<&'static str>,
}
impl std::fmt::Display for InvalidToken {
    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
        if let Some(token) = &self.token {
            write!(f, "Invalid token: {:?}", token)?;
        } else {
            write!(f, "Invalid token: EOF")?;
        }
        write!(f, "\nExpected one of: ")?;
        for (i, token) in self.expected.iter().enumerate() {
            if i != 0 {
                write!(f, ", ")?;
            }
            write!(f, "{}", token)?;
        }
        write!(f, "\nExpected nonterminals: ")?;
        for (i, token) in self.expected_nonterm.iter().enumerate() {
            if i != 0 {
                write!(f, ", ")?;
            }
            write!(f, "{}", token)?;
        }
        Ok(())
    }
}
impl std::error::Error for InvalidToken {}

#[cfg(feature = "diag")]
use codespan_reporting::diagnostic::Diagnostic;
#[cfg(feature = "diag")]
use codespan_reporting::diagnostic::Label;

use crate::SpannedString;

impl InvalidToken {
    #[cfg(feature = "diag")]
    pub fn to_diag<FileId: Copy>(&self, fileid: FileId) -> Diagnostic<FileId> {
        let mut note_message1 = String::from("Expected one of: ");
        for (idx, token) in self.expected.iter().enumerate() {
            if idx != 0 {
                note_message1.push_str(", ");
            }
            note_message1.push_str(format!("{}", token).as_str());
        }
        let mut note_message2 = String::from("Expected(NonTerminals) one of: ");
        for (idx, token) in self.expected_nonterm.iter().enumerate() {
            if idx != 0 {
                note_message2.push_str(", ");
            }
            note_message2.push_str(format!("{}", token).as_str());
        }
        if let Some(token) = &self.token {
            Diagnostic::error()
                .with_message(format!("Invalid token: {}", token))
                .with_labels(vec![
                    Label::primary(fileid, token.span).with_message("token fed here")
                ])
        } else {
            Diagnostic::error().with_message("code not complete")
        }
        .with_notes(vec![note_message1, note_message2])
    }
}

impl ParseError {
    #[cfg(feature = "diag")]
    pub fn to_diag<FileId: Copy>(&self, fileid: FileId) -> Diagnostic<FileId> {
        match self {
            ParseError::TokenizeError(e) => e.to_diag(fileid),
            ParseError::InvalidToken(e) => e.to_diag(fileid),
            ParseError::Ambiguous => Diagnostic::error()
                .with_message("Ambiguous Grammar: I guess the source code is not complete"),
            ParseError::UnknownAttribute(attr) => Diagnostic::error()
                .with_message(format!(
                    "Unknown attribute in local variable definition: {}",
                    attr
                ))
                .with_labels(vec![
                    Label::primary(fileid, attr.span).with_message("unknown attribute here")
                ])
                .with_notes(vec![String::from(
                    "attribute should be one of: const, close",
                )]),
        }
    }
}