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 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 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}