Skip to main content

mirascript_core/parser/
expression.rs

1use crate::parser::helper::unknown_range;
2
3use super::prelude::*;
4
5#[derive(Debug, Clone, PartialEq, strum::EnumIs)]
6pub enum Callable<'s> {
7    /// `type`
8    Type(TokenRef<'s>),
9    /// expression
10    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/// `else` (block_expr | if_expr)
31#[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/// `case` pattern (`if` expression)? block_expression
45#[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    // primary
73    /// number | string | ordinal | `true` | `false` | `nil`
74    Literal(TokenRef<'s>),
75    /// interpolated_string
76    ///
77    /// Holds a [crate::lexer::TokenKind::InterpolatedString], and a list of expressions
78    /// that are interpolated into the string.
79    InterpolatedString(&'s Token<'s>, Vec<Expression<'s>>),
80    /// identifier
81    Variable(TokenRef<'s>),
82    /// `(` expression `)`
83    Grouping(TokenRef<'s>, Box<Expression<'s>>, TokenRef<'s>),
84    /// `(` element* `)`
85    ///
86    /// Use `()` for an empty record.
87    ///
88    /// For a single-element-unnamed record, use `(` expression `,` `)`.
89    ///
90    /// For convenience for JSON-like data, allows following JSON-style trailing record:
91    ///
92    /// `{` ( ( string | interpolated_string ) `:` expression `,` )+ `}`
93    Record(TokenRef<'s>, Vec<RecordElement<'s>>, TokenRef<'s>),
94    /// `[` element* `]`
95    ///
96    /// Use `[]` for an empty list.
97    Array(TokenRef<'s>, Vec<ArrayElement<'s>>, TokenRef<'s>),
98
99    // postfix
100    /// callable `(` arguments `)`
101    ///
102    /// Arguments are a list of expressions, trailing comma is optional.
103    Call(
104        Callable<'s>,
105        TokenRef<'s>,
106        Vec<ArgElement<'s>>,
107        TokenRef<'s>,
108    ),
109    /// expression ( interpolated_string | string )
110    TaggedString(Box<Expression<'s>>, Box<Expression<'s>>),
111    /// expression `::` extension `(` arguments `)`
112    /// extension
113    ///     : identifier (`.` ( identifier | ordinal ))*
114    ///     | pseudo_function
115    ///     | `(` expression `)`
116    ///     ;
117    ///
118    /// Like `Call`, but `expression` is used as the first argument.
119    Extension(
120        Box<Expression<'s>>,
121        TokenRef<'s>,
122        Callable<'s>,
123        TokenRef<'s>,
124        Vec<ArgElement<'s>>,
125        TokenRef<'s>,
126    ),
127    /// expression `.` field
128    ///
129    /// Field must be an identifier or an ordinal.
130    Access(Box<Expression<'s>>, TokenRef<'s>, TokenRef<'s>),
131    /// expression `[` expression `]`
132    Index(
133        Box<Expression<'s>>,
134        TokenRef<'s>,
135        Box<Expression<'s>>,
136        TokenRef<'s>,
137    ),
138    /// expression `[` additive_expression? (`..` | `..<`) additive_expression? `]`
139    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    /// expression `!`
148    NonNil(Box<Expression<'s>>, TokenRef<'s>),
149
150    /// op expression
151    ///
152    /// Prefix operators are:
153    /// - `!` logical not
154    /// - `-` negation
155    /// - `+` unary plus
156    Prefix(TokenRef<'s>, Box<Expression<'s>>),
157
158    // infix
159    /// expression op expression
160    ///
161    /// Infix operators are:
162    /// 1. `^` exponentiation
163    /// 1. `*` `/` `%` multiplicative
164    /// 1. `+` `-` additive
165    /// 1. `is` matching *Use [Expression::Is] for this
166    /// 1. `>` `<` `>=` `<=` `in` relational
167    /// 1. `==` `!=` `=~` `!~` equality
168    /// 1. `&&` logical and
169    /// 1. `||` logical or
170    Infix(Box<Expression<'s>>, TokenRef<'s>, Box<Expression<'s>>),
171    /// expression `is` pattern
172    Is(Box<Expression<'s>>, TokenRef<'s>, Box<Pattern<'s>>),
173
174    // block-like
175    /// `{` statements* expression? `}`
176    ///
177    /// The value of the block is the value of the last expression.
178    /// If no expression is present, the value is `nil`.
179    Block(
180        TokenRef<'s>,
181        Vec<Statement<'s>>,
182        Option<Box<Expression<'s>>>,
183        TokenRef<'s>,
184    ),
185    /// `loop` block_expression
186    ///
187    /// The final expression of the block must not present.
188    ///
189    /// The value of the block is the expression of the `break` statement if present. Otherwise, `nil`.
190    Loop(TokenRef<'s>, Box<Expression<'s>>),
191    /// `while` expression block_expression (`else` expression)?
192    ///
193    /// The final expression of the block must not present.
194    ///
195    /// The `else_block` is a block expression or an if expression.
196    ///
197    /// The value of the block is the expression of the `break` statement if present.
198    /// Otherwise, if the `else_block` is present,
199    /// the value is the value of the `else_block`. Otherwise, `nil`.
200    While(
201        TokenRef<'s>,
202        Box<Expression<'s>>,
203        Box<Expression<'s>>,
204        Option<ElseBlock<'s>>,
205    ),
206    /// `for` pattern `in` expression block_expression (`else` expression)?
207    ///
208    /// The final expression of the block must not present.
209    ///
210    /// The `else_block` is a block expression or an if expression.
211    ///
212    /// The value of the block is the expression of the `break` statement if present.
213    /// Otherwise, if the `else_block` is present,
214    /// the value is the value of the `else_block`. Otherwise, `nil`.
215    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` expression block_expression (`else` expression)?
224    ///
225    /// The `then_block` is a block expression.
226    ///
227    /// The `else_block` is a block expression or an if expression.
228    If(
229        TokenRef<'s>,
230        Box<Expression<'s>>,
231        Box<Expression<'s>>,
232        Option<ElseBlock<'s>>,
233    ),
234    /// cond ? expression : expression
235    Cond(
236        Box<Expression<'s>>,
237        TokenRef<'s>,
238        Box<Expression<'s>>,
239        TokenRef<'s>,
240        Box<Expression<'s>>,
241    ),
242    /// `match` expression `{` ( `case` pattern (`if` expression)? block_expression )* `}`
243    ///
244    /// The value of the block is the value of the matched expression.
245    ///
246    /// If no match is found, the value is `nil`.
247    Match(
248        TokenRef<'s>,
249        Box<Expression<'s>>,
250        TokenRef<'s>,
251        Vec<MatchCase<'s>>,
252        TokenRef<'s>,
253    ),
254    /// `fn` parameters? block_expression
255    ///
256    /// Just like function declarations, but without the identifier.
257    /// See [Statement::Function] for more details.
258    Function(TokenRef<'s>, Option<ParameterList<'s>>, Box<Expression<'s>>),
259    /// Unknown expression
260    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                // skip token ref
342                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}