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 #[allow(dead_code)]
324 pub(crate) fn unknown_errors<T: Into<Vec<TokenRef<'s>>>, E: Into<Vec<SourceDiagnostic>>>(
325 tokens: T,
326 errors: E,
327 ) -> Self {
328 Expression::Unknown {
329 recovered: None,
330 tokens: tokens.into(),
331 errors: errors.into(),
332 }
333 }
334}
335
336impl<'s> AstWalker<'s> for Expression<'s> {
337 fn collect_diagnostics(&mut self, collector: &mut DiagnosticsCollector<'_, '_>) {
338 use Expression::*;
339 match self {
340 Literal(token) => token.collect_diagnostics(collector),
341 InterpolatedString(_, exps) => {
342 exps.collect_diagnostics(collector);
344 }
345 Variable(token) => token.collect_diagnostics(collector),
346 Grouping(op, exp, cp) => {
347 op.collect_diagnostics(collector);
348 exp.collect_diagnostics(collector);
349 cp.collect_diagnostics(collector);
350 }
351 Record(op, exps, cp) => {
352 op.collect_diagnostics(collector);
353 exps.collect_diagnostics(collector);
354 cp.collect_diagnostics(collector);
355 }
356 Array(op, exps, cp) => {
357 op.collect_diagnostics(collector);
358 exps.collect_diagnostics(collector);
359 cp.collect_diagnostics(collector);
360 }
361 TaggedString(callable, exp) => {
362 callable.collect_diagnostics(collector);
363 exp.collect_diagnostics(collector);
364 }
365 Call(exp, op, args, cp) => {
366 exp.collect_diagnostics(collector);
367 op.collect_diagnostics(collector);
368 args.collect_diagnostics(collector);
369 cp.collect_diagnostics(collector);
370 }
371 Extension(exp, e, ext, op, args, cp) => {
372 exp.collect_diagnostics(collector);
373 e.collect_diagnostics(collector);
374 ext.collect_diagnostics(collector);
375 op.collect_diagnostics(collector);
376 args.collect_diagnostics(collector);
377 cp.collect_diagnostics(collector);
378 }
379 Access(exp, dot, token) => {
380 exp.collect_diagnostics(collector);
381 dot.collect_diagnostics(collector);
382 token.collect_diagnostics(collector);
383 }
384 Index(exp, l, index, r) => {
385 exp.collect_diagnostics(collector);
386 l.collect_diagnostics(collector);
387 index.collect_diagnostics(collector);
388 r.collect_diagnostics(collector);
389 }
390 Slice(exp, l, start, op, end, r) => {
391 exp.collect_diagnostics(collector);
392 l.collect_diagnostics(collector);
393 start.collect_diagnostics(collector);
394 op.collect_diagnostics(collector);
395 end.collect_diagnostics(collector);
396 r.collect_diagnostics(collector);
397 }
398 NonNil(exp, op) => {
399 exp.collect_diagnostics(collector);
400 op.collect_diagnostics(collector);
401 }
402 Prefix(op, exp) => {
403 op.collect_diagnostics(collector);
404 exp.collect_diagnostics(collector);
405 }
406 Infix(exp1, op, exp2) => {
407 exp1.collect_diagnostics(collector);
408 op.collect_diagnostics(collector);
409 exp2.collect_diagnostics(collector);
410 }
411 Is(exp1, op, pattern) => {
412 exp1.collect_diagnostics(collector);
413 op.collect_diagnostics(collector);
414 pattern.collect_diagnostics(collector);
415 }
416 Block(op, statements, expression, cp) => {
417 op.collect_diagnostics(collector);
418 statements.collect_diagnostics(collector);
419 expression.collect_diagnostics(collector);
420 cp.collect_diagnostics(collector);
421 }
422 Loop(kw, expression) => {
423 kw.collect_diagnostics(collector);
424 expression.collect_diagnostics(collector);
425 }
426 While(kw, expression, block, None) => {
427 kw.collect_diagnostics(collector);
428 expression.collect_diagnostics(collector);
429 block.collect_diagnostics(collector);
430 }
431 While(kw, expression, block, Some(else_block)) => {
432 kw.collect_diagnostics(collector);
433 expression.collect_diagnostics(collector);
434 block.collect_diagnostics(collector);
435 else_block.collect_diagnostics(collector);
436 }
437 ForIn(kw_for, pattern, kw_in, iter, block, None) => {
438 kw_for.collect_diagnostics(collector);
439 pattern.collect_diagnostics(collector);
440 kw_in.collect_diagnostics(collector);
441 iter.collect_diagnostics(collector);
442 block.collect_diagnostics(collector);
443 }
444 ForIn(kw_for, pattern, kw_in, iter, block, Some(else_block)) => {
445 kw_for.collect_diagnostics(collector);
446 pattern.collect_diagnostics(collector);
447 kw_in.collect_diagnostics(collector);
448 iter.collect_diagnostics(collector);
449 block.collect_diagnostics(collector);
450 else_block.collect_diagnostics(collector);
451 }
452 If(kw_if, cond, then_block, Some(else_block)) => {
453 kw_if.collect_diagnostics(collector);
454 cond.collect_diagnostics(collector);
455 then_block.collect_diagnostics(collector);
456 else_block.collect_diagnostics(collector);
457 }
458 If(kw_if, cond, then_block, None) => {
459 kw_if.collect_diagnostics(collector);
460 cond.collect_diagnostics(collector);
461 then_block.collect_diagnostics(collector);
462 }
463 Cond(cond, q1, then_exp, q2, else_exp) => {
464 cond.collect_diagnostics(collector);
465 q1.collect_diagnostics(collector);
466 then_exp.collect_diagnostics(collector);
467 q2.collect_diagnostics(collector);
468 else_exp.collect_diagnostics(collector);
469 }
470 Match(kw, expression, op, arms, cp) => {
471 kw.collect_diagnostics(collector);
472 expression.collect_diagnostics(collector);
473 op.collect_diagnostics(collector);
474 for arm in arms {
475 arm.collect_diagnostics(collector);
476 }
477 cp.collect_diagnostics(collector);
478 }
479 Function(kw, None, block) => {
480 kw.collect_diagnostics(collector);
481 block.collect_diagnostics(collector);
482 }
483 Function(kw, Some(params), block) => {
484 kw.collect_diagnostics(collector);
485 params.collect_diagnostics(collector);
486 block.collect_diagnostics(collector);
487 }
488 Unknown {
489 recovered,
490 tokens,
491 errors,
492 } => {
493 collector.append(errors);
494 tokens.collect_diagnostics(collector);
495 if let Some(mut recovered) = std::mem::take(recovered) {
496 recovered.collect_diagnostics(collector);
497 *self = *recovered;
498 }
499 }
500 }
501 }
502 fn range(&self) -> SourceRange {
503 use Expression::*;
504 match self {
505 Grouping(op, _, cp) | Record(op, _, cp) | Array(op, _, cp) | Block(op, _, _, cp) => {
506 op.range.start..cp.range.end
507 }
508 InterpolatedString(token, _) => token.range.clone(),
509 Literal(token) | Variable(token) => token.range.clone(),
510 Index(exp, _, _, r) | Slice(exp, _, _, _, _, r) => exp.range().start..r.range.end,
511 TaggedString(callable, exp) => callable.range().start..exp.range().end,
512 Call(callable, _, _, cp) => callable.range().start..cp.range.end,
513 Extension(expression, _, _, _, _, cp) => expression.range().start..cp.range.end,
514 Access(expression, _, cp) => expression.range().start..cp.range.end,
515 NonNil(expression, bang) => expression.range().start..bang.range.end,
516 Prefix(op, expression) => op.range.start..expression.range().end,
517 Infix(left, _, right) => left.range().start..right.range().end,
518 Is(expression, _, pattern) => expression.range().start..pattern.range().end,
519 Loop(kw, expression) => kw.range.start..expression.range().end,
520 While(kw, _, body, None) | ForIn(kw, _, _, _, body, None) | If(kw, _, body, None) => {
521 kw.range.start..body.range().end
522 }
523 While(kw, _, _, Some(else_block))
524 | ForIn(kw, _, _, _, _, Some(else_block))
525 | If(kw, _, _, Some(else_block)) => kw.range.start..else_block.range().end,
526 Cond(cond, _, _, _, else_exp) => cond.range().start..else_exp.range().end,
527 Match(kw, _, _, _, cp) => kw.range.start..cp.range.end,
528 Function(kw, _, expression) => kw.range.start..expression.range().end,
529 Unknown {
530 recovered,
531 tokens,
532 errors: _,
533 } => unknown_range(recovered, tokens),
534 }
535 }
536}