1use std::fmt;
2use strum_macros::EnumString;
3use serde::{Deserialize, Serialize};
4
5#[derive(Default, PartialEq, Debug, Serialize, Deserialize, Clone, EnumString)]
6#[serde(tag="type")]
7pub enum AlephTree {
8 #[default]
9 Unit,
10 Break,
11 Continue,
12 Ellipsis,
13 #[serde(alias="Integer")]
14 Int{value: String},
15 Float{value: String},
16 Bool{value: String},
17 String{value: String},
18 Ident{value: String},
19 Bytes{elems: Vec<u8>},
20 Complex{real: String, imag: String},
21 HexLiteral{value: String},
22 Figurative{
23 #[serde(alias="figurativeType")]
24 figurative_type: String
25 },
26 Tuple{elems: Vec<Box<AlephTree>>},
27 Array{elems: Vec<Box<AlephTree>>},
28 Record{fields: Vec<Box<AlephTree>>},
29 Field{name: String, value: Box<AlephTree>},
30 Neg{expr: Box<AlephTree>},
31 Not{
32 #[serde(alias="boolExpr")]
33 bool_expr: Box<AlephTree>
34 },
35 BitNot{expr: Box<AlephTree>},
36 Abs{expr: Box<AlephTree>},
37 Add{
38 #[serde(alias="numberExpr1")]
39 number_expr1: Box<AlephTree>,
40 #[serde(alias="numberExpr2")]
41 number_expr2: Box<AlephTree>
42 },
43 Sub{
44 #[serde(alias="numberExpr1")]
45 number_expr1: Box<AlephTree>,
46 #[serde(alias="numberExpr2")]
47 number_expr2: Box<AlephTree>
48 },
49 Mul{
50 #[serde(alias="numberExpr1")]
51 number_expr1: Box<AlephTree>,
52 #[serde(alias="numberExpr2")]
53 number_expr2: Box<AlephTree>
54 },
55 Div{
56 #[serde(alias="numberExpr1")]
57 number_expr1: Box<AlephTree>,
58 #[serde(alias="numberExpr2")]
59 number_expr2: Box<AlephTree>
60 },
61 Mod{
62 #[serde(alias="numberExpr1")]
63 number_expr1: Box<AlephTree>,
64 #[serde(alias="numberExpr2")]
65 number_expr2: Box<AlephTree>
66 },
67 DivMod{
68 #[serde(alias="numberExpr1", alias="dividend")]
69 dividend: Box<AlephTree>,
70 #[serde(alias="numberExpr2", alias="divisor")]
71 divisor: Box<AlephTree>
72 },
73 MulDiv{
74 n1: Box<AlephTree>,
75 n2: Box<AlephTree>,
76 n3: Box<AlephTree>
77 },
78 MulDivMod{
79 n1: Box<AlephTree>,
80 n2: Box<AlephTree>,
81 n3: Box<AlephTree>
82 },
83 Pow{base: Box<AlephTree>, exponent: Box<AlephTree>},
84 Min{expr1: Box<AlephTree>, expr2: Box<AlephTree>},
85 Max{expr1: Box<AlephTree>, expr2: Box<AlephTree>},
86 And{
87 #[serde(alias="boolExpr1")]
88 bool_expr1: Box<AlephTree>,
89 #[serde(alias="boolExpr2")]
90 bool_expr2: Box<AlephTree>
91 },
92 Or{
93 #[serde(alias="boolExpr1")]
94 bool_expr1: Box<AlephTree>,
95 #[serde(alias="boolExpr2")]
96 bool_expr2: Box<AlephTree>
97 },
98 Xor{expr1: Box<AlephTree>, expr2: Box<AlephTree>},
99 BitAnd{expr1: Box<AlephTree>, expr2: Box<AlephTree>},
100 BitOr{expr1: Box<AlephTree>, expr2: Box<AlephTree>},
101 BitXor{expr1: Box<AlephTree>, expr2: Box<AlephTree>},
102 LShift{expr: Box<AlephTree>, amount: Box<AlephTree>},
103 RShift{expr: Box<AlephTree>, amount: Box<AlephTree>},
104 Eq{expr1: Box<AlephTree>, expr2: Box<AlephTree>},
105 NotEq{expr1: Box<AlephTree>, expr2: Box<AlephTree>},
106 LT{expr1: Box<AlephTree>, expr2: Box<AlephTree>},
107 LE{expr1: Box<AlephTree>, expr2: Box<AlephTree>},
108 GT{expr1: Box<AlephTree>, expr2: Box<AlephTree>},
109 GE{expr1: Box<AlephTree>, expr2: Box<AlephTree>},
110 In{expr1: Box<AlephTree>, expr2: Box<AlephTree>},
111 If{
112 condition: Box<AlephTree>,
113 then: Box<AlephTree>,
114 #[serde(alias="else")]
115 els: Box<AlephTree>
116 },
117 While{
118 #[serde(alias="initExpr")]
119 init_expr: Box<AlephTree>,
120 condition: Box<AlephTree>,
121 #[serde(alias="loopExpr")]
122 loop_expr: Box<AlephTree>,
123 #[serde(alias="postExpr")]
124 post_expr: Box<AlephTree>
125 },
126 For{
127 var: String,
128 start: Box<AlephTree>,
129 end: Box<AlephTree>,
130 step: Option<Box<AlephTree>>,
131 body: Box<AlephTree>,
132 reverse: bool
133 },
134 Loop{
135 name: Option<String>,
136 body: Vec<Box<AlephTree>>
137 },
138 DoLoop{
139 #[serde(alias="loopVar")]
140 loop_var: Option<String>,
141 #[serde(alias="startIndex")]
142 start: Option<Box<AlephTree>>,
143 #[serde(alias="endIndex")]
144 end: Option<Box<AlephTree>>,
145 by: Option<Box<AlephTree>>,
146 #[serde(alias="whileCond")]
147 while_cond: Option<Box<AlephTree>>,
148 #[serde(alias="untilCond")]
149 until_cond: Option<Box<AlephTree>>,
150 body: Vec<Box<AlephTree>>
151 },
152 Case{
153 expr: Box<AlephTree>,
154 #[serde(alias="caseList", alias="whenClauses", alias="alternatives", alias="ofClauses")]
155 cases: Vec<Box<AlephTree>>,
156 #[serde(alias="whenOther", alias="otherwise", alias="default")]
157 default_case: Option<Box<AlephTree>>
158 },
159 CaseBranch{
160 #[serde(alias="condition", alias="selectionObject", alias="choices", alias="value")]
161 pattern: Box<AlephTree>,
162 #[serde(alias="caseExpr", alias="body", alias="statements")]
163 body: Vec<Box<AlephTree>>
164 },
165 Match{
166 expr: Box<AlephTree>,
167 #[serde(alias="caseList")]
168 case_list: Vec<Box<AlephTree>>
169 },
170 MatchLine{
171 condition: Box<AlephTree>,
172 #[serde(alias="caseExpr")]
173 case_expr: Box<AlephTree>
174 },
175 ProcedureDef{
176 name: String,
177 #[serde(alias="procedureType")]
178 proc_type: Option<String>,
179 parameters: Vec<Box<AlephTree>>,
180 #[serde(alias="returnType")]
181 return_type: Option<Box<AlephTree>>,
182 attributes: Vec<String>,
183 declarations: Vec<Box<AlephTree>>,
184 body: Vec<Box<AlephTree>>
185 },
186 Parameter{
187 name: String,
188 #[serde(alias="paramType", alias="param_type")]
189 param_type: Option<Box<AlephTree>>,
190 mode: Option<String>,
191 default: Option<Box<AlephTree>>
192 },
193 VarDecl{
194 name: String,
195 #[serde(alias="levelNumber")]
196 level: Option<String>,
197 #[serde(alias="varType", alias="var_type", alias="objectType", alias="picture")]
198 var_type: Option<Box<AlephTree>>,
199 #[serde(alias="initialValue", alias="initial_value")]
200 initial_value: Option<Box<AlephTree>>,
201 #[serde(alias="isConstant", alias="is_constant")]
202 is_constant: bool,
203 #[serde(alias="isAliased", alias="is_aliased")]
204 is_aliased: bool,
205 storage: Option<String>,
206 #[serde(alias="occursClause")]
207 occurs: Option<String>,
208 usage: Option<String>,
209 attributes: Vec<String>
210 },
211 StructDecl{
212 name: String,
213 #[serde(alias="levelNumber")]
214 level: Option<String>,
215 members: Vec<Box<AlephTree>>,
216 attributes: Vec<String>
217 },
218 TypeDecl{
219 name: String,
220 definition: Box<AlephTree>,
221 attributes: Vec<String>
222 },
223 Let{
224 var: String,
225 #[serde(alias="isPointer")]
226 is_pointer: String,
227 value: Box<AlephTree>,
228 expr: Box<AlephTree>
229 },
230 LetRec{
231 name: String,
232 args: Vec<Box<AlephTree>>,
233 body: Box<AlephTree>
234 },
235 Var{
236 var: String,
237 #[serde(alias="isPointer")]
238 is_pointer: String
239 },
240 TypeRef{
241 name: String,
242 #[serde(alias="qualifierList")]
243 qualifiers: Vec<String>
244 },
245 ArrayType{
246 #[serde(alias="elementType")]
247 element_type: Box<AlephTree>,
248 dimensions: Vec<Box<AlephTree>>
249 },
250 PointerType{
251 #[serde(alias="targetType")]
252 target_type: Box<AlephTree>,
253 #[serde(alias="isAllAccess")]
254 is_all: bool
255 },
256 RangeType{
257 start: Box<AlephTree>,
258 end: Box<AlephTree>
259 },
260 EnumType{
261 values: Vec<String>
262 },
263 RecordType{
264 fields: Vec<Box<AlephTree>>
265 },
266 FieldDecl{
267 name: String,
268 #[serde(alias="fieldType")]
269 field_type: Box<AlephTree>,
270 attributes: Vec<String>
271 },
272 SubtypeDecl{
273 name: String,
274 #[serde(alias="baseType")]
275 base_type: Box<AlephTree>,
276 constraint: Option<Box<AlephTree>>
277 },
278 Get{
279 #[serde(alias="arrayName")]
280 array_name: String,
281 elem: Box<AlephTree>
282 },
283 Put{
284 #[serde(alias="arrayName")]
285 array_name: String,
286 elem: Box<AlephTree>,
287 value: Box<AlephTree>,
288 insert: String
289 },
290 Remove{
291 #[serde(alias="arrayName")]
292 array_name: String,
293 elem: Box<AlephTree>,
294 #[serde(alias="isValue")]
295 is_value: String
296 },
297 Length{var: String},
298 Slice{
299 array: Box<AlephTree>,
300 start: Option<Box<AlephTree>>,
301 end: Option<Box<AlephTree>>
302 },
303 Alloc{
304 var: Box<AlephTree>,
305 #[serde(alias="setPointer", alias="typeOrExpr")]
306 target: Option<Box<AlephTree>>
307 },
308 Free{
309 var: Box<AlephTree>
310 },
311 Fetch{
312 addr: Box<AlephTree>,
313 #[serde(alias="fetchType")]
314 fetch_type: Option<String>
315 },
316 Store{
317 value: Box<AlephTree>,
318 addr: Box<AlephTree>,
319 #[serde(alias="storeType")]
320 store_type: Option<String>
321 },
322 StoreOp{
323 value: Box<AlephTree>,
324 addr: Box<AlephTree>,
325 op: String
326 },
327 App{
328 #[serde(alias="objectName")]
329 object_name: String,
330 fun: Box<AlephTree>,
331 #[serde(alias="paramList")]
332 param_list: Vec<Box<AlephTree>>
333 },
334 Call{
335 #[serde(alias="programName", alias="entryName")]
336 target: Box<AlephTree>,
337 #[serde(alias="usingParameters")]
338 parameters: Option<Vec<Box<AlephTree>>>,
339 #[serde(alias="givingParameter")]
340 returning: Option<Box<AlephTree>>,
341 #[serde(alias="onException")]
342 on_error: Option<Box<AlephTree>>
343 },
344 Stmts{expr1: Box<AlephTree>, expr2: Box<AlephTree>},
345 Block{statements: Vec<Box<AlephTree>>},
346 Assignment{target: Box<AlephTree>, value: Box<AlephTree>},
347 #[serde(alias="Return")]
348 Return{value: Box<AlephTree>},
349 GoTo{
350 #[serde(alias="targetParagraph", alias="target")]
351 target: String,
352 #[serde(alias="dependingOn")]
353 depending_on: Option<Box<AlephTree>>
354 },
355 Label{
356 name: String,
357 #[serde(alias="labelType")]
358 label_type: Option<String>
359 },
360 Exit,
361 Move{
362 source: Box<AlephTree>,
363 #[serde(alias="targetList")]
364 targets: Vec<Box<AlephTree>>
365 },
366 Compute{
367 target: Box<AlephTree>,
368 expression: Box<AlephTree>,
369 #[serde(alias="onSizeError")]
370 on_error: Option<Box<AlephTree>>
371 },
372 Print{
373 #[serde(alias="itemList", alias="items")]
374 items: Vec<Box<AlephTree>>,
375 #[serde(alias="uponDevice", alias="toFile")]
376 destination: Option<String>,
377 #[serde(alias="formatItems")]
378 format: Option<Vec<Box<AlephTree>>>,
379 options: Vec<String>
380 },
381 Input{
382 #[serde(alias="target", alias="variables")]
383 targets: Vec<Box<AlephTree>>,
384 #[serde(alias="fromDevice", alias="fromFile")]
385 source: Option<String>,
386 options: Vec<String>
387 },
388 FileOpen{
389 #[serde(alias="fileName", alias="file")]
390 file: String,
391 mode: String,
392 attributes: Vec<String>
393 },
394 FileClose{
395 #[serde(alias="fileList", alias="files")]
396 files: Vec<String>
397 },
398 FileRead{
399 #[serde(alias="fileName")]
400 file_name: String,
401 #[serde(alias="intoClause")]
402 into: Option<Box<AlephTree>>,
403 #[serde(alias="keyClause")]
404 key: Option<Box<AlephTree>>,
405 #[serde(alias="atEndClause", alias="onEnd")]
406 on_end: Option<Box<AlephTree>>,
407 #[serde(alias="notAtEndClause")]
408 not_on_end: Option<Box<AlephTree>>
409 },
410 FileWrite{
411 #[serde(alias="recordName")]
412 record_name: String,
413 #[serde(alias="fromClause")]
414 from: Option<Box<AlephTree>>,
415 #[serde(alias="advancingClause")]
416 options: Vec<String>
417 },
418 FileConfig{
419 #[serde(alias="fileName")]
420 file_name: String,
421 #[serde(alias="assignTo")]
422 assign_to: Option<String>,
423 #[serde(alias="accessMode")]
424 access_mode: Option<String>,
425 #[serde(alias="organizationMode")]
426 organization_mode: Option<String>,
427 #[serde(alias="recordDescription")]
428 record_description: Option<Vec<Box<AlephTree>>>,
429 #[serde(alias="blockContains")]
430 block_contains: Option<String>,
431 #[serde(alias="recordContains")]
432 record_contains: Option<String>
433 },
434 StringOp{
435 operation: String,
436 #[serde(alias="sourceItems", alias="sourceItem")]
437 sources: Vec<Box<AlephTree>>,
438 #[serde(alias="delimitedBy")]
439 delimiter: Option<Box<AlephTree>>,
440 #[serde(alias="intoItem", alias="intoItems")]
441 targets: Vec<Box<AlephTree>>,
442 #[serde(alias="withPointer")]
443 pointer: Option<Box<AlephTree>>,
444 #[serde(alias="onOverflow", alias="tallyingClause", alias="replacingClause")]
445 clauses: Vec<Box<AlephTree>>
446 },
447 #[serde(alias="Import")]
448 Iprt{
449 name: String,
450 items: Vec<String>
451 },
452 Export{
453 items: Vec<Box<AlephTree>>,
454 #[serde(alias="exportType")]
455 export_type: Option<String>
456 },
457 Module{
458 name: String,
459 #[serde(alias="moduleType")]
460 module_type: String,
461 #[serde(alias="programId")]
462 id: Option<String>,
463 declarations: Vec<Box<AlephTree>>,
464 body: Option<Vec<Box<AlephTree>>>,
465 initialization: Option<Vec<Box<AlephTree>>>
466 },
467 Division{
468 #[serde(alias="divisionType")]
469 division_type: String,
470 sections: Vec<Box<AlephTree>>
471 },
472 Section{
473 name: String,
474 #[serde(alias="sectionType")]
475 section_type: Option<String>,
476 content: Vec<Box<AlephTree>>
477 },
478 #[serde(alias="Class")]
479 Clss{
480 name: String,
481 #[serde(alias="attributList")]
482 attribute_list: Vec<String>,
483 #[serde(alias="extends")]
484 extends: Option<Box<AlephTree>>,
485 #[serde(alias="implements")]
486 implements: Vec<Box<AlephTree>>,
487 body: Box<AlephTree>
488 },
489 New{
490 constructor: Box<AlephTree>,
491 args: Vec<Box<AlephTree>>
492 },
493 This,
494 Super{
495 #[serde(alias="memberAccess")]
496 member: Option<String>
497 },
498 Member{
499 object: Box<AlephTree>,
500 member: String,
501 #[serde(alias="isOptional")]
502 is_optional: bool
503 },
504 Spread{
505 expr: Box<AlephTree>,
506 #[serde(alias="spreadType")]
507 spread_type: String
508 },
509 Destructure{
510 pattern: Box<AlephTree>,
511 value: Box<AlephTree>,
512 #[serde(alias="destructureType")]
513 destructure_type: String
514 },
515 TryCatch{
516 #[serde(alias="tryBlock")]
517 try_block: Box<AlephTree>,
518 #[serde(alias="catchClauses", alias="handlers")]
519 catch_clauses: Vec<Box<AlephTree>>,
520 #[serde(alias="finallyBlock")]
521 finally_block: Option<Box<AlephTree>>
522 },
523 CatchClause{
524 #[serde(alias="exceptionType", alias="exceptionChoices")]
525 exception_types: Vec<String>,
526 var: Option<String>,
527 body: Box<AlephTree>
528 },
529 OnCondition{
530 condition: String,
531 #[serde(alias="snapOption")]
532 options: Vec<String>,
533 handler: Box<AlephTree>
534 },
535 Raise{
536 #[serde(alias="exception")]
537 condition: Box<AlephTree>
538 },
539 Signal{
540 condition: String
541 },
542 Revert{
543 condition: String
544 },
545 ExceptionDecl{
546 name: String
547 },
548 #[serde(alias="Comment")]
549 Comment{value: String},
550 #[serde(alias="CommentMulti")]
551 CommentMulti{value: String},
552 Assert{
553 condition: Box<AlephTree>,
554 message: Box<AlephTree>
555 },
556 Generic{
557 name: String,
558 #[serde(alias="genericType")]
559 generic_type: String,
560 #[serde(alias="genericParams")]
561 generic_params: Vec<Box<AlephTree>>,
562 body: Box<AlephTree>
563 },
564 GenericParam{
565 name: String,
566 #[serde(alias="paramKind")]
567 param_kind: String,
568 constraint: Option<Box<AlephTree>>,
569 default: Option<Box<AlephTree>>
570 },
571 Instantiation{
572 name: String,
573 #[serde(alias="genericName")]
574 generic_name: String,
575 #[serde(alias="actualParams")]
576 actual_params: Vec<Box<AlephTree>>
577 },
578 Attribute{
579 prefix: Box<AlephTree>,
580 attribute: String,
581 args: Option<Vec<Box<AlephTree>>>
582 },
583 Pragma{
584 name: String,
585 args: Vec<Box<AlephTree>>
586 },
587 RepresentationClause{
588 name: String,
589 #[serde(alias="clauseType")]
590 clause_type: String,
591 specification: Box<AlephTree>
592 },
593 Renaming{
594 #[serde(alias="newName")]
595 new_name: String,
596 #[serde(alias="renamedEntity", alias="redefinedItem")]
597 old_name: Box<AlephTree>,
598 #[serde(alias="entityType")]
599 rename_type: Option<Box<AlephTree>>
600 },
601 Execute{
602 target: Box<AlephTree>,
603 #[serde(alias="executionType")]
604 exec_type: Option<String>
605 },
606 Perform{
607 #[serde(alias="targetParagraph")]
608 target: Option<String>,
609 #[serde(alias="fromParagraph")]
610 from: Option<String>,
611 #[serde(alias="throughParagraph")]
612 through: Option<String>,
613 #[serde(alias="timesClause")]
614 times: Option<Box<AlephTree>>,
615 #[serde(alias="untilClause")]
616 until: Option<Box<AlephTree>>,
617 #[serde(alias="varyingClause")]
618 varying: Option<Box<AlephTree>>,
619 #[serde(alias="inlineStatements")]
620 inline: Option<Vec<Box<AlephTree>>>
621 },
622 StackOp{
623 operation: String,
624 #[serde(alias="operands")]
625 args: Vec<Box<AlephTree>>
626 },
627 TaskType{
628 name: String,
629 #[serde(alias="discriminants")]
630 parameters: Option<Vec<Box<AlephTree>>>,
631 entries: Vec<Box<AlephTree>>,
632 body: Vec<Box<AlephTree>>
633 },
634 ProtectedType{
635 name: String,
636 #[serde(alias="discriminants")]
637 parameters: Option<Vec<Box<AlephTree>>>,
638 declarations: Vec<Box<AlephTree>>
639 },
640 ProtectedBody{
641 name: String,
642 bodies: Vec<Box<AlephTree>>
643 },
644 Accept{
645 #[serde(alias="entryName")]
646 entry_name: String,
647 parameters: Option<Vec<Box<AlephTree>>>,
648 body: Option<Vec<Box<AlephTree>>>
649 },
650 Select{
651 alternatives: Vec<Box<AlephTree>>,
652 #[serde(alias="elseClause")]
653 else_clause: Option<Vec<Box<AlephTree>>>
654 },
655 SelectiveAccept{
656 #[serde(alias="guardCondition")]
657 guard_condition: Option<Box<AlephTree>>,
658 #[serde(alias="acceptStmt")]
659 accept_stmt: Box<AlephTree>,
660 statements: Vec<Box<AlephTree>>
661 },
662 Delay{
663 #[serde(alias="delayType")]
664 delay_type: String,
665 expression: Box<AlephTree>
666 },
667 Abort{
668 targets: Vec<String>
669 },
670 Aggregate{
671 components: Vec<Box<AlephTree>>
672 },
673 ComponentAssoc{
674 choices: Option<Vec<Box<AlephTree>>>,
675 expression: Box<AlephTree>
676 },
677 Qualified{
678 #[serde(alias="typeName")]
679 type_name: Box<AlephTree>,
680 expression: Box<AlephTree>
681 },
682 MemoryOp{
683 operation: String,
684 #[serde(alias="operands")]
685 args: Vec<Box<AlephTree>>
686 },
687 DataOp{
688 operation: String,
689 value: Box<AlephTree>
690 },
691 Emit{
692 #[serde(alias="content")]
693 value: Box<AlephTree>,
694 #[serde(alias="emitType")]
695 emit_type: Option<String>
696 },
697 Immediate,
698 Recursive,
699 Forget{
700 target: String
701 },
702 Postpone{
703 word: String
704 },
705 Literal{
706 value: Box<AlephTree>
707 },
708 CompileTime{
709 expression: Box<AlephTree>
710 },
711 CreateDoes{
712 name: String,
713 #[serde(alias="allotSize")]
714 allot_size: Option<Box<AlephTree>>,
715 #[serde(alias="doesBody")]
716 does_body: Option<Vec<Box<AlephTree>>>
717 },
718 Introspect{
719 operation: String,
720 target: Option<String>
721 },
722 Convert{
723 value: Box<AlephTree>,
724 #[serde(alias="fromType")]
725 from_type: String,
726 #[serde(alias="toType")]
727 to_type: String
728 },
729 Await{
730 expr: Box<AlephTree>
731 },
732 Async{
733 body: Box<AlephTree>
734 },
735 Yield{
736 value: Option<Box<AlephTree>>
737 },
738 Typeof{
739 expr: Box<AlephTree>
740 },
741 Instanceof{
742 expr: Box<AlephTree>,
743 type_expr: Box<AlephTree>
744 },
745 Nullish{
746 expr: Box<AlephTree>,
747 default: Box<AlephTree>
748 },
749 Optional{
750 base: Box<AlephTree>,
751 #[serde(alias="optionalType")]
752 optional_type: String
753 },
754 Decorator{
755 name: String,
756 args: Vec<Box<AlephTree>>,
757 target: Box<AlephTree>
758 },
759 TableOp{
760 operation: String,
761 table: Box<AlephTree>,
762 index: Option<Box<AlephTree>>,
763 value: Option<Box<AlephTree>>
764 },
765 Global{
766 name: String,
767 #[serde(alias="globalType")]
768 global_type: Box<AlephTree>,
769 mutable: bool,
770 #[serde(alias="initialValue")]
771 initial_value: Option<Box<AlephTree>>
772 },
773 Local{
774 name: String,
775 #[serde(alias="localType")]
776 local_type: Box<AlephTree>
777 },
778 Br{
779 depth: Box<AlephTree>,
780 condition: Option<Box<AlephTree>>
781 },
782 Unreachable,
783 Nop,
784 UnionType{
785 variants: Vec<Box<AlephTree>>
786 },
787 Trait{
788 name: String,
789 #[serde(alias="typeParams")]
790 type_params: Vec<Box<AlephTree>>,
791 #[serde(alias="superTraits")]
792 super_traits: Vec<Box<AlephTree>>,
793 items: Vec<Box<AlephTree>>
794 },
795 Impl{
796 trait_ref: Option<Box<AlephTree>>,
797 #[serde(alias="forType")]
798 for_type: Box<AlephTree>,
799 items: Vec<Box<AlephTree>>
800 },
801 Channel{
802 name: String,
803 #[serde(alias="channelType")]
804 channel_type: Box<AlephTree>,
805 capacity: Option<Box<AlephTree>>
806 },
807 Send{
808 channel: Box<AlephTree>,
809 value: Box<AlephTree>
810 },
811 Receive{
812 channel: Box<AlephTree>,
813 timeout: Option<Box<AlephTree>>
814 },
815 Spawn{
816 target: Box<AlephTree>,
817 args: Vec<Box<AlephTree>>
818 },
819 Macro{
820 name: String,
821 parameters: Vec<Box<AlephTree>>,
822 body: Box<AlephTree>,
823 #[serde(alias="macroType")]
824 macro_type: Option<String>
825 },
826 MacroInvoke{
827 name: String,
828 args: Vec<Box<AlephTree>>
829 },
830 Pipe{
831 expr: Box<AlephTree>,
832 operations: Vec<Box<AlephTree>>
833 },
834 Comprehension{
835 #[serde(alias="compType")]
836 comp_type: String,
837 expr: Box<AlephTree>,
838 clauses: Vec<Box<AlephTree>>
839 },
840 CompClause{
841 #[serde(alias="clauseType")]
842 clause_type: String,
843 pattern: Option<Box<AlephTree>>,
844 iter: Option<Box<AlephTree>>,
845 condition: Option<Box<AlephTree>>
846 },
847 With{
848 resources: Vec<Box<AlephTree>>,
849 body: Box<AlephTree>
850 },
851 Query{
852 #[serde(alias="queryType")]
853 query_type: String,
854 #[serde(alias="selectClause")]
855 select: Option<Box<AlephTree>>,
856 #[serde(alias="fromClause")]
857 from: Option<Vec<Box<AlephTree>>>,
858 #[serde(alias="whereClause")]
859 where_clause: Option<Box<AlephTree>>,
860 #[serde(alias="joinClauses")]
861 joins: Vec<Box<AlephTree>>,
862 #[serde(alias="groupByClause")]
863 group_by: Option<Vec<Box<AlephTree>>>,
864 #[serde(alias="havingClause")]
865 having: Option<Box<AlephTree>>,
866 #[serde(alias="orderByClause")]
867 order_by: Option<Vec<Box<AlephTree>>>,
868 limit: Option<Box<AlephTree>>,
869 offset: Option<Box<AlephTree>>
870 },
871 Join{
872 #[serde(alias="joinType")]
873 join_type: String,
874 source: Box<AlephTree>,
875 condition: Box<AlephTree>
876 },
877 Constraint{
878 #[serde(alias="constraintType")]
879 constraint_type: String,
880 expressions: Vec<Box<AlephTree>>
881 },
882 Clause{
883 head: Box<AlephTree>,
884 body: Vec<Box<AlephTree>>
885 },
886 Unify{
887 expr1: Box<AlephTree>,
888 expr2: Box<AlephTree>
889 },
890 Lifetime{
891 name: String,
892 constraint: Option<Box<AlephTree>>
893 },
894 Borrow{
895 expr: Box<AlephTree>,
896 mutable: bool,
897 lifetime: Option<String>
898 },
899 Unsafe{
900 body: Box<AlephTree>
901 },
902}
903
904pub fn json_parse(source: String) -> AlephTree {
905 serde_json::from_str(&source).unwrap()
906}
907
908pub fn to_json(ast: AlephTree) -> String {
909 serde_json::to_string_pretty(&ast).unwrap()
910}
911
912impl FromIterator<AlephTree> for Vec<Box<AlephTree>> {
913 fn from_iter<I: IntoIterator<Item=AlephTree>>(iter : I) -> Self {
914 let mut result: Vec<Box<AlephTree>> = Vec::new();
915 for node in iter {
916 result.push(Box::new(node));
917 }
918 result
919 }
920}
921
922impl fmt::Display for AlephTree {
923 fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
924 match self {
925 e => write!(f, "{:?}", e),
926 }
927 }
928}
929
930impl AlephTree {
931 pub fn to_string_value(&self) -> String {
932 match self {
933 AlephTree::Bool { value } => value.to_string(),
934 AlephTree::Int { value } => value.to_string(),
935 AlephTree::Float { value } => value.to_string(),
936 AlephTree::String { value } => value.to_string(),
937 AlephTree::Ident { value } => value.to_string(),
938 AlephTree::Bytes { elems } => match std::str::from_utf8(elems) {
939 Ok(s) => s.to_string(),
940 Err(e) => panic!("Invalid UTF-8 sequence: {}", e),
941 },
942 AlephTree::Figurative { figurative_type } => figurative_type.to_string(),
943 AlephTree::HexLiteral { value } => value.to_string(),
944 _ => {
945 println!("Can't evaluate to_string_value : {}", self);
946 panic!()
947 }
948 }
949 }
950}