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    #[allow(dead_code)]
108    pub(crate) fn unknown_range<T: Into<Vec<TokenRef<'s>>>>(
109        tokens: T,
110        error_range: SourceRange,
111        error: DiagnosticCode,
112    ) -> Self {
113        Statement::Unknown {
114            tokens: tokens.into(),
115            errors: vec![SourceDiagnostic::new(error_range, error)],
116        }
117    }
118
119    #[allow(dead_code)]
120    pub(crate) fn unknown_errors<T: Into<Vec<TokenRef<'s>>>, E: Into<Vec<SourceDiagnostic>>>(
121        tokens: T,
122        errors: E,
123    ) -> Self {
124        Statement::Unknown {
125            tokens: tokens.into(),
126            errors: errors.into(),
127        }
128    }
129}
130
131impl<'s> AstWalker<'s> for Statement<'s> {
132    fn collect_diagnostics(&mut self, collector: &mut DiagnosticsCollector<'_, '_>) {
133        use Statement::*;
134        match self {
135            Empty(c) => c.collect_diagnostics(collector),
136            Expression(expr, c) => {
137                expr.collect_diagnostics(collector);
138                c.collect_diagnostics(collector);
139            }
140            BlockExpression(expr) => expr.collect_diagnostics(collector),
141            Module(kw_pub, kw_mod, id, body) => {
142                kw_pub.collect_diagnostics(collector);
143                kw_mod.collect_diagnostics(collector);
144                id.collect_diagnostics(collector);
145                body.collect_diagnostics(collector);
146            }
147            Bind(kw_pub, kw_let, pattern, eq, expr, c) => {
148                kw_pub.collect_diagnostics(collector);
149                kw_let.collect_diagnostics(collector);
150                pattern.collect_diagnostics(collector);
151                eq.collect_diagnostics(collector);
152                expr.collect_diagnostics(collector);
153                c.collect_diagnostics(collector);
154            }
155            Rebind(pattern, eq, expr, c) => {
156                pattern.collect_diagnostics(collector);
157                eq.collect_diagnostics(collector);
158                expr.collect_diagnostics(collector);
159                c.collect_diagnostics(collector);
160            }
161            Const(kw_pub, kw_const, id, eq, expr, c) => {
162                kw_pub.collect_diagnostics(collector);
163                kw_const.collect_diagnostics(collector);
164                id.collect_diagnostics(collector);
165                eq.collect_diagnostics(collector);
166                expr.collect_diagnostics(collector);
167                c.collect_diagnostics(collector);
168            }
169            Assign(exp, eq, expr, c) => {
170                exp.collect_diagnostics(collector);
171                eq.collect_diagnostics(collector);
172                expr.collect_diagnostics(collector);
173                c.collect_diagnostics(collector);
174            }
175            Function(kw_pub, kw_fn, id, params, body) => {
176                kw_pub.collect_diagnostics(collector);
177                kw_fn.collect_diagnostics(collector);
178                id.collect_diagnostics(collector);
179                params.collect_diagnostics(collector);
180                body.collect_diagnostics(collector);
181            }
182            Return(kw, expr, c) => {
183                kw.collect_diagnostics(collector);
184                expr.collect_diagnostics(collector);
185                c.collect_diagnostics(collector);
186            }
187            Break(kw, expr, c) => {
188                kw.collect_diagnostics(collector);
189                expr.collect_diagnostics(collector);
190                c.collect_diagnostics(collector);
191            }
192            Continue(kw, c) => {
193                kw.collect_diagnostics(collector);
194                c.collect_diagnostics(collector);
195            }
196            Unknown { tokens, errors } => {
197                collector.append(errors);
198                tokens.collect_diagnostics(collector);
199            }
200        }
201    }
202    fn range(&self) -> SourceRange {
203        use Statement::*;
204        match self {
205            Empty(c) => c.range(),
206            Expression(expr, c) => expr.range().start..c.range.end,
207            BlockExpression(expr) => expr.range(),
208            Module(kw_pub, kw_mod, _, body) => {
209                kw_pub.as_ref().unwrap_or(kw_mod).range.start..body.range().end
210            }
211            Bind(kw_pub, kw_let, _, _, _, c) => {
212                kw_pub.as_ref().unwrap_or(kw_let).range.start..c.range.end
213            }
214            Rebind(pattern, _, _, c) => pattern.range().start..c.range.end,
215            Const(kw_pub, kw_const, _, _, _, c) => {
216                kw_pub.as_ref().unwrap_or(kw_const).range.start..c.range.end
217            }
218            Assign(exp, _, _, c) => exp.range().start..c.range.end,
219            Function(kw_pub, kw_fn, _, _, body) => {
220                kw_pub.as_ref().unwrap_or(kw_fn).range.start..body.range().end
221            }
222            Return(kw, _, c) | Break(kw, _, c) | Continue(kw, c) => kw.range.start..c.range.end,
223            Unknown { tokens, errors: _ } => tokens.range(),
224        }
225    }
226}