OILS / _devbuild / gen / yaks_asdl.py View on Github | oilshell.org

2259 lines, 1642 significant
1from asdl import pybase
2from mycpp import mops
3from typing import Optional, List, Tuple, Dict, Any, cast, TYPE_CHECKING
4
5
6from asdl import runtime # For runtime.NO_SPID
7from asdl.runtime import NewRecord, NewLeaf, TraversalState
8from _devbuild.gen.hnode_asdl import color_e, hnode, hnode_e, hnode_t, Field
9
10class op_t(pybase.SimpleObj):
11 pass
12
13class op_e(object):
14 Plus = op_t(1)
15 Minus = op_t(2)
16
17_op_str = {
18 1: 'op.Plus',
19 2: 'op.Minus',
20}
21
22def op_str(val):
23 # type: (op_t) -> str
24 return _op_str[val]
25
26class kexpr_e(object):
27 Bool = 65
28 Int = 66
29 Str = 67
30 MultiStr = 68
31 Unary = 5
32 Binary = 6
33 Ternary = 7
34 Call = 8
35
36_kexpr_str = {
37 5: 'Unary',
38 6: 'Binary',
39 7: 'Ternary',
40 8: 'Call',
41 65: 'Bool',
42 66: 'Int',
43 67: 'Str',
44 68: 'MultiStr',
45}
46
47def kexpr_str(tag, dot=True):
48 # type: (int, bool) -> str
49 v = _kexpr_str[tag]
50 if dot:
51 return "kexpr.%s" % v
52 else:
53 return v
54
55class kexpr_t(pybase.CompoundObj):
56 def tag(self):
57 # type: () -> int
58 return self._type_tag
59 pass
60
61class kexpr(object):
62 class Unary(kexpr_t):
63 _type_tag = 5
64 __slots__ = ('op', 'child')
65
66 def __init__(self, op, child):
67 # type: (Token, kexpr_t) -> None
68 self.op = op
69 self.child = child
70
71 @staticmethod
72 def CreateNull(alloc_lists=False):
73 # type: () -> kexpr.Unary
74 return kexpr.Unary(cast(Token, None), cast(kexpr_t, None))
75
76 def PrettyTree(self, trav=None):
77 # type: (Optional[TraversalState]) -> hnode_t
78 trav = trav or TraversalState()
79 heap_id = id(self)
80 if heap_id in trav.seen:
81 return hnode.AlreadySeen(heap_id)
82 trav.seen[heap_id] = True
83 out_node = NewRecord('kexpr.Unary')
84 L = out_node.fields
85
86 assert self.op is not None
87 x0 = self.op.PrettyTree(trav=trav)
88 L.append(Field('op', x0))
89
90 assert self.child is not None
91 x1 = self.child.PrettyTree(trav=trav)
92 L.append(Field('child', x1))
93
94 return out_node
95
96 def _AbbreviatedTree(self, trav=None):
97 # type: (Optional[TraversalState]) -> hnode_t
98 trav = trav or TraversalState()
99 heap_id = id(self)
100 if heap_id in trav.seen:
101 return hnode.AlreadySeen(heap_id)
102 trav.seen[heap_id] = True
103 out_node = NewRecord('kexpr.Unary')
104 L = out_node.fields
105 assert self.op is not None
106 x0 = self.op.AbbreviatedTree(trav=trav)
107 L.append(Field('op', x0))
108
109 assert self.child is not None
110 x1 = self.child.AbbreviatedTree(trav=trav)
111 L.append(Field('child', x1))
112
113 return out_node
114
115 def AbbreviatedTree(self, trav=None):
116 # type: (Optional[TraversalState]) -> hnode_t
117 return self._AbbreviatedTree(trav=trav)
118
119 class Binary(kexpr_t):
120 _type_tag = 6
121 __slots__ = ('op', 'left', 'right')
122
123 def __init__(self, op, left, right):
124 # type: (Token, kexpr_t, kexpr_t) -> None
125 self.op = op
126 self.left = left
127 self.right = right
128
129 @staticmethod
130 def CreateNull(alloc_lists=False):
131 # type: () -> kexpr.Binary
132 return kexpr.Binary(cast(Token, None), cast(kexpr_t, None), cast(kexpr_t, None))
133
134 def PrettyTree(self, trav=None):
135 # type: (Optional[TraversalState]) -> hnode_t
136 trav = trav or TraversalState()
137 heap_id = id(self)
138 if heap_id in trav.seen:
139 return hnode.AlreadySeen(heap_id)
140 trav.seen[heap_id] = True
141 out_node = NewRecord('kexpr.Binary')
142 L = out_node.fields
143
144 assert self.op is not None
145 x0 = self.op.PrettyTree(trav=trav)
146 L.append(Field('op', x0))
147
148 assert self.left is not None
149 x1 = self.left.PrettyTree(trav=trav)
150 L.append(Field('left', x1))
151
152 assert self.right is not None
153 x2 = self.right.PrettyTree(trav=trav)
154 L.append(Field('right', x2))
155
156 return out_node
157
158 def _AbbreviatedTree(self, trav=None):
159 # type: (Optional[TraversalState]) -> hnode_t
160 trav = trav or TraversalState()
161 heap_id = id(self)
162 if heap_id in trav.seen:
163 return hnode.AlreadySeen(heap_id)
164 trav.seen[heap_id] = True
165 out_node = NewRecord('kexpr.Binary')
166 L = out_node.fields
167 assert self.op is not None
168 x0 = self.op.AbbreviatedTree(trav=trav)
169 L.append(Field('op', x0))
170
171 assert self.left is not None
172 x1 = self.left.AbbreviatedTree(trav=trav)
173 L.append(Field('left', x1))
174
175 assert self.right is not None
176 x2 = self.right.AbbreviatedTree(trav=trav)
177 L.append(Field('right', x2))
178
179 return out_node
180
181 def AbbreviatedTree(self, trav=None):
182 # type: (Optional[TraversalState]) -> hnode_t
183 return self._AbbreviatedTree(trav=trav)
184
185 class Ternary(kexpr_t):
186 _type_tag = 7
187 __slots__ = ('op', 'left', 'cond', 'right')
188
189 def __init__(self, op, left, cond, right):
190 # type: (Token, kexpr_t, kexpr_t, kexpr_t) -> None
191 self.op = op
192 self.left = left
193 self.cond = cond
194 self.right = right
195
196 @staticmethod
197 def CreateNull(alloc_lists=False):
198 # type: () -> kexpr.Ternary
199 return kexpr.Ternary(cast(Token, None), cast(kexpr_t, None), cast(kexpr_t, None), cast(kexpr_t, None))
200
201 def PrettyTree(self, trav=None):
202 # type: (Optional[TraversalState]) -> hnode_t
203 trav = trav or TraversalState()
204 heap_id = id(self)
205 if heap_id in trav.seen:
206 return hnode.AlreadySeen(heap_id)
207 trav.seen[heap_id] = True
208 out_node = NewRecord('kexpr.Ternary')
209 L = out_node.fields
210
211 assert self.op is not None
212 x0 = self.op.PrettyTree(trav=trav)
213 L.append(Field('op', x0))
214
215 assert self.left is not None
216 x1 = self.left.PrettyTree(trav=trav)
217 L.append(Field('left', x1))
218
219 assert self.cond is not None
220 x2 = self.cond.PrettyTree(trav=trav)
221 L.append(Field('cond', x2))
222
223 assert self.right is not None
224 x3 = self.right.PrettyTree(trav=trav)
225 L.append(Field('right', x3))
226
227 return out_node
228
229 def _AbbreviatedTree(self, trav=None):
230 # type: (Optional[TraversalState]) -> hnode_t
231 trav = trav or TraversalState()
232 heap_id = id(self)
233 if heap_id in trav.seen:
234 return hnode.AlreadySeen(heap_id)
235 trav.seen[heap_id] = True
236 out_node = NewRecord('kexpr.Ternary')
237 L = out_node.fields
238 assert self.op is not None
239 x0 = self.op.AbbreviatedTree(trav=trav)
240 L.append(Field('op', x0))
241
242 assert self.left is not None
243 x1 = self.left.AbbreviatedTree(trav=trav)
244 L.append(Field('left', x1))
245
246 assert self.cond is not None
247 x2 = self.cond.AbbreviatedTree(trav=trav)
248 L.append(Field('cond', x2))
249
250 assert self.right is not None
251 x3 = self.right.AbbreviatedTree(trav=trav)
252 L.append(Field('right', x3))
253
254 return out_node
255
256 def AbbreviatedTree(self, trav=None):
257 # type: (Optional[TraversalState]) -> hnode_t
258 return self._AbbreviatedTree(trav=trav)
259
260 class Call(kexpr_t):
261 _type_tag = 8
262 __slots__ = ('f', 'args')
263
264 def __init__(self, f, args):
265 # type: (kexpr_t, List[kexpr_t]) -> None
266 self.f = f
267 self.args = args
268
269 @staticmethod
270 def CreateNull(alloc_lists=False):
271 # type: () -> kexpr.Call
272 return kexpr.Call(cast(kexpr_t, None), [] if alloc_lists else cast('List[kexpr_t]', None))
273
274 def PrettyTree(self, trav=None):
275 # type: (Optional[TraversalState]) -> hnode_t
276 trav = trav or TraversalState()
277 heap_id = id(self)
278 if heap_id in trav.seen:
279 return hnode.AlreadySeen(heap_id)
280 trav.seen[heap_id] = True
281 out_node = NewRecord('kexpr.Call')
282 L = out_node.fields
283
284 assert self.f is not None
285 x0 = self.f.PrettyTree(trav=trav)
286 L.append(Field('f', x0))
287
288 if self.args is not None: # List
289 x1 = hnode.Array([])
290 for i1 in self.args:
291 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
292 i1.PrettyTree(trav=trav))
293 x1.children.append(h)
294 L.append(Field('args', x1))
295
296 return out_node
297
298 def _AbbreviatedTree(self, trav=None):
299 # type: (Optional[TraversalState]) -> hnode_t
300 trav = trav or TraversalState()
301 heap_id = id(self)
302 if heap_id in trav.seen:
303 return hnode.AlreadySeen(heap_id)
304 trav.seen[heap_id] = True
305 out_node = NewRecord('kexpr.Call')
306 L = out_node.fields
307 assert self.f is not None
308 x0 = self.f.AbbreviatedTree(trav=trav)
309 L.append(Field('f', x0))
310
311 if self.args is not None: # List
312 x1 = hnode.Array([])
313 for i1 in self.args:
314 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
315 i1.AbbreviatedTree(trav=trav))
316 x1.children.append(h)
317 L.append(Field('args', x1))
318
319 return out_node
320
321 def AbbreviatedTree(self, trav=None):
322 # type: (Optional[TraversalState]) -> hnode_t
323 return self._AbbreviatedTree(trav=trav)
324
325 pass
326
327class ktype_e(object):
328 Bool = 1
329 Int = 2
330 Str = 3
331 List = 4
332 Dict = 5
333 Class = 6
334 Data = 7
335 Enum = 8
336
337_ktype_str = {
338 1: 'Bool',
339 2: 'Int',
340 3: 'Str',
341 4: 'List',
342 5: 'Dict',
343 6: 'Class',
344 7: 'Data',
345 8: 'Enum',
346}
347
348def ktype_str(tag, dot=True):
349 # type: (int, bool) -> str
350 v = _ktype_str[tag]
351 if dot:
352 return "ktype.%s" % v
353 else:
354 return v
355
356class ktype_t(pybase.CompoundObj):
357 def tag(self):
358 # type: () -> int
359 return self._type_tag
360 pass
361
362class ktype__Bool(ktype_t):
363 _type_tag = 1
364 __slots__ = ()
365
366 def __init__(self, ):
367 # type: () -> None
368 pass
369
370 def PrettyTree(self, trav=None):
371 # type: (Optional[TraversalState]) -> hnode_t
372 trav = trav or TraversalState()
373 heap_id = id(self)
374 if heap_id in trav.seen:
375 return hnode.AlreadySeen(heap_id)
376 trav.seen[heap_id] = True
377 out_node = NewRecord('ktype__Bool')
378 L = out_node.fields
379
380 return out_node
381
382 def _AbbreviatedTree(self, trav=None):
383 # type: (Optional[TraversalState]) -> hnode_t
384 trav = trav or TraversalState()
385 heap_id = id(self)
386 if heap_id in trav.seen:
387 return hnode.AlreadySeen(heap_id)
388 trav.seen[heap_id] = True
389 out_node = NewRecord('ktype__Bool')
390 L = out_node.fields
391 return out_node
392
393 def AbbreviatedTree(self, trav=None):
394 # type: (Optional[TraversalState]) -> hnode_t
395 return self._AbbreviatedTree(trav=trav)
396
397class ktype__Int(ktype_t):
398 _type_tag = 2
399 __slots__ = ()
400
401 def __init__(self, ):
402 # type: () -> None
403 pass
404
405 def PrettyTree(self, trav=None):
406 # type: (Optional[TraversalState]) -> hnode_t
407 trav = trav or TraversalState()
408 heap_id = id(self)
409 if heap_id in trav.seen:
410 return hnode.AlreadySeen(heap_id)
411 trav.seen[heap_id] = True
412 out_node = NewRecord('ktype__Int')
413 L = out_node.fields
414
415 return out_node
416
417 def _AbbreviatedTree(self, trav=None):
418 # type: (Optional[TraversalState]) -> hnode_t
419 trav = trav or TraversalState()
420 heap_id = id(self)
421 if heap_id in trav.seen:
422 return hnode.AlreadySeen(heap_id)
423 trav.seen[heap_id] = True
424 out_node = NewRecord('ktype__Int')
425 L = out_node.fields
426 return out_node
427
428 def AbbreviatedTree(self, trav=None):
429 # type: (Optional[TraversalState]) -> hnode_t
430 return self._AbbreviatedTree(trav=trav)
431
432class ktype__Str(ktype_t):
433 _type_tag = 3
434 __slots__ = ()
435
436 def __init__(self, ):
437 # type: () -> None
438 pass
439
440 def PrettyTree(self, trav=None):
441 # type: (Optional[TraversalState]) -> hnode_t
442 trav = trav or TraversalState()
443 heap_id = id(self)
444 if heap_id in trav.seen:
445 return hnode.AlreadySeen(heap_id)
446 trav.seen[heap_id] = True
447 out_node = NewRecord('ktype__Str')
448 L = out_node.fields
449
450 return out_node
451
452 def _AbbreviatedTree(self, trav=None):
453 # type: (Optional[TraversalState]) -> hnode_t
454 trav = trav or TraversalState()
455 heap_id = id(self)
456 if heap_id in trav.seen:
457 return hnode.AlreadySeen(heap_id)
458 trav.seen[heap_id] = True
459 out_node = NewRecord('ktype__Str')
460 L = out_node.fields
461 return out_node
462
463 def AbbreviatedTree(self, trav=None):
464 # type: (Optional[TraversalState]) -> hnode_t
465 return self._AbbreviatedTree(trav=trav)
466
467class ktype(object):
468 Bool = ktype__Bool()
469
470 Int = ktype__Int()
471
472 Str = ktype__Str()
473
474 class List(ktype_t):
475 _type_tag = 4
476 __slots__ = ('T',)
477
478 def __init__(self, T):
479 # type: (ktype_t) -> None
480 self.T = T
481
482 @staticmethod
483 def CreateNull(alloc_lists=False):
484 # type: () -> ktype.List
485 return ktype.List(cast(ktype_t, None))
486
487 def PrettyTree(self, trav=None):
488 # type: (Optional[TraversalState]) -> hnode_t
489 trav = trav or TraversalState()
490 heap_id = id(self)
491 if heap_id in trav.seen:
492 return hnode.AlreadySeen(heap_id)
493 trav.seen[heap_id] = True
494 out_node = NewRecord('ktype.List')
495 L = out_node.fields
496
497 assert self.T is not None
498 x0 = self.T.PrettyTree(trav=trav)
499 L.append(Field('T', x0))
500
501 return out_node
502
503 def _AbbreviatedTree(self, trav=None):
504 # type: (Optional[TraversalState]) -> hnode_t
505 trav = trav or TraversalState()
506 heap_id = id(self)
507 if heap_id in trav.seen:
508 return hnode.AlreadySeen(heap_id)
509 trav.seen[heap_id] = True
510 out_node = NewRecord('ktype.List')
511 L = out_node.fields
512 assert self.T is not None
513 x0 = self.T.AbbreviatedTree(trav=trav)
514 L.append(Field('T', x0))
515
516 return out_node
517
518 def AbbreviatedTree(self, trav=None):
519 # type: (Optional[TraversalState]) -> hnode_t
520 return self._AbbreviatedTree(trav=trav)
521
522 class Dict(ktype_t):
523 _type_tag = 5
524 __slots__ = ('K', 'V')
525
526 def __init__(self, K, V):
527 # type: (ktype_t, ktype_t) -> None
528 self.K = K
529 self.V = V
530
531 @staticmethod
532 def CreateNull(alloc_lists=False):
533 # type: () -> ktype.Dict
534 return ktype.Dict(cast(ktype_t, None), cast(ktype_t, None))
535
536 def PrettyTree(self, trav=None):
537 # type: (Optional[TraversalState]) -> hnode_t
538 trav = trav or TraversalState()
539 heap_id = id(self)
540 if heap_id in trav.seen:
541 return hnode.AlreadySeen(heap_id)
542 trav.seen[heap_id] = True
543 out_node = NewRecord('ktype.Dict')
544 L = out_node.fields
545
546 assert self.K is not None
547 x0 = self.K.PrettyTree(trav=trav)
548 L.append(Field('K', x0))
549
550 assert self.V is not None
551 x1 = self.V.PrettyTree(trav=trav)
552 L.append(Field('V', x1))
553
554 return out_node
555
556 def _AbbreviatedTree(self, trav=None):
557 # type: (Optional[TraversalState]) -> hnode_t
558 trav = trav or TraversalState()
559 heap_id = id(self)
560 if heap_id in trav.seen:
561 return hnode.AlreadySeen(heap_id)
562 trav.seen[heap_id] = True
563 out_node = NewRecord('ktype.Dict')
564 L = out_node.fields
565 assert self.K is not None
566 x0 = self.K.AbbreviatedTree(trav=trav)
567 L.append(Field('K', x0))
568
569 assert self.V is not None
570 x1 = self.V.AbbreviatedTree(trav=trav)
571 L.append(Field('V', x1))
572
573 return out_node
574
575 def AbbreviatedTree(self, trav=None):
576 # type: (Optional[TraversalState]) -> hnode_t
577 return self._AbbreviatedTree(trav=trav)
578
579 class Class(ktype_t):
580 _type_tag = 6
581 __slots__ = ('name',)
582
583 def __init__(self, name):
584 # type: (str) -> None
585 self.name = name
586
587 @staticmethod
588 def CreateNull(alloc_lists=False):
589 # type: () -> ktype.Class
590 return ktype.Class('')
591
592 def PrettyTree(self, trav=None):
593 # type: (Optional[TraversalState]) -> hnode_t
594 trav = trav or TraversalState()
595 heap_id = id(self)
596 if heap_id in trav.seen:
597 return hnode.AlreadySeen(heap_id)
598 trav.seen[heap_id] = True
599 out_node = NewRecord('ktype.Class')
600 L = out_node.fields
601
602 x0 = NewLeaf(self.name, color_e.StringConst)
603 L.append(Field('name', x0))
604
605 return out_node
606
607 def _AbbreviatedTree(self, trav=None):
608 # type: (Optional[TraversalState]) -> hnode_t
609 trav = trav or TraversalState()
610 heap_id = id(self)
611 if heap_id in trav.seen:
612 return hnode.AlreadySeen(heap_id)
613 trav.seen[heap_id] = True
614 out_node = NewRecord('ktype.Class')
615 L = out_node.fields
616 x0 = NewLeaf(self.name, color_e.StringConst)
617 L.append(Field('name', x0))
618
619 return out_node
620
621 def AbbreviatedTree(self, trav=None):
622 # type: (Optional[TraversalState]) -> hnode_t
623 return self._AbbreviatedTree(trav=trav)
624
625 class Data(ktype_t):
626 _type_tag = 7
627 __slots__ = ('fields',)
628
629 def __init__(self, fields):
630 # type: (List[Field_]) -> None
631 self.fields = fields
632
633 @staticmethod
634 def CreateNull(alloc_lists=False):
635 # type: () -> ktype.Data
636 return ktype.Data([] if alloc_lists else cast('List[Field_]', None))
637
638 def PrettyTree(self, trav=None):
639 # type: (Optional[TraversalState]) -> hnode_t
640 trav = trav or TraversalState()
641 heap_id = id(self)
642 if heap_id in trav.seen:
643 return hnode.AlreadySeen(heap_id)
644 trav.seen[heap_id] = True
645 out_node = NewRecord('ktype.Data')
646 L = out_node.fields
647
648 if self.fields is not None: # List
649 x0 = hnode.Array([])
650 for i0 in self.fields:
651 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
652 i0.PrettyTree(trav=trav))
653 x0.children.append(h)
654 L.append(Field('fields', x0))
655
656 return out_node
657
658 def _AbbreviatedTree(self, trav=None):
659 # type: (Optional[TraversalState]) -> hnode_t
660 trav = trav or TraversalState()
661 heap_id = id(self)
662 if heap_id in trav.seen:
663 return hnode.AlreadySeen(heap_id)
664 trav.seen[heap_id] = True
665 out_node = NewRecord('ktype.Data')
666 L = out_node.fields
667 if self.fields is not None: # List
668 x0 = hnode.Array([])
669 for i0 in self.fields:
670 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
671 i0.AbbreviatedTree(trav=trav))
672 x0.children.append(h)
673 L.append(Field('fields', x0))
674
675 return out_node
676
677 def AbbreviatedTree(self, trav=None):
678 # type: (Optional[TraversalState]) -> hnode_t
679 return self._AbbreviatedTree(trav=trav)
680
681 class Enum(ktype_t):
682 _type_tag = 8
683 __slots__ = ('variants',)
684
685 def __init__(self, variants):
686 # type: (List[variant]) -> None
687 self.variants = variants
688
689 @staticmethod
690 def CreateNull(alloc_lists=False):
691 # type: () -> ktype.Enum
692 return ktype.Enum([] if alloc_lists else cast('List[variant]', None))
693
694 def PrettyTree(self, trav=None):
695 # type: (Optional[TraversalState]) -> hnode_t
696 trav = trav or TraversalState()
697 heap_id = id(self)
698 if heap_id in trav.seen:
699 return hnode.AlreadySeen(heap_id)
700 trav.seen[heap_id] = True
701 out_node = NewRecord('ktype.Enum')
702 L = out_node.fields
703
704 if self.variants is not None: # List
705 x0 = hnode.Array([])
706 for i0 in self.variants:
707 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
708 i0.PrettyTree(trav=trav))
709 x0.children.append(h)
710 L.append(Field('variants', x0))
711
712 return out_node
713
714 def _AbbreviatedTree(self, trav=None):
715 # type: (Optional[TraversalState]) -> hnode_t
716 trav = trav or TraversalState()
717 heap_id = id(self)
718 if heap_id in trav.seen:
719 return hnode.AlreadySeen(heap_id)
720 trav.seen[heap_id] = True
721 out_node = NewRecord('ktype.Enum')
722 L = out_node.fields
723 if self.variants is not None: # List
724 x0 = hnode.Array([])
725 for i0 in self.variants:
726 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
727 i0.AbbreviatedTree(trav=trav))
728 x0.children.append(h)
729 L.append(Field('variants', x0))
730
731 return out_node
732
733 def AbbreviatedTree(self, trav=None):
734 # type: (Optional[TraversalState]) -> hnode_t
735 return self._AbbreviatedTree(trav=trav)
736
737 pass
738
739class stmt_e(object):
740 VarDecl = 1
741 PlaceMutation = 2
742 If = 3
743 Switch = 4
744 For = 5
745 While = 6
746 Break = 7
747 Continue = 8
748 Return = 9
749 Try = 10
750 With = 11
751
752_stmt_str = {
753 1: 'VarDecl',
754 2: 'PlaceMutation',
755 3: 'If',
756 4: 'Switch',
757 5: 'For',
758 6: 'While',
759 7: 'Break',
760 8: 'Continue',
761 9: 'Return',
762 10: 'Try',
763 11: 'With',
764}
765
766def stmt_str(tag, dot=True):
767 # type: (int, bool) -> str
768 v = _stmt_str[tag]
769 if dot:
770 return "stmt.%s" % v
771 else:
772 return v
773
774class stmt_t(pybase.CompoundObj):
775 def tag(self):
776 # type: () -> int
777 return self._type_tag
778 pass
779
780class stmt__If(stmt_t):
781 _type_tag = 3
782 __slots__ = ()
783
784 def __init__(self, ):
785 # type: () -> None
786 pass
787
788 def PrettyTree(self, trav=None):
789 # type: (Optional[TraversalState]) -> hnode_t
790 trav = trav or TraversalState()
791 heap_id = id(self)
792 if heap_id in trav.seen:
793 return hnode.AlreadySeen(heap_id)
794 trav.seen[heap_id] = True
795 out_node = NewRecord('stmt__If')
796 L = out_node.fields
797
798 return out_node
799
800 def _AbbreviatedTree(self, trav=None):
801 # type: (Optional[TraversalState]) -> hnode_t
802 trav = trav or TraversalState()
803 heap_id = id(self)
804 if heap_id in trav.seen:
805 return hnode.AlreadySeen(heap_id)
806 trav.seen[heap_id] = True
807 out_node = NewRecord('stmt__If')
808 L = out_node.fields
809 return out_node
810
811 def AbbreviatedTree(self, trav=None):
812 # type: (Optional[TraversalState]) -> hnode_t
813 return self._AbbreviatedTree(trav=trav)
814
815class stmt__Switch(stmt_t):
816 _type_tag = 4
817 __slots__ = ()
818
819 def __init__(self, ):
820 # type: () -> None
821 pass
822
823 def PrettyTree(self, trav=None):
824 # type: (Optional[TraversalState]) -> hnode_t
825 trav = trav or TraversalState()
826 heap_id = id(self)
827 if heap_id in trav.seen:
828 return hnode.AlreadySeen(heap_id)
829 trav.seen[heap_id] = True
830 out_node = NewRecord('stmt__Switch')
831 L = out_node.fields
832
833 return out_node
834
835 def _AbbreviatedTree(self, trav=None):
836 # type: (Optional[TraversalState]) -> hnode_t
837 trav = trav or TraversalState()
838 heap_id = id(self)
839 if heap_id in trav.seen:
840 return hnode.AlreadySeen(heap_id)
841 trav.seen[heap_id] = True
842 out_node = NewRecord('stmt__Switch')
843 L = out_node.fields
844 return out_node
845
846 def AbbreviatedTree(self, trav=None):
847 # type: (Optional[TraversalState]) -> hnode_t
848 return self._AbbreviatedTree(trav=trav)
849
850class stmt__For(stmt_t):
851 _type_tag = 5
852 __slots__ = ()
853
854 def __init__(self, ):
855 # type: () -> None
856 pass
857
858 def PrettyTree(self, trav=None):
859 # type: (Optional[TraversalState]) -> hnode_t
860 trav = trav or TraversalState()
861 heap_id = id(self)
862 if heap_id in trav.seen:
863 return hnode.AlreadySeen(heap_id)
864 trav.seen[heap_id] = True
865 out_node = NewRecord('stmt__For')
866 L = out_node.fields
867
868 return out_node
869
870 def _AbbreviatedTree(self, trav=None):
871 # type: (Optional[TraversalState]) -> hnode_t
872 trav = trav or TraversalState()
873 heap_id = id(self)
874 if heap_id in trav.seen:
875 return hnode.AlreadySeen(heap_id)
876 trav.seen[heap_id] = True
877 out_node = NewRecord('stmt__For')
878 L = out_node.fields
879 return out_node
880
881 def AbbreviatedTree(self, trav=None):
882 # type: (Optional[TraversalState]) -> hnode_t
883 return self._AbbreviatedTree(trav=trav)
884
885class stmt__While(stmt_t):
886 _type_tag = 6
887 __slots__ = ()
888
889 def __init__(self, ):
890 # type: () -> None
891 pass
892
893 def PrettyTree(self, trav=None):
894 # type: (Optional[TraversalState]) -> hnode_t
895 trav = trav or TraversalState()
896 heap_id = id(self)
897 if heap_id in trav.seen:
898 return hnode.AlreadySeen(heap_id)
899 trav.seen[heap_id] = True
900 out_node = NewRecord('stmt__While')
901 L = out_node.fields
902
903 return out_node
904
905 def _AbbreviatedTree(self, trav=None):
906 # type: (Optional[TraversalState]) -> hnode_t
907 trav = trav or TraversalState()
908 heap_id = id(self)
909 if heap_id in trav.seen:
910 return hnode.AlreadySeen(heap_id)
911 trav.seen[heap_id] = True
912 out_node = NewRecord('stmt__While')
913 L = out_node.fields
914 return out_node
915
916 def AbbreviatedTree(self, trav=None):
917 # type: (Optional[TraversalState]) -> hnode_t
918 return self._AbbreviatedTree(trav=trav)
919
920class stmt__Break(stmt_t):
921 _type_tag = 7
922 __slots__ = ()
923
924 def __init__(self, ):
925 # type: () -> None
926 pass
927
928 def PrettyTree(self, trav=None):
929 # type: (Optional[TraversalState]) -> hnode_t
930 trav = trav or TraversalState()
931 heap_id = id(self)
932 if heap_id in trav.seen:
933 return hnode.AlreadySeen(heap_id)
934 trav.seen[heap_id] = True
935 out_node = NewRecord('stmt__Break')
936 L = out_node.fields
937
938 return out_node
939
940 def _AbbreviatedTree(self, trav=None):
941 # type: (Optional[TraversalState]) -> hnode_t
942 trav = trav or TraversalState()
943 heap_id = id(self)
944 if heap_id in trav.seen:
945 return hnode.AlreadySeen(heap_id)
946 trav.seen[heap_id] = True
947 out_node = NewRecord('stmt__Break')
948 L = out_node.fields
949 return out_node
950
951 def AbbreviatedTree(self, trav=None):
952 # type: (Optional[TraversalState]) -> hnode_t
953 return self._AbbreviatedTree(trav=trav)
954
955class stmt__Continue(stmt_t):
956 _type_tag = 8
957 __slots__ = ()
958
959 def __init__(self, ):
960 # type: () -> None
961 pass
962
963 def PrettyTree(self, trav=None):
964 # type: (Optional[TraversalState]) -> hnode_t
965 trav = trav or TraversalState()
966 heap_id = id(self)
967 if heap_id in trav.seen:
968 return hnode.AlreadySeen(heap_id)
969 trav.seen[heap_id] = True
970 out_node = NewRecord('stmt__Continue')
971 L = out_node.fields
972
973 return out_node
974
975 def _AbbreviatedTree(self, trav=None):
976 # type: (Optional[TraversalState]) -> hnode_t
977 trav = trav or TraversalState()
978 heap_id = id(self)
979 if heap_id in trav.seen:
980 return hnode.AlreadySeen(heap_id)
981 trav.seen[heap_id] = True
982 out_node = NewRecord('stmt__Continue')
983 L = out_node.fields
984 return out_node
985
986 def AbbreviatedTree(self, trav=None):
987 # type: (Optional[TraversalState]) -> hnode_t
988 return self._AbbreviatedTree(trav=trav)
989
990class stmt__Try(stmt_t):
991 _type_tag = 10
992 __slots__ = ()
993
994 def __init__(self, ):
995 # type: () -> None
996 pass
997
998 def PrettyTree(self, trav=None):
999 # type: (Optional[TraversalState]) -> hnode_t
1000 trav = trav or TraversalState()
1001 heap_id = id(self)
1002 if heap_id in trav.seen:
1003 return hnode.AlreadySeen(heap_id)
1004 trav.seen[heap_id] = True
1005 out_node = NewRecord('stmt__Try')
1006 L = out_node.fields
1007
1008 return out_node
1009
1010 def _AbbreviatedTree(self, trav=None):
1011 # type: (Optional[TraversalState]) -> hnode_t
1012 trav = trav or TraversalState()
1013 heap_id = id(self)
1014 if heap_id in trav.seen:
1015 return hnode.AlreadySeen(heap_id)
1016 trav.seen[heap_id] = True
1017 out_node = NewRecord('stmt__Try')
1018 L = out_node.fields
1019 return out_node
1020
1021 def AbbreviatedTree(self, trav=None):
1022 # type: (Optional[TraversalState]) -> hnode_t
1023 return self._AbbreviatedTree(trav=trav)
1024
1025class stmt__With(stmt_t):
1026 _type_tag = 11
1027 __slots__ = ()
1028
1029 def __init__(self, ):
1030 # type: () -> None
1031 pass
1032
1033 def PrettyTree(self, trav=None):
1034 # type: (Optional[TraversalState]) -> hnode_t
1035 trav = trav or TraversalState()
1036 heap_id = id(self)
1037 if heap_id in trav.seen:
1038 return hnode.AlreadySeen(heap_id)
1039 trav.seen[heap_id] = True
1040 out_node = NewRecord('stmt__With')
1041 L = out_node.fields
1042
1043 return out_node
1044
1045 def _AbbreviatedTree(self, trav=None):
1046 # type: (Optional[TraversalState]) -> hnode_t
1047 trav = trav or TraversalState()
1048 heap_id = id(self)
1049 if heap_id in trav.seen:
1050 return hnode.AlreadySeen(heap_id)
1051 trav.seen[heap_id] = True
1052 out_node = NewRecord('stmt__With')
1053 L = out_node.fields
1054 return out_node
1055
1056 def AbbreviatedTree(self, trav=None):
1057 # type: (Optional[TraversalState]) -> hnode_t
1058 return self._AbbreviatedTree(trav=trav)
1059
1060class stmt(object):
1061 class VarDecl(stmt_t):
1062 _type_tag = 1
1063 __slots__ = ('keyword',)
1064
1065 def __init__(self, keyword):
1066 # type: (Token) -> None
1067 self.keyword = keyword
1068
1069 @staticmethod
1070 def CreateNull(alloc_lists=False):
1071 # type: () -> stmt.VarDecl
1072 return stmt.VarDecl(cast(Token, None))
1073
1074 def PrettyTree(self, trav=None):
1075 # type: (Optional[TraversalState]) -> hnode_t
1076 trav = trav or TraversalState()
1077 heap_id = id(self)
1078 if heap_id in trav.seen:
1079 return hnode.AlreadySeen(heap_id)
1080 trav.seen[heap_id] = True
1081 out_node = NewRecord('stmt.VarDecl')
1082 L = out_node.fields
1083
1084 assert self.keyword is not None
1085 x0 = self.keyword.PrettyTree(trav=trav)
1086 L.append(Field('keyword', x0))
1087
1088 return out_node
1089
1090 def _AbbreviatedTree(self, trav=None):
1091 # type: (Optional[TraversalState]) -> hnode_t
1092 trav = trav or TraversalState()
1093 heap_id = id(self)
1094 if heap_id in trav.seen:
1095 return hnode.AlreadySeen(heap_id)
1096 trav.seen[heap_id] = True
1097 out_node = NewRecord('stmt.VarDecl')
1098 L = out_node.fields
1099 assert self.keyword is not None
1100 x0 = self.keyword.AbbreviatedTree(trav=trav)
1101 L.append(Field('keyword', x0))
1102
1103 return out_node
1104
1105 def AbbreviatedTree(self, trav=None):
1106 # type: (Optional[TraversalState]) -> hnode_t
1107 return self._AbbreviatedTree(trav=trav)
1108
1109 class PlaceMutation(stmt_t):
1110 _type_tag = 2
1111 __slots__ = ('keyword',)
1112
1113 def __init__(self, keyword):
1114 # type: (Token) -> None
1115 self.keyword = keyword
1116
1117 @staticmethod
1118 def CreateNull(alloc_lists=False):
1119 # type: () -> stmt.PlaceMutation
1120 return stmt.PlaceMutation(cast(Token, None))
1121
1122 def PrettyTree(self, trav=None):
1123 # type: (Optional[TraversalState]) -> hnode_t
1124 trav = trav or TraversalState()
1125 heap_id = id(self)
1126 if heap_id in trav.seen:
1127 return hnode.AlreadySeen(heap_id)
1128 trav.seen[heap_id] = True
1129 out_node = NewRecord('stmt.PlaceMutation')
1130 L = out_node.fields
1131
1132 assert self.keyword is not None
1133 x0 = self.keyword.PrettyTree(trav=trav)
1134 L.append(Field('keyword', x0))
1135
1136 return out_node
1137
1138 def _AbbreviatedTree(self, trav=None):
1139 # type: (Optional[TraversalState]) -> hnode_t
1140 trav = trav or TraversalState()
1141 heap_id = id(self)
1142 if heap_id in trav.seen:
1143 return hnode.AlreadySeen(heap_id)
1144 trav.seen[heap_id] = True
1145 out_node = NewRecord('stmt.PlaceMutation')
1146 L = out_node.fields
1147 assert self.keyword is not None
1148 x0 = self.keyword.AbbreviatedTree(trav=trav)
1149 L.append(Field('keyword', x0))
1150
1151 return out_node
1152
1153 def AbbreviatedTree(self, trav=None):
1154 # type: (Optional[TraversalState]) -> hnode_t
1155 return self._AbbreviatedTree(trav=trav)
1156
1157 If = stmt__If()
1158
1159 Switch = stmt__Switch()
1160
1161 For = stmt__For()
1162
1163 While = stmt__While()
1164
1165 Break = stmt__Break()
1166
1167 Continue = stmt__Continue()
1168
1169 class Return(stmt_t):
1170 _type_tag = 9
1171 __slots__ = ('e',)
1172
1173 def __init__(self, e):
1174 # type: (kexpr_t) -> None
1175 self.e = e
1176
1177 @staticmethod
1178 def CreateNull(alloc_lists=False):
1179 # type: () -> stmt.Return
1180 return stmt.Return(cast(kexpr_t, None))
1181
1182 def PrettyTree(self, trav=None):
1183 # type: (Optional[TraversalState]) -> hnode_t
1184 trav = trav or TraversalState()
1185 heap_id = id(self)
1186 if heap_id in trav.seen:
1187 return hnode.AlreadySeen(heap_id)
1188 trav.seen[heap_id] = True
1189 out_node = NewRecord('stmt.Return')
1190 L = out_node.fields
1191
1192 assert self.e is not None
1193 x0 = self.e.PrettyTree(trav=trav)
1194 L.append(Field('e', x0))
1195
1196 return out_node
1197
1198 def _AbbreviatedTree(self, trav=None):
1199 # type: (Optional[TraversalState]) -> hnode_t
1200 trav = trav or TraversalState()
1201 heap_id = id(self)
1202 if heap_id in trav.seen:
1203 return hnode.AlreadySeen(heap_id)
1204 trav.seen[heap_id] = True
1205 out_node = NewRecord('stmt.Return')
1206 L = out_node.fields
1207 assert self.e is not None
1208 x0 = self.e.AbbreviatedTree(trav=trav)
1209 L.append(Field('e', x0))
1210
1211 return out_node
1212
1213 def AbbreviatedTree(self, trav=None):
1214 # type: (Optional[TraversalState]) -> hnode_t
1215 return self._AbbreviatedTree(trav=trav)
1216
1217 Try = stmt__Try()
1218
1219 With = stmt__With()
1220
1221 pass
1222
1223class class_def_t(pybase.SimpleObj):
1224 pass
1225
1226class class_def_e(object):
1227 Constructor = class_def_t(1)
1228 Destructor = class_def_t(2)
1229 Method = class_def_t(3)
1230 Field = class_def_t(4)
1231
1232_class_def_str = {
1233 1: 'class_def.Constructor',
1234 2: 'class_def.Destructor',
1235 3: 'class_def.Method',
1236 4: 'class_def.Field',
1237}
1238
1239def class_def_str(val):
1240 # type: (class_def_t) -> str
1241 return _class_def_str[val]
1242
1243class mod_def_e(object):
1244 Global = 1
1245 Func = 2
1246 Class = 3
1247 Import = 4
1248 Include = 5
1249 Data = 6
1250 Enum = 7
1251
1252_mod_def_str = {
1253 1: 'Global',
1254 2: 'Func',
1255 3: 'Class',
1256 4: 'Import',
1257 5: 'Include',
1258 6: 'Data',
1259 7: 'Enum',
1260}
1261
1262def mod_def_str(tag, dot=True):
1263 # type: (int, bool) -> str
1264 v = _mod_def_str[tag]
1265 if dot:
1266 return "mod_def.%s" % v
1267 else:
1268 return v
1269
1270class mod_def_t(pybase.CompoundObj):
1271 def tag(self):
1272 # type: () -> int
1273 return self._type_tag
1274 pass
1275
1276class mod_def__Import(mod_def_t):
1277 _type_tag = 4
1278 __slots__ = ()
1279
1280 def __init__(self, ):
1281 # type: () -> None
1282 pass
1283
1284 def PrettyTree(self, trav=None):
1285 # type: (Optional[TraversalState]) -> hnode_t
1286 trav = trav or TraversalState()
1287 heap_id = id(self)
1288 if heap_id in trav.seen:
1289 return hnode.AlreadySeen(heap_id)
1290 trav.seen[heap_id] = True
1291 out_node = NewRecord('mod_def__Import')
1292 L = out_node.fields
1293
1294 return out_node
1295
1296 def _AbbreviatedTree(self, trav=None):
1297 # type: (Optional[TraversalState]) -> hnode_t
1298 trav = trav or TraversalState()
1299 heap_id = id(self)
1300 if heap_id in trav.seen:
1301 return hnode.AlreadySeen(heap_id)
1302 trav.seen[heap_id] = True
1303 out_node = NewRecord('mod_def__Import')
1304 L = out_node.fields
1305 return out_node
1306
1307 def AbbreviatedTree(self, trav=None):
1308 # type: (Optional[TraversalState]) -> hnode_t
1309 return self._AbbreviatedTree(trav=trav)
1310
1311class mod_def__Data(mod_def_t):
1312 _type_tag = 6
1313 __slots__ = ()
1314
1315 def __init__(self, ):
1316 # type: () -> None
1317 pass
1318
1319 def PrettyTree(self, trav=None):
1320 # type: (Optional[TraversalState]) -> hnode_t
1321 trav = trav or TraversalState()
1322 heap_id = id(self)
1323 if heap_id in trav.seen:
1324 return hnode.AlreadySeen(heap_id)
1325 trav.seen[heap_id] = True
1326 out_node = NewRecord('mod_def__Data')
1327 L = out_node.fields
1328
1329 return out_node
1330
1331 def _AbbreviatedTree(self, trav=None):
1332 # type: (Optional[TraversalState]) -> hnode_t
1333 trav = trav or TraversalState()
1334 heap_id = id(self)
1335 if heap_id in trav.seen:
1336 return hnode.AlreadySeen(heap_id)
1337 trav.seen[heap_id] = True
1338 out_node = NewRecord('mod_def__Data')
1339 L = out_node.fields
1340 return out_node
1341
1342 def AbbreviatedTree(self, trav=None):
1343 # type: (Optional[TraversalState]) -> hnode_t
1344 return self._AbbreviatedTree(trav=trav)
1345
1346class mod_def__Enum(mod_def_t):
1347 _type_tag = 7
1348 __slots__ = ()
1349
1350 def __init__(self, ):
1351 # type: () -> None
1352 pass
1353
1354 def PrettyTree(self, trav=None):
1355 # type: (Optional[TraversalState]) -> hnode_t
1356 trav = trav or TraversalState()
1357 heap_id = id(self)
1358 if heap_id in trav.seen:
1359 return hnode.AlreadySeen(heap_id)
1360 trav.seen[heap_id] = True
1361 out_node = NewRecord('mod_def__Enum')
1362 L = out_node.fields
1363
1364 return out_node
1365
1366 def _AbbreviatedTree(self, trav=None):
1367 # type: (Optional[TraversalState]) -> hnode_t
1368 trav = trav or TraversalState()
1369 heap_id = id(self)
1370 if heap_id in trav.seen:
1371 return hnode.AlreadySeen(heap_id)
1372 trav.seen[heap_id] = True
1373 out_node = NewRecord('mod_def__Enum')
1374 L = out_node.fields
1375 return out_node
1376
1377 def AbbreviatedTree(self, trav=None):
1378 # type: (Optional[TraversalState]) -> hnode_t
1379 return self._AbbreviatedTree(trav=trav)
1380
1381class mod_def(object):
1382 class Global(mod_def_t):
1383 _type_tag = 1
1384 __slots__ = ('name_type',)
1385
1386 def __init__(self, name_type):
1387 # type: (NameType) -> None
1388 self.name_type = name_type
1389
1390 @staticmethod
1391 def CreateNull(alloc_lists=False):
1392 # type: () -> mod_def.Global
1393 return mod_def.Global(cast(NameType, None))
1394
1395 def PrettyTree(self, trav=None):
1396 # type: (Optional[TraversalState]) -> hnode_t
1397 trav = trav or TraversalState()
1398 heap_id = id(self)
1399 if heap_id in trav.seen:
1400 return hnode.AlreadySeen(heap_id)
1401 trav.seen[heap_id] = True
1402 out_node = NewRecord('mod_def.Global')
1403 L = out_node.fields
1404
1405 assert self.name_type is not None
1406 x0 = self.name_type.PrettyTree(trav=trav)
1407 L.append(Field('name_type', x0))
1408
1409 return out_node
1410
1411 def _AbbreviatedTree(self, trav=None):
1412 # type: (Optional[TraversalState]) -> hnode_t
1413 trav = trav or TraversalState()
1414 heap_id = id(self)
1415 if heap_id in trav.seen:
1416 return hnode.AlreadySeen(heap_id)
1417 trav.seen[heap_id] = True
1418 out_node = NewRecord('mod_def.Global')
1419 L = out_node.fields
1420 assert self.name_type is not None
1421 x0 = self.name_type.AbbreviatedTree(trav=trav)
1422 L.append(Field('name_type', x0))
1423
1424 return out_node
1425
1426 def AbbreviatedTree(self, trav=None):
1427 # type: (Optional[TraversalState]) -> hnode_t
1428 return self._AbbreviatedTree(trav=trav)
1429
1430 class Func(mod_def_t):
1431 _type_tag = 2
1432 __slots__ = ('name', 'sig', 'statements')
1433
1434 def __init__(self, name, sig, statements):
1435 # type: (str, Signature, List[stmt_t]) -> None
1436 self.name = name
1437 self.sig = sig
1438 self.statements = statements
1439
1440 @staticmethod
1441 def CreateNull(alloc_lists=False):
1442 # type: () -> mod_def.Func
1443 return mod_def.Func('', cast(Signature, None), [] if alloc_lists else cast('List[stmt_t]', None))
1444
1445 def PrettyTree(self, trav=None):
1446 # type: (Optional[TraversalState]) -> hnode_t
1447 trav = trav or TraversalState()
1448 heap_id = id(self)
1449 if heap_id in trav.seen:
1450 return hnode.AlreadySeen(heap_id)
1451 trav.seen[heap_id] = True
1452 out_node = NewRecord('mod_def.Func')
1453 L = out_node.fields
1454
1455 x0 = NewLeaf(self.name, color_e.StringConst)
1456 L.append(Field('name', x0))
1457
1458 assert self.sig is not None
1459 x1 = self.sig.PrettyTree(trav=trav)
1460 L.append(Field('sig', x1))
1461
1462 if self.statements is not None: # List
1463 x2 = hnode.Array([])
1464 for i2 in self.statements:
1465 h = (hnode.Leaf("_", color_e.OtherConst) if i2 is None else
1466 i2.PrettyTree(trav=trav))
1467 x2.children.append(h)
1468 L.append(Field('statements', x2))
1469
1470 return out_node
1471
1472 def _AbbreviatedTree(self, trav=None):
1473 # type: (Optional[TraversalState]) -> hnode_t
1474 trav = trav or TraversalState()
1475 heap_id = id(self)
1476 if heap_id in trav.seen:
1477 return hnode.AlreadySeen(heap_id)
1478 trav.seen[heap_id] = True
1479 out_node = NewRecord('mod_def.Func')
1480 L = out_node.fields
1481 x0 = NewLeaf(self.name, color_e.StringConst)
1482 L.append(Field('name', x0))
1483
1484 assert self.sig is not None
1485 x1 = self.sig.AbbreviatedTree(trav=trav)
1486 L.append(Field('sig', x1))
1487
1488 if self.statements is not None: # List
1489 x2 = hnode.Array([])
1490 for i2 in self.statements:
1491 h = (hnode.Leaf("_", color_e.OtherConst) if i2 is None else
1492 i2.AbbreviatedTree(trav=trav))
1493 x2.children.append(h)
1494 L.append(Field('statements', x2))
1495
1496 return out_node
1497
1498 def AbbreviatedTree(self, trav=None):
1499 # type: (Optional[TraversalState]) -> hnode_t
1500 return self._AbbreviatedTree(trav=trav)
1501
1502 class Class(mod_def_t):
1503 _type_tag = 3
1504 __slots__ = ('name', 'defs')
1505
1506 def __init__(self, name, defs):
1507 # type: (str, List[class_def_t]) -> None
1508 self.name = name
1509 self.defs = defs
1510
1511 @staticmethod
1512 def CreateNull(alloc_lists=False):
1513 # type: () -> mod_def.Class
1514 return mod_def.Class('', [] if alloc_lists else cast('List[class_def_t]', None))
1515
1516 def PrettyTree(self, trav=None):
1517 # type: (Optional[TraversalState]) -> hnode_t
1518 trav = trav or TraversalState()
1519 heap_id = id(self)
1520 if heap_id in trav.seen:
1521 return hnode.AlreadySeen(heap_id)
1522 trav.seen[heap_id] = True
1523 out_node = NewRecord('mod_def.Class')
1524 L = out_node.fields
1525
1526 x0 = NewLeaf(self.name, color_e.StringConst)
1527 L.append(Field('name', x0))
1528
1529 if self.defs is not None: # List
1530 x1 = hnode.Array([])
1531 for i1 in self.defs:
1532 x1.children.append(hnode.Leaf(class_def_str(i1), color_e.TypeName))
1533 L.append(Field('defs', x1))
1534
1535 return out_node
1536
1537 def _AbbreviatedTree(self, trav=None):
1538 # type: (Optional[TraversalState]) -> hnode_t
1539 trav = trav or TraversalState()
1540 heap_id = id(self)
1541 if heap_id in trav.seen:
1542 return hnode.AlreadySeen(heap_id)
1543 trav.seen[heap_id] = True
1544 out_node = NewRecord('mod_def.Class')
1545 L = out_node.fields
1546 x0 = NewLeaf(self.name, color_e.StringConst)
1547 L.append(Field('name', x0))
1548
1549 if self.defs is not None: # List
1550 x1 = hnode.Array([])
1551 for i1 in self.defs:
1552 x1.children.append(hnode.Leaf(class_def_str(i1), color_e.TypeName))
1553 L.append(Field('defs', x1))
1554
1555 return out_node
1556
1557 def AbbreviatedTree(self, trav=None):
1558 # type: (Optional[TraversalState]) -> hnode_t
1559 return self._AbbreviatedTree(trav=trav)
1560
1561 Import = mod_def__Import()
1562
1563 class Include(mod_def_t):
1564 _type_tag = 5
1565 __slots__ = ('path',)
1566
1567 def __init__(self, path):
1568 # type: (str) -> None
1569 self.path = path
1570
1571 @staticmethod
1572 def CreateNull(alloc_lists=False):
1573 # type: () -> mod_def.Include
1574 return mod_def.Include('')
1575
1576 def PrettyTree(self, trav=None):
1577 # type: (Optional[TraversalState]) -> hnode_t
1578 trav = trav or TraversalState()
1579 heap_id = id(self)
1580 if heap_id in trav.seen:
1581 return hnode.AlreadySeen(heap_id)
1582 trav.seen[heap_id] = True
1583 out_node = NewRecord('mod_def.Include')
1584 L = out_node.fields
1585
1586 x0 = NewLeaf(self.path, color_e.StringConst)
1587 L.append(Field('path', x0))
1588
1589 return out_node
1590
1591 def _AbbreviatedTree(self, trav=None):
1592 # type: (Optional[TraversalState]) -> hnode_t
1593 trav = trav or TraversalState()
1594 heap_id = id(self)
1595 if heap_id in trav.seen:
1596 return hnode.AlreadySeen(heap_id)
1597 trav.seen[heap_id] = True
1598 out_node = NewRecord('mod_def.Include')
1599 L = out_node.fields
1600 x0 = NewLeaf(self.path, color_e.StringConst)
1601 L.append(Field('path', x0))
1602
1603 return out_node
1604
1605 def AbbreviatedTree(self, trav=None):
1606 # type: (Optional[TraversalState]) -> hnode_t
1607 return self._AbbreviatedTree(trav=trav)
1608
1609 Data = mod_def__Data()
1610
1611 Enum = mod_def__Enum()
1612
1613 pass
1614
1615class Token(pybase.CompoundObj):
1616 _type_tag = 64
1617 __slots__ = ('path', 'chunk', 'start', 'length')
1618
1619 def __init__(self, path, chunk, start, length):
1620 # type: (str, str, int, int) -> None
1621 self.path = path
1622 self.chunk = chunk
1623 self.start = start
1624 self.length = length
1625
1626 @staticmethod
1627 def CreateNull(alloc_lists=False):
1628 # type: () -> Token
1629 return Token('', '', -1, -1)
1630
1631 def PrettyTree(self, trav=None):
1632 # type: (Optional[TraversalState]) -> hnode_t
1633 trav = trav or TraversalState()
1634 heap_id = id(self)
1635 if heap_id in trav.seen:
1636 return hnode.AlreadySeen(heap_id)
1637 trav.seen[heap_id] = True
1638 out_node = NewRecord('Token')
1639 L = out_node.fields
1640
1641 x0 = NewLeaf(self.path, color_e.StringConst)
1642 L.append(Field('path', x0))
1643
1644 x1 = NewLeaf(self.chunk, color_e.StringConst)
1645 L.append(Field('chunk', x1))
1646
1647 x2 = hnode.Leaf(str(self.start), color_e.OtherConst)
1648 L.append(Field('start', x2))
1649
1650 x3 = hnode.Leaf(str(self.length), color_e.OtherConst)
1651 L.append(Field('length', x3))
1652
1653 return out_node
1654
1655 def _AbbreviatedTree(self, trav=None):
1656 # type: (Optional[TraversalState]) -> hnode_t
1657 trav = trav or TraversalState()
1658 heap_id = id(self)
1659 if heap_id in trav.seen:
1660 return hnode.AlreadySeen(heap_id)
1661 trav.seen[heap_id] = True
1662 out_node = NewRecord('Token')
1663 L = out_node.fields
1664 x0 = NewLeaf(self.path, color_e.StringConst)
1665 L.append(Field('path', x0))
1666
1667 x1 = NewLeaf(self.chunk, color_e.StringConst)
1668 L.append(Field('chunk', x1))
1669
1670 x2 = hnode.Leaf(str(self.start), color_e.OtherConst)
1671 L.append(Field('start', x2))
1672
1673 x3 = hnode.Leaf(str(self.length), color_e.OtherConst)
1674 L.append(Field('length', x3))
1675
1676 return out_node
1677
1678 def AbbreviatedTree(self, trav=None):
1679 # type: (Optional[TraversalState]) -> hnode_t
1680 return self._AbbreviatedTree(trav=trav)
1681
1682class Bool(kexpr_t):
1683 _type_tag = 65
1684 __slots__ = ('b', 'loc')
1685
1686 def __init__(self, b, loc):
1687 # type: (bool, Token) -> None
1688 self.b = b
1689 self.loc = loc
1690
1691 @staticmethod
1692 def CreateNull(alloc_lists=False):
1693 # type: () -> Bool
1694 return Bool(False, cast(Token, None))
1695
1696 def PrettyTree(self, trav=None):
1697 # type: (Optional[TraversalState]) -> hnode_t
1698 trav = trav or TraversalState()
1699 heap_id = id(self)
1700 if heap_id in trav.seen:
1701 return hnode.AlreadySeen(heap_id)
1702 trav.seen[heap_id] = True
1703 out_node = NewRecord('Bool')
1704 L = out_node.fields
1705
1706 x0 = hnode.Leaf('T' if self.b else 'F', color_e.OtherConst)
1707 L.append(Field('b', x0))
1708
1709 assert self.loc is not None
1710 x1 = self.loc.PrettyTree(trav=trav)
1711 L.append(Field('loc', x1))
1712
1713 return out_node
1714
1715 def _AbbreviatedTree(self, trav=None):
1716 # type: (Optional[TraversalState]) -> hnode_t
1717 trav = trav or TraversalState()
1718 heap_id = id(self)
1719 if heap_id in trav.seen:
1720 return hnode.AlreadySeen(heap_id)
1721 trav.seen[heap_id] = True
1722 out_node = NewRecord('Bool')
1723 L = out_node.fields
1724 x0 = hnode.Leaf('T' if self.b else 'F', color_e.OtherConst)
1725 L.append(Field('b', x0))
1726
1727 assert self.loc is not None
1728 x1 = self.loc.AbbreviatedTree(trav=trav)
1729 L.append(Field('loc', x1))
1730
1731 return out_node
1732
1733 def AbbreviatedTree(self, trav=None):
1734 # type: (Optional[TraversalState]) -> hnode_t
1735 return self._AbbreviatedTree(trav=trav)
1736
1737class Int(kexpr_t):
1738 _type_tag = 66
1739 __slots__ = ('i', 'loc')
1740
1741 def __init__(self, i, loc):
1742 # type: (int, Token) -> None
1743 self.i = i
1744 self.loc = loc
1745
1746 @staticmethod
1747 def CreateNull(alloc_lists=False):
1748 # type: () -> Int
1749 return Int(-1, cast(Token, None))
1750
1751 def PrettyTree(self, trav=None):
1752 # type: (Optional[TraversalState]) -> hnode_t
1753 trav = trav or TraversalState()
1754 heap_id = id(self)
1755 if heap_id in trav.seen:
1756 return hnode.AlreadySeen(heap_id)
1757 trav.seen[heap_id] = True
1758 out_node = NewRecord('Int')
1759 L = out_node.fields
1760
1761 x0 = hnode.Leaf(str(self.i), color_e.OtherConst)
1762 L.append(Field('i', x0))
1763
1764 assert self.loc is not None
1765 x1 = self.loc.PrettyTree(trav=trav)
1766 L.append(Field('loc', x1))
1767
1768 return out_node
1769
1770 def _AbbreviatedTree(self, trav=None):
1771 # type: (Optional[TraversalState]) -> hnode_t
1772 trav = trav or TraversalState()
1773 heap_id = id(self)
1774 if heap_id in trav.seen:
1775 return hnode.AlreadySeen(heap_id)
1776 trav.seen[heap_id] = True
1777 out_node = NewRecord('Int')
1778 L = out_node.fields
1779 x0 = hnode.Leaf(str(self.i), color_e.OtherConst)
1780 L.append(Field('i', x0))
1781
1782 assert self.loc is not None
1783 x1 = self.loc.AbbreviatedTree(trav=trav)
1784 L.append(Field('loc', x1))
1785
1786 return out_node
1787
1788 def AbbreviatedTree(self, trav=None):
1789 # type: (Optional[TraversalState]) -> hnode_t
1790 return self._AbbreviatedTree(trav=trav)
1791
1792class Str(kexpr_t):
1793 _type_tag = 67
1794 __slots__ = ('s', 'loc')
1795
1796 def __init__(self, s, loc):
1797 # type: (str, Token) -> None
1798 self.s = s
1799 self.loc = loc
1800
1801 @staticmethod
1802 def CreateNull(alloc_lists=False):
1803 # type: () -> Str
1804 return Str('', cast(Token, None))
1805
1806 def PrettyTree(self, trav=None):
1807 # type: (Optional[TraversalState]) -> hnode_t
1808 trav = trav or TraversalState()
1809 heap_id = id(self)
1810 if heap_id in trav.seen:
1811 return hnode.AlreadySeen(heap_id)
1812 trav.seen[heap_id] = True
1813 out_node = NewRecord('Str')
1814 L = out_node.fields
1815
1816 x0 = NewLeaf(self.s, color_e.StringConst)
1817 L.append(Field('s', x0))
1818
1819 assert self.loc is not None
1820 x1 = self.loc.PrettyTree(trav=trav)
1821 L.append(Field('loc', x1))
1822
1823 return out_node
1824
1825 def _AbbreviatedTree(self, trav=None):
1826 # type: (Optional[TraversalState]) -> hnode_t
1827 trav = trav or TraversalState()
1828 heap_id = id(self)
1829 if heap_id in trav.seen:
1830 return hnode.AlreadySeen(heap_id)
1831 trav.seen[heap_id] = True
1832 out_node = NewRecord('Str')
1833 L = out_node.fields
1834 x0 = NewLeaf(self.s, color_e.StringConst)
1835 L.append(Field('s', x0))
1836
1837 assert self.loc is not None
1838 x1 = self.loc.AbbreviatedTree(trav=trav)
1839 L.append(Field('loc', x1))
1840
1841 return out_node
1842
1843 def AbbreviatedTree(self, trav=None):
1844 # type: (Optional[TraversalState]) -> hnode_t
1845 return self._AbbreviatedTree(trav=trav)
1846
1847class MultiStr(kexpr_t):
1848 _type_tag = 68
1849 __slots__ = ('lines',)
1850
1851 def __init__(self, lines):
1852 # type: (List[Token]) -> None
1853 self.lines = lines
1854
1855 @staticmethod
1856 def CreateNull(alloc_lists=False):
1857 # type: () -> MultiStr
1858 return MultiStr([] if alloc_lists else cast('List[Token]', None))
1859
1860 def PrettyTree(self, trav=None):
1861 # type: (Optional[TraversalState]) -> hnode_t
1862 trav = trav or TraversalState()
1863 heap_id = id(self)
1864 if heap_id in trav.seen:
1865 return hnode.AlreadySeen(heap_id)
1866 trav.seen[heap_id] = True
1867 out_node = NewRecord('MultiStr')
1868 L = out_node.fields
1869
1870 if self.lines is not None: # List
1871 x0 = hnode.Array([])
1872 for i0 in self.lines:
1873 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
1874 i0.PrettyTree(trav=trav))
1875 x0.children.append(h)
1876 L.append(Field('lines', x0))
1877
1878 return out_node
1879
1880 def _AbbreviatedTree(self, trav=None):
1881 # type: (Optional[TraversalState]) -> hnode_t
1882 trav = trav or TraversalState()
1883 heap_id = id(self)
1884 if heap_id in trav.seen:
1885 return hnode.AlreadySeen(heap_id)
1886 trav.seen[heap_id] = True
1887 out_node = NewRecord('MultiStr')
1888 L = out_node.fields
1889 if self.lines is not None: # List
1890 x0 = hnode.Array([])
1891 for i0 in self.lines:
1892 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
1893 i0.AbbreviatedTree(trav=trav))
1894 x0.children.append(h)
1895 L.append(Field('lines', x0))
1896
1897 return out_node
1898
1899 def AbbreviatedTree(self, trav=None):
1900 # type: (Optional[TraversalState]) -> hnode_t
1901 return self._AbbreviatedTree(trav=trav)
1902
1903class Field_(pybase.CompoundObj):
1904 _type_tag = 69
1905 __slots__ = ('name', 'typ')
1906
1907 def __init__(self, name, typ):
1908 # type: (str, ktype_t) -> None
1909 self.name = name
1910 self.typ = typ
1911
1912 @staticmethod
1913 def CreateNull(alloc_lists=False):
1914 # type: () -> Field_
1915 return Field_('', cast(ktype_t, None))
1916
1917 def PrettyTree(self, trav=None):
1918 # type: (Optional[TraversalState]) -> hnode_t
1919 trav = trav or TraversalState()
1920 heap_id = id(self)
1921 if heap_id in trav.seen:
1922 return hnode.AlreadySeen(heap_id)
1923 trav.seen[heap_id] = True
1924 out_node = NewRecord('Field_')
1925 L = out_node.fields
1926
1927 x0 = NewLeaf(self.name, color_e.StringConst)
1928 L.append(Field('name', x0))
1929
1930 assert self.typ is not None
1931 x1 = self.typ.PrettyTree(trav=trav)
1932 L.append(Field('typ', x1))
1933
1934 return out_node
1935
1936 def _AbbreviatedTree(self, trav=None):
1937 # type: (Optional[TraversalState]) -> hnode_t
1938 trav = trav or TraversalState()
1939 heap_id = id(self)
1940 if heap_id in trav.seen:
1941 return hnode.AlreadySeen(heap_id)
1942 trav.seen[heap_id] = True
1943 out_node = NewRecord('Field_')
1944 L = out_node.fields
1945 x0 = NewLeaf(self.name, color_e.StringConst)
1946 L.append(Field('name', x0))
1947
1948 assert self.typ is not None
1949 x1 = self.typ.AbbreviatedTree(trav=trav)
1950 L.append(Field('typ', x1))
1951
1952 return out_node
1953
1954 def AbbreviatedTree(self, trav=None):
1955 # type: (Optional[TraversalState]) -> hnode_t
1956 return self._AbbreviatedTree(trav=trav)
1957
1958class variant(pybase.CompoundObj):
1959 _type_tag = 70
1960 __slots__ = ('fields',)
1961
1962 def __init__(self, fields):
1963 # type: (List[Field_]) -> None
1964 self.fields = fields
1965
1966 @staticmethod
1967 def CreateNull(alloc_lists=False):
1968 # type: () -> variant
1969 return variant([] if alloc_lists else cast('List[Field_]', None))
1970
1971 def PrettyTree(self, trav=None):
1972 # type: (Optional[TraversalState]) -> hnode_t
1973 trav = trav or TraversalState()
1974 heap_id = id(self)
1975 if heap_id in trav.seen:
1976 return hnode.AlreadySeen(heap_id)
1977 trav.seen[heap_id] = True
1978 out_node = NewRecord('variant')
1979 L = out_node.fields
1980
1981 if self.fields is not None: # List
1982 x0 = hnode.Array([])
1983 for i0 in self.fields:
1984 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
1985 i0.PrettyTree(trav=trav))
1986 x0.children.append(h)
1987 L.append(Field('fields', x0))
1988
1989 return out_node
1990
1991 def _AbbreviatedTree(self, trav=None):
1992 # type: (Optional[TraversalState]) -> hnode_t
1993 trav = trav or TraversalState()
1994 heap_id = id(self)
1995 if heap_id in trav.seen:
1996 return hnode.AlreadySeen(heap_id)
1997 trav.seen[heap_id] = True
1998 out_node = NewRecord('variant')
1999 L = out_node.fields
2000 if self.fields is not None: # List
2001 x0 = hnode.Array([])
2002 for i0 in self.fields:
2003 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
2004 i0.AbbreviatedTree(trav=trav))
2005 x0.children.append(h)
2006 L.append(Field('fields', x0))
2007
2008 return out_node
2009
2010 def AbbreviatedTree(self, trav=None):
2011 # type: (Optional[TraversalState]) -> hnode_t
2012 return self._AbbreviatedTree(trav=trav)
2013
2014class NameType(pybase.CompoundObj):
2015 _type_tag = 71
2016 __slots__ = ('name', 'typ')
2017
2018 def __init__(self, name, typ):
2019 # type: (str, ktype_t) -> None
2020 self.name = name
2021 self.typ = typ
2022
2023 @staticmethod
2024 def CreateNull(alloc_lists=False):
2025 # type: () -> NameType
2026 return NameType('', cast(ktype_t, None))
2027
2028 def PrettyTree(self, trav=None):
2029 # type: (Optional[TraversalState]) -> hnode_t
2030 trav = trav or TraversalState()
2031 heap_id = id(self)
2032 if heap_id in trav.seen:
2033 return hnode.AlreadySeen(heap_id)
2034 trav.seen[heap_id] = True
2035 out_node = NewRecord('NameType')
2036 L = out_node.fields
2037
2038 x0 = NewLeaf(self.name, color_e.StringConst)
2039 L.append(Field('name', x0))
2040
2041 assert self.typ is not None
2042 x1 = self.typ.PrettyTree(trav=trav)
2043 L.append(Field('typ', x1))
2044
2045 return out_node
2046
2047 def _AbbreviatedTree(self, trav=None):
2048 # type: (Optional[TraversalState]) -> hnode_t
2049 trav = trav or TraversalState()
2050 heap_id = id(self)
2051 if heap_id in trav.seen:
2052 return hnode.AlreadySeen(heap_id)
2053 trav.seen[heap_id] = True
2054 out_node = NewRecord('NameType')
2055 L = out_node.fields
2056 x0 = NewLeaf(self.name, color_e.StringConst)
2057 L.append(Field('name', x0))
2058
2059 assert self.typ is not None
2060 x1 = self.typ.AbbreviatedTree(trav=trav)
2061 L.append(Field('typ', x1))
2062
2063 return out_node
2064
2065 def AbbreviatedTree(self, trav=None):
2066 # type: (Optional[TraversalState]) -> hnode_t
2067 return self._AbbreviatedTree(trav=trav)
2068
2069class Signature(pybase.CompoundObj):
2070 _type_tag = 72
2071 __slots__ = ('params', 'return_type')
2072
2073 def __init__(self, params, return_type):
2074 # type: (List[NameType], ktype_t) -> None
2075 self.params = params
2076 self.return_type = return_type
2077
2078 @staticmethod
2079 def CreateNull(alloc_lists=False):
2080 # type: () -> Signature
2081 return Signature([] if alloc_lists else cast('List[NameType]', None), cast(ktype_t, None))
2082
2083 def PrettyTree(self, trav=None):
2084 # type: (Optional[TraversalState]) -> hnode_t
2085 trav = trav or TraversalState()
2086 heap_id = id(self)
2087 if heap_id in trav.seen:
2088 return hnode.AlreadySeen(heap_id)
2089 trav.seen[heap_id] = True
2090 out_node = NewRecord('Signature')
2091 L = out_node.fields
2092
2093 if self.params is not None: # List
2094 x0 = hnode.Array([])
2095 for i0 in self.params:
2096 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
2097 i0.PrettyTree(trav=trav))
2098 x0.children.append(h)
2099 L.append(Field('params', x0))
2100
2101 assert self.return_type is not None
2102 x1 = self.return_type.PrettyTree(trav=trav)
2103 L.append(Field('return_type', x1))
2104
2105 return out_node
2106
2107 def _AbbreviatedTree(self, trav=None):
2108 # type: (Optional[TraversalState]) -> hnode_t
2109 trav = trav or TraversalState()
2110 heap_id = id(self)
2111 if heap_id in trav.seen:
2112 return hnode.AlreadySeen(heap_id)
2113 trav.seen[heap_id] = True
2114 out_node = NewRecord('Signature')
2115 L = out_node.fields
2116 if self.params is not None: # List
2117 x0 = hnode.Array([])
2118 for i0 in self.params:
2119 h = (hnode.Leaf("_", color_e.OtherConst) if i0 is None else
2120 i0.AbbreviatedTree(trav=trav))
2121 x0.children.append(h)
2122 L.append(Field('params', x0))
2123
2124 assert self.return_type is not None
2125 x1 = self.return_type.AbbreviatedTree(trav=trav)
2126 L.append(Field('return_type', x1))
2127
2128 return out_node
2129
2130 def AbbreviatedTree(self, trav=None):
2131 # type: (Optional[TraversalState]) -> hnode_t
2132 return self._AbbreviatedTree(trav=trav)
2133
2134class Module(pybase.CompoundObj):
2135 _type_tag = 73
2136 __slots__ = ('name', 'defs')
2137
2138 def __init__(self, name, defs):
2139 # type: (str, List[mod_def_t]) -> None
2140 self.name = name
2141 self.defs = defs
2142
2143 @staticmethod
2144 def CreateNull(alloc_lists=False):
2145 # type: () -> Module
2146 return Module('', [] if alloc_lists else cast('List[mod_def_t]', None))
2147
2148 def PrettyTree(self, trav=None):
2149 # type: (Optional[TraversalState]) -> hnode_t
2150 trav = trav or TraversalState()
2151 heap_id = id(self)
2152 if heap_id in trav.seen:
2153 return hnode.AlreadySeen(heap_id)
2154 trav.seen[heap_id] = True
2155 out_node = NewRecord('Module')
2156 L = out_node.fields
2157
2158 x0 = NewLeaf(self.name, color_e.StringConst)
2159 L.append(Field('name', x0))
2160
2161 if self.defs is not None: # List
2162 x1 = hnode.Array([])
2163 for i1 in self.defs:
2164 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
2165 i1.PrettyTree(trav=trav))
2166 x1.children.append(h)
2167 L.append(Field('defs', x1))
2168
2169 return out_node
2170
2171 def _AbbreviatedTree(self, trav=None):
2172 # type: (Optional[TraversalState]) -> hnode_t
2173 trav = trav or TraversalState()
2174 heap_id = id(self)
2175 if heap_id in trav.seen:
2176 return hnode.AlreadySeen(heap_id)
2177 trav.seen[heap_id] = True
2178 out_node = NewRecord('Module')
2179 L = out_node.fields
2180 x0 = NewLeaf(self.name, color_e.StringConst)
2181 L.append(Field('name', x0))
2182
2183 if self.defs is not None: # List
2184 x1 = hnode.Array([])
2185 for i1 in self.defs:
2186 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
2187 i1.AbbreviatedTree(trav=trav))
2188 x1.children.append(h)
2189 L.append(Field('defs', x1))
2190
2191 return out_node
2192
2193 def AbbreviatedTree(self, trav=None):
2194 # type: (Optional[TraversalState]) -> hnode_t
2195 return self._AbbreviatedTree(trav=trav)
2196
2197class Program(pybase.CompoundObj):
2198 _type_tag = 74
2199 __slots__ = ('main_module', 'modules')
2200
2201 def __init__(self, main_module, modules):
2202 # type: (str, List[Module]) -> None
2203 self.main_module = main_module
2204 self.modules = modules
2205
2206 @staticmethod
2207 def CreateNull(alloc_lists=False):
2208 # type: () -> Program
2209 return Program('', [] if alloc_lists else cast('List[Module]', None))
2210
2211 def PrettyTree(self, trav=None):
2212 # type: (Optional[TraversalState]) -> hnode_t
2213 trav = trav or TraversalState()
2214 heap_id = id(self)
2215 if heap_id in trav.seen:
2216 return hnode.AlreadySeen(heap_id)
2217 trav.seen[heap_id] = True
2218 out_node = NewRecord('Program')
2219 L = out_node.fields
2220
2221 x0 = NewLeaf(self.main_module, color_e.StringConst)
2222 L.append(Field('main_module', x0))
2223
2224 if self.modules is not None: # List
2225 x1 = hnode.Array([])
2226 for i1 in self.modules:
2227 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
2228 i1.PrettyTree(trav=trav))
2229 x1.children.append(h)
2230 L.append(Field('modules', x1))
2231
2232 return out_node
2233
2234 def _AbbreviatedTree(self, trav=None):
2235 # type: (Optional[TraversalState]) -> hnode_t
2236 trav = trav or TraversalState()
2237 heap_id = id(self)
2238 if heap_id in trav.seen:
2239 return hnode.AlreadySeen(heap_id)
2240 trav.seen[heap_id] = True
2241 out_node = NewRecord('Program')
2242 L = out_node.fields
2243 x0 = NewLeaf(self.main_module, color_e.StringConst)
2244 L.append(Field('main_module', x0))
2245
2246 if self.modules is not None: # List
2247 x1 = hnode.Array([])
2248 for i1 in self.modules:
2249 h = (hnode.Leaf("_", color_e.OtherConst) if i1 is None else
2250 i1.AbbreviatedTree(trav=trav))
2251 x1.children.append(h)
2252 L.append(Field('modules', x1))
2253
2254 return out_node
2255
2256 def AbbreviatedTree(self, trav=None):
2257 # type: (Optional[TraversalState]) -> hnode_t
2258 return self._AbbreviatedTree(trav=trav)
2259