src/parser/parser_nodes.nit

   1 # This file is part of NIT ( http://www.nitlanguage.org ).
   2 #
   3 # Licensed under the Apache License, Version 2.0 (the "License");
   4 # you may not use this file except in compliance with the License.
   5 # You may obtain a copy of the License at
   6 #
   7 #     http://www.apache.org/licenses/LICENSE-2.0
   8 #
   9 # Unless required by applicable law or agreed to in writing, software
  10 # distributed under the License is distributed on an "AS IS" BASIS,
  11 # WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  12 # See the License for the specific language governing permissions and
  13 # limitations under the License.
  14
  15 # AST nodes of the Nit language
  16 # Was previously based on parser_abs.nit.
  17 module parser_nodes
  18
  19 import location
  20 import ordered_tree
  21
  22 # Root of the AST class-hierarchy
  23 abstract class ANode
  24         # Location is set during AST building. Once built, location cannon be null.
  25         # However, manual instantiated nodes may need more care.
  26         var location: Location is writable, noinit
  27
  28         # The location of the important part of the node (identifier or whatever)
  29         fun hot_location: Location do return location
  30
  31         # Display a message for the colored location of the node
  32         fun debug(message: String)
  33         do
  34                 sys.stderr.write "{hot_location} {self.class_name}: {message}\n{hot_location.colored_line("0;32")}\n"
  35         end
  36
  37         # Write the subtree on stdout.
  38         # See `ASTDump`
  39         fun dump_tree
  40         do
  41                 var d = new ASTDump
  42                 d.enter_visit(self)
  43                 d.write_to(sys.stdout)
  44         end
  45
  46         # Parent of the node in the AST
  47         var parent: nullable ANode = null
  48
  49         # The topmost ancestor of the element
  50         # This just apply `parent` until the first one
  51         fun root: ANode
  52         do
  53                 var res = self
  54                 loop
  55                         var p = res.parent
  56                         if p == null then return res
  57                         res = p
  58                 end
  59         end
  60
  61         # The most specific common parent between `self` and `other`
  62         # Return null if the two node are unrelated (distinct root)
  63         fun common_parent(other: ANode): nullable ANode
  64         do
  65                 # First, get the same depth
  66                 var s: nullable ANode = self
  67                 var o: nullable ANode = other
  68                 var d = s.depth - o.depth
  69                 while d > 0 do
  70                         s = s.parent
  71                         d -= 1
  72                 end
  73                 while d < 0 do
  74                         o = o.parent
  75                         d += 1
  76                 end
  77                 assert o.depth == s.depth
  78                 # Second, go up until same in found
  79                 while s != o do
  80                         s = s.parent
  81                         o = o.parent
  82                 end
  83                 return s
  84         end
  85
  86         # Number of nodes between `self` and the `root` of the AST
  87         # ENSURE `self == self.root implies result == 0 `
  88         # ENSURE `self != self.root implies result == self.parent.depth + 1`
  89         fun depth: Int
  90         do
  91                 var n = self
  92                 var res = 0
  93                 loop
  94                         var p = n.parent
  95                         if p == null then return res
  96                         n = p
  97                         res += 1
  98                 end
  99         end
 100
 101         # Replace a child with an other node in the AST
 102         private fun replace_child(old_child: ANode, new_child: nullable ANode) is abstract
 103
 104         # Detach a node from its parent
 105         # Aborts if the node is not detachable. use `replace_with` instead
 106         # REQUIRE: parent != null
 107         # REQUIRE: is_detachable
 108         # ENDURE: parent == null
 109         fun detach
 110         do
 111                 assert parent != null
 112                 parent.replace_child(self, null)
 113                 parent = null
 114         end
 115
 116         # Replace itself with an other node in the AST
 117         # REQUIRE: parent != null
 118         # ENSURE: node.parent == old(parent)
 119         # ENSURE: parent == null
 120         fun replace_with(node: ANode)
 121         do
 122                 assert parent != null
 123                 parent.replace_child(self, node)
 124                 parent = null
 125         end
 126
 127         # Visit all nodes in order.
 128         # Thus, call `v.enter_visit(e)` for each child `e`
 129         fun visit_all(v: Visitor) is abstract
 130
 131         # Do a deep search and return an array of tokens that match a given text
 132         fun collect_tokens_by_text(text: String): Array[Token]
 133         do
 134                 var v = new CollectTokensByTextVisitor(text)
 135                 v.enter_visit(self)
 136                 return v.result
 137         end
 138
 139         # Do a deep search and return an array of node that are annotated
 140         # The attached node can be retrieved by two invocations of parent
 141         fun collect_annotations_by_name(name: String): Array[AAnnotation]
 142         do
 143                 var v = new CollectAnnotationsByNameVisitor(name)
 144                 v.enter_visit(self)
 145                 return v.result
 146         end
 147 end
 148
 149 private class CollectTokensByTextVisitor
 150         super Visitor
 151         var text: String
 152         var result = new Array[Token]
 153         redef fun visit(node)
 154         do
 155                 node.visit_all(self)
 156                 if node isa Token and node.text == text then result.add(node)
 157         end
 158 end
 159
 160 private class CollectAnnotationsByNameVisitor
 161         super Visitor
 162         var name: String
 163         var result = new Array[AAnnotation]
 164         redef fun visit(node)
 165         do
 166                 node.visit_all(self)
 167                 if node isa AAnnotation and node.n_atid.n_id.text == name then result.add(node)
 168         end
 169 end
 170
 171 # A helper class to handle (print) Nit AST as an OrderedTree
 172 class ASTDump
 173         super Visitor
 174         super OrderedTree[ANode]
 175
 176         # Reference to the last parent in the Ordered Tree
 177         # Is used to handle the initial node parent and workaround possible inconsistent `ANode::parent`
 178         private var last_parent: nullable ANode = null
 179
 180         redef fun visit(n)
 181         do
 182                 var p = last_parent
 183                 add(p, n)
 184                 last_parent = n
 185                 n.visit_all(self)
 186                 last_parent = p
 187         end
 188
 189         redef fun display(n)
 190         do
 191                 if n isa Token then
 192                         return "{n.class_name} \"{n.text.escape_to_c}\" @{n.location}"
 193                 else
 194                         return "{n.class_name} @{n.location}"
 195                 end
 196         end
 197 end
 198
 199 # A sequence of nodes
 200 # It is a specific class (instead of using a Array) to track the parent/child relation when nodes are added or removed
 201 class ANodes[E: ANode]
 202         super Sequence[E]
 203         private var parent: ANode
 204         private var items = new Array[E]
 205         redef fun iterator do return items.iterator
 206         redef fun length do return items.length
 207         redef fun is_empty do return items.is_empty
 208         redef fun push(e)
 209         do
 210                 hook_add(e)
 211                 items.push(e)
 212         end
 213         redef fun pop
 214         do
 215                 var res = items.pop
 216                 hook_remove(res)
 217                 return res
 218         end
 219         redef fun unshift(e)
 220         do
 221                 hook_add(e)
 222                 items.unshift(e)
 223         end
 224         redef fun shift
 225         do
 226                 var res = items.shift
 227                 hook_remove(res)
 228                 return res
 229         end
 230         redef fun has(e)
 231         do
 232                 return items.has(e)
 233         end
 234         redef fun [](index)
 235         do
 236                 return items[index]
 237         end
 238         redef fun []=(index, e)
 239         do
 240                 hook_remove(self[index])
 241                 hook_add(e)
 242                 items[index]=e
 243         end
 244         redef fun remove_at(index)
 245         do
 246                 hook_remove(items[index])
 247                 items.remove_at(index)
 248         end
 249         private fun hook_add(e: E)
 250         do
 251                 #assert e.parent == null
 252                 e.parent = parent
 253         end
 254         private fun hook_remove(e: E)
 255         do
 256                 assert e.parent == parent
 257                 e.parent = null
 258         end
 259
 260         # Used in parent constructor to fill elements
 261         private fun unsafe_add_all(nodes: Collection[Object])
 262         do
 263                 var parent = self.parent
 264                 for n in nodes do
 265                         assert n isa E
 266                         add n
 267                         n.parent = parent
 268                 end
 269         end
 270
 271         private fun replace_child(old_child: ANode, new_child: nullable ANode): Bool
 272         do
 273                 var parent = self.parent
 274                 for i in [0..length[ do
 275                         if self[i] == old_child then
 276                                 if new_child != null then
 277                                         assert new_child isa E
 278                                         self[i] = new_child
 279                                         new_child.parent = parent
 280                                 else
 281                                         self.remove_at(i)
 282                                 end
 283                                 return true
 284                         end
 285                 end
 286                 return false
 287         end
 288
 289         private fun visit_all(v: Visitor)
 290         do
 291                 for n in self do v.enter_visit(n)
 292         end
 293 end
 294
 295 # Ancestor of all tokens
 296 # A token is a node that has a `text` but no children.
 297 abstract class Token
 298         super ANode
 299
 300         # The raw content on the token
 301         fun text: String is abstract
 302
 303         # The raw content on the token
 304         fun text=(text: String) is abstract
 305
 306         # The previous token in the Lexer.
 307         # May have disappeared in the AST
 308         var prev_token: nullable Token = null
 309
 310         # The next token in the Lexer.
 311         # May have disappeared in the AST
 312         var next_token: nullable Token = null
 313
 314         # Is `self` a token discarded from the AST?
 315         #
 316         # Loose tokens are not present in the AST.
 317         # It means they were identified by the lexer but were discarded by the parser.
 318         # It also means that they are not visited or manipulated by AST-related functions.
 319         #
 320         # Each loose token is attached to the non-loose token that precedes or follows it.
 321         # The rules are the following:
 322         #
 323         # * tokens that follow a non-loose token on a same line are attached to it.
 324         #   See `next_looses`.
 325         # * other tokens, thus that precede a non-loose token on the same line or the next one,
 326         # are attached to this one. See `prev_looses`.
 327         #
 328         # Loose tokens are mostly end of lines (`TEol`) and comments (`TComment`).
 329         # Whitespace are ignored by the lexer, so they are not even considered as loose tokens.
 330         # See `blank_before` to get the whitespace that separate tokens.
 331         var is_loose = false
 332
 333         # Loose tokens that precede `self`.
 334         #
 335         # These tokens start the line or belong to a line with only loose tokens.
 336         var prev_looses = new Array[Token] is lazy
 337
 338         # Loose tokens that follow `self`
 339         #
 340         # These tokens are on the same line than `self`.
 341         var next_looses = new Array[Token] is lazy
 342
 343         # The verbatim blank text between `prev_token` and `self`
 344         fun blank_before: String
 345         do
 346                 if prev_token == null then return ""
 347                 var from = prev_token.location.pend+1
 348                 var to = location.pstart
 349                 return location.file.string.substring(from,to-from)
 350         end
 351
 352         redef fun to_s: String do
 353                 return "'{text}'"
 354         end
 355
 356         redef fun visit_all(v: Visitor) do end
 357         redef fun replace_child(old_child: ANode, new_child: nullable ANode) do end
 358 end
 359
 360 redef class SourceFile
 361         # The first token parser by the lexer
 362         # May have disappeared in the final AST
 363         var first_token: nullable Token = null
 364
 365         # The first token parser by the lexer
 366         # May have disappeared in the final AST
 367         var last_token: nullable Token = null
 368 end
 369
 370 # Ancestor of all productions
 371 # A production is a node without text but that usually has children.
 372 abstract class Prod
 373         super ANode
 374
 375         # All the annotations attached directly to the node
 376         var n_annotations: nullable AAnnotations = null is writable
 377
 378         # Return all its annotations of a given name in the order of their declaration
 379         # Retun an empty array if no such an annotation.
 380         fun get_annotations(name: String): Array[AAnnotation]
 381         do
 382                 var res = new Array[AAnnotation]
 383                 var nas = n_annotations
 384                 if nas != null then for na in nas.n_items do
 385                         if na.name != name then continue
 386                         res.add(na)
 387                 end
 388                 if self isa AClassdef then for na in n_propdefs do
 389                         if na isa AAnnotPropdef then
 390                                 if na.name != name then continue
 391                                 res.add na
 392                         end
 393                 end
 394
 395                 return res
 396         end
 397
 398         redef fun replace_with(n: ANode)
 399         do
 400                 super
 401                 assert n isa Prod
 402                 if not isset n._location and isset _location then n._location = _location
 403         end
 404 end
 405
 406 # Abstract standard visitor on the AST
 407 abstract class Visitor
 408         # What the visitor do when a node is visited
 409         # Concrete visitors should implement this method.
 410         # @toimplement
 411         protected fun visit(e: ANode) is abstract
 412
 413         # Ask the visitor to visit a given node.
 414         # Usually automatically called by visit_all* methods.
 415         # This method should not be redefined
 416         fun enter_visit(e: nullable ANode)
 417         do
 418                 if e == null then return
 419                 var old = _current_node
 420                 _current_node = e
 421                 visit(e)
 422                 _current_node = old
 423         end
 424
 425         # The current visited node
 426         var current_node: nullable ANode = null is writable
 427 end
 428
 429 # Token of end of line (basically `\n`)
 430 class TEol
 431         super Token
 432         redef fun to_s
 433         do
 434                 return "end of line"
 435         end
 436 end
 437
 438 # Token of a line of comments
 439 # Starts with the `#` and contains the final end-of-line (if any)
 440 class TComment
 441         super Token
 442 end
 443
 444 # A token associated with a keyword
 445 abstract class TokenKeyword
 446         super Token
 447         redef fun to_s
 448         do
 449                 return "keyword '{text}'"
 450         end
 451 end
 452
 453 # The deprecated keyword `package`.
 454 class TKwpackage
 455         super TokenKeyword
 456 end
 457
 458 # The keyword `module`
 459 class TKwmodule
 460         super TokenKeyword
 461 end
 462
 463 # The keyword `import`
 464 class TKwimport
 465         super TokenKeyword
 466 end
 467
 468 # The keyword `class`
 469 class TKwclass
 470         super TokenKeyword
 471 end
 472
 473 # The keyword `abstract`
 474 class TKwabstract
 475         super TokenKeyword
 476 end
 477
 478 # The keyword `interface`
 479 class TKwinterface
 480         super TokenKeyword
 481 end
 482
 483 # The keywords `enum` ane `universal`
 484 class TKwenum
 485         super TokenKeyword
 486 end
 487
 488 # The keyword `end`
 489 class TKwend
 490         super TokenKeyword
 491 end
 492
 493 # The keyword `fun`
 494 class TKwmeth
 495         super TokenKeyword
 496 end
 497
 498 # The keyword `type`
 499 class TKwtype
 500         super TokenKeyword
 501 end
 502
 503 # The keyword `init`
 504 class TKwinit
 505         super TokenKeyword
 506 end
 507
 508 # The keyword `redef`
 509 class TKwredef
 510         super TokenKeyword
 511 end
 512
 513 # The keyword `is`
 514 class TKwis
 515         super TokenKeyword
 516 end
 517
 518 # The keyword `do`
 519 class TKwdo
 520         super TokenKeyword
 521 end
 522
 523 # The keyword `var`
 524 class TKwvar
 525         super TokenKeyword
 526 end
 527
 528 # The keyword `extern`
 529 class TKwextern
 530         super TokenKeyword
 531 end
 532
 533 # The keyword `public`
 534 class TKwpublic
 535         super TokenKeyword
 536 end
 537
 538 # The keyword `protected`
 539 class TKwprotected
 540         super TokenKeyword
 541 end
 542
 543 # The keyword `private`
 544 class TKwprivate
 545         super TokenKeyword
 546 end
 547
 548 # The keyword `intrude`
 549 class TKwintrude
 550         super TokenKeyword
 551 end
 552
 553 # The keyword `if`
 554 class TKwif
 555         super TokenKeyword
 556 end
 557
 558 # The keyword `then`
 559 class TKwthen
 560         super TokenKeyword
 561 end
 562
 563 # The keyword `else`
 564 class TKwelse
 565         super TokenKeyword
 566 end
 567
 568 # The keyword `while`
 569 class TKwwhile
 570         super TokenKeyword
 571 end
 572
 573 # The keyword `loop`
 574 class TKwloop
 575         super TokenKeyword
 576 end
 577
 578 # The keyword `for`
 579 class TKwfor
 580         super TokenKeyword
 581 end
 582
 583 # The keyword `in`
 584 class TKwin
 585         super TokenKeyword
 586 end
 587
 588 # The keyword `and`
 589 class TKwand
 590         super TokenKeyword
 591 end
 592
 593 # The keyword `or`
 594 class TKwor
 595         super TokenKeyword
 596 end
 597
 598 # The keyword `implies`
 599 class TKwimplies
 600         super TokenKeyword
 601 end
 602
 603 # The keyword `not`
 604 class TKwnot
 605         super TokenKeyword
 606 end
 607
 608 # The keyword `return`
 609 class TKwreturn
 610         super TokenKeyword
 611 end
 612
 613 # The keyword `continue`
 614 class TKwcontinue
 615         super TokenKeyword
 616 end
 617
 618 # The keyword `break`
 619 class TKwbreak
 620         super TokenKeyword
 621 end
 622
 623 # The keyword `abort`
 624 class TKwabort
 625         super TokenKeyword
 626 end
 627
 628 # The keyword `assert`
 629 class TKwassert
 630         super TokenKeyword
 631 end
 632
 633 # The keyword `new`
 634 class TKwnew
 635         super TokenKeyword
 636 end
 637
 638 # The keyword `isa`
 639 class TKwisa
 640         super TokenKeyword
 641 end
 642
 643 # The keyword `once`
 644 class TKwonce
 645         super TokenKeyword
 646 end
 647
 648 # The keyword `super`
 649 class TKwsuper
 650         super TokenKeyword
 651 end
 652
 653 # The keyword `self`
 654 class TKwself
 655         super TokenKeyword
 656 end
 657
 658 # The keyword `true`
 659 class TKwtrue
 660         super TokenKeyword
 661 end
 662
 663 # The keyword `false`
 664 class TKwfalse
 665         super TokenKeyword
 666 end
 667
 668 # The keyword `null`
 669 class TKwnull
 670         super TokenKeyword
 671 end
 672
 673 # The keyword `as`
 674 class TKwas
 675         super TokenKeyword
 676 end
 677
 678 # The keyword `nullable`
 679 class TKwnullable
 680         super TokenKeyword
 681 end
 682
 683 # The keyword `isset`
 684 class TKwisset
 685         super TokenKeyword
 686 end
 687
 688 # The keyword `label`
 689 class TKwlabel
 690         super TokenKeyword
 691 end
 692
 693 # The keyword `with`
 694 class TKwwith
 695         super TokenKeyword
 696 end
 697
 698 # The special keyword `__DEBUG__`
 699 class TKwdebug
 700         super Token
 701 end
 702
 703 # The symbol `(`
 704 class TOpar
 705         super Token
 706 end
 707
 708 # The symbol `)`
 709 class TCpar
 710         super Token
 711 end
 712
 713 # The symbol `[`
 714 class TObra
 715         super Token
 716 end
 717
 718 # The symbol `]`
 719 class TCbra
 720         super Token
 721 end
 722
 723 # The symbol `,`
 724 class TComma
 725         super Token
 726 end
 727
 728 # The symbol `:`
 729 class TColumn
 730         super Token
 731 end
 732
 733 # The symbol `::`
 734 class TQuad
 735         super Token
 736 end
 737
 738 # The symbol `=`
 739 class TAssign
 740         super Token
 741 end
 742
 743 # A token associated with an operator (and other lookalike symbols)
 744 abstract class TokenOperator
 745         super Token
 746         redef fun to_s
 747         do
 748                 return "operator '{text}'"
 749         end
 750 end
 751
 752 # The operator `+=`
 753 class TPluseq
 754         super TokenOperator
 755 end
 756
 757 # The operator `-=`
 758 class TMinuseq
 759         super TokenOperator
 760 end
 761
 762 # The operator `*=`
 763 class TStareq
 764         super TokenOperator
 765 end
 766
 767 # The operator `/=`
 768 class TSlasheq
 769         super TokenOperator
 770 end
 771
 772 # The operator `%=`
 773 class TPercenteq
 774         super TokenOperator
 775 end
 776
 777 # The operator `**=`
 778 class TStarstareq
 779         super TokenOperator
 780 end
 781
 782 # The operator `|=`
 783 class TPipeeq
 784         super TokenOperator
 785 end
 786
 787 # The operator `^=`
 788 class TCareteq
 789         super TokenOperator
 790 end
 791
 792 # The operator `&=`
 793 class TAmpeq
 794         super TokenOperator
 795 end
 796
 797 # The operator `<<=`
 798 class TLleq
 799         super TokenOperator
 800 end
 801
 802 # The operator `>>=`
 803 class TGgeq
 804         super TokenOperator
 805 end
 806
 807 # The symbol `...`
 808 class TDotdotdot
 809         super Token
 810 end
 811
 812 # The symbol `..`
 813 class TDotdot
 814         super Token
 815 end
 816
 817 # The symbol `.`
 818 class TDot
 819         super Token
 820 end
 821
 822 # The operator `+`
 823 class TPlus
 824         super TokenOperator
 825 end
 826
 827 # The operator `-`
 828 class TMinus
 829         super TokenOperator
 830 end
 831
 832 # The operator `*`
 833 class TStar
 834         super TokenOperator
 835 end
 836
 837 # The operator `**`
 838 class TStarstar
 839         super TokenOperator
 840 end
 841
 842 # The operator `/`
 843 class TSlash
 844         super TokenOperator
 845 end
 846
 847 # The operator `%`
 848 class TPercent
 849         super TokenOperator
 850 end
 851
 852 # The operator `|`
 853 class TPipe
 854         super TokenOperator
 855 end
 856
 857 # The operator `^`
 858 class TCaret
 859         super TokenOperator
 860 end
 861
 862 # The operator `&`
 863 class TAmp
 864         super TokenOperator
 865 end
 866
 867 # The operator `~`
 868 class TTilde
 869         super TokenOperator
 870 end
 871
 872 # The operator `==`
 873 class TEq
 874         super TokenOperator
 875 end
 876
 877 # The operator `!=`
 878 class TNe
 879         super TokenOperator
 880 end
 881
 882 # The operator `<`
 883 class TLt
 884         super TokenOperator
 885 end
 886
 887 # The operator `<=`
 888 class TLe
 889         super TokenOperator
 890 end
 891
 892 # The operator `<<`
 893 class TLl
 894         super TokenOperator
 895 end
 896
 897 # The operator `>`
 898 class TGt
 899         super TokenOperator
 900 end
 901
 902 # The operator `>=`
 903 class TGe
 904         super TokenOperator
 905 end
 906
 907 # The operator `>>`
 908 class TGg
 909         super TokenOperator
 910 end
 911
 912 # The operator `<=>`
 913 class TStarship
 914         super TokenOperator
 915 end
 916
 917 # The operator `!`
 918 class TBang
 919         super TokenOperator
 920 end
 921
 922 # The symbol `@`
 923 class TAt
 924         super Token
 925 end
 926
 927 # The symbol `;`
 928 class TSemi
 929         super Token
 930 end
 931
 932 # A class (or formal type) identifier. They start with an uppercase.
 933 class TClassid
 934         super Token
 935         redef fun to_s
 936         do
 937                 do return "type identifier '{text}'"
 938         end
 939 end
 940
 941 # A standard identifier (variable, method...). They start with a lowercase.
 942 class TId
 943         super Token
 944         redef fun to_s
 945         do
 946                 do return "identifier '{text}'"
 947         end
 948 end
 949
 950 # An attribute identifier. They start with an underscore.
 951 class TAttrid
 952         super Token
 953         redef fun to_s
 954         do
 955                 do return "attribute '{text}'"
 956         end
 957 end
 958
 959 # A token of a literal value (string, integer, etc).
 960 abstract class TokenLiteral
 961         super Token
 962         redef fun to_s
 963         do
 964                 do return "literal value '{text}'"
 965         end
 966 end
 967
 968 # A literal decimal integer
 969 class TNumber
 970         super TokenLiteral
 971 end
 972
 973 # A literal hexadecimal integer
 974 class THexNumber
 975         super TokenLiteral
 976 end
 977
 978 # A literal floating point number
 979 class TFloat
 980         super TokenLiteral
 981 end
 982
 983 # A literal character
 984 class TChar
 985         super TokenLiteral
 986 end
 987
 988 # A literal string
 989 class TString
 990         super TokenLiteral
 991 end
 992
 993 # The starting part of a super string (between `"` and `{`)
 994 class TStartString
 995         super TokenLiteral
 996 end
 997
 998 # The middle part of a super string (between `}` and `{`)
 999 class TMidString
1000         super TokenLiteral
1001 end
1002
1003 # The final part of a super string (between `}` and `"`)
1004 class TEndString
1005         super TokenLiteral
1006 end
1007
1008 # A malformed string
1009 class TBadString
1010         super Token
1011         redef fun to_s
1012         do
1013                 do return "malformed string {text}"
1014         end
1015 end
1016
1017 # A malformed char
1018 class TBadChar
1019         super Token
1020         redef fun to_s
1021         do
1022                 do return "malformed character {text}"
1023         end
1024 end
1025
1026 # A extern code block
1027 class TExternCodeSegment
1028         super Token
1029 end
1030
1031 # A end of file
1032 class EOF
1033         super Token
1034         redef fun to_s
1035         do
1036                 return "end of file"
1037         end
1038 end
1039
1040 # A mark of an error
1041 class AError
1042         super EOF
1043 end
1044 # A lexical error (unexpected character)
1045 class ALexerError
1046         super AError
1047 end
1048 # A syntactic error (unexpected token)
1049 class AParserError
1050         super AError
1051 end
1052
1053 # The main node of a Nit source-file
1054 class AModule
1055         super Prod
1056
1057         # The declaration part of the module
1058         var n_moduledecl: nullable AModuledecl = null is writable
1059
1060         # List of importation clauses
1061         var n_imports = new ANodes[AImport](self)
1062
1063         # List of extern blocks
1064         var n_extern_code_blocks = new ANodes[AExternCodeBlock](self)
1065
1066         # List of class definition (including top-level methods and the main)
1067         var n_classdefs = new ANodes[AClassdef](self)
1068 end
1069
1070 # Abstract class for definition of entities
1071 abstract class ADefinition
1072         super Prod
1073         # The documentation
1074         var n_doc: nullable ADoc = null is writable
1075
1076         # The `redef` keyword
1077         var n_kwredef: nullable TKwredef = null is writable
1078
1079         # The declared visibility
1080         var n_visibility: nullable AVisibility = null is writable
1081 end
1082
1083 # The declaration of the module with the documentation, name, and annotations
1084 class AModuledecl
1085         super ADefinition
1086
1087         # The `module` keyword
1088         var n_kwmodule: TKwmodule is writable, noinit
1089
1090         # The declared module name
1091         var n_name: AModuleName is writable, noinit
1092 end
1093
1094 # A import clause of a module
1095 abstract class AImport
1096         super Prod
1097
1098         # The declared visibility
1099         var n_visibility: AVisibility is writable, noinit
1100
1101         # The `import` keyword
1102         var n_kwimport: TKwimport is writable, noinit
1103 end
1104
1105 # A standard import clause. eg `import x`
1106 class AStdImport
1107         super AImport
1108         # The imported module name
1109         var n_name: AModuleName is writable, noinit
1110 end
1111
1112 # The special import clause of the kernel module. eg `import end`
1113 class ANoImport
1114         super AImport
1115         # The `end` keyword, that indicate the root module
1116         var n_kwend: TKwend is writable, noinit
1117 end
1118
1119 # A visibility modifier
1120 #
1121 # The public visibility is an empty production (no keyword).
1122 #
1123 # Note: even if some visibilities are only valid on some placse (for instance, no `protected` class or no `intrude` method)
1124 # the parser has no such a restriction, therefore the semantic phases has to check that the visibilities make sense.
1125 abstract class AVisibility
1126         super Prod
1127 end
1128
1129 # An implicit or explicit public visibility modifier
1130 class APublicVisibility
1131         super AVisibility
1132         # The `public` keyword, if any
1133         var n_kwpublic: nullable TKwpublic is writable
1134 end
1135 # An explicit private visibility modifier
1136 class APrivateVisibility
1137         super AVisibility
1138         # The `private` keyword
1139         var n_kwprivate: TKwprivate is writable, noinit
1140 end
1141 # An explicit protected visibility modifier
1142 class AProtectedVisibility
1143         super AVisibility
1144         # The `protected` keyword
1145         var n_kwprotected: TKwprotected is writable, noinit
1146 end
1147 # An explicit intrude visibility modifier
1148 class AIntrudeVisibility
1149         super AVisibility
1150         # The `intrude` keyword
1151         var n_kwintrude: TKwintrude is writable, noinit
1152 end
1153
1154 # A class definition
1155 # While most definition are `AStdClassdef`
1156 # There is tow special case of class definition
1157 abstract class AClassdef
1158         super Prod
1159         # All the declared properties (including the main method)
1160         var n_propdefs = new ANodes[APropdef](self)
1161 end
1162
1163 # A standard class definition with a name, superclasses and properties
1164 class AStdClassdef
1165         super AClassdef
1166         super ADefinition
1167
1168         # The class kind (interface, abstract class, etc.)
1169         var n_classkind: AClasskind is writable, noinit
1170
1171         # The name of the class
1172         var n_id: nullable TClassid = null is writable
1173
1174         # The `[` symbol
1175         var n_obra: nullable TObra = null is writable
1176
1177         # The list of formal parameter types
1178         var n_formaldefs = new ANodes[AFormaldef](self)
1179
1180         # The `]` symbol
1181         var n_cbra: nullable TCbra = null is writable
1182
1183         # The extern block code
1184         var n_extern_code_block: nullable AExternCodeBlock = null is writable
1185
1186         # The `end` keyword
1187         var n_kwend: TKwend is writable, noinit
1188
1189         fun n_superclasses: Array[ASuperPropdef] do
1190                 return [for d in n_propdefs do if d isa ASuperPropdef then d]
1191         end
1192
1193         redef fun hot_location do return n_id.location
1194 end
1195
1196 # The implicit class definition of the implicit main method
1197 class ATopClassdef
1198         super AClassdef
1199 end
1200
1201 # The implicit class definition of the top-level methods
1202 class AMainClassdef
1203         super AClassdef
1204 end
1205
1206 # The modifier for the kind of class (abstract, interface, etc.)
1207 abstract class AClasskind
1208         super Prod
1209 end
1210
1211 # A default, or concrete class modifier (just `class`)
1212 class AConcreteClasskind
1213         super AClasskind
1214
1215         # The `class` keyword.
1216         var n_kwclass: TKwclass is writable, noinit
1217 end
1218
1219 # An abstract class modifier (`abstract class`)
1220 class AAbstractClasskind
1221         super AClasskind
1222
1223         # The `abstract` keyword.
1224         var n_kwabstract: TKwabstract is writable, noinit
1225
1226         # The `class` keyword.
1227         var n_kwclass: TKwclass is writable, noinit
1228 end
1229
1230 # An interface class modifier (`interface`)
1231 class AInterfaceClasskind
1232         super AClasskind
1233
1234         # The `interface` keyword.
1235         var n_kwinterface: TKwinterface is writable, noinit
1236 end
1237
1238 # An enum/universal class modifier (`enum class`)
1239 class AEnumClasskind
1240         super AClasskind
1241
1242         # The `enum` keyword.
1243         var n_kwenum: TKwenum is writable, noinit
1244 end
1245
1246 # An extern class modifier (`extern class`)
1247 class AExternClasskind
1248         super AClasskind
1249
1250         # The `extern` keyword.
1251         var n_kwextern: TKwextern is writable, noinit
1252
1253         # The `class` keyword.
1254         var n_kwclass: nullable TKwclass = null is writable
1255 end
1256
1257 # The definition of a formal generic parameter type. eg `X: Y`
1258 class AFormaldef
1259         super Prod
1260
1261         # The name of the parameter type
1262         var n_id: TClassid is writable, noinit
1263
1264         # The bound of the parameter type
1265         var n_type: nullable AType = null is writable
1266 end
1267
1268 # The definition of a property
1269 abstract class APropdef
1270         super ADefinition
1271 end
1272
1273 # A definition of an attribute
1274 # For historical reason, old-syle and new-style attributes use the same `ANode` sub-class
1275 class AAttrPropdef
1276         super APropdef
1277
1278         # The `var` keyword
1279         var n_kwvar: TKwvar is writable, noinit
1280
1281         # The identifier for a new-style attribute
1282         var n_id2: TId is writable, noinit
1283
1284         # The declared type of the attribute
1285         var n_type: nullable AType = null is writable
1286
1287         # The `=` symbol
1288         var n_assign: nullable TAssign = null is writable
1289
1290         # The initial value, if any (set with `=`)
1291         var n_expr: nullable AExpr = null is writable
1292
1293         # The `do` keyword
1294         var n_kwdo: nullable TKwdo = null is writable
1295
1296         # The initial value, if any (set with `do return`)
1297         var n_block: nullable AExpr = null is writable
1298
1299         # The `end` keyword
1300         var n_kwend: nullable TKwend = null is writable
1301
1302         redef fun hot_location
1303         do
1304                 return n_id2.location
1305         end
1306 end
1307
1308 # A definition of all kind of method (including constructors)
1309 class AMethPropdef
1310         super APropdef
1311
1312         # The `fun` keyword, if any
1313         var n_kwmeth: nullable TKwmeth = null is writable
1314
1315         # The `init` keyword, if any
1316         var n_kwinit: nullable TKwinit = null is writable
1317
1318         # The `new` keyword, if any
1319         var n_kwnew: nullable TKwnew = null is writable
1320
1321         # The name of the method, if any
1322         var n_methid: nullable AMethid = null is writable
1323
1324         # The signature of the method, if any
1325         var n_signature: nullable ASignature = null is writable
1326
1327         # The `do` keyword
1328         var n_kwdo: nullable TKwdo = null is writable
1329
1330         # The body (in Nit) of the method, if any
1331         var n_block: nullable AExpr = null is writable
1332
1333         # The `end` keyword
1334         var n_kwend: nullable TKwend = null is writable
1335
1336         # The list of declared callbacks (for extern methods)
1337         var n_extern_calls: nullable AExternCalls = null is writable
1338
1339         # The body (in extern code) of the method, if any
1340         var n_extern_code_block: nullable AExternCodeBlock = null is writable
1341
1342         redef fun hot_location
1343         do
1344                 if n_methid != null then
1345                         return n_methid.location
1346                 else if n_kwinit != null then
1347                         return n_kwinit.location
1348                 else if n_kwnew != null then
1349                         return n_kwnew.location
1350                 else
1351                         return location
1352                 end
1353         end
1354 end
1355
1356 # The implicit main method
1357 class AMainMethPropdef
1358         super AMethPropdef
1359 end
1360
1361 class AAnnotPropdef
1362         super APropdef
1363         super AAnnotation
1364 end
1365
1366 # A super-class. eg `super X`
1367 class ASuperPropdef
1368         super APropdef
1369
1370         # The super keyword
1371         var n_kwsuper: TKwsuper is writable, noinit
1372
1373         # The super-class (indicated as a type)
1374         var n_type: AType is writable, noinit
1375 end
1376
1377
1378 # Declaration of callbacks for extern methods
1379 class AExternCalls
1380         super Prod
1381
1382         # The `import` keyword
1383         var n_kwimport: TKwimport is writable, noinit
1384
1385         # The list of declared callbacks
1386         var n_extern_calls: ANodes[AExternCall] = new ANodes[AExternCall](self)
1387 end
1388
1389 # A single callback declaration
1390 abstract class AExternCall
1391         super Prod
1392 end
1393
1394 # A single callback declaration on a method
1395 abstract class APropExternCall
1396         super AExternCall
1397 end
1398
1399 # A single callback declaration on a method on the current receiver
1400 class ALocalPropExternCall
1401         super APropExternCall
1402
1403         # The name of the called-back method
1404         var n_methid: AMethid is writable, noinit
1405 end
1406
1407 # A single callback declaration on a method on an explicit receiver type.
1408 class AFullPropExternCall
1409         super APropExternCall
1410
1411         # The type of the receiver of the called-back method
1412         var n_type: AType is writable, noinit
1413
1414         # The dot `.`
1415         var n_dot: nullable TDot = null is writable
1416
1417         # The name of the called-back method
1418         var n_methid: AMethid is writable, noinit
1419 end
1420
1421 # A single callback declaration on a method on a constructor
1422 class AInitPropExternCall
1423         super APropExternCall
1424
1425         # The allocated type
1426         var n_type: AType is writable, noinit
1427 end
1428
1429 # A single callback declaration on a `super` call
1430 class ASuperExternCall
1431         super AExternCall
1432
1433         # The `super` keyword
1434         var n_kwsuper: TKwsuper is writable, noinit
1435 end
1436
1437 # A single callback declaration on a cast
1438 abstract class ACastExternCall
1439         super AExternCall
1440 end
1441
1442 # A single callback declaration on a cast to a given type
1443 class ACastAsExternCall
1444         super ACastExternCall
1445
1446         # The origin type of the cast
1447         var n_from_type: AType is writable, noinit
1448
1449         # The dot (`.`)
1450         var n_dot: nullable TDot = null is writable
1451
1452         # The `as` keyword
1453         var n_kwas: TKwas is writable, noinit
1454
1455         # The destination of the cast
1456         var n_to_type: AType is writable, noinit
1457 end
1458
1459 # A single callback declaration on a cast to a nullable type
1460 class AAsNullableExternCall
1461         super ACastExternCall
1462
1463         # The origin type to cast as nullable
1464         var n_type: AType is writable, noinit
1465
1466         # The `as` keyword
1467         var n_kwas: TKwas is writable, noinit
1468
1469         # The `nullable` keyword
1470         var n_kwnullable: TKwnullable is writable, noinit
1471 end
1472
1473 # A single callback declaration on a cast to a non-nullable type
1474 class AAsNotNullableExternCall
1475         super ACastExternCall
1476
1477         # The destination type on a cast to not nullable
1478         var n_type: AType is writable, noinit
1479
1480         # The `as` keyword.
1481         var n_kwas: TKwas is writable, noinit
1482
1483         # The `not` keyword
1484         var n_kwnot: TKwnot is writable, noinit
1485
1486         # The `nullable` keyword
1487         var n_kwnullable: TKwnullable is writable, noinit
1488 end
1489
1490 # A definition of a virtual type
1491 class ATypePropdef
1492         super APropdef
1493
1494         # The `type` keyword
1495         var n_kwtype: TKwtype is writable, noinit
1496
1497         # The name of the virtual type
1498         var n_id: TClassid is writable, noinit
1499
1500         # The bound of the virtual type
1501         var n_type: AType is writable, noinit
1502 end
1503
1504 # The identifier of a method in a method declaration.
1505 # There is a specific class because of operator and setters.
1506 abstract class AMethid
1507         super Prod
1508 end
1509
1510 # A method name with a simple identifier
1511 class AIdMethid
1512         super AMethid
1513
1514         # The simple identifier
1515         var n_id: TId is writable, noinit
1516 end
1517
1518 # A method name for an operator
1519 class AOperatorMethid
1520         super AMethid
1521
1522         # The associated operator symbol
1523         var n_op: Token is writable, noinit
1524 end
1525 # A method name `+`
1526 class APlusMethid
1527         super AOperatorMethid
1528 end
1529
1530 # A method name `-`
1531 class AMinusMethid
1532         super AOperatorMethid
1533 end
1534
1535 # A method name `*`
1536 class AStarMethid
1537         super AOperatorMethid
1538 end
1539
1540 # A method name `**`
1541 class AStarstarMethid
1542         super AOperatorMethid
1543 end
1544
1545 # A method name `/`
1546 class ASlashMethid
1547         super AOperatorMethid
1548 end
1549
1550 # A method name `%`
1551 class APercentMethid
1552         super AOperatorMethid
1553 end
1554
1555 # A method name `|`
1556 class APipeMethid
1557         super AOperatorMethid
1558 end
1559
1560 # A method name `^`
1561 class ACaretMethid
1562         super AOperatorMethid
1563 end
1564
1565 # A method name `&`
1566 class AAmpMethid
1567         super AOperatorMethid
1568 end
1569
1570 # A method name `~`
1571 class ATildeMethid
1572         super AOperatorMethid
1573 end
1574
1575 # A method name `==`
1576 class AEqMethid
1577         super AOperatorMethid
1578 end
1579
1580 # A method name `!=`
1581 class ANeMethid
1582         super AOperatorMethid
1583 end
1584
1585 # A method name `<=`
1586 class ALeMethid
1587         super AOperatorMethid
1588 end
1589
1590 # A method name `>=`
1591 class AGeMethid
1592         super AOperatorMethid
1593 end
1594
1595 # A method name `<`
1596 class ALtMethid
1597         super AOperatorMethid
1598 end
1599
1600 # A method name `>`
1601 class AGtMethid
1602         super AOperatorMethid
1603 end
1604
1605 # A method name `<<`
1606 class ALlMethid
1607         super AOperatorMethid
1608 end
1609
1610 # A method name `>>`
1611 class AGgMethid
1612         super AOperatorMethid
1613 end
1614
1615 # A method name `<=>`
1616 class AStarshipMethid
1617         super AOperatorMethid
1618 end
1619
1620 # A method name `[]`
1621 class ABraMethid
1622         super AMethid
1623
1624         # The `[` symbol
1625         var n_obra: TObra is writable, noinit
1626
1627         # The `]` symbol
1628         var n_cbra: TCbra is writable, noinit
1629 end
1630
1631 # A setter method name with a simple identifier (with a `=`)
1632 class AAssignMethid
1633         super AMethid
1634
1635         # The base identifier
1636         var n_id: TId is writable, noinit
1637
1638         # The `=` symbol
1639         var n_assign: TAssign is writable, noinit
1640 end
1641
1642 # A method name `[]=`
1643 class ABraassignMethid
1644         super AMethid
1645
1646         # The `[` symbol
1647         var n_obra: TObra is writable, noinit
1648
1649         # The `]` symbol
1650         var n_cbra: TCbra is writable, noinit
1651
1652         # The `=` symbol
1653         var n_assign: TAssign is writable, noinit
1654 end
1655
1656 # A signature in a method definition. eg `(x,y:X,z:Z):T`
1657 class ASignature
1658         super Prod
1659
1660         # The `(` symbol
1661         var n_opar: nullable TOpar = null is writable
1662
1663         # The list of parameters
1664         var n_params = new ANodes[AParam](self)
1665
1666         # The `)` symbol
1667         var n_cpar: nullable TCpar = null is writable
1668
1669         # The return type
1670         var n_type: nullable AType = null is writable
1671 end
1672
1673 # A parameter definition in a signature. eg `x:X`
1674 class AParam
1675         super Prod
1676
1677         # The name of the parameter
1678         var n_id: TId is writable, noinit
1679
1680         # The type of the parameter, if any
1681         var n_type: nullable AType = null is writable
1682
1683         # The `...` symbol to indicate varargs
1684         var n_dotdotdot: nullable TDotdotdot = null is writable
1685 end
1686
1687 # A static type. eg `nullable X[Y]`
1688 class AType
1689         super Prod
1690         # The `nullable` keyword
1691         var n_kwnullable: nullable TKwnullable = null is writable
1692
1693         # The name of the class or of the formal type
1694         var n_id: TClassid is writable, noinit
1695
1696         # The opening bracket
1697         var n_obra: nullable TObra = null is writable
1698
1699         # Type arguments for a generic type
1700         var n_types = new ANodes[AType](self)
1701
1702         # The closing bracket
1703         var n_cbra: nullable TCbra = null is writable
1704 end
1705
1706 # A label at the end of a block or in a break/continue statement. eg `label x`
1707 class ALabel
1708         super Prod
1709
1710         # The `label` keyword
1711         var n_kwlabel: TKwlabel is writable, noinit
1712
1713         # The name of the label, if any
1714         var n_id: nullable TId is writable, noinit
1715 end
1716
1717 # Expression and statements
1718 # From a AST point of view there is no distinction between statement and expressions (even if the parser has to distinguish them)
1719 abstract class AExpr
1720         super Prod
1721 end
1722
1723 # A sequence of `AExpr` (usually statements)
1724 # The last `AExpr` gives the value of the whole block
1725 class ABlockExpr
1726         super AExpr
1727
1728         # The list of statements in the bloc.
1729         # The last element is often considered as an expression that give the value of the whole block.
1730         var n_expr = new ANodes[AExpr](self)
1731
1732         # The `end` keyword
1733         var n_kwend: nullable TKwend = null is writable
1734 end
1735
1736 # A declaration of a local variable. eg `var x: X = y`
1737 class AVardeclExpr
1738         super AExpr
1739
1740         # The `var` keyword
1741         var n_kwvar: nullable TKwvar = null is writable
1742
1743         # The name of the local variable
1744         var n_id: TId is writable, noinit
1745
1746         # The declaration type of the local variable
1747         var n_type: nullable AType = null is writable
1748
1749         # The `=` symbol (for the initial value)
1750         var n_assign: nullable TAssign = null is writable
1751
1752         # The initial value, if any
1753         var n_expr: nullable AExpr = null is writable
1754 end
1755
1756 # A `return` statement. eg `return x`
1757 class AReturnExpr
1758         super AExpr
1759
1760         # The `return` keyword
1761         var n_kwreturn: nullable TKwreturn = null is writable
1762
1763         # The return value, if any
1764         var n_expr: nullable AExpr = null is writable
1765 end
1766
1767 # Something that has a label.
1768 abstract class ALabelable
1769         super Prod
1770
1771         # The associated label declatation
1772         var n_label: nullable ALabel = null is writable
1773 end
1774
1775 # A `break` or a `continue`
1776 abstract class AEscapeExpr
1777         super AExpr
1778         super ALabelable
1779
1780         # The return value, if nay (unused currently)
1781         var n_expr: nullable AExpr = null is writable
1782 end
1783
1784 # A `break` statement.
1785 class ABreakExpr
1786         super AEscapeExpr
1787
1788         # The `break` keyword
1789         var n_kwbreak: TKwbreak is writable, noinit
1790 end
1791
1792 # An `abort` statement
1793 class AAbortExpr
1794         super AExpr
1795
1796         # The `abort` keyword
1797         var n_kwabort: TKwabort is writable, noinit
1798 end
1799
1800 # A `continue` statement
1801 class AContinueExpr
1802         super AEscapeExpr
1803
1804         # The `continue` keyword.
1805         var n_kwcontinue: nullable TKwcontinue = null is writable
1806 end
1807
1808 # A `do` statement
1809 class ADoExpr
1810         super AExpr
1811         super ALabelable
1812
1813         # The `do` keyword
1814         var n_kwdo: TKwdo is writable, noinit
1815
1816         # The list of statements of the `do`.
1817         var n_block: nullable AExpr = null is writable
1818 end
1819
1820 # A `if` statement
1821 class AIfExpr
1822         super AExpr
1823
1824         # The `if` keyword
1825         var n_kwif: TKwif is writable, noinit
1826
1827         # The expression used as the condition of the `if`
1828         var n_expr: AExpr is writable, noinit
1829
1830         # The `then` keyword
1831         var n_kwthen: TKwthen is writable, noinit
1832
1833         # The body of the `then` part
1834         var n_then: nullable AExpr = null is writable
1835
1836         # The `else` keyword
1837         var n_kwelse: nullable TKwelse = null is writable
1838
1839         # The body of the `else` part
1840         var n_else: nullable AExpr = null is writable
1841 end
1842
1843 # A `if` expression (ternary conditional). eg. `if true then 1 else 0`
1844 class AIfexprExpr
1845         super AExpr
1846
1847         # The `if` keyword
1848         var n_kwif: TKwif is writable, noinit
1849
1850         # The expression used as the condition of the `if`
1851         var n_expr: AExpr is writable, noinit
1852
1853         # The `then` keyword
1854         var n_kwthen: TKwthen is writable, noinit
1855
1856         # The expression in the `then` part
1857         var n_then: AExpr is writable, noinit
1858
1859         # The `else` keyword
1860         var n_kwelse: TKwelse is writable, noinit
1861
1862         # The expression in the `else` part
1863         var n_else: AExpr is writable, noinit
1864 end
1865
1866 # A `while` statement
1867 class AWhileExpr
1868         super AExpr
1869         super ALabelable
1870
1871         # The `while` keyword
1872         var n_kwwhile:  TKwwhile is writable, noinit
1873
1874         # The expression used as the condition of the `while`
1875         var n_expr: AExpr is writable, noinit
1876
1877         # The `do` keyword
1878         var n_kwdo: TKwdo is writable, noinit
1879
1880         # The body of the loop
1881         var n_block: nullable AExpr = null is writable
1882 end
1883
1884 # A `loop` statement
1885 class ALoopExpr
1886         super AExpr
1887         super ALabelable
1888
1889         # The `loop` keyword
1890         var n_kwloop: TKwloop is writable, noinit
1891
1892         # The body of the loop
1893         var n_block: nullable AExpr = null is writable
1894 end
1895
1896 # A `for` statement
1897 class AForExpr
1898         super AExpr
1899         super ALabelable
1900
1901         # The `for` keyword
1902         var n_kwfor: TKwfor is writable, noinit
1903
1904         # The list of name of the automatic variables
1905         var n_ids = new ANodes[TId](self)
1906
1907         # The `in` keyword
1908         var n_kwin: TKwin is writable, noinit
1909
1910         # The expression used as the collection to iterate on
1911         var n_expr: AExpr is writable, noinit
1912
1913         # The `do` keyword
1914         var n_kwdo: TKwdo is writable, noinit
1915
1916         # The body of the loop
1917         var n_block: nullable AExpr = null is writable
1918 end
1919
1920 # A `with` statement
1921 class AWithExpr
1922         super AExpr
1923         super ALabelable
1924
1925         # The `with` keyword
1926         var n_kwwith: TKwwith is writable, noinit
1927
1928         # The expression used to get the value to control
1929         var n_expr: AExpr is writable, noinit
1930
1931         # The `do` keyword
1932         var n_kwdo: TKwdo is writable, noinit
1933
1934         # The body of the loop
1935         var n_block: nullable AExpr = null is writable
1936 end
1937
1938 # An `assert` statement
1939 class AAssertExpr
1940         super AExpr
1941
1942         # The `assert` keyword
1943         var n_kwassert: TKwassert is writable, noinit
1944
1945         # The name of the assert, if any
1946         var n_id: nullable TId = null is writable
1947
1948         # The expression used as the condition of the `assert`
1949         var n_expr: AExpr is writable, noinit
1950
1951         # The `else` keyword
1952         var n_kwelse: nullable TKwelse = null is writable
1953
1954         # The body to execute when the assert fails
1955         var n_else: nullable AExpr = null is writable
1956 end
1957
1958 # Whatever is a simple assignment. eg `= something`
1959 abstract class AAssignFormExpr
1960         super AExpr
1961
1962         # The `=` symbol
1963         var n_assign: TAssign is writable, noinit
1964
1965         # The right-value to assign.
1966         var n_value: AExpr is writable, noinit
1967 end
1968
1969 # Whatever is a combined assignment. eg `+= something`
1970 abstract class AReassignFormExpr
1971         super AExpr
1972
1973         # The combined operator (eg. `+=`)
1974         var n_assign_op: AAssignOp is writable, noinit
1975
1976         # The right-value to apply on the combined operator.
1977         var n_value: AExpr is writable, noinit
1978 end
1979
1980 # A `once` expression. eg `once x`
1981 class AOnceExpr
1982         super AExpr
1983
1984         # The `once` keyword
1985         var n_kwonce: TKwonce is writable, noinit
1986
1987         # The expression to evaluate only one time
1988         var n_expr: AExpr is writable, noinit
1989 end
1990
1991 # A polymorphic invocation of a method
1992 # The form of the invocation (name, arguments, etc.) are specific
1993 abstract class ASendExpr
1994         super AExpr
1995         # The receiver of the method invocation
1996         var n_expr: AExpr is writable, noinit
1997 end
1998
1999 # A binary operation on a method
2000 abstract class ABinopExpr
2001         super ASendExpr
2002
2003         # The operator
2004         var n_op: Token is writable, noinit
2005
2006         # The second operand of the operation
2007         # Note: the receiver (`n_expr`) is the first operand
2008         var n_expr2: AExpr is writable, noinit
2009
2010         # The name of the operator (eg '+')
2011         fun operator: String is abstract
2012 end
2013
2014 # Something that is boolean expression
2015 abstract class ABoolExpr
2016         super AExpr
2017 end
2018
2019 # Something that is binary boolean expression
2020 abstract class ABinBoolExpr
2021         super ABoolExpr
2022
2023         # The first boolean operand
2024         var n_expr: AExpr is writable, noinit
2025
2026         # The operator
2027         var n_op: Token is writable, noinit
2028
2029         # The second boolean operand
2030         var n_expr2: AExpr is writable, noinit
2031 end
2032
2033 # A `or` expression
2034 class AOrExpr
2035         super ABinBoolExpr
2036 end
2037
2038 # A `and` expression
2039 class AAndExpr
2040         super ABinBoolExpr
2041 end
2042
2043 # A `or else` expression
2044 class AOrElseExpr
2045         super ABinBoolExpr
2046
2047         # The `else` keyword
2048         var n_kwelse: TKwelse is writable, noinit
2049 end
2050
2051 # A `implies` expression
2052 class AImpliesExpr
2053         super ABinBoolExpr
2054 end
2055
2056 # A `not` expression
2057 class ANotExpr
2058         super ABoolExpr
2059
2060         # The `not` keyword
2061         var n_kwnot: TKwnot is writable, noinit
2062
2063         # The boolean operand of the `not`
2064         var n_expr: AExpr is writable, noinit
2065 end
2066
2067 # A `==` expression
2068 class AEqExpr
2069         super ABinopExpr
2070         redef fun operator do return "=="
2071 end
2072
2073 # A `!=` expression
2074 class ANeExpr
2075         super ABinopExpr
2076         redef fun operator do return "!="
2077 end
2078
2079 # A `<` expression
2080 class ALtExpr
2081         super ABinopExpr
2082         redef fun operator do return "<"
2083 end
2084
2085 # A `<=` expression
2086 class ALeExpr
2087         super ABinopExpr
2088         redef fun operator do return "<="
2089 end
2090
2091 # A `<<` expression
2092 class ALlExpr
2093         super ABinopExpr
2094         redef fun operator do return "<<"
2095 end
2096
2097 # A `>` expression
2098 class AGtExpr
2099         super ABinopExpr
2100         redef fun operator do return ">"
2101 end
2102
2103 # A `>=` expression
2104 class AGeExpr
2105         super ABinopExpr
2106         redef fun operator do return ">="
2107 end
2108
2109 # A `>>` expression
2110 class AGgExpr
2111         super ABinopExpr
2112         redef fun operator do return ">>"
2113 end
2114
2115 # A type-ckeck expression. eg `x isa T`
2116 class AIsaExpr
2117         super ABoolExpr
2118
2119         # The expression to check
2120         var n_expr: AExpr is writable, noinit
2121
2122         # The `isa` keyword
2123         var n_kwisa: TKwisa is writable, noinit
2124
2125         # The destination type to check to
2126         var n_type: AType is writable, noinit
2127 end
2128
2129 # A `+` expression
2130 class APlusExpr
2131         super ABinopExpr
2132         redef fun operator do return "+"
2133 end
2134
2135 # A `-` expression
2136 class AMinusExpr
2137         super ABinopExpr
2138         redef fun operator do return "-"
2139 end
2140
2141 # A `<=>` expression
2142 class AStarshipExpr
2143         super ABinopExpr
2144         redef fun operator do return "<=>"
2145 end
2146
2147 # A `*` expression
2148 class AStarExpr
2149         super ABinopExpr
2150         redef fun operator do return "*"
2151 end
2152
2153 # A `**` expression
2154 class AStarstarExpr
2155         super ABinopExpr
2156         redef fun operator do return "**"
2157 end
2158
2159 # A `/` expression
2160 class ASlashExpr
2161         super ABinopExpr
2162         redef fun operator do return "/"
2163 end
2164
2165 # A `%` expression
2166 class APercentExpr
2167         super ABinopExpr
2168         redef fun operator do return "%"
2169 end
2170
2171 # A `|` expression
2172 class APipeExpr
2173         super ABinopExpr
2174         redef fun operator do return "|"
2175 end
2176
2177 # A `^` expression
2178 class ACaretExpr
2179         super ABinopExpr
2180         redef fun operator do return "^"
2181 end
2182
2183 # A `&` expression
2184 class AAmpExpr
2185         super ABinopExpr
2186         redef fun operator do return "&"
2187 end
2188
2189 # A unary operation on a method
2190 class AUnaryopExpr
2191         super ASendExpr
2192
2193         # The operator
2194         var n_op: Token is writable, noinit
2195
2196         # The name of the operator (eg '+')
2197         fun operator: String is abstract
2198 end
2199
2200 # A unary minus expression. eg `-x`
2201 class AUminusExpr
2202         super AUnaryopExpr
2203         redef fun operator do return "-"
2204 end
2205
2206 # A unary plus expression. eg `+x`
2207 class AUplusExpr
2208         super AUnaryopExpr
2209         redef fun operator do return "+"
2210 end
2211
2212 # A unary `~` expression
2213 class AUtildeExpr
2214         super AUnaryopExpr
2215         redef fun operator do return "~"
2216 end
2217
2218 # An explicit instantiation. eg `new T`
2219 class ANewExpr
2220         super AExpr
2221
2222         # The `new` keyword
2223         var n_kwnew: TKwnew is writable, noinit
2224
2225         # The `type` keyword
2226         var n_type: AType is writable, noinit
2227
2228         # The name of the named-constructor, if any
2229         var n_id: nullable TId = null is writable
2230
2231         # The arguments of the `new`
2232         var n_args: AExprs is writable, noinit
2233 end
2234
2235 # Whatever is a old-style attribute access
2236 abstract class AAttrFormExpr
2237         super AExpr
2238
2239         # The receiver of the attribute
2240         var n_expr: AExpr is writable, noinit
2241
2242         # The name of the attribute
2243         var n_id: TAttrid is writable, noinit
2244
2245 end
2246
2247 # The read of an attribute. eg `x._a`
2248 class AAttrExpr
2249         super AAttrFormExpr
2250 end
2251
2252 # The assignment of an attribute. eg `x._a=y`
2253 class AAttrAssignExpr
2254         super AAttrFormExpr
2255         super AAssignFormExpr
2256 end
2257
2258 # Whatever looks-like a call with a standard method and any number of arguments.
2259 abstract class ACallFormExpr
2260         super ASendExpr
2261
2262         # The name of the method
2263         var n_id: TId is writable, noinit
2264
2265         # The arguments of the call
2266         var n_args: AExprs is writable, noinit
2267 end
2268
2269 # A complex setter call (standard or brackets)
2270 abstract class ASendReassignFormExpr
2271         super ASendExpr
2272         super AReassignFormExpr
2273 end
2274
2275 # A complex attribute assignment. eg `x._a+=y`
2276 class AAttrReassignExpr
2277         super AAttrFormExpr
2278         super AReassignFormExpr
2279 end
2280
2281 # A call with a standard method-name and any number of arguments. eg `x.m(y)`. OR just a simple id
2282 # Note: because the parser cannot distinguish a variable read with a method call with an implicit receiver and no arguments, it always returns a `ACallExpr`.
2283 # Semantic analysis have to transform them to instance of `AVarExpr`.
2284 class ACallExpr
2285         super ACallFormExpr
2286 end
2287
2288 # A setter call with a standard method-name and any number of arguments. eg `x.m(y)=z`. OR just a simple assignment.
2289 # Note: because the parser cannot distinguish a variable write with a setter call with an implicit receiver and no arguments, it always returns a `ACallAssignExpr`.
2290 # Semantic analysis have to transform them to instance of `AVarAssignExpr`.
2291 class ACallAssignExpr
2292         super ACallFormExpr
2293         super AAssignFormExpr
2294 end
2295
2296 # A complex setter call with a standard method-name and any number of arguments. eg `x.m(y)+=z`. OR just a simple complex assignment.
2297 # Note: because the parser cannot distinguish a variable write with a complex setter call with an implicit receiver and no arguments, it always returns a `ACallReassignExpr`.
2298 # Semantic analysis have to transform them to instance of `AVarReassignExpr`.
2299 class ACallReassignExpr
2300         super ACallFormExpr
2301         super ASendReassignFormExpr
2302 end
2303
2304 # A call to `super`. OR a call of a super-constructor
2305 class ASuperExpr
2306         super AExpr
2307
2308         # The qualifier part before the super (currenlty unused)
2309         var n_qualified: nullable AQualified = null is writable
2310
2311         # The `super` keyword
2312         var n_kwsuper: TKwsuper is writable, noinit
2313
2314         # The arguments of the super
2315         var n_args: AExprs is writable, noinit
2316 end
2317
2318 # A call to the `init` constructor.
2319 # Note: because `init` is a keyword and not a `TId`, the explicit call to init cannot be a `ACallFormExpr`.
2320 class AInitExpr
2321         super ASendExpr
2322
2323         # The `init` keyword
2324         var n_kwinit: TKwinit is writable, noinit
2325
2326         # The arguments of the init
2327         var n_args: AExprs is writable, noinit
2328 end
2329
2330 # Whatever looks-like a call of the brackets `[]` operator.
2331 abstract class ABraFormExpr
2332         super ASendExpr
2333
2334         # The arguments inside the brackets
2335         var n_args: AExprs is writable, noinit
2336 end
2337
2338 # A call of the brackets operator. eg `x[y,z]`
2339 class ABraExpr
2340         super ABraFormExpr
2341 end
2342
2343 # A setter call of the bracket operator. eg `x[y,z]=t`
2344 class ABraAssignExpr
2345         super ABraFormExpr
2346         super AAssignFormExpr
2347 end
2348
2349 # Whatever is an access to a local variable
2350 abstract class AVarFormExpr
2351         super AExpr
2352
2353         # The name of the attribute
2354         var n_id: TId is writable, noinit
2355 end
2356
2357 # A complex setter call of the bracket operator. eg `x[y,z]+=t`
2358 class ABraReassignExpr
2359         super ABraFormExpr
2360         super ASendReassignFormExpr
2361 end
2362
2363 # A local variable read access.
2364 # The parser cannot instantiate them, see `ACallExpr`.
2365 class AVarExpr
2366         super AVarFormExpr
2367 end
2368
2369 # A local variable simple assignment access
2370 # The parser cannot instantiate them, see `ACallAssignExpr`.
2371 class AVarAssignExpr
2372         super AVarFormExpr
2373         super AAssignFormExpr
2374 end
2375
2376 # A local variable complex assignment access
2377 # The parser cannot instantiate them, see `ACallReassignExpr`.
2378 class AVarReassignExpr
2379         super AVarFormExpr
2380         super AReassignFormExpr
2381 end
2382
2383 # A literal range, open or closed
2384 abstract class ARangeExpr
2385         super AExpr
2386
2387         # The left (lower) element of the range
2388         var n_expr: AExpr is writable, noinit
2389
2390         # The `..`
2391         var n_dotdot: TDotdot is writable, noinit
2392
2393         # The right (upper) element of the range
2394         var n_expr2: AExpr is writable, noinit
2395 end
2396
2397 # A closed literal range. eg `[x..y]`
2398 class ACrangeExpr
2399         super ARangeExpr
2400
2401         # The opening bracket `[`
2402         var n_obra: TObra is writable, noinit
2403
2404         # The closing bracket `]`
2405         var n_cbra: TCbra is writable, noinit
2406 end
2407
2408 # An open literal range. eg `[x..y[`
2409 class AOrangeExpr
2410         super ARangeExpr
2411
2412         # The opening bracket `[`
2413         var n_obra: TObra is writable, noinit
2414
2415         # The closing bracket `[` (because open range)
2416         var n_cbra: TObra is writable, noinit
2417 end
2418
2419 # A literal array. eg. `[x,y,z]`
2420 class AArrayExpr
2421         super AExpr
2422
2423         # The opening bracket `[`
2424         var n_obra: TObra is writable, noinit
2425
2426         # The elements of the array
2427         var n_exprs = new ANodes[AExpr](self)
2428
2429         # The type of the element of the array (if any)
2430         var n_type: nullable AType = null is writable
2431
2432         # The closing bracket `]`
2433         var n_cbra: TCbra is writable, noinit
2434 end
2435
2436 # A read of `self`
2437 class ASelfExpr
2438         super AExpr
2439
2440         # The `self` keyword
2441         var n_kwself: nullable TKwself = null is writable
2442 end
2443
2444 # When there is no explicit receiver, `self` is implicit
2445 class AImplicitSelfExpr
2446         super ASelfExpr
2447 end
2448
2449 # A `true` boolean literal constant
2450 class ATrueExpr
2451         super ABoolExpr
2452
2453         # The `true` keyword
2454         var n_kwtrue: TKwtrue is writable, noinit
2455 end
2456
2457 # A `false` boolean literal constant
2458 class AFalseExpr
2459         super ABoolExpr
2460
2461         # The `false` keyword
2462         var n_kwfalse: TKwfalse is writable, noinit
2463 end
2464
2465 # A `null` literal constant
2466 class ANullExpr
2467         super AExpr
2468
2469         # The `null` keyword
2470         var n_kwnull: TKwnull is writable, noinit
2471 end
2472
2473 # An integer literal
2474 class AIntExpr
2475         super AExpr
2476 end
2477
2478 # An integer literal in decimal format
2479 class ADecIntExpr
2480         super AIntExpr
2481
2482         # The decimal token
2483         var n_number: TNumber is writable, noinit
2484 end
2485
2486 # An integer literal in hexadecimal format
2487 class AHexIntExpr
2488         super AIntExpr
2489
2490         # The hexadecimal token
2491         var n_hex_number: THexNumber is writable, noinit
2492 end
2493
2494 # A float literal
2495 class AFloatExpr
2496         super AExpr
2497
2498         # The float token
2499         var n_float: TFloat is writable, noinit
2500 end
2501
2502 # A character literal
2503 class ACharExpr
2504         super AExpr
2505
2506         # The character token
2507         var n_char: TChar is writable, noinit
2508 end
2509
2510 # A string literal
2511 abstract class AStringFormExpr
2512         super AExpr
2513
2514         # The string token
2515         var n_string: Token is writable, noinit
2516 end
2517
2518 # A simple string. eg. `"abc"`
2519 class AStringExpr
2520         super AStringFormExpr
2521 end
2522
2523 # The start of a superstring. eg `"abc{`
2524 class AStartStringExpr
2525         super AStringFormExpr
2526 end
2527
2528 # The middle of a superstring. eg `}abc{`
2529 class AMidStringExpr
2530         super AStringFormExpr
2531 end
2532
2533 # The end of a superstrng. eg `}abc"`
2534 class AEndStringExpr
2535         super AStringFormExpr
2536 end
2537
2538 # A superstring literal. eg `"a{x}b{y}c"`
2539 # Each part is modeled a sequence of expression. eg. `["a{, x, }b{, y, }c"]`
2540 class ASuperstringExpr
2541         super AExpr
2542
2543         # The list of the expressions of the superstring
2544         var n_exprs = new ANodes[AExpr](self)
2545 end
2546
2547 # A simple parenthesis. eg `(x)`
2548 class AParExpr
2549         super AExpr
2550
2551         # The opening parenthesis
2552         var n_opar: TOpar is writable, noinit
2553
2554         # The inner expression
2555         var n_expr: AExpr is writable, noinit
2556
2557         # The closing parenthesis
2558         var n_cpar: TCpar is writable, noinit
2559 end
2560
2561 # A cast, against a type or `not null`
2562 class AAsCastForm
2563         super AExpr
2564
2565         # The expression to cast
2566         var n_expr: AExpr is writable, noinit
2567
2568         # The `as` keyword
2569         var n_kwas: TKwas is writable, noinit
2570
2571         # The opening parenthesis
2572         var n_opar: nullable TOpar = null is writable
2573
2574         # The closing parenthesis
2575         var n_cpar: nullable TCpar = null is writable
2576 end
2577
2578 # A type cast. eg `x.as(T)`
2579 class AAsCastExpr
2580         super AAsCastForm
2581
2582         # The target type to cast to
2583         var n_type: AType is writable, noinit
2584 end
2585
2586 # A as-not-null cast. eg `x.as(not null)`
2587 class AAsNotnullExpr
2588         super AAsCastForm
2589
2590         # The `not` keyword
2591         var n_kwnot: TKwnot is writable, noinit
2592
2593         # The `null` keyword
2594         var n_kwnull: TKwnull is writable, noinit
2595 end
2596
2597 # A is-set check of old-style attributes. eg `isset x._a`
2598 class AIssetAttrExpr
2599         super AAttrFormExpr
2600
2601         # The `isset` keyword
2602         var n_kwisset: TKwisset is writable, noinit
2603 end
2604
2605 # An ellipsis notation used to pass an expression as it, in a vararg parameter
2606 class AVarargExpr
2607         super AExpr
2608
2609         # The passed expression
2610         var n_expr: AExpr is writable, noinit
2611
2612         # The `...` symbol
2613         var n_dotdotdot: TDotdotdot is writable, noinit
2614 end
2615
2616 # An named notation used to pass an expression by name in a parameter
2617 class ANamedargExpr
2618         super AExpr
2619
2620         # The name of the argument
2621         var n_id: TId is writable, noinit
2622
2623         # The `=` synbol
2624         var n_assign: TAssign is writable, noinit
2625
2626         # The passed expression
2627         var n_expr: AExpr is writable, noinit
2628 end
2629
2630 # A list of expression separated with commas (arguments for instance)
2631 class AManyExpr
2632         super AExpr
2633
2634         # The list of expressions
2635         var n_exprs = new ANodes[AExpr](self)
2636 end
2637
2638 # A special expression that encapsulates a static type
2639 # Can only be found in special construction like arguments of annotations.
2640 class ATypeExpr
2641         super AExpr
2642
2643         # The encapsulated type
2644         var n_type: AType is writable, noinit
2645 end
2646
2647 # A special expression that encapsulates a method identifier
2648 # Can only be found in special construction like arguments of annotations.
2649 class AMethidExpr
2650         super AExpr
2651
2652         # The receiver
2653         var n_expr: AExpr is writable, noinit
2654
2655         # The encapsulated method identifier
2656         var n_id: AMethid is writable, noinit
2657 end
2658
2659 # A special expression that encapsulate an annotation
2660 # Can only be found in special construction like arguments of annotations.
2661 #
2662 # The encapsulated annotations are in `n_annotations`
2663 class AAtExpr
2664         super AExpr
2665 end
2666
2667 # A special expression to debug types
2668 class ADebugTypeExpr
2669         super AExpr
2670
2671         # The `debug` keyword
2672         var n_kwdebug: TKwdebug is writable, noinit
2673
2674         # The `type` keyword
2675         var n_kwtype: TKwtype is writable, noinit
2676
2677         # The expression to check
2678         var n_expr: AExpr is writable, noinit
2679
2680         # The type to check
2681         var n_type: AType is writable, noinit
2682 end
2683
2684 # A list of expression separated with commas (arguments for instance)
2685 abstract class AExprs
2686         super Prod
2687
2688         # The list of expressions
2689         var n_exprs = new ANodes[AExpr](self)
2690 end
2691
2692 # A simple list of expressions
2693 class AListExprs
2694         super AExprs
2695 end
2696
2697 # A list of expressions enclosed in parentheses
2698 class AParExprs
2699         super AExprs
2700
2701         # The opening parenthesis
2702         var n_opar: TOpar is writable, noinit
2703
2704         # The closing parenthesis
2705         var n_cpar: TCpar is writable, noinit
2706 end
2707
2708 # A list of expressions enclosed in brackets
2709 class ABraExprs
2710         super AExprs
2711
2712         # The opening bracket
2713         var n_obra: TObra is writable, noinit
2714
2715         # The closing bracket
2716         var n_cbra: TCbra is writable, noinit
2717 end
2718
2719 # A complex assignment operator. (`+=` and `-=`)
2720 abstract class AAssignOp
2721         super Prod
2722
2723         # The combined assignment operator
2724         var n_op: Token is writable, noinit
2725
2726         # The name of the operator without the `=` (eg '+')
2727         fun operator: String is abstract
2728 end
2729
2730 # A `+=` assignment operation
2731 class APlusAssignOp
2732         super AAssignOp
2733
2734         redef fun operator do return "+"
2735 end
2736
2737 # A `-=` assignment operation
2738 class AMinusAssignOp
2739         super AAssignOp
2740
2741         redef fun operator do return "-"
2742 end
2743
2744 # A `*=` assignment operation
2745 class AStarAssignOp
2746         super AAssignOp
2747
2748         redef fun operator do return "*"
2749 end
2750
2751 # A `/=` assignment operation
2752 class ASlashAssignOp
2753         super AAssignOp
2754
2755         redef fun operator do return "/"
2756 end
2757
2758 # A `%=` assignment operation
2759 class APercentAssignOp
2760         super AAssignOp
2761
2762         redef fun operator do return "%"
2763 end
2764
2765 # A `**=` assignment operation
2766 class AStarstarAssignOp
2767         super AAssignOp
2768
2769         redef fun operator do return "**"
2770 end
2771
2772 # A `|=` assignment operation
2773 class APipeAssignOp
2774         super AAssignOp
2775
2776         redef fun operator do return "|"
2777 end
2778
2779 # A `^=` assignment operation
2780 class ACaretAssignOp
2781         super AAssignOp
2782
2783         redef fun operator do return "^"
2784 end
2785
2786 # A `&=` assignment operation
2787 class AAmpAssignOp
2788         super AAssignOp
2789
2790         redef fun operator do return "&"
2791 end
2792
2793 # A `<<=` assignment operation
2794 class ALlAssignOp
2795         super AAssignOp
2796
2797         redef fun operator do return "<<"
2798 end
2799
2800 # A `>>=` assignment operation
2801 class AGgAssignOp
2802         super AAssignOp
2803
2804         redef fun operator do return ">>"
2805 end
2806
2807 # A possibly fully-qualified module identifier
2808 class AModuleName
2809         super Prod
2810
2811         # The starting quad (`::`)
2812         var n_quad: nullable TQuad = null is writable
2813
2814         # The list of quad-separated project/group identifiers
2815         var n_path = new ANodes[TId](self)
2816
2817         # The final module identifier
2818         var n_id: TId is writable, noinit
2819 end
2820
2821 # A language declaration for an extern block
2822 class AInLanguage
2823         super Prod
2824
2825         # The `in` keyword
2826         var n_kwin: TKwin is writable, noinit
2827
2828         # The language name
2829         var n_string: TString is writable, noinit
2830 end
2831
2832 # An full extern block
2833 class AExternCodeBlock
2834         super Prod
2835
2836         # The language declration
2837         var n_in_language: nullable AInLanguage = null is writable
2838
2839         # The block of extern code
2840         var n_extern_code_segment: TExternCodeSegment is writable, noinit
2841 end
2842
2843 # A possible full method qualifier.
2844 class AQualified
2845         super Prod
2846
2847         # The starting quad (`::`)
2848         var n_quad: nullable TQuad = null is writable
2849
2850         # The list of quad-separated project/group/module identifiers
2851         var n_id = new ANodes[TId](self)
2852
2853         # A class identifier
2854         var n_classid: nullable TClassid = null is writable
2855 end
2856
2857 # A documentation of a definition
2858 # It contains the block of comments just above the declaration
2859 class ADoc
2860         super Prod
2861
2862         # A list of lines of comment
2863         var n_comment = new ANodes[TComment](self)
2864 end
2865
2866 # A group of annotation on a node
2867 #
2868 # This same class is used for the 3 kind of annotations:
2869 #
2870 # * *is* annotations. eg `module foo is bar`.
2871 # * *at* annotations. eg `foo@bar` or `foo@(bar,baz)`.
2872 # * *class* annotations, defined in classes.
2873 class AAnnotations
2874         super Prod
2875
2876         # The `is` keyword, for *is* annotations
2877         var n_kwis: nullable TKwis = null is writable
2878
2879         # The `@` symbol, for *at* annotations
2880         var n_at: nullable TAt = null is writable
2881
2882         # The opening parenthesis in *at* annotations
2883         var n_opar: nullable TOpar = null is writable
2884
2885         # The list of annotations
2886         var n_items = new ANodes[AAnnotation](self)
2887
2888         # The closing parenthesis in *at* annotations
2889         var n_cpar: nullable TCpar = null is writable
2890
2891         # The `end` keyword, for *is* annotations
2892         var n_kwend: nullable TKwend = null is writable
2893 end
2894
2895 # A single annotation
2896 class AAnnotation
2897         super ADefinition
2898
2899         # The name of the annotation
2900         var n_atid: AAtid is writable, noinit
2901
2902         # The opening parenthesis of the arguments
2903         var n_opar: nullable TOpar = null is writable
2904
2905         # The list of arguments
2906         var n_args = new ANodes[AExpr](self)
2907
2908         # The closing parenthesis
2909         var n_cpar: nullable TCpar = null is writable
2910
2911         # The name of the annotation
2912         fun name: String
2913         do
2914                 return n_atid.n_id.text
2915         end
2916 end
2917
2918 # An annotation name
2919 abstract class AAtid
2920         super Prod
2921
2922         # The identifier of the annotation.
2923         # Can be a TId of a keyword
2924         var n_id: Token is writable, noinit
2925 end
2926
2927 # An annotation name based on an identifier
2928 class AIdAtid
2929         super AAtid
2930 end
2931
2932 # An annotation name based on the keyword `extern`
2933 class AKwexternAtid
2934         super AAtid
2935 end
2936
2937 # An annotation name based on the keyword `import`
2938 class AKwimportAtid
2939         super AAtid
2940 end
2941
2942 # An annotation name based on the keyword `abstract`
2943 class AKwabstractAtid
2944         super AAtid
2945 end
2946
2947 # The root of the AST
2948 class Start
2949         super Prod
2950
2951         # The main module
2952         var n_base: nullable AModule is writable
2953
2954         # The end of file (or error) token
2955         var n_eof: EOF is writable
2956 end