1use schemars::JsonSchema;
2use serde::Deserialize;
3use serde::Serialize;
4
5use crate::lexer::token::Span;
6use crate::node::Node;
7use crate::parser::ast::Expression;
8
9#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
10#[serde(tag = "type", content = "value")]
11pub enum ArithmeticOperationExpression {
12 Addition {
13 left: Box<Expression>,
14 plus: Span,
15 right: Box<Expression>,
16 },
17 Subtraction {
18 left: Box<Expression>,
19 minus: Span,
20 right: Box<Expression>,
21 },
22 Multiplication {
23 left: Box<Expression>,
24 asterisk: Span,
25 right: Box<Expression>,
26 },
27 Division {
28 left: Box<Expression>,
29 slash: Span,
30 right: Box<Expression>,
31 },
32 Modulo {
33 left: Box<Expression>,
34 percent: Span,
35 right: Box<Expression>,
36 },
37 Exponentiation {
38 left: Box<Expression>,
39 pow: Span,
40 right: Box<Expression>,
41 },
42 Negative {
43 minus: Span,
44 right: Box<Expression>,
45 },
46 Positive {
47 plus: Span,
48 right: Box<Expression>,
49 },
50 PreIncrement {
51 increment: Span,
52 right: Box<Expression>,
53 },
54 PostIncrement {
55 left: Box<Expression>,
56 increment: Span,
57 },
58 PreDecrement {
59 decrement: Span,
60 right: Box<Expression>,
61 },
62 PostDecrement {
63 left: Box<Expression>,
64 decrement: Span,
65 },
66}
67
68impl Node for ArithmeticOperationExpression {
69 fn children(&mut self) -> Vec<&mut dyn Node> {
70 match self {
71 ArithmeticOperationExpression::Addition { left, right, .. } => {
72 vec![left.as_mut(), right.as_mut()]
73 }
74 ArithmeticOperationExpression::Subtraction { left, right, .. } => {
75 vec![left.as_mut(), right.as_mut()]
76 }
77 ArithmeticOperationExpression::Multiplication { left, right, .. } => {
78 vec![left.as_mut(), right.as_mut()]
79 }
80 ArithmeticOperationExpression::Division { left, right, .. } => {
81 vec![left.as_mut(), right.as_mut()]
82 }
83 ArithmeticOperationExpression::Modulo { left, right, .. } => {
84 vec![left.as_mut(), right.as_mut()]
85 }
86 ArithmeticOperationExpression::Exponentiation { left, right, .. } => {
87 vec![left.as_mut(), right.as_mut()]
88 }
89 ArithmeticOperationExpression::Negative { right, .. } => vec![right.as_mut()],
90 ArithmeticOperationExpression::Positive { right, .. } => vec![right.as_mut()],
91 ArithmeticOperationExpression::PreIncrement { right, .. } => vec![right.as_mut()],
92 ArithmeticOperationExpression::PostIncrement { left, .. } => vec![left.as_mut()],
93 ArithmeticOperationExpression::PreDecrement { right, .. } => vec![right.as_mut()],
94 ArithmeticOperationExpression::PostDecrement { left, .. } => vec![left.as_mut()],
95 }
96 }
97}
98
99#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
100#[serde(tag = "type", content = "value")]
101pub enum AssignmentOperationExpression {
102 Assign {
103 left: Box<Expression>,
104 equals: Span,
105 right: Box<Expression>,
106 },
107 Addition {
108 left: Box<Expression>,
109 plus_equals: Span,
110 right: Box<Expression>,
111 },
112 Subtraction {
113 left: Box<Expression>,
114 minus_equals: Span,
115 right: Box<Expression>,
116 },
117 Multiplication {
118 left: Box<Expression>,
119 asterisk_equals: Span,
120 right: Box<Expression>,
121 },
122 Division {
123 left: Box<Expression>,
124 slash_equals: Span,
125 right: Box<Expression>,
126 },
127 Modulo {
128 left: Box<Expression>,
129 percent_equals: Span,
130 right: Box<Expression>,
131 },
132 Exponentiation {
133 left: Box<Expression>,
134 pow_equals: Span,
135 right: Box<Expression>,
136 },
137 Concat {
138 left: Box<Expression>,
139 dot_equals: Span,
140 right: Box<Expression>,
141 },
142 BitwiseAnd {
143 left: Box<Expression>,
144 ampersand_equals: Span,
145 right: Box<Expression>,
146 },
147 BitwiseOr {
148 left: Box<Expression>,
149 pipe_equals: Span,
150 right: Box<Expression>,
151 },
152 BitwiseXor {
153 left: Box<Expression>,
154 caret_equals: Span,
155 right: Box<Expression>,
156 },
157 LeftShift {
158 left: Box<Expression>,
159 left_shift_equals: Span,
160 right: Box<Expression>,
161 },
162 RightShift {
163 left: Box<Expression>,
164 right_shift_equals: Span,
165 right: Box<Expression>,
166 },
167 Coalesce {
168 left: Box<Expression>,
169 coalesce_equals: Span,
170 right: Box<Expression>,
171 },
172}
173
174impl AssignmentOperationExpression {
175 pub fn left(&self) -> &Expression {
176 match self {
177 AssignmentOperationExpression::Assign { left, .. } => left.as_ref(),
178 AssignmentOperationExpression::Addition { left, .. } => left.as_ref(),
179 AssignmentOperationExpression::Subtraction { left, .. } => left.as_ref(),
180 AssignmentOperationExpression::Multiplication { left, .. } => left.as_ref(),
181 AssignmentOperationExpression::Division { left, .. } => left.as_ref(),
182 AssignmentOperationExpression::Modulo { left, .. } => left.as_ref(),
183 AssignmentOperationExpression::Exponentiation { left, .. } => left.as_ref(),
184 AssignmentOperationExpression::Concat { left, .. } => left.as_ref(),
185 AssignmentOperationExpression::BitwiseAnd { left, .. } => left.as_ref(),
186 AssignmentOperationExpression::BitwiseOr { left, .. } => left.as_ref(),
187 AssignmentOperationExpression::BitwiseXor { left, .. } => left.as_ref(),
188 AssignmentOperationExpression::LeftShift { left, .. } => left.as_ref(),
189 AssignmentOperationExpression::RightShift { left, .. } => left.as_ref(),
190 AssignmentOperationExpression::Coalesce { left, .. } => left.as_ref(),
191 }
192 }
193
194 pub fn right(&self) -> &Expression {
195 match self {
196 AssignmentOperationExpression::Assign { right, .. } => right.as_ref(),
197 AssignmentOperationExpression::Addition { right, .. } => right.as_ref(),
198 AssignmentOperationExpression::Subtraction { right, .. } => right.as_ref(),
199 AssignmentOperationExpression::Multiplication { right, .. } => right.as_ref(),
200 AssignmentOperationExpression::Division { right, .. } => right.as_ref(),
201 AssignmentOperationExpression::Modulo { right, .. } => right.as_ref(),
202 AssignmentOperationExpression::Exponentiation { right, .. } => right.as_ref(),
203 AssignmentOperationExpression::Concat { right, .. } => right.as_ref(),
204 AssignmentOperationExpression::BitwiseAnd { right, .. } => right.as_ref(),
205 AssignmentOperationExpression::BitwiseOr { right, .. } => right.as_ref(),
206 AssignmentOperationExpression::BitwiseXor { right, .. } => right.as_ref(),
207 AssignmentOperationExpression::LeftShift { right, .. } => right.as_ref(),
208 AssignmentOperationExpression::RightShift { right, .. } => right.as_ref(),
209 AssignmentOperationExpression::Coalesce { right, .. } => right.as_ref(),
210 }
211 }
212
213 pub fn operator(&self) -> &Span {
214 match self {
215 AssignmentOperationExpression::Assign { equals, .. } => equals,
216 AssignmentOperationExpression::Addition { plus_equals, .. } => plus_equals,
217 AssignmentOperationExpression::Subtraction { minus_equals, .. } => minus_equals,
218 AssignmentOperationExpression::Multiplication {
219 asterisk_equals, ..
220 } => asterisk_equals,
221 AssignmentOperationExpression::Division { slash_equals, .. } => slash_equals,
222 AssignmentOperationExpression::Modulo { percent_equals, .. } => percent_equals,
223 AssignmentOperationExpression::Exponentiation { pow_equals, .. } => pow_equals,
224 AssignmentOperationExpression::Concat { dot_equals, .. } => dot_equals,
225 AssignmentOperationExpression::BitwiseAnd {
226 ampersand_equals, ..
227 } => ampersand_equals,
228 AssignmentOperationExpression::BitwiseOr { pipe_equals, .. } => pipe_equals,
229 AssignmentOperationExpression::BitwiseXor { caret_equals, .. } => caret_equals,
230 AssignmentOperationExpression::LeftShift {
231 left_shift_equals, ..
232 } => left_shift_equals,
233 AssignmentOperationExpression::RightShift {
234 right_shift_equals, ..
235 } => right_shift_equals,
236 AssignmentOperationExpression::Coalesce {
237 coalesce_equals, ..
238 } => coalesce_equals,
239 }
240 }
241}
242
243impl Node for AssignmentOperationExpression {
244 fn children(&mut self) -> Vec<&mut dyn Node> {
245 match self {
246 AssignmentOperationExpression::Assign { left, right, .. } => {
247 vec![left.as_mut(), right.as_mut()]
248 }
249 AssignmentOperationExpression::Addition { left, right, .. } => {
250 vec![left.as_mut(), right.as_mut()]
251 }
252 AssignmentOperationExpression::Subtraction { left, right, .. } => {
253 vec![left.as_mut(), right.as_mut()]
254 }
255 AssignmentOperationExpression::Multiplication { left, right, .. } => {
256 vec![left.as_mut(), right.as_mut()]
257 }
258 AssignmentOperationExpression::Division { left, right, .. } => {
259 vec![left.as_mut(), right.as_mut()]
260 }
261 AssignmentOperationExpression::Modulo { left, right, .. } => {
262 vec![left.as_mut(), right.as_mut()]
263 }
264 AssignmentOperationExpression::Exponentiation { left, right, .. } => {
265 vec![left.as_mut(), right.as_mut()]
266 }
267 AssignmentOperationExpression::Concat { left, right, .. } => {
268 vec![left.as_mut(), right.as_mut()]
269 }
270 AssignmentOperationExpression::BitwiseAnd { left, right, .. } => {
271 vec![left.as_mut(), right.as_mut()]
272 }
273 AssignmentOperationExpression::BitwiseOr { left, right, .. } => {
274 vec![left.as_mut(), right.as_mut()]
275 }
276 AssignmentOperationExpression::BitwiseXor { left, right, .. } => {
277 vec![left.as_mut(), right.as_mut()]
278 }
279 AssignmentOperationExpression::LeftShift { left, right, .. } => {
280 vec![left.as_mut(), right.as_mut()]
281 }
282 AssignmentOperationExpression::RightShift { left, right, .. } => {
283 vec![left.as_mut(), right.as_mut()]
284 }
285 AssignmentOperationExpression::Coalesce { left, right, .. } => {
286 vec![left.as_mut(), right.as_mut()]
287 }
288 }
289 }
290}
291
292#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
293#[serde(tag = "type", content = "value")]
294pub enum BitwiseOperationExpression {
295 And {
296 left: Box<Expression>,
297 and: Span,
298 right: Box<Expression>,
299 },
300 Or {
301 left: Box<Expression>,
302 or: Span,
303 right: Box<Expression>,
304 },
305 Xor {
306 left: Box<Expression>,
307 xor: Span,
308 right: Box<Expression>,
309 },
310 LeftShift {
311 left: Box<Expression>,
312 left_shift: Span,
313 right: Box<Expression>,
314 },
315 RightShift {
316 left: Box<Expression>,
317 right_shift: Span,
318 right: Box<Expression>,
319 },
320 Not {
321 not: Span,
322 right: Box<Expression>,
323 },
324}
325
326impl Node for BitwiseOperationExpression {
327 fn children(&mut self) -> Vec<&mut dyn Node> {
328 match self {
329 BitwiseOperationExpression::And { left, right, .. } => {
330 vec![left.as_mut(), right.as_mut()]
331 }
332 BitwiseOperationExpression::Or { left, right, .. } => {
333 vec![left.as_mut(), right.as_mut()]
334 }
335 BitwiseOperationExpression::Xor { left, right, .. } => {
336 vec![left.as_mut(), right.as_mut()]
337 }
338 BitwiseOperationExpression::LeftShift { left, right, .. } => {
339 vec![left.as_mut(), right.as_mut()]
340 }
341 BitwiseOperationExpression::RightShift { left, right, .. } => {
342 vec![left.as_mut(), right.as_mut()]
343 }
344 BitwiseOperationExpression::Not { right, .. } => vec![right.as_mut()],
345 }
346 }
347}
348
349#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
350#[serde(tag = "type", content = "value")]
351pub enum ComparisonOperationExpression {
352 Equal {
353 left: Box<Expression>,
354 double_equals: Span,
355 right: Box<Expression>,
356 },
357 Identical {
358 left: Box<Expression>,
359 triple_equals: Span,
360 right: Box<Expression>,
361 },
362 NotEqual {
363 left: Box<Expression>,
364 bang_equals: Span,
365 right: Box<Expression>,
366 },
367 AngledNotEqual {
368 left: Box<Expression>,
369 angled_left_right: Span,
370 right: Box<Expression>,
371 },
372 NotIdentical {
373 left: Box<Expression>,
374 bang_double_equals: Span,
375 right: Box<Expression>,
376 },
377 LessThan {
378 left: Box<Expression>,
379 less_than: Span,
380 right: Box<Expression>,
381 },
382 GreaterThan {
383 left: Box<Expression>,
384 greater_than: Span,
385 right: Box<Expression>,
386 },
387 LessThanOrEqual {
388 left: Box<Expression>,
389 less_than_equals: Span,
390 right: Box<Expression>,
391 },
392 GreaterThanOrEqual {
393 left: Box<Expression>,
394 greater_than_equals: Span,
395 right: Box<Expression>,
396 },
397 Spaceship {
398 left: Box<Expression>,
399 spaceship: Span,
400 right: Box<Expression>,
401 },
402}
403
404impl Node for ComparisonOperationExpression {
405 fn children(&mut self) -> Vec<&mut dyn Node> {
406 match self {
407 ComparisonOperationExpression::Equal { left, right, .. } => {
408 vec![left.as_mut(), right.as_mut()]
409 }
410 ComparisonOperationExpression::Identical { left, right, .. } => {
411 vec![left.as_mut(), right.as_mut()]
412 }
413 ComparisonOperationExpression::NotEqual { left, right, .. } => {
414 vec![left.as_mut(), right.as_mut()]
415 }
416 ComparisonOperationExpression::AngledNotEqual { left, right, .. } => {
417 vec![left.as_mut(), right.as_mut()]
418 }
419 ComparisonOperationExpression::NotIdentical { left, right, .. } => {
420 vec![left.as_mut(), right.as_mut()]
421 }
422 ComparisonOperationExpression::LessThan { left, right, .. } => {
423 vec![left.as_mut(), right.as_mut()]
424 }
425 ComparisonOperationExpression::GreaterThan { left, right, .. } => {
426 vec![left.as_mut(), right.as_mut()]
427 }
428 ComparisonOperationExpression::LessThanOrEqual { left, right, .. } => {
429 vec![left.as_mut(), right.as_mut()]
430 }
431 ComparisonOperationExpression::GreaterThanOrEqual { left, right, .. } => {
432 vec![left.as_mut(), right.as_mut()]
433 }
434 ComparisonOperationExpression::Spaceship { left, right, .. } => {
435 vec![left.as_mut(), right.as_mut()]
436 }
437 }
438 }
439}
440
441#[derive(Debug, PartialEq, Eq, Clone, Deserialize, Serialize, JsonSchema)]
442#[serde(tag = "type", content = "value")]
443pub enum LogicalOperationExpression {
444 And {
445 left: Box<Expression>,
446 double_ampersand: Span,
447 right: Box<Expression>,
448 },
449 Or {
450 left: Box<Expression>,
451 double_pipe: Span,
452 right: Box<Expression>,
453 },
454 Not {
455 bang: Span,
456 right: Box<Expression>,
457 },
458 LogicalAnd {
459 left: Box<Expression>,
460 and: Span,
461 right: Box<Expression>,
462 },
463 LogicalOr {
464 left: Box<Expression>,
465 or: Span,
466 right: Box<Expression>,
467 },
468 LogicalXor {
469 left: Box<Expression>,
470 xor: Span,
471 right: Box<Expression>,
472 },
473}
474
475impl Node for LogicalOperationExpression {
476 fn children(&mut self) -> Vec<&mut dyn Node> {
477 match self {
478 LogicalOperationExpression::And { left, right, .. } => {
479 vec![left.as_mut(), right.as_mut()]
480 }
481 LogicalOperationExpression::Or { left, right, .. } => {
482 vec![left.as_mut(), right.as_mut()]
483 }
484 LogicalOperationExpression::Not { right, .. } => vec![right.as_mut()],
485 LogicalOperationExpression::LogicalAnd { left, right, .. } => {
486 vec![left.as_mut(), right.as_mut()]
487 }
488 LogicalOperationExpression::LogicalOr { left, right, .. } => {
489 vec![left.as_mut(), right.as_mut()]
490 }
491 LogicalOperationExpression::LogicalXor { left, right, .. } => {
492 vec![left.as_mut(), right.as_mut()]
493 }
494 }
495 }
496}