1 # This file is part of NIT ( http://www.nitlanguage.org ).
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
7 # http://www.apache.org/licenses/LICENSE-2.0
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.
15 # AST nodes of the Nit language
16 # Was previously based on parser_abs.nit.
21 private import console
23 # Root of the AST class-hierarchy
25 # Location is set during AST building. Once built, location can not be null.
26 # However, manual instantiated nodes may need more care.
27 var location
: Location is writable, noinit
29 # The location of the important part of the node (identifier or whatever)
30 fun hot_location
: Location do return location
32 # Display a message for the colored location of the node
33 fun debug
(message
: String)
35 sys
.stderr
.write
"{hot_location} {self.class_name}: {message}\n{hot_location.colored_line("0;32")}\n"
38 # Is `self` a token or a pure-structural production like `AQId`?
39 fun is_structural
: Bool do return false
41 # Write the subtree on stdout.
43 # Visit the subtree and display it with additional and useful information.
45 # By default, this displays all kind of nodes and the corresponding lines of codes.
47 # See `ASTDump` for details.
48 fun dump_tree
(display_structural
, display_line
: nullable Bool)
50 var d
= new ASTDump(display_structural
or else true, display_line
or else true)
52 d
.write_to
(sys
.stdout
)
55 # Information to display on a node
57 # Refine this method to add additional information on each node type.
58 fun dump_info
(v
: ASTDump): String do return ""
60 # Parent of the node in the AST
61 var parent
: nullable ANode = null
63 # The topmost ancestor of the element
64 # This just apply `parent` until the first one
70 if p
== null then return res
75 # The most specific common parent between `self` and `other`
76 # Return null if the two node are unrelated (distinct root)
77 fun common_parent
(other
: ANode): nullable ANode
79 # First, get the same depth
80 var s
: nullable ANode = self
81 var o
: nullable ANode = other
82 var d
= s
.depth
- o
.depth
91 assert o
.depth
== s
.depth
92 # Second, go up until same in found
100 # Number of nodes between `self` and the `root` of the AST
101 # ENSURE `self == self.root implies result == 0 `
102 # ENSURE `self != self.root implies result == self.parent.depth + 1`
109 if p
== null then return res
115 # Replace a child with an other node in the AST
116 private fun replace_child
(old_child
: ANode, new_child
: nullable ANode) is abstract
118 # Detach a node from its parent
119 # Aborts if the node is not detachable. use `replace_with` instead
120 # REQUIRE: parent != null
121 # REQUIRE: is_detachable
122 # ENDURE: parent == null
125 assert parent
!= null
126 parent
.replace_child
(self, null)
130 # Replace itself with an other node in the AST
131 # REQUIRE: parent != null
132 # ENSURE: node.parent == old(parent)
133 # ENSURE: parent == null
134 fun replace_with
(node
: ANode)
136 assert parent
!= null
137 parent
.replace_child
(self, node
)
141 # Visit all nodes in order.
142 # Thus, call `v.enter_visit(e)` for each child `e`
143 fun visit_all
(v
: Visitor) is abstract
145 # Do a deep search and return an array of tokens that match a given text
146 fun collect_tokens_by_text
(text
: String): Array[Token]
148 var v
= new CollectTokensByTextVisitor(text
)
153 # Do a deep search and return an array of node that are annotated
154 # The attached node can be retrieved by two invocations of parent
155 fun collect_annotations_by_name
(name
: String): Array[AAnnotation]
157 var v
= new CollectAnnotationsByNameVisitor(name
)
163 private class CollectTokensByTextVisitor
166 var result
= new Array[Token]
167 redef fun visit
(node
)
170 if node
isa Token and node
.text
== text
then result
.add
(node
)
174 private class CollectAnnotationsByNameVisitor
177 var result
= new Array[AAnnotation]
178 redef fun visit
(node
)
181 if node
isa AAnnotation and node
.n_atid
.n_id
.text
== name
then result
.add
(node
)
185 # A helper class to handle (print) Nit AST as an OrderedTree
188 super OrderedTree[ANode]
190 # Reference to the last parent in the Ordered Tree
191 # Is used to handle the initial node parent and workaround possible inconsistent `ANode::parent`
192 private var last_parent
: nullable ANode = null
194 # Display tokens and structural production?
196 # Should tokens (and structural production like AQId) be displayed?
197 var display_structural
: Bool
201 # Should each new line be displayed (numbered and in gray)?
202 var display_line
: Bool
204 # Current line number (when printing lines)
209 if not display_structural
and n
.is_structural
then return
217 redef fun write_line
(o
, n
, p
)
220 var ls
= n
.location
.line_start
221 var file
= n
.location
.file
223 if ls
> line
and file
!= null then
224 if line
== 0 then line
= ls
- 1
227 o
.write
"{line}\t{file.get_line(line)}\n".light_gray
238 return "{n.class_name} {n.dump_info(self)} @{n.location}"
242 fun yellow
(s
: String): String do return s
.yellow
245 fun red
(s
: String): String do return s
.red
248 # A sequence of nodes
249 # It is a specific class (instead of using a Array) to track the parent/child relation when nodes are added or removed
250 class ANodes[E
: ANode]
252 private var parent
: ANode
253 private var items
= new Array[E
]
254 redef fun iterator
do return items
.iterator
255 redef fun reverse_iterator
do return items
.reverse_iterator
256 redef fun length
do return items
.length
257 redef fun is_empty
do return items
.is_empty
276 var res
= items
.shift
288 redef fun []=(index
, e
)
290 hook_remove
(self[index
])
294 redef fun remove_at
(index
)
296 hook_remove
(items
[index
])
297 items
.remove_at
(index
)
299 private fun hook_add
(e
: E
)
301 #assert e.parent == null
304 private fun hook_remove
(e
: E
)
306 assert e
.parent
== parent
310 # Used in parent constructor to fill elements
311 private fun unsafe_add_all
(nodes
: Collection[Object])
313 var parent
= self.parent
321 private fun replace_child
(old_child
: ANode, new_child
: nullable ANode): Bool
323 var parent
= self.parent
324 for i
in [0..length
[ do
325 if self[i
] == old_child
then
326 if new_child
!= null then
327 assert new_child
isa E
329 new_child
.parent
= parent
339 private fun visit_all
(v
: Visitor)
341 for n
in self do v
.enter_visit
(n
)
345 # Ancestor of all tokens
346 # A token is a node that has a `text` but no children.
350 # The raw content on the token
351 fun text
: String is abstract
353 # The raw content on the token
354 fun text
=(text
: String) is abstract
356 # The previous token in the Lexer.
357 # May have disappeared in the AST
358 var prev_token
: nullable Token = null
360 # The next token in the Lexer.
361 # May have disappeared in the AST
362 var next_token
: nullable Token = null
364 # Is `self` a token discarded from the AST?
366 # Loose tokens are not present in the AST.
367 # It means they were identified by the lexer but were discarded by the parser.
368 # It also means that they are not visited or manipulated by AST-related functions.
370 # Each loose token is attached to the non-loose token that precedes or follows it.
371 # The rules are the following:
373 # * tokens that follow a non-loose token on a same line are attached to it.
375 # * other tokens, thus that precede a non-loose token on the same line or the next one,
376 # are attached to this one. See `prev_looses`.
378 # Loose tokens are mostly end of lines (`TEol`) and comments (`TComment`).
379 # Whitespace are ignored by the lexer, so they are not even considered as loose tokens.
380 # See `blank_before` to get the whitespace that separate tokens.
383 redef fun is_structural
do return true
385 redef fun dump_info
(v
) do return " {text.escape_to_c}"
387 # Loose tokens that precede `self`.
389 # These tokens start the line or belong to a line with only loose tokens.
390 var prev_looses
= new Array[Token] is lazy
392 # Loose tokens that follow `self`
394 # These tokens are on the same line than `self`.
395 var next_looses
= new Array[Token] is lazy
397 # The verbatim blank text between `prev_token` and `self`
398 fun blank_before
: String
400 if prev_token
== null then return ""
401 var from
= prev_token
.location
.pend
+1
402 var to
= location
.pstart
403 return location
.file
.string
.substring
(from
,to-from
)
406 redef fun to_s
: String do
410 redef fun visit_all
(v
: Visitor) do end
411 redef fun replace_child
(old_child
: ANode, new_child
: nullable ANode) do end
414 redef class SourceFile
415 # The first token parser by the lexer
416 # May have disappeared in the final AST
417 var first_token
: nullable Token = null
419 # The first token parser by the lexer
420 # May have disappeared in the final AST
421 var last_token
: nullable Token = null
424 # Ancestor of all productions
425 # A production is a node without text but that usually has children.
429 # All the annotations attached directly to the node
430 var n_annotations
: nullable AAnnotations = null is writable
432 # Return all its annotations of a given name in the order of their declaration
433 # Retun an empty array if no such an annotation.
434 fun get_annotations
(name
: String): Array[AAnnotation]
436 var res
= new Array[AAnnotation]
437 var nas
= n_annotations
438 if nas
!= null then for na
in nas
.n_items
do
439 if na
.name
!= name
then continue
442 if self isa AClassdef then for na
in n_propdefs
do
443 if na
isa AAnnotPropdef then
444 if na
.name
!= name
then continue
452 redef fun replace_with
(n
: ANode)
456 if not isset n
._location
and isset _location
then n
._location
= _location
460 # Abstract standard visitor on the AST
461 abstract class Visitor
462 # What the visitor do when a node is visited
463 # Concrete visitors should implement this method.
465 protected fun visit
(e
: ANode) is abstract
467 # Ask the visitor to visit a given node.
468 # Usually automatically called by visit_all* methods.
469 # This method should not be redefined
470 fun enter_visit
(e
: nullable ANode)
472 if e
== null then return
473 var old
= _current_node
479 # The current visited node
480 var current_node
: nullable ANode = null is writable
483 # Token of end of line (basically `\n`)
492 # Token of a line of comments
493 # Starts with the `#` and contains the final end-of-line (if any)
498 # A token associated with a keyword
499 abstract class TokenKeyword
503 return "keyword '{text}'"
507 # The deprecated keyword `package`.
512 # The keyword `module`
517 # The keyword `import`
522 # The keyword `class`
527 # The keyword `abstract`
532 # The keyword `interface`
537 # The keywords `enum` and `universal`
542 # The keyword `subset`
567 # The keyword `redef`
582 # The keyword `catch`
592 # The keyword `extern`
597 # The keyword `public`
602 # The keyword `protected`
607 # The keyword `private`
612 # The keyword `intrude`
632 # The keyword `while`
662 # The keyword `implies`
672 # The keyword `return`
677 # The keyword `continue`
682 # The keyword `break`
687 # The keyword `abort`
692 # The keyword `assert`
712 # The keyword `super`
727 # The keyword `false`
742 # The keyword `nullable`
747 # The keyword `isset`
752 # The keyword `label`
762 # The keyword `yield`
767 # The special keyword `__DEBUG__`
812 # A token associated with an operator (and other lookalike symbols)
813 abstract class TokenOperator
817 return "operator '{text}'"
1006 # A class (or formal type) identifier. They start with an uppercase.
1011 do return "type identifier '{text}'"
1015 # A standard identifier (variable, method...). They start with a lowercase.
1020 do return "identifier '{text}'"
1024 # An attribute identifier. They start with an underscore.
1029 do return "attribute '{text}'"
1033 # A token of a literal value (string, integer, etc).
1034 abstract class TokenLiteral
1038 do return "literal value '{text}'"
1047 # A literal floating point number
1052 # A literal character
1062 # The starting part of a super string (between `"` and `{`)
1067 # The middle part of a super string (between `}` and `{`)
1072 # The final part of a super string (between `}` and `"`)
1077 # A malformed string
1082 do return "malformed string {text}"
1086 # A malformed triple quoted string
1096 do return "malformed character {text}"
1100 # A extern code block
1101 class TExternCodeSegment
1105 # A malformed extern code block
1110 do return "malformed extern segment {text}"
1119 return "end of file"
1123 # A mark of an error
1127 # A lexical error (unexpected character)
1131 # A syntactic error (unexpected token)
1136 # The main node of a Nit source-file
1140 # The declaration part of the module
1141 var n_moduledecl
: nullable AModuledecl = null is writable
1143 # List of importation clauses
1144 var n_imports
= new ANodes[AImport](self)
1146 # List of extern blocks
1147 var n_extern_code_blocks
= new ANodes[AExternCodeBlock](self)
1149 # List of class definition (including top-level methods and the main)
1150 var n_classdefs
= new ANodes[AClassdef](self)
1153 # Abstract class for definition of entities
1154 abstract class ADefinition
1157 var n_doc
: nullable ADoc = null is writable
1159 # The `redef` keyword
1160 var n_kwredef
: nullable TKwredef = null is writable
1162 # The declared visibility
1163 var n_visibility
: nullable AVisibility = null is writable
1166 # The declaration of the module with the documentation, name, and annotations
1170 # The `module` keyword
1171 var n_kwmodule
: TKwmodule is writable, noinit
1173 # The declared module name
1174 var n_name
: AModuleName is writable, noinit
1177 # A import clause of a module
1178 abstract class AImport
1181 # The declared visibility
1182 var n_visibility
: AVisibility is writable, noinit
1184 # The `import` keyword
1185 var n_kwimport
: TKwimport is writable, noinit
1188 # A standard import clause. eg `import x`
1191 # The imported module name
1192 var n_name
: AModuleName is writable, noinit
1195 # The special import clause of the kernel module. eg `import end`
1198 # The `end` keyword, that indicate the root module
1199 var n_kwend
: TKwend is writable, noinit
1202 # A visibility modifier
1204 # The public visibility is an empty production (no keyword).
1206 # Note: even if some visibilities are only valid on some placse (for instance, no `protected` class or no `intrude` method)
1207 # the parser has no such a restriction, therefore the semantic phases has to check that the visibilities make sense.
1208 abstract class AVisibility
1212 # An implicit or explicit public visibility modifier
1213 class APublicVisibility
1215 # The `public` keyword, if any
1216 var n_kwpublic
: nullable TKwpublic = null is writable
1218 # An explicit private visibility modifier
1219 class APrivateVisibility
1221 # The `private` keyword
1222 var n_kwprivate
: TKwprivate is writable, noinit
1224 # An explicit protected visibility modifier
1225 class AProtectedVisibility
1227 # The `protected` keyword
1228 var n_kwprotected
: TKwprotected is writable, noinit
1230 # An explicit intrude visibility modifier
1231 class AIntrudeVisibility
1233 # The `intrude` keyword
1234 var n_kwintrude
: TKwintrude is writable, noinit
1237 # A class definition
1239 # While most definitions are `AStdClassdef`s,
1240 # there are 2 special cases of class definitions.
1241 abstract class AClassdef
1243 # All the declared properties (including the main method)
1244 var n_propdefs
= new ANodes[APropdef](self)
1247 # A standard class definition with a name, superclasses and properties
1252 # The class kind (interface, abstract class, etc.)
1253 var n_classkind
: AClasskind is writable, noinit
1255 # The name of the class
1256 var n_qid
: nullable AQclassid = null is writable
1259 var n_obra
: nullable TObra = null is writable
1261 # The list of formal parameter types
1262 var n_formaldefs
= new ANodes[AFormaldef](self)
1265 var n_cbra
: nullable TCbra = null is writable
1267 # The extern block code
1268 var n_extern_code_block
: nullable AExternCodeBlock = null is writable
1271 var n_kwend
: TKwend is writable, noinit
1273 fun n_superclasses
: Array[ASuperPropdef] do
1274 return [for d
in n_propdefs
do if d
isa ASuperPropdef then d
]
1277 redef fun hot_location
do return n_qid
.location
1280 # The implicit class definition of the implicit main method
1285 # The implicit class definition of the top-level methods
1290 # The modifier for the kind of class (abstract, interface, etc.)
1291 abstract class AClasskind
1295 # A default, or concrete class modifier (just `class`)
1296 class AConcreteClasskind
1299 # The `class` keyword.
1300 var n_kwclass
: TKwclass is writable, noinit
1303 # An abstract class modifier (`abstract class`)
1304 class AAbstractClasskind
1307 # The `abstract` keyword.
1308 var n_kwabstract
: TKwabstract is writable, noinit
1310 # The `class` keyword.
1311 var n_kwclass
: TKwclass is writable, noinit
1314 # An interface class modifier (`interface`)
1315 class AInterfaceClasskind
1318 # The `interface` keyword.
1319 var n_kwinterface
: TKwinterface is writable, noinit
1322 # An enum/universal class modifier (`enum class`)
1323 class AEnumClasskind
1326 # The `enum` keyword.
1327 var n_kwenum
: TKwenum is writable, noinit
1330 # An extern class modifier (`extern class`)
1331 class AExternClasskind
1334 # The `extern` keyword.
1335 var n_kwextern
: TKwextern is writable, noinit
1337 # The `class` keyword.
1338 var n_kwclass
: nullable TKwclass = null is writable
1341 class ASubsetClasskind
1344 # The `subset` keyword.
1345 var n_kwsubset
: TKwsubset is writable, noinit
1347 redef fun visit_all
(v
) do
1348 # TODO: Remove this redefinition once generated from the grammar.
1349 v
.enter_visit
(n_kwsubset
)
1353 # The definition of a formal generic parameter type. eg `X: Y`
1357 # The name of the parameter type
1358 var n_id
: TClassid is writable, noinit
1360 # The bound of the parameter type
1361 var n_type
: nullable AType = null is writable
1364 # The definition of a property
1365 abstract class APropdef
1369 # A definition of an attribute
1370 # For historical reason, old-syle and new-style attributes use the same `ANode` sub-class
1375 var n_kwvar
: TKwvar is writable, noinit
1377 # The identifier for a new-style attribute
1378 var n_id2
: TId is writable, noinit
1380 # The declared type of the attribute
1381 var n_type
: nullable AType = null is writable
1384 var n_assign
: nullable TAssign = null is writable
1386 # The initial value, if any (set with `=`)
1387 var n_expr
: nullable AExpr = null is writable
1390 var n_kwdo
: nullable TKwdo = null is writable
1392 # The initial value, if any (set with `do return`)
1393 var n_block
: nullable AExpr = null is writable
1396 var n_kwend
: nullable TKwend = null is writable
1398 redef fun hot_location
1400 return n_id2
.location
1404 # A definition of all kind of method (including constructors)
1408 # The `fun` keyword, if any
1409 var n_kwmeth
: nullable TKwmeth = null is writable
1411 # The `init` keyword, if any
1412 var n_kwinit
: nullable TKwinit = null is writable
1414 # The `isa` keyword, if any
1415 var n_kwisa
: nullable TKwisa = null is writable
1417 # The `new` keyword, if any
1418 var n_kwnew
: nullable TKwnew = null is writable
1420 # The name of the method, if any
1421 var n_methid
: nullable AMethid = null is writable
1423 # The signature of the method, if any
1424 var n_signature
: nullable ASignature = null is writable
1427 var n_kwdo
: nullable TKwdo = null is writable
1429 # The body (in Nit) of the method, if any
1430 var n_block
: nullable AExpr = null is writable
1433 var n_kwend
: nullable TKwend = null is writable
1435 # The list of declared callbacks (for extern methods)
1436 var n_extern_calls
: nullable AExternCalls = null is writable
1438 # The body (in extern code) of the method, if any
1439 var n_extern_code_block
: nullable AExternCodeBlock = null is writable
1441 redef fun hot_location
1443 if n_methid
!= null then
1444 return n_methid
.location
1445 else if n_kwinit
!= null then
1446 return n_kwinit
.location
1447 else if n_kwnew
!= null then
1448 return n_kwnew
.location
1455 # The implicit main method
1456 class AMainMethPropdef
1465 # A super-class. eg `super X`
1470 var n_kwsuper
: TKwsuper is writable, noinit
1472 # The super-class (indicated as a type)
1473 var n_type
: AType is writable, noinit
1477 # Declaration of callbacks for extern methods
1481 # The `import` keyword
1482 var n_kwimport
: TKwimport is writable, noinit
1484 # The list of declared callbacks
1485 var n_extern_calls
: ANodes[AExternCall] = new ANodes[AExternCall](self)
1488 # A single callback declaration
1489 abstract class AExternCall
1493 # A single callback declaration on a method
1494 abstract class APropExternCall
1498 # A single callback declaration on a method on the current receiver
1499 class ALocalPropExternCall
1500 super APropExternCall
1502 # The name of the called-back method
1503 var n_methid
: AMethid is writable, noinit
1506 # A single callback declaration on a method on an explicit receiver type.
1507 class AFullPropExternCall
1508 super APropExternCall
1510 # The type of the receiver of the called-back method
1511 var n_type
: AType is writable, noinit
1514 var n_dot
: nullable TDot = null is writable
1516 # The name of the called-back method
1517 var n_methid
: AMethid is writable, noinit
1520 # A single callback declaration on a method on a constructor
1521 class AInitPropExternCall
1522 super APropExternCall
1524 # The allocated type
1525 var n_type
: AType is writable, noinit
1528 # A single callback declaration on a `super` call
1529 class ASuperExternCall
1532 # The `super` keyword
1533 var n_kwsuper
: TKwsuper is writable, noinit
1536 # A single callback declaration on a cast
1537 abstract class ACastExternCall
1541 # A single callback declaration on a cast to a given type
1542 class ACastAsExternCall
1543 super ACastExternCall
1545 # The origin type of the cast
1546 var n_from_type
: AType is writable, noinit
1549 var n_dot
: nullable TDot = null is writable
1552 var n_kwas
: TKwas is writable, noinit
1554 # The destination of the cast
1555 var n_to_type
: AType is writable, noinit
1558 # A single callback declaration on a cast to a nullable type
1559 class AAsNullableExternCall
1560 super ACastExternCall
1562 # The origin type to cast as nullable
1563 var n_type
: AType is writable, noinit
1566 var n_kwas
: TKwas is writable, noinit
1568 # The `nullable` keyword
1569 var n_kwnullable
: TKwnullable is writable, noinit
1572 # A single callback declaration on a cast to a non-nullable type
1573 class AAsNotNullableExternCall
1574 super ACastExternCall
1576 # The destination type on a cast to not nullable
1577 var n_type
: AType is writable, noinit
1580 var n_kwas
: TKwas is writable, noinit
1583 var n_kwnot
: TKwnot is writable, noinit
1585 # The `nullable` keyword
1586 var n_kwnullable
: TKwnullable is writable, noinit
1589 # A definition of a virtual type
1593 # The `type` keyword
1594 var n_kwtype
: TKwtype is writable, noinit
1596 # The name of the virtual type
1597 var n_qid
: AQclassid is writable, noinit
1599 # The bound of the virtual type
1600 var n_type
: AType is writable, noinit
1603 # The identifier of a method in a method declaration.
1604 # There is a specific class because of operator and setters.
1605 abstract class AMethid
1609 # A method name with a simple identifier
1613 # The simple identifier
1614 var n_id
: TId is writable, noinit
1617 # A method name for an operator
1618 class AOperatorMethid
1621 # The associated operator symbol
1622 var n_op
: Token is writable, noinit
1626 super AOperatorMethid
1631 super AOperatorMethid
1636 super AOperatorMethid
1639 # A method name `**`
1640 class AStarstarMethid
1641 super AOperatorMethid
1646 super AOperatorMethid
1650 class APercentMethid
1651 super AOperatorMethid
1656 super AOperatorMethid
1661 super AOperatorMethid
1666 super AOperatorMethid
1671 super AOperatorMethid
1674 # A method name `==`
1676 super AOperatorMethid
1679 # A method name `!=`
1681 super AOperatorMethid
1684 # A method name `<=`
1686 super AOperatorMethid
1689 # A method name `>=`
1691 super AOperatorMethid
1696 super AOperatorMethid
1701 super AOperatorMethid
1704 # A method name `<<`
1706 super AOperatorMethid
1709 # A method name `>>`
1711 super AOperatorMethid
1714 # A method name `<=>`
1715 class AStarshipMethid
1716 super AOperatorMethid
1719 # A method name `[]`
1724 var n_obra
: TObra is writable, noinit
1727 var n_cbra
: TCbra is writable, noinit
1730 # A setter method name with a simple identifier (with a `=`)
1734 # The base identifier
1735 var n_id
: TId is writable, noinit
1738 var n_assign
: TAssign is writable, noinit
1741 # A method name `[]=`
1742 class ABraassignMethid
1746 var n_obra
: TObra is writable, noinit
1749 var n_cbra
: TCbra is writable, noinit
1752 var n_assign
: TAssign is writable, noinit
1755 # A potentially qualified simple identifier `foo::bar::baz`
1758 # The qualifier, if any
1759 var n_qualified
: nullable AQualified = null is writable
1761 # The final identifier
1762 var n_id
: TId is writable, noinit
1764 redef fun is_structural
do return true
1767 # A potentially qualified class identifier `foo::bar::Baz`
1770 # The qualifier, if any
1771 var n_qualified
: nullable AQualified = null is writable
1773 # The final identifier
1774 var n_id
: TClassid is writable, noinit
1776 redef fun is_structural
do return true
1779 # A signature in a method definition. eg `(x,y:X,z:Z):T`
1784 var n_opar
: nullable TOpar = null is writable
1786 # The list of parameters
1787 var n_params
= new ANodes[AParam](self)
1790 var n_cpar
: nullable TCpar = null is writable
1793 var n_type
: nullable AType = null is writable
1796 # A parameter definition in a signature. eg `x:X`
1800 # The name of the parameter
1801 var n_id
: TId is writable, noinit
1803 # The type of the parameter, if any
1804 var n_type
: nullable AType = null is writable
1806 # The `...` symbol to indicate varargs
1807 var n_dotdotdot
: nullable TDotdotdot = null is writable
1810 # A static type. eg `nullable X[Y]`
1813 # The `nullable` keyword
1814 var n_kwnullable
: nullable TKwnullable = null is writable
1816 # The name of the class or of the formal type
1817 var n_qid
: AQclassid is writable, noinit
1819 # The opening bracket
1820 var n_obra
: nullable TObra = null is writable
1822 # Type arguments for a generic type
1823 var n_types
= new ANodes[AType](self)
1825 # The closing bracket
1826 var n_cbra
: nullable TCbra = null is writable
1829 # A label at the end of a block or in a break/continue statement. eg `label x`
1833 # The `label` keyword
1834 var n_kwlabel
: TKwlabel is writable, noinit
1836 # The name of the label, if any
1837 var n_id
: nullable TId is writable, noinit
1840 # Expression and statements
1841 # From a AST point of view there is no distinction between statement and expressions (even if the parser has to distinguish them)
1842 abstract class AExpr
1846 # A sequence of `AExpr` (usually statements)
1847 # The last `AExpr` gives the value of the whole block
1851 # The list of statements in the bloc.
1852 # The last element is often considered as an expression that give the value of the whole block.
1853 var n_expr
= new ANodes[AExpr](self)
1856 var n_kwend
: nullable TKwend = null is writable
1859 # A declaration of a local variable. eg `var x: X = y`
1864 var n_kwvar
: nullable TKwvar = null is writable
1866 # The name of the local variable
1867 var n_id
: TId is writable, noinit
1869 # The declaration type of the local variable
1870 var n_type
: nullable AType = null is writable
1872 # The `=` symbol (for the initial value)
1873 var n_assign
: nullable TAssign = null is writable
1875 # The initial value, if any
1876 var n_expr
: nullable AExpr = null is writable
1879 # A `return` statement. eg `return x`
1883 # The `return` keyword
1884 var n_kwreturn
: nullable TKwreturn = null is writable
1887 # A `yield` statement. eg `yield x`
1891 # The `yield` keyword
1892 var n_kwyield
: nullable TKwyield = null is writable
1894 # The return value, if any
1895 var n_expr
: nullable AExpr = null is writable
1898 # Something that has a label.
1899 abstract class ALabelable
1902 # The associated label declatation
1903 var n_label
: nullable ALabel = null is writable
1906 # A `break` or a `continue`
1907 abstract class AEscapeExpr
1911 # The return value, if nay (unused currently)
1912 var n_expr
: nullable AExpr = null is writable
1915 # A `break` statement.
1919 # The `break` keyword
1920 var n_kwbreak
: TKwbreak is writable, noinit
1923 # An `abort` statement
1927 # The `abort` keyword
1928 var n_kwabort
: TKwabort is writable, noinit
1931 # A `continue` statement
1935 # The `continue` keyword.
1936 var n_kwcontinue
: nullable TKwcontinue = null is writable
1945 var n_kwdo
: TKwdo is writable, noinit
1947 # The list of statements of the `do`.
1948 var n_block
: nullable AExpr = null is writable
1950 # The `catch` keyword
1951 var n_kwcatch
: nullable TKwcatch = null is writable
1953 # The do catch block
1954 var n_catch
: nullable AExpr = null is writable
1962 var n_kwif
: TKwif is writable, noinit
1964 # The expression used as the condition of the `if`
1965 var n_expr
: AExpr is writable, noinit
1967 # The `then` keyword
1968 var n_kwthen
: TKwthen is writable, noinit
1970 # The body of the `then` part
1971 var n_then
: nullable AExpr = null is writable
1973 # The `else` keyword
1974 var n_kwelse
: nullable TKwelse = null is writable
1976 # The body of the `else` part
1977 var n_else
: nullable AExpr = null is writable
1980 # A `if` expression (ternary conditional). eg. `if true then 1 else 0`
1985 var n_kwif
: TKwif is writable, noinit
1987 # The expression used as the condition of the `if`
1988 var n_expr
: AExpr is writable, noinit
1990 # The `then` keyword
1991 var n_kwthen
: TKwthen is writable, noinit
1993 # The expression in the `then` part
1994 var n_then
: AExpr is writable, noinit
1996 # The `else` keyword
1997 var n_kwelse
: TKwelse is writable, noinit
1999 # The expression in the `else` part
2000 var n_else
: AExpr is writable, noinit
2003 # A `while` statement
2008 # The `while` keyword
2009 var n_kwwhile
: TKwwhile is writable, noinit
2011 # The expression used as the condition of the `while`
2012 var n_expr
: AExpr is writable, noinit
2015 var n_kwdo
: TKwdo is writable, noinit
2017 # The body of the loop
2018 var n_block
: nullable AExpr = null is writable
2021 # A `loop` statement
2026 # The `loop` keyword
2027 var n_kwloop
: TKwloop is writable, noinit
2029 # The body of the loop
2030 var n_block
: nullable AExpr = null is writable
2039 var n_kwfor
: TKwfor is writable, noinit
2041 # The list of groups to iterate
2042 var n_groups
= new ANodes[AForGroup](self)
2045 var n_kwdo
: TKwdo is writable, noinit
2047 # The body of the loop
2048 var n_block
: nullable AExpr = null is writable
2051 # A collection iterated by a for, its automatic variables and its implicit iterator.
2053 # Standard `for` iterate on a single collection.
2054 # Multiple `for` can iterate on more than one collection at once.
2058 # The list of name of the automatic variables
2059 var n_ids
= new ANodes[TId](self)
2062 var n_kwin
: TKwin is writable, noinit
2064 # The expression used as the collection to iterate on
2065 var n_expr
: AExpr is writable, noinit
2068 # A `with` statement
2073 # The `with` keyword
2074 var n_kwwith
: TKwwith is writable, noinit
2076 # The expression used to get the value to control
2077 var n_expr
: AExpr is writable, noinit
2080 var n_kwdo
: TKwdo is writable, noinit
2082 # The body of the loop
2083 var n_block
: nullable AExpr = null is writable
2086 # An `assert` statement
2090 # The `assert` keyword
2091 var n_kwassert
: TKwassert is writable, noinit
2093 # The name of the assert, if any
2094 var n_id
: nullable TId = null is writable
2096 # The expression used as the condition of the `assert`
2097 var n_expr
: AExpr is writable, noinit
2099 # The `else` keyword
2100 var n_kwelse
: nullable TKwelse = null is writable
2102 # The body to execute when the assert fails
2103 var n_else
: nullable AExpr = null is writable
2106 # Whatever is a simple assignment. eg `= something`
2107 abstract class AAssignFormExpr
2111 var n_assign
: TAssign is writable, noinit
2113 # The right-value to assign.
2114 var n_value
: AExpr is writable, noinit
2117 # Whatever is a combined assignment. eg `+= something`
2118 abstract class AReassignFormExpr
2121 # The combined operator (eg. `+=`)
2122 var n_assign_op
: AAssignOp is writable, noinit
2124 # The right-value to apply on the combined operator.
2125 var n_value
: AExpr is writable, noinit
2128 # A `once` expression. eg `once x`
2132 # The `once` keyword
2133 var n_kwonce
: TKwonce is writable, noinit
2135 # The expression to evaluate only one time
2136 var n_expr
: AExpr is writable, noinit
2139 # A polymorphic invocation of a method
2140 # The form of the invocation (name, arguments, etc.) are specific
2141 abstract class ASendExpr
2143 # The receiver of the method invocation
2144 var n_expr
: AExpr is writable, noinit
2147 # A binary operation on a method
2148 abstract class ABinopExpr
2152 var n_op
: Token is writable, noinit
2154 # The second operand of the operation
2155 # Note: the receiver (`n_expr`) is the first operand
2156 var n_expr2
: AExpr is writable, noinit
2158 # The name of the operator (eg '+')
2159 fun operator
: String is abstract
2162 # Something that is boolean expression
2163 abstract class ABoolExpr
2167 # Something that is binary boolean expression
2168 abstract class ABinBoolExpr
2171 # The first boolean operand
2172 var n_expr
: AExpr is writable, noinit
2175 var n_op
: Token is writable, noinit
2177 # The second boolean operand
2178 var n_expr2
: AExpr is writable, noinit
2186 # A `and` expression
2191 # A `or else` expression
2195 # The `else` keyword
2196 var n_kwelse
: TKwelse is writable, noinit
2199 # A `implies` expression
2204 # A `not` expression
2209 var n_kwnot
: TKwnot is writable, noinit
2211 # The boolean operand of the `not`
2212 var n_expr
: AExpr is writable, noinit
2215 # A `==` or a `!=` expression
2217 # Both have a similar effect on adaptive typing, so this class factorizes the common behavior.
2225 redef fun operator
do return "=="
2231 redef fun operator
do return "!="
2237 redef fun operator
do return "<"
2243 redef fun operator
do return "<="
2249 redef fun operator
do return "<<"
2255 redef fun operator
do return ">"
2261 redef fun operator
do return ">="
2267 redef fun operator
do return ">>"
2270 # A type-ckeck expression. eg `x isa T`
2274 # The expression to check
2275 var n_expr
: AExpr is writable, noinit
2278 var n_kwisa
: TKwisa is writable, noinit
2280 # The destination type to check to
2281 var n_type
: AType is writable, noinit
2287 redef fun operator
do return "+"
2293 redef fun operator
do return "-"
2296 # A `<=>` expression
2299 redef fun operator
do return "<=>"
2305 redef fun operator
do return "*"
2311 redef fun operator
do return "**"
2317 redef fun operator
do return "/"
2323 redef fun operator
do return "%"
2329 redef fun operator
do return "|"
2335 redef fun operator
do return "^"
2341 redef fun operator
do return "&"
2344 # A unary operation on a method
2345 abstract class AUnaryopExpr
2349 var n_op
: Token is writable, noinit
2351 # The name of the operator (eg '+')
2352 fun operator
: String is abstract
2355 # A unary minus expression. eg `-x`
2358 redef fun operator
do return "-"
2361 # A unary plus expression. eg `+x`
2364 redef fun operator
do return "+"
2367 # A unary `~` expression
2370 redef fun operator
do return "~"
2373 # An explicit instantiation. eg `new T`
2378 var n_kwnew
: TKwnew is writable, noinit
2380 # The `type` keyword
2381 var n_type
: AType is writable, noinit
2383 # The name of the named-constructor, if any
2384 var n_qid
: nullable AQid = null is writable
2386 # The arguments of the `new`
2387 var n_args
: AExprs is writable, noinit
2390 # Whatever is a old-style attribute access
2391 abstract class AAttrFormExpr
2394 # The receiver of the attribute
2395 var n_expr
: AExpr is writable, noinit
2397 # The name of the attribute
2398 var n_id
: TAttrid is writable, noinit
2402 # The read of an attribute. eg `x._a`
2407 # The assignment of an attribute. eg `x._a=y`
2408 class AAttrAssignExpr
2410 super AAssignFormExpr
2413 # Whatever looks-like a call with a standard method and any number of arguments.
2414 abstract class ACallFormExpr
2417 # The name of the method
2418 var n_qid
: AQid is writable, noinit
2420 # The arguments of the call
2421 var n_args
: AExprs is writable, noinit
2424 # A complex setter call (standard or brackets)
2425 abstract class ASendReassignFormExpr
2427 super AReassignFormExpr
2430 # A complex attribute assignment. eg `x._a+=y`
2431 class AAttrReassignExpr
2433 super AReassignFormExpr
2436 # A call with a standard method-name and any number of arguments. eg `x.m(y)`. OR just a simple id
2437 # 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`.
2438 # Semantic analysis have to transform them to instance of `AVarExpr`.
2443 # A setter call with a standard method-name and any number of arguments. eg `x.m(y)=z`. OR just a simple assignment.
2444 # 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`.
2445 # Semantic analysis have to transform them to instance of `AVarAssignExpr`.
2446 class ACallAssignExpr
2448 super AAssignFormExpr
2451 # 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.
2452 # 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`.
2453 # Semantic analysis have to transform them to instance of `AVarReassignExpr`.
2454 class ACallReassignExpr
2456 super ASendReassignFormExpr
2459 # A reference to a method with a captured receiver. eg. `&x.foo` or just `&foo` is self is captured.
2461 # Currently, the syntax is analogous to a simple call (`recv.foo`) with a prefix `&`.
2462 # On chains, only the last call is captured (`.` has a higher precedence than `&`).
2464 # The syntax is analogous to a call (except the &), there is always a receiver (including the implicit self or sys) and arguments are accepted by the parser.
2466 # TODO There is no clear syntax proposal
2468 # * to avoid the capture of a receiver since a receiver is statically expected to resolve the method name
2469 # * for special method names (setters, brackets and operators)
2471 # Note: The class specializes `ASendExpr` (trough `ACallFormExpr`) so some behavior of a genuine send expression must be redefined.
2476 var n_amp
: TAmp is writable, noinit
2480 # A call to `super`. OR a call of a super-constructor
2484 # The qualifier part before the super (currenlty unused)
2485 var n_qualified
: nullable AQualified = null is writable
2487 # The `super` keyword
2488 var n_kwsuper
: TKwsuper is writable, noinit
2490 # The arguments of the super
2491 var n_args
: AExprs is writable, noinit
2494 # A call to the `init` constructor.
2495 # Note: because `init` is a keyword and not a `TId`, the explicit call to init cannot be a `ACallFormExpr`.
2499 # The `init` keyword
2500 var n_kwinit
: TKwinit is writable, noinit
2502 # The arguments of the init
2503 var n_args
: AExprs is writable, noinit
2506 # Whatever looks-like a call of the brackets `[]` operator.
2507 abstract class ABraFormExpr
2510 # The arguments inside the brackets
2511 var n_args
: AExprs is writable, noinit
2514 # A call of the brackets operator. eg `x[y,z]`
2519 # A setter call of the bracket operator. eg `x[y,z]=t`
2520 class ABraAssignExpr
2522 super AAssignFormExpr
2525 # Whatever is an access to a local variable
2526 abstract class AVarFormExpr
2529 # The name of the attribute
2530 var n_id
: TId is writable, noinit
2533 # A complex setter call of the bracket operator. eg `x[y,z]+=t`
2534 class ABraReassignExpr
2536 super ASendReassignFormExpr
2539 # A local variable read access.
2540 # The parser cannot instantiate them, see `ACallExpr`.
2545 # A local variable simple assignment access
2546 # The parser cannot instantiate them, see `ACallAssignExpr`.
2547 class AVarAssignExpr
2549 super AAssignFormExpr
2552 # A local variable complex assignment access
2553 # The parser cannot instantiate them, see `ACallReassignExpr`.
2554 class AVarReassignExpr
2556 super AReassignFormExpr
2559 # A literal range, open or closed
2560 abstract class ARangeExpr
2563 # The left (lower) element of the range
2564 var n_expr
: AExpr is writable, noinit
2567 var n_dotdot
: TDotdot is writable, noinit
2569 # The right (upper) element of the range
2570 var n_expr2
: AExpr is writable, noinit
2573 # A closed literal range. eg `[x..y]`
2577 # The opening bracket `[`
2578 var n_obra
: TObra is writable, noinit
2580 # The closing bracket `]`
2581 var n_cbra
: TCbra is writable, noinit
2584 # An open literal range. eg `[x..y[`
2588 # The opening bracket `[`
2589 var n_obra
: TObra is writable, noinit
2591 # The closing bracket `[` (because open range)
2592 var n_cbra
: TObra is writable, noinit
2595 # A literal array. eg. `[x,y,z]`
2599 # The opening bracket `[`
2600 var n_obra
: TObra is writable, noinit
2602 # The elements of the array
2603 var n_exprs
= new ANodes[AExpr](self)
2605 # The type of the element of the array (if any)
2606 var n_type
: nullable AType = null is writable
2608 # The closing bracket `]`
2609 var n_cbra
: TCbra is writable, noinit
2616 # The `self` keyword
2617 var n_kwself
: nullable TKwself = null is writable
2620 # When there is no explicit receiver, `self` is implicit
2621 class AImplicitSelfExpr
2625 # A `true` boolean literal constant
2629 # The `true` keyword
2630 var n_kwtrue
: TKwtrue is writable, noinit
2633 # A `false` boolean literal constant
2637 # The `false` keyword
2638 var n_kwfalse
: TKwfalse is writable, noinit
2641 # A `null` literal constant
2645 # The `null` keyword
2646 var n_kwnull
: TKwnull is writable, noinit
2649 # An integer literal
2654 var n_integer
: TInteger is writable, noinit
2662 var n_float
: TFloat is writable, noinit
2665 # A character literal
2669 # The character token
2670 var n_char
: TChar is writable, noinit
2674 abstract class AStringFormExpr
2678 var n_string
: Token is writable, noinit
2681 # A simple string. eg. `"abc"`
2683 super AStringFormExpr
2686 # The start of a superstring. eg `"abc{`
2687 class AStartStringExpr
2688 super AStringFormExpr
2691 # The middle of a superstring. eg `}abc{`
2692 class AMidStringExpr
2693 super AStringFormExpr
2696 # The end of a superstrng. eg `}abc"`
2697 class AEndStringExpr
2698 super AStringFormExpr
2701 # A superstring literal. eg `"a{x}b{y}c"`
2702 # Each part is modeled a sequence of expression. eg. `["a{, x, }b{, y, }c"]`
2703 class ASuperstringExpr
2706 # The list of the expressions of the superstring
2707 var n_exprs
= new ANodes[AExpr](self)
2712 var n_kwmeth
: TKwmeth is writable, noinit
2713 var n_signature
: ASignature is writable, noinit
2714 var n_kwdo
: TKwdo is writable, noinit
2715 var n_expr
: AExpr is writable, noinit
2718 # A simple parenthesis. eg `(x)`
2722 # The opening parenthesis
2723 var n_opar
: TOpar is writable, noinit
2725 # The inner expression
2726 var n_expr
: AExpr is writable, noinit
2728 # The closing parenthesis
2729 var n_cpar
: TCpar is writable, noinit
2732 # A cast, against a type or `not null`
2736 # The expression to cast
2737 var n_expr
: AExpr is writable, noinit
2740 var n_kwas
: TKwas is writable, noinit
2742 # The opening parenthesis
2743 var n_opar
: nullable TOpar = null is writable
2745 # The closing parenthesis
2746 var n_cpar
: nullable TCpar = null is writable
2749 # A type cast. eg `x.as(T)`
2753 # The target type to cast to
2754 var n_type
: AType is writable, noinit
2757 # A as-not-null cast. eg `x.as(not null)`
2758 class AAsNotnullExpr
2762 var n_kwnot
: TKwnot is writable, noinit
2764 # The `null` keyword
2765 var n_kwnull
: TKwnull is writable, noinit
2768 # A is-set check of old-style attributes. eg `isset x._a`
2769 class AIssetAttrExpr
2772 # The `isset` keyword
2773 var n_kwisset
: TKwisset is writable, noinit
2776 # An ellipsis notation used to pass an expression as it, in a vararg parameter
2780 # The passed expression
2781 var n_expr
: AExpr is writable, noinit
2784 var n_dotdotdot
: TDotdotdot is writable, noinit
2787 # A receiver with a `?` suffix used in safe call operator.
2791 # The expression made safe
2792 var n_expr
: AExpr is writable, noinit
2795 var n_quest
: TQuest is writable, noinit
2798 # An named notation used to pass an expression by name in a parameter
2802 # The name of the argument
2803 var n_id
: TId is writable, noinit
2806 var n_assign
: TAssign is writable, noinit
2808 # The passed expression
2809 var n_expr
: AExpr is writable, noinit
2812 # A list of expression separated with commas (arguments for instance)
2816 # The list of expressions
2817 var n_exprs
= new ANodes[AExpr](self)
2820 # A special expression that encapsulates a static type
2821 # Can only be found in special construction like arguments of annotations.
2825 # The encapsulated type
2826 var n_type
: AType is writable, noinit
2829 # A special expression that encapsulates a method identifier
2830 # Can only be found in special construction like arguments of annotations.
2835 var n_expr
: AExpr is writable, noinit
2837 # The encapsulated method identifier
2838 var n_id
: AMethid is writable, noinit
2841 # A special expression that encapsulate an annotation
2842 # Can only be found in special construction like arguments of annotations.
2844 # The encapsulated annotations are in `n_annotations`
2849 # A special expression to debug types
2850 class ADebugTypeExpr
2853 # The `debug` keyword
2854 var n_kwdebug
: TKwdebug is writable, noinit
2856 # The `type` keyword
2857 var n_kwtype
: TKwtype is writable, noinit
2859 # The expression to check
2860 var n_expr
: AExpr is writable, noinit
2863 var n_type
: AType is writable, noinit
2866 # A list of expression separated with commas (arguments for instance)
2867 abstract class AExprs
2870 # The list of expressions
2871 var n_exprs
= new ANodes[AExpr](self)
2874 # A simple list of expressions
2879 # A list of expressions enclosed in parentheses
2883 # The opening parenthesis
2884 var n_opar
: TOpar is writable, noinit
2886 # The closing parenthesis
2887 var n_cpar
: TCpar is writable, noinit
2890 # A list of expressions enclosed in brackets
2894 # The opening bracket
2895 var n_obra
: TObra is writable, noinit
2897 # The closing bracket
2898 var n_cbra
: TCbra is writable, noinit
2901 # A complex assignment operator. (`+=` and `-=`)
2902 abstract class AAssignOp
2905 # The combined assignment operator
2906 var n_op
: Token is writable, noinit
2908 # The name of the operator without the `=` (eg '+')
2909 fun operator
: String is abstract
2912 # A `+=` assignment operation
2916 redef fun operator
do return "+"
2919 # A `-=` assignment operation
2920 class AMinusAssignOp
2923 redef fun operator
do return "-"
2926 # A `*=` assignment operation
2930 redef fun operator
do return "*"
2933 # A `/=` assignment operation
2934 class ASlashAssignOp
2937 redef fun operator
do return "/"
2940 # A `%=` assignment operation
2941 class APercentAssignOp
2944 redef fun operator
do return "%"
2947 # A `**=` assignment operation
2948 class AStarstarAssignOp
2951 redef fun operator
do return "**"
2954 # A `|=` assignment operation
2958 redef fun operator
do return "|"
2961 # A `^=` assignment operation
2962 class ACaretAssignOp
2965 redef fun operator
do return "^"
2968 # A `&=` assignment operation
2972 redef fun operator
do return "&"
2975 # A `<<=` assignment operation
2979 redef fun operator
do return "<<"
2982 # A `>>=` assignment operation
2986 redef fun operator
do return ">>"
2989 # A possibly fully-qualified module identifier
2993 # The starting quad (`::`)
2994 var n_quad
: nullable TQuad = null is writable
2996 # The list of quad-separated package/group identifiers
2997 var n_path
= new ANodes[TId](self)
2999 # The final module identifier
3000 var n_id
: TId is writable, noinit
3003 # A language declaration for an extern block
3008 var n_kwin
: TKwin is writable, noinit
3011 var n_string
: TString is writable, noinit
3014 # An full extern block
3015 class AExternCodeBlock
3018 # The language declration
3019 var n_in_language
: nullable AInLanguage = null is writable
3021 # The block of extern code
3022 var n_extern_code_segment
: TExternCodeSegment is writable, noinit
3025 # A possible full method qualifier.
3029 # The starting quad (`::`)
3030 var n_quad
: nullable TQuad = null is writable
3032 # The list of quad-separated package/group/module identifiers
3033 var n_id
= new ANodes[TId](self)
3035 # A class identifier
3036 var n_classid
: nullable TClassid = null is writable
3039 # A documentation of a definition
3040 # It contains the block of comments just above the declaration
3044 # A list of lines of comment
3045 var n_comment
= new ANodes[TComment](self)
3048 # A group of annotation on a node
3050 # This same class is used for the 3 kind of annotations:
3052 # * *is* annotations. eg `module foo is bar`.
3053 # * *at* annotations. eg `foo@bar` or `foo@(bar,baz)`.
3054 # * *class* annotations, defined in classes.
3058 # The `is` keyword, for *is* annotations
3059 var n_kwis
: nullable TKwis = null is writable
3061 # The `@` symbol, for *at* annotations
3062 var n_at
: nullable TAt = null is writable
3064 # The opening parenthesis in *at* annotations
3065 var n_opar
: nullable TOpar = null is writable
3067 # The list of annotations
3068 var n_items
= new ANodes[AAnnotation](self)
3070 # The closing parenthesis in *at* annotations
3071 var n_cpar
: nullable TCpar = null is writable
3073 # The `end` keyword, for *is* annotations
3074 var n_kwend
: nullable TKwend = null is writable
3077 # A single annotation
3081 # The name of the annotation
3082 var n_atid
: AAtid is writable, noinit
3084 # The opening parenthesis of the arguments
3085 var n_opar
: nullable TOpar = null is writable
3087 # The list of arguments
3088 var n_args
= new ANodes[AExpr](self)
3090 # The closing parenthesis
3091 var n_cpar
: nullable TCpar = null is writable
3093 # The name of the annotation
3096 return n_atid
.n_id
.text
3100 # An annotation name
3101 abstract class AAtid
3104 # The identifier of the annotation.
3106 # Can be a TId or a keyword.
3107 var n_id
: Token is writable, noinit
3110 # An annotation name based on an identifier
3115 # An annotation name based on the keyword `extern`
3120 # An annotation name based on the keyword `import`
3125 # An annotation name based on the keyword `abstract`
3126 class AKwabstractAtid
3130 # The root of the AST
3135 var n_base
: nullable AModule is writable
3137 # The end of file (or error) token
3138 var n_eof
: EOF is writable