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 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}