Skip to main content

mirascript_core/parser/
statement.rs

1use super::prelude::*;
2
3#[derive(Debug, Clone, PartialEq, strum::EnumIs)]
4pub enum Statement<'s> {
5    /// `';'`
6    ///
7    /// An empty statement.
8    Empty(TokenRef<'s>),
9    /// `expression ';'`
10    Expression(Box<Expression<'s>>, TokenRef<'s>),
11    /// `expression_ends_with_block`
12    ///
13    /// No trailing semicolon in this case. For expressions that end with a semicolon, use [Statement::Expression].
14    BlockExpression(Box<Expression<'s>>),
15    /// `'pub'? 'mod' identifier block_expression_no_expr`
16    Module(
17        Option<TokenRef<'s>>,
18        TokenRef<'s>,
19        TokenRef<'s>,
20        Box<Expression<'s>>,
21    ),
22    /// `'pub'? 'let' pattern '=' expression ';'`
23    Bind(
24        Option<TokenRef<'s>>,
25        TokenRef<'s>,
26        Box<Pattern<'s>>,
27        TokenRef<'s>,
28        Box<Expression<'s>>,
29        TokenRef<'s>,
30    ),
31    /// `pattern_rebind '=' expression ';'`
32    Rebind(
33        Box<Pattern<'s>>,
34        TokenRef<'s>,
35        Box<Expression<'s>>,
36        TokenRef<'s>,
37    ),
38    /// `'pub'? 'const' @id '=' expression ';'`
39    Const(
40        Option<TokenRef<'s>>,
41        TokenRef<'s>,
42        TokenRef<'s>,
43        TokenRef<'s>,
44        Box<Expression<'s>>,
45        TokenRef<'s>,
46    ),
47    /// `expression ('=' | '+=' | '-=' | '*=' | '/=' | '%=' | '^=' | '&&=' | '||=') expression ';'`
48    ///
49    /// The assigner must be one of the following:
50    /// - `identifier`
51    /// - `expression_access` where the accessed is an extern
52    /// - `expression_index` where the indexed is an extern
53    Assign(
54        Box<Expression<'s>>,
55        TokenRef<'s>,
56        Box<Expression<'s>>,
57        TokenRef<'s>,
58    ),
59    /// `'pub'? 'fn' identifier (parameters) block_expression`
60    ///
61    /// Parameters are a list of identifiers, trailing comma is optional.
62    ///
63    /// If parameters and parentheses are omitted,
64    /// the function is considered with an implicit parameter called `it`.
65    ///
66    /// ```mira
67    /// fn filter { it % 2 == 0 }
68    /// ```
69    ///
70    /// The function body is a block expression.
71    Function(
72        Option<TokenRef<'s>>,
73        TokenRef<'s>,
74        TokenRef<'s>,
75        Option<ParameterList<'s>>,
76        Box<Expression<'s>>,
77    ),
78    /// `return expression;` or `return;`
79    ///
80    /// If the expression is omitted, the return value is `nil`.
81    Return(TokenRef<'s>, Option<Box<Expression<'s>>>, TokenRef<'s>),
82    /// `break expression;` or `break;`
83    ///
84    /// The expression is only allowed in a `loop` expression.
85    Break(TokenRef<'s>, Option<Box<Expression<'s>>>, TokenRef<'s>),
86    /// `continue;`
87    Continue(TokenRef<'s>, TokenRef<'s>),
88    /// Unknown statement.
89    Unknown {
90        tokens: Vec<TokenRef<'s>>,
91        errors: Vec<SourceDiagnostic>,
92    },
93}
94
95impl<'s> Statement<'s> {
96    pub(crate) fn unknown<T: Into<Vec<TokenRef<'s>>>>(tokens: T, error: DiagnosticCode) -> Self {
97        let tokens = tokens.into();
98        assert!(!tokens.is_empty());
99        let mut range = tokens[0].range.clone();
100        range.end = tokens.last().unwrap().range.end;
101        Statement::Unknown {
102            tokens,
103            errors: vec![SourceDiagnostic::new(range, error)],
104        }
105    }
106
107    pub(crate) fn unknown_range<T: Into<Vec<TokenRef<'s>>>>(
108        tokens: T,
109        error_range: SourceRange,
110        error: DiagnosticCode,
111    ) -> Self {
112        Statement::Unknown {
113            tokens: tokens.into(),
114            errors: vec![SourceDiagnostic::new(error_range, error)],
115        }
116    }
117
118    pub(crate) fn unknown_errors<T: Into<Vec<TokenRef<'s>>>, E: Into<Vec<SourceDiagnostic>>>(
119        tokens: T,
120        errors: E,
121    ) -> Self {
122        Statement::Unknown {
123            tokens: tokens.into(),
124            errors: errors.into(),
125        }
126    }
127}
128
129impl<'s> AstWalker<'s> for Statement<'s> {
130    fn collect_diagnostics(&mut self, collector: &mut DiagnosticsCollector<'_, '_>) {
131        use Statement::*;
132        match self {
133            Empty(c) => c.collect_diagnostics(collector),
134            Expression(expr, c) => {
135                expr.collect_diagnostics(collector);
136                c.collect_diagnostics(collector);
137            }
138            BlockExpression(expr) => expr.collect_diagnostics(collector),
139            Module(kw_pub, kw_mod, id, body) => {
140                kw_pub.collect_diagnostics(collector);
141                kw_mod.collect_diagnostics(collector);
142                id.collect_diagnostics(collector);
143                body.collect_diagnostics(collector);
144            }
145            Bind(kw_pub, kw_let, pattern, eq, expr, c) => {
146                kw_pub.collect_diagnostics(collector);
147                kw_let.collect_diagnostics(collector);
148                pattern.collect_diagnostics(collector);
149                eq.collect_diagnostics(collector);
150                expr.collect_diagnostics(collector);
151                c.collect_diagnostics(collector);
152            }
153            Rebind(pattern, eq, expr, c) => {
154                pattern.collect_diagnostics(collector);
155                eq.collect_diagnostics(collector);
156                expr.collect_diagnostics(collector);
157                c.collect_diagnostics(collector);
158            }
159            Const(kw_pub, kw_const, id, eq, expr, c) => {
160                kw_pub.collect_diagnostics(collector);
161                kw_const.collect_diagnostics(collector);
162                id.collect_diagnostics(collector);
163                eq.collect_diagnostics(collector);
164                expr.collect_diagnostics(collector);
165                c.collect_diagnostics(collector);
166            }
167            Assign(exp, eq, expr, c) => {
168                exp.collect_diagnostics(collector);
169                eq.collect_diagnostics(collector);
170                expr.collect_diagnostics(collector);
171                c.collect_diagnostics(collector);
172            }
173            Function(kw_pub, kw_fn, id, params, body) => {
174                kw_pub.collect_diagnostics(collector);
175                kw_fn.collect_diagnostics(collector);
176                id.collect_diagnostics(collector);
177                params.collect_diagnostics(collector);
178                body.collect_diagnostics(collector);
179            }
180            Return(kw, expr, c) => {
181                kw.collect_diagnostics(collector);
182                expr.collect_diagnostics(collector);
183                c.collect_diagnostics(collector);
184            }
185            Break(kw, expr, c) => {
186                kw.collect_diagnostics(collector);
187                expr.collect_diagnostics(collector);
188                c.collect_diagnostics(collector);
189            }
190            Continue(kw, c) => {
191                kw.collect_diagnostics(collector);
192                c.collect_diagnostics(collector);
193            }
194            Unknown { tokens, errors } => {
195                collector.append(errors);
196                tokens.collect_diagnostics(collector);
197            }
198        }
199    }
200    fn range(&self) -> SourceRange {
201        use Statement::*;
202        match self {
203            Empty(c) => c.range(),
204            Expression(expr, c) => expr.range().start..c.range.end,
205            BlockExpression(expr) => expr.range(),
206            Module(kw_pub, kw_mod, _, body) => {
207                kw_pub.as_ref().unwrap_or(kw_mod).range.start..body.range().end
208            }
209            Bind(kw_pub, kw_let, _, _, _, c) => {
210                kw_pub.as_ref().unwrap_or(kw_let).range.start..c.range.end
211            }
212            Rebind(pattern, _, _, c) => pattern.range().start..c.range.end,
213            Const(kw_pub, kw_const, _, _, _, c) => {
214                kw_pub.as_ref().unwrap_or(kw_const).range.start..c.range.end
215            }
216            Assign(exp, _, _, c) => exp.range().start..c.range.end,
217            Function(kw_pub, kw_fn, _, _, body) => {
218                kw_pub.as_ref().unwrap_or(kw_fn).range.start..body.range().end
219            }
220            Return(kw, _, c) | Break(kw, _, c) | Continue(kw, c) => kw.range.start..c.range.end,
221            Unknown { tokens, errors: _ } => tokens.range(),
222        }
223    }
224}