Skip to main content

mirascript_core/lexer/
token_kind.rs

1use std::{borrow::Cow, fmt::Display};
2
3use super::{numeric::NumberInfo, prelude::*, string::StringInfo};
4
5#[derive(Debug, Clone, strum::EnumIs)]
6pub enum TokenKind<'s> {
7    Eof,
8    Identifier(&'s str),
9    Ordinal(i32),
10    Number(f64, Box<NumberInfo<'s>>),
11    String(Cow<'s, str>, Box<StringInfo<'s>>),
12    /// Interpolated string, stored as a tuple of the string parts, the tokens that are interpolated, and format string of tokens.
13    /// The last tuple element is the string part after the last interpolation, with the tokens and format being empty.
14    InterpolatedString(
15        Vec<(Cow<'s, str>, Vec<Token<'s>>, &'s str)>,
16        Box<StringInfo<'s>>,
17    ),
18    Operator(Operator),
19    Keyword(Keyword),
20    Unknown {
21        recovered: Box<TokenKind<'s>>,
22        errors: Vec<SourceDiagnostic>,
23    },
24    /// Contains no token, only position information.
25    Empty,
26}
27
28impl<'s> TokenKind<'s> {
29    pub(crate) fn unknown<R: Into<TokenKind<'s>>>(
30        recovered: R,
31        error_range: SourceRange,
32        error: DiagnosticCode,
33    ) -> Self {
34        TokenKind::Unknown {
35            recovered: Box::new(recovered.into()),
36            errors: vec![SourceDiagnostic::new(error_range, error)],
37        }
38    }
39
40    pub(crate) fn unknown_errors<E: Into<Vec<SourceDiagnostic>>, R: Into<TokenKind<'s>>>(
41        recovered: R,
42        errors: E,
43    ) -> Self {
44        TokenKind::Unknown {
45            recovered: Box::new(recovered.into()),
46            errors: errors.into(),
47        }
48    }
49
50    pub(crate) fn to_field_name(&'s self) -> Option<(DiagnosticCode, Cow<'s, str>)> {
51        match self {
52            Self::Identifier(name) => Some((
53                DiagnosticCode::RecordFieldIdName,
54                std::borrow::Cow::Borrowed(name),
55            )),
56            Self::Keyword(kw) => Some((
57                DiagnosticCode::RecordFieldIdName,
58                std::borrow::Cow::Borrowed(kw.into()),
59            )),
60            Self::Ordinal(n) => {
61                Some((DiagnosticCode::RecordFieldOrdinalName, n.to_string().into()))
62            }
63            Self::String(s, _) => Some((DiagnosticCode::RecordFieldStringName, Cow::Borrowed(s))),
64            _ => None,
65        }
66    }
67
68    pub(crate) fn to_id_name(&self) -> Option<&'s str> {
69        match self {
70            Self::Identifier(name) => Some(name),
71            _ => None,
72        }
73    }
74
75    pub(crate) fn is_number_nan_literal(&self) -> bool {
76        self.is_number_literal() || matches!(self, Self::Keyword(Keyword::Nan))
77    }
78    pub(crate) fn is_number_literal(&self) -> bool {
79        self.is_finite_number_literal() || matches!(self, Self::Keyword(Keyword::Inf))
80    }
81    pub(crate) fn is_finite_number_literal(&self) -> bool {
82        self.is_number() || self.is_ordinal()
83    }
84    pub(crate) fn is_boolean_literal(&self) -> bool {
85        matches!(self, Self::Keyword(Keyword::True | Keyword::False))
86    }
87}
88
89impl PartialEq for TokenKind<'_> {
90    fn eq(&self, other: &Self) -> bool {
91        match (self, other) {
92            (Self::Identifier(l0), Self::Identifier(r0)) => l0 == r0,
93            (Self::Ordinal(l0), Self::Ordinal(r0)) => l0 == r0,
94            (Self::Number(l0, _), Self::Number(r0, _)) => (*l0).to_bits() == (*r0).to_bits(),
95            (Self::String(l0, _), Self::String(r0, _)) => l0 == r0,
96            (Self::InterpolatedString(l0, _), Self::InterpolatedString(r0, _)) => l0 == r0,
97            (Self::Operator(l0), Self::Operator(r0)) => l0 == r0,
98            (Self::Keyword(l0), Self::Keyword(r0)) => l0 == r0,
99            (
100                Self::Unknown {
101                    recovered: l_recovered,
102                    ..
103                },
104                Self::Unknown {
105                    recovered: r_recovered,
106                    ..
107                },
108            ) => l_recovered == r_recovered,
109            _ => core::mem::discriminant(self) == core::mem::discriminant(other),
110        }
111    }
112}
113
114impl PartialEq<Token<'_>> for TokenKind<'_> {
115    fn eq(&self, other: &Token<'_>) -> bool {
116        self == &other.kind
117    }
118}
119
120impl PartialEq<TokenKind<'_>> for Token<'_> {
121    fn eq(&self, other: &TokenKind<'_>) -> bool {
122        &self.kind == other
123    }
124}
125
126impl Display for TokenKind<'_> {
127    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
128        match self {
129            Self::Eof => write!(f, "␃"),
130            Self::Identifier(s) => write!(f, "{s}"),
131            Self::Ordinal(n) => write!(f, "{n}"),
132            Self::Number(n, _) => write!(f, "{n}"),
133            Self::String(s, _) => {
134                write!(f, "\"{}\"", s.escape_debug())
135            }
136            Self::InterpolatedString(v, _) => {
137                write!(f, "\"")?;
138                for (s, e, fmt) in v {
139                    write!(f, "{}", s.escape_debug())?;
140                    if !e.is_empty() {
141                        write!(f, "$(")?;
142                        for token in e {
143                            write!(f, "{token}")?;
144                        }
145                        if !fmt.is_empty() {
146                            write!(f, ":{fmt}")?;
147                        }
148                        write!(f, ")")?;
149                    }
150                }
151                write!(f, "\"")
152            }
153            Self::Operator(op) => write!(f, "{}", op),
154            Self::Keyword(kw) => write!(f, "{}", kw),
155            Self::Unknown { recovered, .. } => write!(f, "<?{recovered}>"),
156            Self::Empty => write!(f, ""),
157        }
158    }
159}