1use super::prelude::*;
2
3#[derive(Debug, Clone, PartialEq, strum::EnumIs)]
4pub enum Statement<'s> {
5 Empty(TokenRef<'s>),
9 Expression(Box<Expression<'s>>, TokenRef<'s>),
11 BlockExpression(Box<Expression<'s>>),
15 Module(
17 Option<TokenRef<'s>>,
18 TokenRef<'s>,
19 TokenRef<'s>,
20 Box<Expression<'s>>,
21 ),
22 Bind(
24 Option<TokenRef<'s>>,
25 TokenRef<'s>,
26 Box<Pattern<'s>>,
27 TokenRef<'s>,
28 Box<Expression<'s>>,
29 TokenRef<'s>,
30 ),
31 Rebind(
33 Box<Pattern<'s>>,
34 TokenRef<'s>,
35 Box<Expression<'s>>,
36 TokenRef<'s>,
37 ),
38 Const(
40 Option<TokenRef<'s>>,
41 TokenRef<'s>,
42 TokenRef<'s>,
43 TokenRef<'s>,
44 Box<Expression<'s>>,
45 TokenRef<'s>,
46 ),
47 Assign(
54 Box<Expression<'s>>,
55 TokenRef<'s>,
56 Box<Expression<'s>>,
57 TokenRef<'s>,
58 ),
59 Function(
72 Option<TokenRef<'s>>,
73 TokenRef<'s>,
74 TokenRef<'s>,
75 Option<ParameterList<'s>>,
76 Box<Expression<'s>>,
77 ),
78 Return(TokenRef<'s>, Option<Box<Expression<'s>>>, TokenRef<'s>),
82 Break(TokenRef<'s>, Option<Box<Expression<'s>>>, TokenRef<'s>),
86 Continue(TokenRef<'s>, TokenRef<'s>),
88 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}