1use crate::parser::helper::unknown_range;
2
3use super::prelude::*;
4
5#[derive(Debug, Clone, PartialEq, strum::EnumIs)]
6pub enum Callable<'s> {
7 Type(TokenRef<'s>),
9 Expression(Box<Expression<'s>>),
11}
12
13impl<'s> AstWalker<'s> for Callable<'s> {
14 fn collect_diagnostics(&mut self, collector: &mut DiagnosticsCollector<'_, '_>) {
15 use Callable::*;
16 match self {
17 Type(token) => token.collect_diagnostics(collector),
18 Expression(exp) => exp.collect_diagnostics(collector),
19 }
20 }
21 fn range(&self) -> SourceRange {
22 use Callable::*;
23 match self {
24 Type(token) => token.range(),
25 Expression(exp) => exp.range(),
26 }
27 }
28}
29
30#[derive(Debug, Clone, PartialEq)]
32pub struct ElseBlock<'s>(pub TokenRef<'s>, pub Box<Expression<'s>>);
33
34impl<'s> AstWalker<'s> for ElseBlock<'s> {
35 fn collect_diagnostics(&mut self, collector: &mut DiagnosticsCollector<'_, '_>) {
36 self.0.collect_diagnostics(collector);
37 self.1.collect_diagnostics(collector);
38 }
39 fn range(&self) -> SourceRange {
40 self.0.range.start..self.1.range().end
41 }
42}
43
44#[derive(Debug, Clone, PartialEq)]
46pub struct MatchCase<'s>(
47 pub TokenRef<'s>,
48 pub Pattern<'s>,
49 pub Option<(TokenRef<'s>, Expression<'s>)>,
50 pub Expression<'s>,
51);
52
53impl<'s> AstWalker<'s> for MatchCase<'s> {
54 fn collect_diagnostics(&mut self, collector: &mut DiagnosticsCollector<'_, '_>) {
55 self.0.collect_diagnostics(collector);
56 self.1.collect_diagnostics(collector);
57 if let Some((kw_if, expr)) = &mut self.2 {
58 kw_if.collect_diagnostics(collector);
59 expr.collect_diagnostics(collector);
60 }
61 self.3.collect_diagnostics(collector);
62 }
63 fn range(&self) -> SourceRange {
64 let start = self.0.range.start;
65 let end = self.3.range().end;
66 start..end
67 }
68}
69
70#[derive(Debug, Clone, PartialEq, strum::EnumIs)]
71pub enum Expression<'s> {
72 Literal(TokenRef<'s>),
75 InterpolatedString(&'s Token<'s>, Vec<Expression<'s>>),
80 Variable(TokenRef<'s>),
82 Grouping(TokenRef<'s>, Box<Expression<'s>>, TokenRef<'s>),
84 Record(TokenRef<'s>, Vec<RecordElement<'s>>, TokenRef<'s>),
94 Array(TokenRef<'s>, Vec<ArrayElement<'s>>, TokenRef<'s>),
98
99 Call(
104 Callable<'s>,
105 TokenRef<'s>,
106 Vec<ArgElement<'s>>,
107 TokenRef<'s>,
108 ),
109 TaggedString(Box<Expression<'s>>, Box<Expression<'s>>),
111 Extension(
120 Box<Expression<'s>>,
121 TokenRef<'s>,
122 Callable<'s>,
123 TokenRef<'s>,
124 Vec<ArgElement<'s>>,
125 TokenRef<'s>,
126 ),
127 Access(Box<Expression<'s>>, TokenRef<'s>, TokenRef<'s>),
131 Index(
133 Box<Expression<'s>>,
134 TokenRef<'s>,
135 Box<Expression<'s>>,
136 TokenRef<'s>,
137 ),
138 Slice(
140 Box<Expression<'s>>,
141 TokenRef<'s>,
142 Option<Box<Expression<'s>>>,
143 TokenRef<'s>,
144 Option<Box<Expression<'s>>>,
145 TokenRef<'s>,
146 ),
147 NonNil(Box<Expression<'s>>, TokenRef<'s>),
149
150 Prefix(TokenRef<'s>, Box<Expression<'s>>),
157
158 Infix(Box<Expression<'s>>, TokenRef<'s>, Box<Expression<'s>>),
171 Is(Box<Expression<'s>>, TokenRef<'s>, Box<Pattern<'s>>),
173
174 Block(
180 TokenRef<'s>,
181 Vec<Statement<'s>>,
182 Option<Box<Expression<'s>>>,
183 TokenRef<'s>,
184 ),
185 Loop(TokenRef<'s>, Box<Expression<'s>>),
191 While(
201 TokenRef<'s>,
202 Box<Expression<'s>>,
203 Box<Expression<'s>>,
204 Option<ElseBlock<'s>>,
205 ),
206 ForIn(
216 TokenRef<'s>,
217 Box<Pattern<'s>>,
218 TokenRef<'s>,
219 Box<Iterable<'s>>,
220 Box<Expression<'s>>,
221 Option<ElseBlock<'s>>,
222 ),
223 If(
229 TokenRef<'s>,
230 Box<Expression<'s>>,
231 Box<Expression<'s>>,
232 Option<ElseBlock<'s>>,
233 ),
234 Cond(
236 Box<Expression<'s>>,
237 TokenRef<'s>,
238 Box<Expression<'s>>,
239 TokenRef<'s>,
240 Box<Expression<'s>>,
241 ),
242 Match(
248 TokenRef<'s>,
249 Box<Expression<'s>>,
250 TokenRef<'s>,
251 Vec<MatchCase<'s>>,
252 TokenRef<'s>,
253 ),
254 Function(TokenRef<'s>, Option<ParameterList<'s>>, Box<Expression<'s>>),
259 Unknown {
261 recovered: Option<Box<Expression<'s>>>,
262 tokens: Vec<TokenRef<'s>>,
263 errors: Vec<SourceDiagnostic>,
264 },
265}
266
267impl<'s> Expression<'s> {
268 pub(crate) fn wrap_as_unknown<T: Into<Vec<TokenRef<'s>>>>(
269 self,
270 tokens: T,
271 error: DiagnosticCode,
272 ) -> Self {
273 let tokens = tokens.into();
274 assert!(!tokens.is_empty());
275 let mut range = tokens[0].range.clone();
276 range.end = tokens.last().unwrap().range.end;
277 Expression::Unknown {
278 recovered: Some(Box::new(self)),
279 tokens,
280 errors: vec![SourceDiagnostic::new(range, error)],
281 }
282 }
283
284 pub(crate) fn is_block_like(&self) -> bool {
285 matches!(
286 self,
287 Expression::Block(..)
288 | Expression::Loop(..)
289 | Expression::While(..)
290 | Expression::ForIn(..)
291 | Expression::If(..)
292 | Expression::Match(..)
293 )
294 }
295
296 pub(crate) fn unknown<T: Into<Vec<TokenRef<'s>>>>(tokens: T, error: DiagnosticCode) -> Self {
297 let tokens = tokens.into();
298 assert!(!tokens.is_empty());
299 let mut range = tokens[0].range.clone();
300 range.end = tokens.last().unwrap().range.end;
301 Expression::Unknown {
302 recovered: None,
303 tokens,
304 errors: vec![SourceDiagnostic::new(range, error)],
305 }
306 }
307 pub(crate) fn unknown_range<T: Into<Vec<TokenRef<'s>>>>(
308 tokens: T,
309 error_range: SourceRange,
310 error: DiagnosticCode,
311 ) -> Self {
312 let mut tokens = tokens.into();
313 if tokens.is_empty() {
314 tokens.push(Token::empty_range(error_range.clone()).into());
315 }
316 Expression::Unknown {
317 recovered: None,
318 tokens,
319 errors: vec![SourceDiagnostic::new(error_range, error)],
320 }
321 }
322
323 pub(crate) fn unknown_errors<T: Into<Vec<TokenRef<'s>>>, E: Into<Vec<SourceDiagnostic>>>(
324 tokens: T,
325 errors: E,
326 ) -> Self {
327 Expression::Unknown {
328 recovered: None,
329 tokens: tokens.into(),
330 errors: errors.into(),
331 }
332 }
333}
334
335impl<'s> AstWalker<'s> for Expression<'s> {
336 fn collect_diagnostics(&mut self, collector: &mut DiagnosticsCollector<'_, '_>) {
337 use Expression::*;
338 match self {
339 Literal(token) => token.collect_diagnostics(collector),
340 InterpolatedString(_, exps) => {
341 exps.collect_diagnostics(collector);
343 }
344 Variable(token) => token.collect_diagnostics(collector),
345 Grouping(op, exp, cp) => {
346 op.collect_diagnostics(collector);
347 exp.collect_diagnostics(collector);
348 cp.collect_diagnostics(collector);
349 }
350 Record(op, exps, cp) => {
351 op.collect_diagnostics(collector);
352 exps.collect_diagnostics(collector);
353 cp.collect_diagnostics(collector);
354 }
355 Array(op, exps, cp) => {
356 op.collect_diagnostics(collector);
357 exps.collect_diagnostics(collector);
358 cp.collect_diagnostics(collector);
359 }
360 TaggedString(callable, exp) => {
361 callable.collect_diagnostics(collector);
362 exp.collect_diagnostics(collector);
363 }
364 Call(exp, op, args, cp) => {
365 exp.collect_diagnostics(collector);
366 op.collect_diagnostics(collector);
367 args.collect_diagnostics(collector);
368 cp.collect_diagnostics(collector);
369 }
370 Extension(exp, e, ext, op, args, cp) => {
371 exp.collect_diagnostics(collector);
372 e.collect_diagnostics(collector);
373 ext.collect_diagnostics(collector);
374 op.collect_diagnostics(collector);
375 args.collect_diagnostics(collector);
376 cp.collect_diagnostics(collector);
377 }
378 Access(exp, dot, token) => {
379 exp.collect_diagnostics(collector);
380 dot.collect_diagnostics(collector);
381 token.collect_diagnostics(collector);
382 }
383 Index(exp, l, index, r) => {
384 exp.collect_diagnostics(collector);
385 l.collect_diagnostics(collector);
386 index.collect_diagnostics(collector);
387 r.collect_diagnostics(collector);
388 }
389 Slice(exp, l, start, op, end, r) => {
390 exp.collect_diagnostics(collector);
391 l.collect_diagnostics(collector);
392 start.collect_diagnostics(collector);
393 op.collect_diagnostics(collector);
394 end.collect_diagnostics(collector);
395 r.collect_diagnostics(collector);
396 }
397 NonNil(exp, op) => {
398 exp.collect_diagnostics(collector);
399 op.collect_diagnostics(collector);
400 }
401 Prefix(op, exp) => {
402 op.collect_diagnostics(collector);
403 exp.collect_diagnostics(collector);
404 }
405 Infix(exp1, op, exp2) => {
406 exp1.collect_diagnostics(collector);
407 op.collect_diagnostics(collector);
408 exp2.collect_diagnostics(collector);
409 }
410 Is(exp1, op, pattern) => {
411 exp1.collect_diagnostics(collector);
412 op.collect_diagnostics(collector);
413 pattern.collect_diagnostics(collector);
414 }
415 Block(op, statements, expression, cp) => {
416 op.collect_diagnostics(collector);
417 statements.collect_diagnostics(collector);
418 expression.collect_diagnostics(collector);
419 cp.collect_diagnostics(collector);
420 }
421 Loop(kw, expression) => {
422 kw.collect_diagnostics(collector);
423 expression.collect_diagnostics(collector);
424 }
425 While(kw, expression, block, None) => {
426 kw.collect_diagnostics(collector);
427 expression.collect_diagnostics(collector);
428 block.collect_diagnostics(collector);
429 }
430 While(kw, expression, block, Some(else_block)) => {
431 kw.collect_diagnostics(collector);
432 expression.collect_diagnostics(collector);
433 block.collect_diagnostics(collector);
434 else_block.collect_diagnostics(collector);
435 }
436 ForIn(kw_for, pattern, kw_in, iter, block, None) => {
437 kw_for.collect_diagnostics(collector);
438 pattern.collect_diagnostics(collector);
439 kw_in.collect_diagnostics(collector);
440 iter.collect_diagnostics(collector);
441 block.collect_diagnostics(collector);
442 }
443 ForIn(kw_for, pattern, kw_in, iter, block, Some(else_block)) => {
444 kw_for.collect_diagnostics(collector);
445 pattern.collect_diagnostics(collector);
446 kw_in.collect_diagnostics(collector);
447 iter.collect_diagnostics(collector);
448 block.collect_diagnostics(collector);
449 else_block.collect_diagnostics(collector);
450 }
451 If(kw_if, cond, then_block, Some(else_block)) => {
452 kw_if.collect_diagnostics(collector);
453 cond.collect_diagnostics(collector);
454 then_block.collect_diagnostics(collector);
455 else_block.collect_diagnostics(collector);
456 }
457 If(kw_if, cond, then_block, None) => {
458 kw_if.collect_diagnostics(collector);
459 cond.collect_diagnostics(collector);
460 then_block.collect_diagnostics(collector);
461 }
462 Cond(cond, q1, then_exp, q2, else_exp) => {
463 cond.collect_diagnostics(collector);
464 q1.collect_diagnostics(collector);
465 then_exp.collect_diagnostics(collector);
466 q2.collect_diagnostics(collector);
467 else_exp.collect_diagnostics(collector);
468 }
469 Match(kw, expression, op, arms, cp) => {
470 kw.collect_diagnostics(collector);
471 expression.collect_diagnostics(collector);
472 op.collect_diagnostics(collector);
473 for arm in arms {
474 arm.collect_diagnostics(collector);
475 }
476 cp.collect_diagnostics(collector);
477 }
478 Function(kw, None, block) => {
479 kw.collect_diagnostics(collector);
480 block.collect_diagnostics(collector);
481 }
482 Function(kw, Some(params), block) => {
483 kw.collect_diagnostics(collector);
484 params.collect_diagnostics(collector);
485 block.collect_diagnostics(collector);
486 }
487 Unknown {
488 recovered,
489 tokens,
490 errors,
491 } => {
492 collector.append(errors);
493 tokens.collect_diagnostics(collector);
494 if let Some(mut recovered) = std::mem::take(recovered) {
495 recovered.collect_diagnostics(collector);
496 *self = *recovered;
497 }
498 }
499 }
500 }
501 fn range(&self) -> SourceRange {
502 use Expression::*;
503 match self {
504 Grouping(op, _, cp) | Record(op, _, cp) | Array(op, _, cp) | Block(op, _, _, cp) => {
505 op.range.start..cp.range.end
506 }
507 InterpolatedString(token, _) => token.range.clone(),
508 Literal(token) | Variable(token) => token.range.clone(),
509 Index(exp, _, _, r) | Slice(exp, _, _, _, _, r) => exp.range().start..r.range.end,
510 TaggedString(callable, exp) => callable.range().start..exp.range().end,
511 Call(callable, _, _, cp) => callable.range().start..cp.range.end,
512 Extension(expression, _, _, _, _, cp) => expression.range().start..cp.range.end,
513 Access(expression, _, cp) => expression.range().start..cp.range.end,
514 NonNil(expression, bang) => expression.range().start..bang.range.end,
515 Prefix(op, expression) => op.range.start..expression.range().end,
516 Infix(left, _, right) => left.range().start..right.range().end,
517 Is(expression, _, pattern) => expression.range().start..pattern.range().end,
518 Loop(kw, expression) => kw.range.start..expression.range().end,
519 While(kw, _, body, None) | ForIn(kw, _, _, _, body, None) | If(kw, _, body, None) => {
520 kw.range.start..body.range().end
521 }
522 While(kw, _, _, Some(else_block))
523 | ForIn(kw, _, _, _, _, Some(else_block))
524 | If(kw, _, _, Some(else_block)) => kw.range.start..else_block.range().end,
525 Cond(cond, _, _, _, else_exp) => cond.range().start..else_exp.range().end,
526 Match(kw, _, _, _, cp) => kw.range.start..cp.range.end,
527 Function(kw, _, expression) => kw.range.start..expression.range().end,
528 Unknown {
529 recovered,
530 tokens,
531 errors: _,
532 } => unknown_range(recovered, tokens),
533 }
534 }
535}