bluejay_parser/lexer/
lex_error.rs

1use crate::error::{Annotation, Error};
2use crate::Span;
3
4#[derive(Debug, PartialEq, Clone, Default)]
5pub enum LexError {
6    #[default]
7    UnrecognizedToken,
8    IntegerValueTooLarge,
9    FloatValueTooLarge,
10    StringValueInvalid(Vec<StringValueLexError>),
11}
12
13impl From<Vec<StringValueLexError>> for LexError {
14    fn from(errors: Vec<StringValueLexError>) -> Self {
15        Self::StringValueInvalid(errors)
16    }
17}
18
19#[derive(Debug, PartialEq, Clone)]
20pub enum StringValueLexError {
21    InvalidUnicodeEscapeSequence(Span),
22    InvalidCharacters(Span),
23}
24
25impl From<(LexError, Span)> for Error {
26    fn from((error, span): (LexError, Span)) -> Self {
27        match error {
28            LexError::UnrecognizedToken => Self::new(
29                "Unrecognized token",
30                Some(Annotation::new("Unable to parse", span)),
31                Vec::new(),
32            ),
33            LexError::IntegerValueTooLarge => Self::new(
34                "Value too large to fit in a 32-bit signed integer",
35                Some(Annotation::new("Integer too large", span)),
36                Vec::new(),
37            ),
38            LexError::FloatValueTooLarge => Self::new(
39                "Value too large to fit in a 64-bit float",
40                Some(Annotation::new("Float too large", span)),
41                Vec::new(),
42            ),
43            LexError::StringValueInvalid(errors) => Self::new(
44                "String value invalid",
45                Some(Annotation::new("String value invalid", span)),
46                errors
47                    .into_iter()
48                    .map(|error| {
49                        let (message, span) = match error {
50                            StringValueLexError::InvalidUnicodeEscapeSequence(span) => {
51                                ("Invalid unicode escape sequence", span)
52                            }
53                            StringValueLexError::InvalidCharacters(span) => {
54                                ("Invalid characters", span)
55                            }
56                        };
57                        Annotation::new(message, span)
58                    })
59                    .collect(),
60            ),
61        }
62    }
63}