1use chumsky::{error::Rich, extra, prelude::*, span::SimpleSpan as ChumskySpan};
2use ordered_float::OrderedFloat;
3use std::fmt;
4
5use crate::ast::Type;
6
7use super::SimpleSpan;
8
9#[derive(Debug, Clone, PartialEq, Eq, Hash)]
10pub enum Token {
11 Forge,
12 Morph,
13 Core,
14 Oracle,
15 Orbit,
16 Resume,
17 Eject,
18 Engrave,
19 Reveal,
20 Artifact,
21 Identifier(String),
22 Type(Type),
23 OmenLiteral(bool),
24 Arcana(i64),
25 Aether(OrderedFloat<f64>),
26 Rune(String),
27 Semicolon,
28 Colon,
29 Comma,
30 Arrow,
31 FatArrow,
32 DoubleColon,
33 Assign,
34 AddAssign,
35 SubAssign,
36 MulAssign,
37 DivAssign,
38 ModAssign,
39 PowArcanaAssign,
40 PowAetherAssign,
41 Equal,
42 NotEqual,
43 LessThan,
44 LessThanOrEqual,
45 GreaterThan,
46 GreaterThanOrEqual,
47 Plus,
48 Minus,
49 Star,
50 Slash,
51 Percent,
52 Caret,
53 DoubleStar,
54 DoublePipe,
55 DoubleAmpersand,
56 Bang,
57 OpenParen,
58 CloseParen,
59 OpenBrace,
60 CloseBrace,
61 OpenBracket,
62 CloseBracket,
63 RangeInclusive,
64 RangeExclusive,
65 Dot,
66}
67
68pub type SpannedToken = (Token, SimpleSpan<usize>);
69
70impl fmt::Display for Token {
71 fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
72 match self {
73 Token::Forge => write!(f, "forge"),
74 Token::Morph => write!(f, "morph"),
75 Token::Core => write!(f, "core"),
76 Token::Oracle => write!(f, "oracle"),
77 Token::Orbit => write!(f, "orbit"),
78 Token::Resume => write!(f, "resume"),
79 Token::Eject => write!(f, "eject"),
80 Token::Engrave => write!(f, "engrave"),
81 Token::Reveal => write!(f, "reveal"),
82 Token::Artifact => write!(f, "artifact"),
83 Token::Identifier(name) => write!(f, "identifier `{name}`"),
84 Token::Type(ty) => write!(f, "type `{ty:?}`"),
85 Token::OmenLiteral(true) => write!(f, "boon"),
86 Token::OmenLiteral(false) => write!(f, "hex"),
87 Token::Arcana(value) => write!(f, "arcana literal {value}"),
88 Token::Aether(value) => write!(f, "aether literal {value}"),
89 Token::Rune(value) => write!(f, "rune literal \"{value}\""),
90 Token::Semicolon => write!(f, ";"),
91 Token::Colon => write!(f, ":"),
92 Token::Comma => write!(f, ","),
93 Token::Arrow => write!(f, "->"),
94 Token::FatArrow => write!(f, "=>"),
95 Token::DoubleColon => write!(f, "::"),
96 Token::Assign => write!(f, "="),
97 Token::AddAssign => write!(f, "+="),
98 Token::SubAssign => write!(f, "-="),
99 Token::MulAssign => write!(f, "*="),
100 Token::DivAssign => write!(f, "/="),
101 Token::ModAssign => write!(f, "%="),
102 Token::PowArcanaAssign => write!(f, "^="),
103 Token::PowAetherAssign => write!(f, "**="),
104 Token::Equal => write!(f, "=="),
105 Token::NotEqual => write!(f, "!="),
106 Token::LessThan => write!(f, "<"),
107 Token::LessThanOrEqual => write!(f, "<="),
108 Token::GreaterThan => write!(f, ">"),
109 Token::GreaterThanOrEqual => write!(f, ">="),
110 Token::Plus => write!(f, "+"),
111 Token::Minus => write!(f, "-"),
112 Token::Star => write!(f, "*"),
113 Token::Slash => write!(f, "/"),
114 Token::Percent => write!(f, "%"),
115 Token::Caret => write!(f, "^"),
116 Token::DoubleStar => write!(f, "**"),
117 Token::DoublePipe => write!(f, "||"),
118 Token::DoubleAmpersand => write!(f, "&&"),
119 Token::Bang => write!(f, "!"),
120 Token::OpenParen => write!(f, "("),
121 Token::CloseParen => write!(f, ")"),
122 Token::OpenBrace => write!(f, "{{"),
123 Token::CloseBrace => write!(f, "}}"),
124 Token::OpenBracket => write!(f, "["),
125 Token::CloseBracket => write!(f, "]"),
126 Token::RangeInclusive => write!(f, "..="),
127 Token::RangeExclusive => write!(f, ".."),
128 Token::Dot => write!(f, "."),
129 }
130 }
131}
132
133type LexerExtra<'src> = extra::Err<Rich<'src, char, ChumskySpan<usize>>>;
134
135pub fn lexer<'src>() -> impl Parser<'src, &'src str, Vec<SpannedToken>, LexerExtra<'src>> {
136 use chumsky::text;
137
138 let sign = just::<&str, _, LexerExtra<'src>>("-")
139 .to(String::from("-"))
140 .or_not();
141
142 let digits = |radix| text::digits::<_, LexerExtra<'src>>(radix).collect::<String>();
143
144 let aether = sign
145 .clone()
146 .then(digits(10))
147 .then_ignore(just::<&str, _, LexerExtra<'src>>("."))
148 .then(digits(10))
149 .map(|((sign, int_part), frac_part)| {
150 let mut number = String::new();
151 if let Some(sign) = sign {
152 number.push_str(&sign);
153 }
154 number.push_str(&int_part);
155 number.push('.');
156 number.push_str(&frac_part);
157 let value = number
158 .parse::<f64>()
159 .expect("parser should only construct valid f64 literals");
160 Token::Aether(OrderedFloat(value))
161 });
162
163 let arcana = sign.then(digits(10)).map(|(sign, value)| {
164 let mut number = String::new();
165 if let Some(sign) = sign {
166 number.push_str(&sign);
167 }
168 number.push_str(&value);
169 Token::Arcana(
170 number
171 .parse::<i64>()
172 .expect("parser should only construct valid i64 literals"),
173 )
174 });
175
176 let escape = just::<char, _, LexerExtra<'src>>('\\').ignore_then(
177 one_of::<_, _, LexerExtra<'src>>(r#""ntr\"#).map(|c| match c {
178 '"' => '"',
179 'n' => '\n',
180 't' => '\t',
181 'r' => '\r',
182 '\\' => '\\',
183 other => other, }),
185 );
186 let rune_char =
187 escape.or(any::<_, LexerExtra<'src>>().filter(|c: &char| *c != '"' && *c != '\\'));
188 let rune = just::<char, _, LexerExtra<'src>>('"')
189 .ignore_then(rune_char.repeated().collect::<String>())
190 .then_ignore(just::<char, _, LexerExtra<'src>>('"'))
191 .map(Token::Rune);
192
193 let ident = text::ident::<_, LexerExtra<'src>>().map(|ident: &'src str| match ident {
194 "forge" => Token::Forge,
195 "morph" => Token::Morph,
196 "core" => Token::Core,
197 "oracle" => Token::Oracle,
198 "orbit" => Token::Orbit,
199 "resume" => Token::Resume,
200 "eject" => Token::Eject,
201 "engrave" => Token::Engrave,
202 "reveal" => Token::Reveal,
203 "trans" => Token::Identifier("trans".to_string()),
204 "as" => Token::Identifier("as".to_string()),
205 "artifact" => Token::Artifact,
206 "arcana" => Token::Type(Type::Arcana),
207 "aether" => Token::Type(Type::Aether),
208 "rune" => Token::Type(Type::Rune),
209 "omen" => Token::Type(Type::Omen),
210 "abyss" => Token::Type(Type::Abyss),
211 "scroll" => Token::Type(Type::Scroll),
212 "lexicon" => Token::Type(Type::Lexicon),
213 "materia" => Token::Type(Type::Materia),
214 "glyph" => Token::Type(Type::Glyph),
215 "boon" => Token::OmenLiteral(true),
216 "hex" => Token::OmenLiteral(false),
217 _ => Token::Identifier(ident.to_string()),
218 });
219
220 let multi_char_symbols = choice((
221 just::<&str, _, LexerExtra<'src>>("**=").to(Token::PowAetherAssign),
222 just::<&str, _, LexerExtra<'src>>("**").to(Token::DoubleStar),
223 just::<&str, _, LexerExtra<'src>>("^=").to(Token::PowArcanaAssign),
224 just::<&str, _, LexerExtra<'src>>("+=").to(Token::AddAssign),
225 just::<&str, _, LexerExtra<'src>>("-=").to(Token::SubAssign),
226 just::<&str, _, LexerExtra<'src>>("*=").to(Token::MulAssign),
227 just::<&str, _, LexerExtra<'src>>("/=").to(Token::DivAssign),
228 just::<&str, _, LexerExtra<'src>>("%=").to(Token::ModAssign),
229 just::<&str, _, LexerExtra<'src>>("=>").to(Token::FatArrow),
230 just::<&str, _, LexerExtra<'src>>("::").to(Token::DoubleColon),
231 just::<&str, _, LexerExtra<'src>>("->").to(Token::Arrow),
232 just::<&str, _, LexerExtra<'src>>("||").to(Token::DoublePipe),
233 just::<&str, _, LexerExtra<'src>>("&&").to(Token::DoubleAmpersand),
234 just::<&str, _, LexerExtra<'src>>("==").to(Token::Equal),
235 just::<&str, _, LexerExtra<'src>>("!=").to(Token::NotEqual),
236 just::<&str, _, LexerExtra<'src>>("<=").to(Token::LessThanOrEqual),
237 just::<&str, _, LexerExtra<'src>>(">=").to(Token::GreaterThanOrEqual),
238 just::<&str, _, LexerExtra<'src>>("..=").to(Token::RangeInclusive),
239 just::<&str, _, LexerExtra<'src>>("..").to(Token::RangeExclusive),
240 ));
241
242 let single_char_symbols = choice((
243 just::<char, _, LexerExtra<'src>>('=').to(Token::Assign),
244 just::<char, _, LexerExtra<'src>>('+').to(Token::Plus),
245 just::<char, _, LexerExtra<'src>>('-').to(Token::Minus),
246 just::<char, _, LexerExtra<'src>>('*').to(Token::Star),
247 just::<char, _, LexerExtra<'src>>('/').to(Token::Slash),
248 just::<char, _, LexerExtra<'src>>('%').to(Token::Percent),
249 just::<char, _, LexerExtra<'src>>('^').to(Token::Caret),
250 just::<char, _, LexerExtra<'src>>('<').to(Token::LessThan),
251 just::<char, _, LexerExtra<'src>>('>').to(Token::GreaterThan),
252 just::<char, _, LexerExtra<'src>>('!').to(Token::Bang),
253 just::<char, _, LexerExtra<'src>>(';').to(Token::Semicolon),
254 just::<char, _, LexerExtra<'src>>(':').to(Token::Colon),
255 just::<char, _, LexerExtra<'src>>(',').to(Token::Comma),
256 just::<char, _, LexerExtra<'src>>('(').to(Token::OpenParen),
257 just::<char, _, LexerExtra<'src>>(')').to(Token::CloseParen),
258 just::<char, _, LexerExtra<'src>>('{').to(Token::OpenBrace),
259 just::<char, _, LexerExtra<'src>>('}').to(Token::CloseBrace),
260 just::<char, _, LexerExtra<'src>>('[').to(Token::OpenBracket),
261 just::<char, _, LexerExtra<'src>>(']').to(Token::CloseBracket),
262 just::<char, _, LexerExtra<'src>>('.').to(Token::Dot),
263 ));
264
265 let token = choice((
266 aether,
267 arcana,
268 rune,
269 ident,
270 multi_char_symbols,
271 single_char_symbols,
272 ))
273 .map_with(|tok, extra| {
274 let span: ChumskySpan<usize> = extra.span();
275 (tok, SimpleSpan::new(span.start(), span.end()))
276 });
277
278 token
279 .padded_by(crate::parser::helpers::abyss_whitespace())
280 .repeated()
281 .collect()
282 .then_ignore(end())
283}