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    #[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                // skip token ref
343                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}