X-Git-Url: http://nitlanguage.org diff --git a/src/parser/parser_nodes.nit b/src/parser/parser_nodes.nit index a5f09ca..070a8f8 100644 --- a/src/parser/parser_nodes.nit +++ b/src/parser/parser_nodes.nit @@ -1,8 +1,5 @@ # This file is part of NIT ( http://www.nitlanguage.org ). # -# Copyright 2008-2009 Jean Privat -# Copyright 2009 Jean-Sebastien Gelinas -# # Licensed under the Apache License, Version 2.0 (the "License"); # you may not use this file except in compliance with the License. # You may obtain a copy of the License at @@ -17,181 +14,474 @@ # AST nodes of the Nit language # Was previously based on parser_abs.nit. -package parser_nodes +module parser_nodes import location -# Root of the AST hierarchy +# Root of the AST class-hierarchy abstract class ANode - var _location: nullable Location - # Location is set during AST building. Once built, location cannon be null - # However, manual instanciated nodes may need mode care + var _location: nullable Location = null + + # Location is set during AST building. Once built, location cannon be null. + # However, manual instantiated nodes may need more care. fun location: Location do return _location.as(not null) + # The location of the important part of the node (identifier or whatever) fun hot_location: Location do return location + + # Display a message for the colored location of the node + fun debug(message: String) + do + sys.stderr.write "{hot_location} {self.class_name}: {message}\n{hot_location.colored_line("0;32")}\n" + end + + # Parent of the node in the AST + var parent: nullable ANode = null + + # The topmost ancestor of the element + # This just apply `parent` until the first one + fun root: ANode + do + var res = self + loop + var p = res.parent + if p == null then return res + res = p + end + end + + # The most specific common parent between `self` and `other` + # Return null if the two node are unrelated (distinct root) + fun common_parent(other: ANode): nullable ANode + do + # First, get the same depth + var s: nullable ANode = self + var o: nullable ANode = other + var d = s.depth - o.depth + while d > 0 do + s = s.parent + d -= 1 + end + while d < 0 do + o = o.parent + d += 1 + end + assert o.depth == s.depth + # Second, go up until same in found + while s != o do + s = s.parent + o = o.parent + end + return s + end + + # Number of nodes between `self` and the `root` of the AST + # ENSURE `self == self.root implies result == 0 ` + # ENSURE `self != self.root implies result == self.parent.depth + 1` + fun depth: Int + do + var n = self + var res = 0 + loop + var p = n.parent + if p == null then return res + n = p + res += 1 + end + end + + # Protect from invalid instantiation of nodes + private init do end + + # Replace a child with an other node in the AST + private fun replace_child(old_child: ANode, new_child: nullable ANode) is abstract + + # Detach a node from its parent + # Aborts if the node is not detashable. use `replace_with` instead + # REQUIRE: parent != null + # REQUIRE: is_detachable + # ENDURE: parent == null + fun detach + do + assert parent != null + parent.replace_child(self, null) + parent = null + end + + # Replace itself with an other node in the AST + # REQUIRE: parent != null + # ENSURE: node.parent == old(parent) + # ENSURE: parent == null + fun replace_with(node: ANode) + do + assert parent != null + parent.replace_child(self, node) + parent = null + end + + # Visit all nodes in order. + # Thus, call `v.enter_visit(e)` for each child `e` + fun visit_all(v: Visitor) is abstract +end + +# A sequence of nodes +# There is a specifc class (instead of a using Array) to track the parent/child relation when nodes are added or removed +class ANodes[E: ANode] + super Sequence[E] + private var parent: ANode + private var items = new Array[E] + redef fun iterator do return items.iterator + redef fun length do return items.length + redef fun is_empty do return items.is_empty + redef fun push(e) + do + hook_add(e) + items.push(e) + end + redef fun pop + do + var res = items.pop + hook_remove(res) + return res + end + redef fun unshift(e) + do + hook_add(e) + items.unshift(e) + end + redef fun shift + do + var res = items.shift + hook_remove(res) + return res + end + redef fun has(e) + do + return items.has(e) + end + redef fun [](index) + do + return items[index] + end + redef fun []=(index, e) + do + hook_remove(self[index]) + hook_add(e) + items[index]=e + end + redef fun remove_at(index) + do + hook_remove(items[index]) + items.remove_at(index) + end + private fun hook_add(e: E) + do + #assert e.parent == null + e.parent = parent + end + private fun hook_remove(e: E) + do + assert e.parent == parent + e.parent = null + end + + # Used in parent contructor to fill elements + private fun unsafe_add_all(nodes: Collection[Object]) + do + var parent = self.parent + for n in nodes do + assert n isa E + add n + n.parent = parent + end + end + + private fun replace_child(old_child: ANode, new_child: nullable ANode): Bool + do + var parent = self.parent + for i in [0..length[ do + if self[i] == old_child then + if new_child != null then + assert new_child isa E + self[i] = new_child + new_child.parent = parent + else + self.remove_at(i) + end + return true + end + end + return false + end + + private fun visit_all(v: Visitor) + do + for n in self do v.enter_visit(n) + end end # Ancestor of all tokens +# A token is a node that has a `text` but no children. abstract class Token super ANode + + # The raw content on the token + fun text: String is abstract + fun text=(text: String) is abstract + + # The previous token in the Lexer. + # May have disapeared in the AST + var prev_token: nullable Token = null + + # The next token in the Lexer. + # May have disapeared in the AST + var next_token: nullable Token = null + + # The verbatim blank text between `prev_token` and `self` + fun blank_before: String + do + if prev_token == null then return "" + var from = prev_token.location.pend+1 + var to = location.pstart + return location.file.string.substring(from,to-from) + end + + redef fun to_s: String do + return "'{text}'" + end + + redef fun visit_all(v: Visitor) do end + redef fun replace_child(old_child: ANode, new_child: nullable ANode) do end +end + +redef class SourceFile + # The first token parser by the lexer + # May have disapeared in the final AST + var first_token: nullable Token = null + + # The first token parser by the lexer + # May have disapeared in the final AST + var last_token: nullable Token = null end # Ancestor of all productions +# A production is a node without text but that usually has children. abstract class Prod super ANode + fun location=(l: Location) do _location = l + + # All the annotations attached directly to the node + readable writable var _n_annotations: nullable AAnnotations = null + + redef fun replace_with(n: ANode) + do + super + assert n isa Prod + if n._location == null then n._location = _location + end +end + +# Abstract standard visitor on the AST +abstract class Visitor + # What the visitor do when a node is visited + # Concrete visitors should implement this method. + # @toimplement + protected fun visit(e: ANode) is abstract + + # Ask the visitor to visit a given node. + # Usually automatically called by visit_all* methods. + # This method should not be redefined + fun enter_visit(e: nullable ANode) + do + if e == null then return + var old = _current_node + _current_node = e + visit(e) + _current_node = old + end + + # The current visited node + readable writable var _current_node: nullable ANode = null end + +# Token of end of line (basically `\n`) class TEol super Token + redef fun to_s + do + return "end of line" + end end + +# Token of a line of comments +# Starts with the `#` and contains the final end-of-line (if any) class TComment super Token end -class TKwmodule + +# A token associated with a keyword +abstract class TokenKeyword super Token + redef fun to_s + do + return "keyword '{text}'" + end +end +class TKwpackage + super TokenKeyword +end +class TKwmodule + super TokenKeyword end class TKwimport - super Token + super TokenKeyword end class TKwclass - super Token + super TokenKeyword end class TKwabstract - super Token + super TokenKeyword end class TKwinterface - super Token + super TokenKeyword end class TKwenum - super Token -end -class TKwspecial - super Token + super TokenKeyword end class TKwend - super Token + super TokenKeyword end class TKwmeth - super Token + super TokenKeyword end class TKwtype - super Token + super TokenKeyword end class TKwinit - super Token + super TokenKeyword end class TKwredef - super Token + super TokenKeyword end class TKwis - super Token + super TokenKeyword end class TKwdo - super Token + super TokenKeyword end class TKwreadable - super Token + super TokenKeyword end class TKwwritable - super Token + super TokenKeyword end class TKwvar - super Token + super TokenKeyword end class TKwintern - super Token + super TokenKeyword end class TKwextern - super Token + super TokenKeyword +end +class TKwpublic + super TokenKeyword end class TKwprotected - super Token + super TokenKeyword end class TKwprivate - super Token + super TokenKeyword end class TKwintrude - super Token + super TokenKeyword end class TKwif - super Token + super TokenKeyword end class TKwthen - super Token + super TokenKeyword end class TKwelse - super Token + super TokenKeyword end class TKwwhile - super Token + super TokenKeyword end class TKwloop - super Token + super TokenKeyword end class TKwfor - super Token + super TokenKeyword end class TKwin - super Token + super TokenKeyword end class TKwand - super Token + super TokenKeyword end class TKwor - super Token + super TokenKeyword +end +class TKwimplies + super TokenKeyword end class TKwnot - super Token + super TokenKeyword end class TKwreturn - super Token + super TokenKeyword end class TKwcontinue - super Token + super TokenKeyword end class TKwbreak - super Token + super TokenKeyword end class TKwabort - super Token + super TokenKeyword end class TKwassert - super Token + super TokenKeyword end class TKwnew - super Token + super TokenKeyword end class TKwisa - super Token + super TokenKeyword end class TKwonce - super Token + super TokenKeyword end class TKwsuper - super Token + super TokenKeyword end class TKwself - super Token + super TokenKeyword end class TKwtrue - super Token + super TokenKeyword end class TKwfalse - super Token + super TokenKeyword end class TKwnull - super Token + super TokenKeyword end class TKwas - super Token + super TokenKeyword end class TKwnullable - super Token + super TokenKeyword end class TKwisset - super Token + super TokenKeyword end class TKwlabel + super TokenKeyword +end +class TKwdebug super Token end class TOpar @@ -218,11 +508,20 @@ end class TAssign super Token end -class TPluseq + +# A token associated with an operator (and other lookalike symbols) +abstract class TokenOperator super Token + redef fun to_s + do + return "operator '{text}'" + end +end +class TPluseq + super TokenOperator end class TMinuseq - super Token + super TokenOperator end class TDotdotdot super Token @@ -234,782 +533,1435 @@ class TDot super Token end class TPlus - super Token + super TokenOperator end class TMinus - super Token + super TokenOperator end class TStar - super Token + super TokenOperator end class TSlash - super Token + super TokenOperator end class TPercent - super Token + super TokenOperator end class TEq - super Token + super TokenOperator end class TNe - super Token + super TokenOperator end class TLt - super Token + super TokenOperator end class TLe - super Token + super TokenOperator end class TLl - super Token + super TokenOperator end class TGt - super Token + super TokenOperator end class TGe - super Token + super TokenOperator end class TGg - super Token + super TokenOperator end class TStarship - super Token + super TokenOperator end class TBang + super TokenOperator +end +class TAt super Token end + +# A class (or formal type) identifier. They start with an uppercase. class TClassid super Token + redef fun to_s + do + do return "type identifier '{text}'" + end end + +# A standard identifier (variable, method...). They start with a lowercase. class TId super Token + redef fun to_s + do + do return "identifier '{text}'" + end end + +# An attribute identifier. They start with an underscore. class TAttrid super Token + redef fun to_s + do + do return "attribute '{text}'" + end end -class TNumber + +# A token of a literal value (string, integer, etc). +abstract class TokenLiteral super Token + redef fun to_s + do + do return "literal value '{text}'" + end +end +class TNumber + super TokenLiteral +end +class THexNumber + super TokenLiteral end class TFloat - super Token + super TokenLiteral end class TChar - super Token + super TokenLiteral end class TString - super Token + super TokenLiteral end class TStartString - super Token + super TokenLiteral end class TMidString - super Token + super TokenLiteral end class TEndString + super TokenLiteral +end + +# A malformed string +class TBadString super Token + redef fun to_s + do + do return "malformed string {text}" + end end + +# A malformed char +class TBadChar + super Token + redef fun to_s + do + do return "malformed character {text}" + end +end + +class TExternCodeSegment + super Token +end + +# A end of file class EOF super Token -private init noinit do end + redef fun to_s + do + return "end of file" + end end + +# A mark of an error class AError super EOF -private init noinit do end +end +class ALexerError + super AError +end +class AParserError + super AError end +# The main node of a Nit source-file class AModule super Prod - readable var _n_moduledecl: nullable AModuledecl = null - readable var _n_imports: List[AImport] = new List[AImport] - readable var _n_classdefs: List[AClassdef] = new List[AClassdef] + + readable writable var _n_moduledecl: nullable AModuledecl = null + readable var _n_imports: ANodes[AImport] = new ANodes[AImport](self) + readable var _n_extern_code_blocks: ANodes[AExternCodeBlock] = new ANodes[AExternCodeBlock](self) + readable var _n_classdefs: ANodes[AClassdef] = new ANodes[AClassdef](self) + init do end end + +# The declaration of the module with the documentation, name, and annotations class AModuledecl super Prod - readable var _n_doc: nullable ADoc = null - readable var _n_kwmodule: TKwmodule - readable var _n_id: TId - redef fun hot_location do return n_id.location + readable writable var _n_doc: nullable ADoc = null + readable writable var _n_kwmodule: TKwmodule + readable writable var _n_name: AModuleName + init do end end -class AImport super Prod end + +# A import clause of a module +abstract class AImport + super Prod +end + +# A standard import clause. eg `import x` class AStdImport super AImport - readable var _n_visibility: AVisibility - readable var _n_kwimport: TKwimport - readable var _n_id: TId + readable writable var _n_visibility: AVisibility + readable writable var _n_kwimport: TKwimport + readable writable var _n_name: AModuleName + init do end end + +# The special import clause of the kernel module. eg `import end` class ANoImport super AImport - readable var _n_visibility: AVisibility - readable var _n_kwimport: TKwimport - readable var _n_kwend: TKwend + readable writable var _n_visibility: AVisibility + readable writable var _n_kwimport: TKwimport + readable writable var _n_kwend: TKwend + init do end +end + +# A visibility modifier +# +# The public visibility is an empty production (no keyword). +# +# Note: even if some visibilities are only valid on some placse (for instance, no `protected` class or no `intrude` method) +# the parser has no such a restriction, therefore the semantic phases has to check that the visibilities make sense. +abstract class AVisibility + super Prod end -class AVisibility super Prod end class APublicVisibility super AVisibility end class APrivateVisibility super AVisibility - readable var _n_kwprivate: TKwprivate + readable writable var _n_kwprivate: TKwprivate + init do end end class AProtectedVisibility super AVisibility - readable var _n_kwprotected: TKwprotected + readable writable var _n_kwprotected: TKwprotected + init do end end class AIntrudeVisibility super AVisibility - readable var _n_kwintrude: TKwintrude + readable writable var _n_kwintrude: TKwintrude + init do end end -class AClassdef super Prod end + +# A class definition +# While most definition are `AStdClassdef` +# There is tow special case of class definition +abstract class AClassdef + super Prod + readable var _n_propdefs: ANodes[APropdef] = new ANodes[APropdef](self) + init do end +end + +# A standard class definition with a name, superclasses and properties class AStdClassdef super AClassdef - readable var _n_doc: nullable ADoc = null - readable var _n_kwredef: nullable TKwredef = null - readable var _n_visibility: AVisibility - readable var _n_classkind: AClasskind - readable var _n_id: nullable TClassid = null - readable var _n_formaldefs: List[AFormaldef] = new List[AFormaldef] - readable var _n_superclasses: List[ASuperclass] = new List[ASuperclass] - readable var _n_propdefs: List[APropdef] = new List[APropdef] - redef fun hot_location do return n_id.location + readable writable var _n_doc: nullable ADoc = null + readable writable var _n_kwredef: nullable TKwredef = null + readable writable var _n_visibility: AVisibility + readable writable var _n_classkind: AClasskind + readable writable var _n_id: nullable TClassid = null + readable var _n_formaldefs: ANodes[AFormaldef] = new ANodes[AFormaldef](self) + readable writable var _n_extern_code_block: nullable AExternCodeBlock = null + readable var _n_superclasses: ANodes[ASuperclass] = new ANodes[ASuperclass](self) + readable writable var _n_kwend: TKwend + redef fun hot_location do return n_id.location + init do end end + +# The implicit class definition of the implicit main method class ATopClassdef super AClassdef - readable var _n_propdefs: List[APropdef] = new List[APropdef] end + +# The implicit class definition of the top-level methods class AMainClassdef super AClassdef - readable var _n_propdefs: List[APropdef] = new List[APropdef] end -class AClasskind super Prod end + +# The modifier for the kind of class (abstract, interface, etc.) +abstract class AClasskind + super Prod +end class AConcreteClasskind super AClasskind - readable var _n_kwclass: TKwclass + readable writable var _n_kwclass: TKwclass + init do end end class AAbstractClasskind super AClasskind - readable var _n_kwabstract: TKwabstract - readable var _n_kwclass: TKwclass + readable writable var _n_kwabstract: TKwabstract + readable writable var _n_kwclass: TKwclass + init do end end class AInterfaceClasskind super AClasskind - readable var _n_kwinterface: TKwinterface + readable writable var _n_kwinterface: TKwinterface + init do end end class AEnumClasskind super AClasskind - readable var _n_kwenum: TKwenum + readable writable var _n_kwenum: TKwenum + init do end +end +class AExternClasskind + super AClasskind + readable writable var _n_kwextern: TKwextern + readable writable var _n_kwclass: nullable TKwclass = null + init do end end + +# The definition of a formal generic parameter type. eg `X: Y` class AFormaldef super Prod - readable var _n_id: TClassid - readable var _n_type: nullable AType = null + readable writable var _n_id: TClassid + # The bound of the parameter type + readable writable var _n_type: nullable AType = null + init do end end + +# A super-class. eg `super X` class ASuperclass super Prod - readable var _n_kwspecial: nullable TKwspecial = null - readable var _n_kwsuper: nullable TKwsuper = null - readable var _n_type: AType + readable writable var _n_kwsuper: TKwsuper + readable writable var _n_type: AType + init do end end -class APropdef super Prod - readable var _n_doc: nullable ADoc = null + +# The definition of a property +abstract class APropdef + super Prod + readable writable var _n_doc: nullable ADoc = null + readable writable var _n_kwredef: nullable TKwredef = null + readable writable var _n_visibility: nullable AVisibility = null end + +# A definition of an attribute +# For historical reason, old-syle and new-style attributes use the same `ANode` sub-class class AAttrPropdef super APropdef - readable var _n_kwredef: nullable TKwredef = null - readable var _n_visibility: AVisibility - readable var _n_kwvar: TKwvar - readable var _n_id: nullable TAttrid - readable var _n_id2: nullable TId - readable var _n_type: nullable AType = null - readable var _n_readable: nullable AAble = null - readable var _n_writable: nullable AAble = null - readable var _n_expr: nullable AExpr = null - redef fun hot_location - do - if n_id != null then return n_id.location else return n_id2.location - end -end -class AMethPropdef + readable writable var _n_kwvar: TKwvar + + # The identifier for an old-style attribute (null if new-style) + readable writable var _n_id: nullable TAttrid + + # The identifier for a new-style attribute (null if old-style) + readable writable var _n_id2: nullable TId + + readable writable var _n_type: nullable AType = null + readable writable var _n_readable: nullable AAble = null + readable writable var _n_writable: nullable AAble = null + + # The initial value, if any + readable writable var _n_expr: nullable AExpr = null + redef fun hot_location + do + if n_id != null then return n_id.location else return n_id2.location + end + init do end +end + +# A definition of all kind of method (including constructors) +abstract class AMethPropdef super APropdef - readable var _n_kwredef: nullable TKwredef = null - readable var _n_visibility: nullable AVisibility - readable var _n_methid: nullable AMethid = null - readable var _n_signature: nullable ASignature - redef fun hot_location - do - if n_methid != null then - return n_methid.location - else - return location - end - end + readable writable var _n_kwmeth: nullable TKwmeth = null + readable writable var _n_kwinit: nullable TKwinit = null + readable writable var _n_kwnew: nullable TKwnew = null + readable writable var _n_methid: nullable AMethid = null + readable writable var _n_signature: nullable ASignature = null + readable writable var _n_block: nullable AExpr = null + readable writable var _n_extern: nullable TString = null + readable writable var _n_extern_calls: nullable AExternCalls = null + readable writable var _n_extern_code_block: nullable AExternCodeBlock = null + redef fun hot_location + do + if n_methid != null then + return n_methid.location + else if n_kwinit != null then + return n_kwinit.location + else if n_kwnew != null then + return n_kwnew.location + else + return location + end + end end + +# A method marked abstract +# *deferred* is a old synonynmous of *abstract* that comes from PRM, that comes from Eiffel. class ADeferredMethPropdef super AMethPropdef - readable var _n_kwmeth: TKwmeth end + +# A method marked intern class AInternMethPropdef super AMethPropdef - readable var _n_kwmeth: TKwmeth end -class AExternMethPropdef + +# A method of a constructor marked extern +abstract class AExternPropdef super AMethPropdef - readable var _n_kwmeth: TKwmeth - readable var _n_extern: nullable TString = null end + +# A method marked extern +class AExternMethPropdef + super AExternPropdef +end + +# A method with a body class AConcreteMethPropdef super AMethPropdef - readable var _n_kwmeth: nullable TKwmeth - readable var _n_block: nullable AExpr = null end + +# A constructor +abstract class AInitPropdef + super AMethPropdef +end + +# A constructor with a body class AConcreteInitPropdef super AConcreteMethPropdef - readable var _n_kwinit: TKwinit - redef fun hot_location do return n_kwinit.location + super AInitPropdef end + +# A constructor marked extern (defined with the `new` keyword) +class AExternInitPropdef + super AExternPropdef + super AInitPropdef +end + +# The implicit main method class AMainMethPropdef super AConcreteMethPropdef end + +# Declaration of callbacks for extern methods +class AExternCalls + super Prod + readable writable var _n_kwimport: TKwimport + readable var _n_extern_calls: ANodes[AExternCall] = new ANodes[AExternCall](self) + init do end +end +abstract class AExternCall + super Prod +end +abstract class APropExternCall + super AExternCall +end +class ALocalPropExternCall + super APropExternCall + readable writable var _n_methid: AMethid + init do end +end +class AFullPropExternCall + super APropExternCall + readable writable var _n_type: AType + readable writable var _n_dot: nullable TDot = null + readable writable var _n_methid: AMethid + init do end +end +class AInitPropExternCall + super APropExternCall + readable writable var _n_type: AType + init do end +end +class ASuperExternCall + super AExternCall + readable writable var _n_kwsuper: TKwsuper + init do end +end +abstract class ACastExternCall + super AExternCall +end +class ACastAsExternCall + super ACastExternCall + readable writable var _n_from_type: AType + readable writable var _n_dot: nullable TDot = null + readable writable var _n_kwas: TKwas + readable writable var _n_to_type: AType + init do end +end +class AAsNullableExternCall + super ACastExternCall + readable writable var _n_type: AType + readable writable var _n_kwas: TKwas + readable writable var _n_kwnullable: TKwnullable + init do end +end +class AAsNotNullableExternCall + super ACastExternCall + readable writable var _n_type: AType + readable writable var _n_kwas: TKwas + readable writable var _n_kwnot: TKwnot + readable writable var _n_kwnullable: TKwnullable + init do end +end + +# A definition of a virtual type class ATypePropdef super APropdef - readable var _n_kwredef: nullable TKwredef = null - readable var _n_visibility: AVisibility - readable var _n_kwtype: TKwtype - readable var _n_id: TClassid - readable var _n_type: AType + readable writable var _n_kwtype: TKwtype + readable writable var _n_id: TClassid + readable writable var _n_type: AType + init do end end -class AAble super Prod - readable var _n_visibility: nullable AVisibility = null - readable var _n_kwredef: nullable TKwredef = null + +# A `writable` or `readable` modifier +abstract class AAble + super Prod + readable writable var _n_visibility: nullable AVisibility = null + readable writable var _n_kwredef: nullable TKwredef = null + init do end end + +# A `readable` modifier class AReadAble super AAble - readable var _n_kwreadable: TKwreadable + readable writable var _n_kwreadable: TKwreadable + init do end end + +# A `writable` modifier class AWriteAble super AAble - readable var _n_kwwritable: TKwwritable + readable writable var _n_kwwritable: TKwwritable + init do end +end + +# The identifier of a method in a method declaration. +# There is a specific class because of operator and setters. +abstract class AMethid + super Prod end -class AMethid super Prod end class AIdMethid super AMethid - readable var _n_id: TId + readable writable var _n_id: TId + init do end end class APlusMethid super AMethid - readable var _n_plus: TPlus + readable writable var _n_plus: TPlus + init do end end class AMinusMethid super AMethid - readable var _n_minus: TMinus + readable writable var _n_minus: TMinus + init do end end class AStarMethid super AMethid - readable var _n_star: TStar + readable writable var _n_star: TStar + init do end end class ASlashMethid super AMethid - readable var _n_slash: TSlash + readable writable var _n_slash: TSlash + init do end end class APercentMethid super AMethid - readable var _n_percent: TPercent + readable writable var _n_percent: TPercent + init do end end class AEqMethid super AMethid - readable var _n_eq: TEq + readable writable var _n_eq: TEq + init do end end class ANeMethid super AMethid - readable var _n_ne: TNe + readable writable var _n_ne: TNe + init do end end class ALeMethid super AMethid - readable var _n_le: TLe + readable writable var _n_le: TLe + init do end end class AGeMethid super AMethid - readable var _n_ge: TGe + readable writable var _n_ge: TGe + init do end end class ALtMethid super AMethid - readable var _n_lt: TLt + readable writable var _n_lt: TLt + init do end end class AGtMethid super AMethid - readable var _n_gt: TGt + readable writable var _n_gt: TGt + init do end end class ALlMethid super AMethid - readable writable var _n_ll: TLl + readable writable var _n_ll: TLl + init do end end class AGgMethid super AMethid - readable writable var _n_gg: TGg + readable writable var _n_gg: TGg + init do end end class ABraMethid super AMethid - readable var _n_obra: TObra - readable var _n_cbra: TCbra + readable writable var _n_obra: TObra + readable writable var _n_cbra: TCbra + init do end end class AStarshipMethid super AMethid - readable var _n_starship: TStarship + readable writable var _n_starship: TStarship + init do end end class AAssignMethid super AMethid - readable var _n_id: TId - readable var _n_assign: TAssign + readable writable var _n_id: TId + readable writable var _n_assign: TAssign + init do end end class ABraassignMethid super AMethid - readable var _n_obra: TObra - readable var _n_cbra: TCbra - readable var _n_assign: TAssign + readable writable var _n_obra: TObra + readable writable var _n_cbra: TCbra + readable writable var _n_assign: TAssign + init do end end + +# A signature in a method definition. eg `(x,y:X,z:Z):T` class ASignature super Prod - readable var _n_params: List[AParam] = new List[AParam] - readable var _n_type: nullable AType = null - readable var _n_closure_decls: List[AClosureDecl] = new List[AClosureDecl] + readable writable var _n_opar: nullable TOpar = null + readable var _n_params: ANodes[AParam] = new ANodes[AParam](self) + readable writable var _n_cpar: nullable TCpar = null + readable writable var _n_type: nullable AType = null + init do end end + +# A parameter definition in a signature. eg `x:X` class AParam super Prod - readable var _n_id: TId - readable var _n_type: nullable AType = null - readable var _n_dotdotdot: nullable TDotdotdot = null -end -class AClosureDecl - super Prod - readable var _n_kwbreak: nullable TKwbreak = null - readable var _n_bang: TBang - readable var _n_id: TId - readable var _n_signature: ASignature - readable var _n_expr: nullable AExpr = null + readable writable var _n_id: TId + readable writable var _n_type: nullable AType = null + readable writable var _n_dotdotdot: nullable TDotdotdot = null + init do end end + +# A static type. eg `nullable X[Y]` class AType super Prod - readable var _n_kwnullable: nullable TKwnullable = null - readable var _n_id: TClassid - readable var _n_types: List[AType] = new List[AType] + readable writable var _n_kwnullable: nullable TKwnullable = null + + # The name of the class or of the formal type + readable writable var _n_id: TClassid + + # Type arguments for a generic type + readable var _n_types: ANodes[AType] = new ANodes[AType](self) + init do end end + +# A label at the end of a block or in a break/continue statement. eg `label x` class ALabel super Prod - readable var _n_kwlabel: TKwlabel - readable var _n_id: TId + readable writable var _n_kwlabel: TKwlabel + readable writable var _n_id: TId + init do end end -class AExpr super Prod end + +# Expression and statements +# From a AST point of view there is no distinction between statement and expressions (even if the parser has to distinguish them) +abstract class AExpr + super Prod +end + +# A sequence of AExpr (usually statements) +# The last AExpr gives the value of the whole block class ABlockExpr super AExpr - readable var _n_expr: List[AExpr] = new List[AExpr] + readable var _n_expr: ANodes[AExpr] = new ANodes[AExpr](self) + readable writable var _n_kwend: nullable TKwend = null + init do end end + +# A declaration of a local variable. eg `var x: X = y` class AVardeclExpr super AExpr - readable var _n_kwvar: TKwvar - readable var _n_id: TId - readable var _n_type: nullable AType = null - readable var _n_assign: nullable TAssign = null - readable var _n_expr: nullable AExpr = null + readable writable var _n_kwvar: TKwvar + readable writable var _n_id: TId + readable writable var _n_type: nullable AType = null + readable writable var _n_assign: nullable TAssign = null + + # The initial value, if any + readable writable var _n_expr: nullable AExpr = null + init do end end + +# A `return` statement. eg `return x` class AReturnExpr super AExpr - readable var _n_kwreturn: nullable TKwreturn = null - readable var _n_expr: nullable AExpr = null + readable writable var _n_kwreturn: nullable TKwreturn = null + readable writable var _n_expr: nullable AExpr = null + init do end end -class ALabelable + +# Something that has a label. +abstract class ALabelable super Prod - readable var _n_label: nullable ALabel = null + readable writable var _n_label: nullable ALabel = null + init do end end + +# A `break` statement. class ABreakExpr super AExpr super ALabelable - readable var _n_kwbreak: TKwbreak - readable var _n_expr: nullable AExpr = null + readable writable var _n_kwbreak: TKwbreak + readable writable var _n_expr: nullable AExpr = null + init do end end + +# An `abort` statement class AAbortExpr super AExpr - readable var _n_kwabort: TKwabort + readable writable var _n_kwabort: TKwabort + init do end end + +# A `continue` statement class AContinueExpr super AExpr super ALabelable - readable var _n_kwcontinue: nullable TKwcontinue = null - readable var _n_expr: nullable AExpr = null + readable writable var _n_kwcontinue: nullable TKwcontinue = null + readable writable var _n_expr: nullable AExpr = null + init do end end + +# A `do` statement class ADoExpr super AExpr super ALabelable - readable var _n_kwdo: TKwdo - readable var _n_block: nullable AExpr = null + readable writable var _n_kwdo: TKwdo + readable writable var _n_block: nullable AExpr = null + init do end end + +# A `if` statement class AIfExpr super AExpr - readable var _n_kwif: TKwif - readable var _n_expr: AExpr - readable var _n_then: nullable AExpr = null - readable var _n_else: nullable AExpr = null + readable writable var _n_kwif: TKwif + readable writable var _n_expr: AExpr + readable writable var _n_then: nullable AExpr = null + readable writable var _n_else: nullable AExpr = null + init do end end + +# A `if` expression class AIfexprExpr super AExpr - readable var _n_kwif: TKwif - readable var _n_expr: AExpr - readable var _n_kwthen: TKwthen - readable var _n_then: AExpr - readable var _n_kwelse: TKwelse - readable var _n_else: AExpr + readable writable var _n_kwif: TKwif + readable writable var _n_expr: AExpr + readable writable var _n_kwthen: TKwthen + readable writable var _n_then: AExpr + readable writable var _n_kwelse: TKwelse + readable writable var _n_else: AExpr + init do end end + +# A `while` statement class AWhileExpr super AExpr super ALabelable - readable var _n_kwwhile: TKwwhile - readable var _n_expr: AExpr - readable var _n_kwdo: TKwdo - readable var _n_block: nullable AExpr = null + readable writable var _n_kwwhile: TKwwhile + readable writable var _n_expr: AExpr + readable writable var _n_kwdo: TKwdo + readable writable var _n_block: nullable AExpr = null + init do end end + +# A `loop` statement class ALoopExpr super AExpr super ALabelable - readable var _n_kwloop: TKwloop - readable var _n_block: nullable AExpr = null + readable writable var _n_kwloop: TKwloop + readable writable var _n_block: nullable AExpr = null + init do end end + +# A `for` statement class AForExpr super AExpr super ALabelable - readable var _n_kwfor: TKwfor - readable var _n_ids: List[TId] = new List[TId] - readable var _n_expr: AExpr - readable var _n_kwdo: TKwdo - readable var _n_block: nullable AExpr = null + readable writable var _n_kwfor: TKwfor + readable var _n_ids: ANodes[TId] = new ANodes[TId](self) + readable writable var _n_expr: AExpr + readable writable var _n_kwdo: TKwdo + readable writable var _n_block: nullable AExpr = null + init do end end + +# An `assert` statement class AAssertExpr super AExpr - readable var _n_kwassert: TKwassert - readable var _n_id: nullable TId = null - readable var _n_expr: AExpr - readable var _n_else: nullable AExpr = null + readable writable var _n_kwassert: TKwassert + readable writable var _n_id: nullable TId = null + readable writable var _n_expr: AExpr + readable writable var _n_else: nullable AExpr = null + init do end end -class AAssignFormExpr + +# Whatever is a simple assignment. eg `= something` +abstract class AAssignFormExpr super AExpr - readable var _n_assign: TAssign - readable var _n_value: AExpr + readable writable var _n_assign: TAssign + readable writable var _n_value: AExpr + init do end end -class AReassignFormExpr + +# Whatever is a combined assignment. eg `+= something` +abstract class AReassignFormExpr super AExpr - readable var _n_assign_op: AAssignOp - readable var _n_value: AExpr + readable writable var _n_assign_op: AAssignOp + readable writable var _n_value: AExpr + init do end end + +# A `once` expression. eg `once x` class AOnceExpr super AProxyExpr - readable var _n_kwonce: TKwonce + readable writable var _n_kwonce: TKwonce + init do end end -class ASendExpr + +# A polymorphic invocation of a method +# The form of the invocation (name, arguments, etc) are specific +abstract class ASendExpr super AExpr - readable var _n_expr: AExpr - readable var _n_closure_defs: List[AClosureDef] = new List[AClosureDef] + # The receiver of the method invocation + readable writable var _n_expr: AExpr + init do end end -class ABinopExpr + +# A binary operation on a method +abstract class ABinopExpr super ASendExpr - readable var _n_expr2: AExpr + # The second operand of the operation + # Note: the receiver (`n_expr`) is the first operand + readable writable var _n_expr2: AExpr + init do end end -class ABoolExpr + +# Something that is boolean expression +abstract class ABoolExpr super AExpr end + +# A `or` expression class AOrExpr super ABoolExpr - readable var _n_expr: AExpr - readable var _n_expr2: AExpr + readable writable var _n_expr: AExpr + readable writable var _n_expr2: AExpr + init do end end + +# A `and` expression class AAndExpr super ABoolExpr - readable var _n_expr: AExpr - readable var _n_expr2: AExpr + readable writable var _n_expr: AExpr + readable writable var _n_expr2: AExpr + init do end end + +# A `or else` expression class AOrElseExpr super ABoolExpr - readable var _n_expr: AExpr - readable var _n_expr2: AExpr + readable writable var _n_expr: AExpr + readable writable var _n_expr2: AExpr + init do end end + +# A `implies` expression +class AImpliesExpr + super ABoolExpr + readable writable var _n_expr: AExpr + readable writable var _n_expr2: AExpr + init do end +end + +# A `not` expression class ANotExpr super ABoolExpr - readable var _n_kwnot: TKwnot - readable var _n_expr: AExpr + readable writable var _n_kwnot: TKwnot + readable writable var _n_expr: AExpr + init do end end + +# A `==` expression class AEqExpr super ABinopExpr end -class AEeExpr - super ABoolExpr - readable var _n_expr: AExpr - readable var _n_expr2: AExpr -end + +# A `!=` expression class ANeExpr super ABinopExpr end + +# A `<` expression class ALtExpr super ABinopExpr end + +# A `<=` expression class ALeExpr super ABinopExpr end + +# A `<<` expression class ALlExpr super ABinopExpr end + +# A `>` expression class AGtExpr super ABinopExpr end + +# A `>=` expression class AGeExpr super ABinopExpr end + +# A `>>` expression class AGgExpr super ABinopExpr end + +# A type-ckeck expression. eg `x isa T` class AIsaExpr super ABoolExpr - readable var _n_expr: AExpr - readable var _n_type: AType + readable writable var _n_expr: AExpr + readable writable var _n_type: AType + init do end end + +# A `+` expression class APlusExpr super ABinopExpr end + +# A `-` expression class AMinusExpr super ABinopExpr end + +# A `<=>` expression class AStarshipExpr super ABinopExpr end + +# A `*` expression class AStarExpr super ABinopExpr end + +# A `/` expression class ASlashExpr super ABinopExpr end + +# A `%` expression class APercentExpr super ABinopExpr end + +# A unary minus expression. eg `-x` class AUminusExpr super ASendExpr - readable var _n_minus: TMinus + readable writable var _n_minus: TMinus + init do end end + +# An explicit instantiation. eg `new T` class ANewExpr super AExpr - readable var _n_kwnew: TKwnew - readable var _n_type: AType - readable var _n_id: nullable TId = null - readable var _n_args: List[AExpr] = new List[AExpr] + readable writable var _n_kwnew: TKwnew + readable writable var _n_type: AType + + # The name of the named-constructor, if any + readable writable var _n_id: nullable TId = null + readable writable var _n_args: AExprs + init do end end -class AAttrFormExpr + +# Whatever is a old-style attribute access +abstract class AAttrFormExpr super AExpr - readable var _n_expr: AExpr - readable var _n_id: TAttrid + + # The receiver of the attribute + readable writable var _n_expr: AExpr + + # The name of the attribute + readable writable var _n_id: TAttrid + + init do end end + +# The read of an attribute. eg `x._a` class AAttrExpr super AAttrFormExpr end + +# The assignment of an attribute. eg `x._a=y` class AAttrAssignExpr super AAttrFormExpr super AAssignFormExpr end -class ACallFormExpr + +# Whatever looks-like a call with a standard method and any number of arguments. +abstract class ACallFormExpr super ASendExpr - readable var _n_id: TId - readable var _n_args: List[AExpr] = new List[AExpr] + + # The name of the method + readable writable var _n_id: TId + + # The arguments of the call + readable writable var _n_args: AExprs + init do end end + +# A complex setter call (standard or brackets) +abstract class ASendReassignFormExpr + super ASendExpr + super AReassignFormExpr +end + +# A complex attribute assignment. eg `x._a+=y` class AAttrReassignExpr - super AExpr super AAttrFormExpr super AReassignFormExpr end + +# A call with a standard method-name and any number of arguments. eg `x.m(y)`. OR just a simple id +# 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`. +# Semantic analysis have to transform them to instance of `AVarExpr`. class ACallExpr super ACallFormExpr end + +# A setter call with a standard method-name and any number of arguments. eg `x.m(y)=z`. OR just a simple assignment. +# 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`. +# Semantic analysis have to transform them to instance of `AVarAssignExpr`. class ACallAssignExpr super ACallFormExpr super AAssignFormExpr end + +# 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. +# Note: because the parser cannot distinguish a variable write with a compex setter call with an implicit receiver and no arguments, it always returns a `ACallReassignExpr`. +# Semantic analysis have to transform them to instance of `AVarReassignExpr`. class ACallReassignExpr - super AExpr super ACallFormExpr - super AReassignFormExpr + super ASendReassignFormExpr end + +# A call to `super`. OR a call of a super-constructor class ASuperExpr super AExpr - readable var _n_qualified: nullable AQualified = null - readable var _n_kwsuper: TKwsuper - readable var _n_args: List[AExpr] = new List[AExpr] + readable writable var _n_qualified: nullable AQualified = null + readable writable var _n_kwsuper: TKwsuper + readable writable var _n_args: AExprs + init do end end + +# A call to the `init` constructor. +# Note: because `init` is a keyword and not a `TId`, the explicit call to init cannot be a ACallFormExpr. class AInitExpr super ASendExpr - readable var _n_kwinit: TKwinit - readable var _n_args: List[AExpr] = new List[AExpr] + readable writable var _n_kwinit: TKwinit + readable writable var _n_args: AExprs + init do end end -class ABraFormExpr + +# Whatever looks-like a call of the brackets `[]` operator. +abstract class ABraFormExpr super ASendExpr - readable var _n_args: List[AExpr] = new List[AExpr] + readable writable var _n_args: AExprs + init do end end + +# A call of the brackets operator. eg `x[y,z]` class ABraExpr super ABraFormExpr end + +# A setter call of the bracket operator. eg `x[y,z]=t` class ABraAssignExpr super ABraFormExpr super AAssignFormExpr end -class AVarFormExpr + +# Whatever is an access to a local variable +abstract class AVarFormExpr super AExpr - readable var _n_id: TId + readable writable var _n_id: TId + init do end end + +# A complex setter call of the bracket operator. eg `x[y,z]+=t` class ABraReassignExpr super ABraFormExpr - super AReassignFormExpr -end -class AClosureCallExpr - super AExpr - readable var _n_id: TId - readable var _n_args: List[AExpr] = new List[AExpr] - readable var _n_closure_defs: List[AClosureDef] = new List[AClosureDef] + super ASendReassignFormExpr end + +# A local variable read access. +# The parser cannot instantiate them, see `ACallExpr`. class AVarExpr super AVarFormExpr end + +# A local variable simple assigment access +# The parser cannot instantiate them, see `ACallAssignExpr`. class AVarAssignExpr super AVarFormExpr super AAssignFormExpr end + +# A local variable complex assignment access +# The parser cannot instantiate them, see `ACallReassignExpr`. class AVarReassignExpr super AVarFormExpr super AReassignFormExpr end -class ARangeExpr + +# A literal range, open or closed +abstract class ARangeExpr super AExpr - readable var _n_expr: AExpr - readable var _n_expr2: AExpr + readable writable var _n_expr: AExpr + readable writable var _n_expr2: AExpr + init do end end + +# A closed literal range. eg `[x..y]` class ACrangeExpr super ARangeExpr + readable writable var _n_obra: TObra + readable writable var _n_cbra: TCbra + init do end end + +# An open literal range. eg `[x..y[` class AOrangeExpr super ARangeExpr + readable writable var _n_obra: TObra + readable writable var _n_cbra: TObra + init do end end + +# A literal array. eg. `[x,y,z]` class AArrayExpr super AExpr - readable var _n_exprs: List[AExpr] = new List[AExpr] + readable writable var _n_exprs: AExprs + init do end end + +# A read of `self` class ASelfExpr super AExpr - readable var _n_kwself: nullable TKwself + readable writable var _n_kwself: nullable TKwself + init do end end + +# When there is no explicit receiver, `self` is implicit class AImplicitSelfExpr super ASelfExpr end + +# A `true` boolean literal constant class ATrueExpr super ABoolExpr - readable var _n_kwtrue: TKwtrue + readable writable var _n_kwtrue: TKwtrue + init do end end +# A `false` boolean literal constant class AFalseExpr super ABoolExpr - readable var _n_kwfalse: TKwfalse + readable writable var _n_kwfalse: TKwfalse + init do end end +# A `null` literal constant class ANullExpr super AExpr - readable var _n_kwnull: TKwnull + readable writable var _n_kwnull: TKwnull + init do end end +# An integer literal class AIntExpr super AExpr - readable var _n_number: TNumber end +# An integer literal in decimal format +class ADecIntExpr + super AIntExpr + readable writable var _n_number: TNumber + init do end +end +# An integer literal in hexadecimal format +class AHexIntExpr + super AIntExpr + readable writable var _n_hex_number: THexNumber + init do end +end +# A float literal class AFloatExpr super AExpr - readable var _n_float: TFloat + readable writable var _n_float: TFloat + init do end end +# A character literal class ACharExpr super AExpr - readable var _n_char: TChar + readable writable var _n_char: TChar + init do end end -class AStringFormExpr +# A string literal +abstract class AStringFormExpr super AExpr + readable writable var _n_string: Token + init do end end + +# A simple string. eg. `"abc"` class AStringExpr super AStringFormExpr - readable var _n_string: TString end + +# The start of a superstring. eg `"abc{` class AStartStringExpr super AStringFormExpr - readable var _n_string: TStartString end + +# The middle of a superstring. eg `}abc{` class AMidStringExpr super AStringFormExpr - readable var _n_string: TMidString end + +# The end of a superstrng. eg `}abc"` class AEndStringExpr super AStringFormExpr - readable var _n_string: TEndString end + +# A superstring literal. eg `"a{x}b{y}c"` +# Each part is modelized a sequence of expression. eg. `["a{, x, }b{, y, }c"]` class ASuperstringExpr super AExpr - readable var _n_exprs: List[AExpr] = new List[AExpr] + readable var _n_exprs: ANodes[AExpr] = new ANodes[AExpr](self) + init do end end + +# A simple parenthesis. eg `(x)` class AParExpr super AProxyExpr + readable writable var _n_opar: TOpar + readable writable var _n_cpar: TCpar + init do end end -class AProxyExpr + +# Whatevej just contains (and mimic) an other expression +abstract class AProxyExpr super AExpr - readable var _n_expr: AExpr + readable writable var _n_expr: AExpr + init do end end + +# A type cast. eg `x.as(T)` class AAsCastExpr super AExpr - readable var _n_expr: AExpr - readable var _n_kwas: TKwas - readable var _n_type: AType + readable writable var _n_expr: AExpr + readable writable var _n_kwas: TKwas + readable writable var _n_opar: nullable TOpar = null + readable writable var _n_type: AType + readable writable var _n_cpar: nullable TCpar = null + init do end end + +# A as-not-null cast. eg `x.as(not null)` class AAsNotnullExpr super AExpr - readable var _n_expr: AExpr - readable var _n_kwas: TKwas - readable var _n_kwnot: TKwnot - readable var _n_kwnull: TKwnull + readable writable var _n_expr: AExpr + readable writable var _n_kwas: TKwas + readable writable var _n_opar: nullable TOpar = null + readable writable var _n_kwnot: TKwnot + readable writable var _n_kwnull: TKwnull + readable writable var _n_cpar: nullable TCpar = null + init do end end + +# A is-set check of old-style attributes. eg `isset x._a` class AIssetAttrExpr super AAttrFormExpr - readable var _n_kwisset: TKwisset + readable writable var _n_kwisset: TKwisset + init do end +end + +# A list of expression separated with commas (arguments for instance) +abstract class AExprs + super Prod + readable var _n_exprs: ANodes[AExpr] = new ANodes[AExpr](self) + init do end +end + +class ADebugTypeExpr + super AExpr + readable writable var _n_kwdebug: TKwdebug + readable writable var _n_kwtype: TKwtype + readable writable var _n_expr: AExpr + readable writable var _n_type: AType + init do end +end + +# A simple list of expressions +class AListExprs + super AExprs +end + +# A list of expressions enclosed in parentheses +class AParExprs + super AExprs + readable writable var _n_opar: TOpar + readable writable var _n_cpar: TCpar + init do end +end + +# A list of expressions enclosed in brackets +class ABraExprs + super AExprs + readable writable var _n_obra: TObra + readable writable var _n_cbra: TCbra + init do end +end + +# A complex assignment operator. eg `+=` +abstract class AAssignOp + super Prod end -class AAssignOp super Prod end class APlusAssignOp super AAssignOp - readable var _n_pluseq: TPluseq + readable writable var _n_pluseq: TPluseq + init do end end class AMinusAssignOp super AAssignOp - readable var _n_minuseq: TMinuseq + readable writable var _n_minuseq: TMinuseq + init do end end -class AClosureDef - super ALabelable - readable var _n_bang: TBang - readable var _n_id: AClosureId - readable var _n_ids: List[TId] = new List[TId] - readable var _n_kwdo: nullable TKwdo = null - readable var _n_expr: nullable AExpr = null -end -class AClosureId + +class AModuleName super Prod + readable writable var _n_quad: nullable TQuad = null + readable var _n_path: ANodes[TId] = new ANodes[TId](self) + readable writable var _n_id: TId + init do end end -class ASimpleClosureId - super AClosureId - readable var _n_id: TId +class AInLanguage + super Prod + readable writable var _n_kwin: TKwin + readable writable var _n_string: TString + init do end end -class ABreakClosureId - super AClosureId - readable var _n_kwbreak: TKwbreak +class AExternCodeBlock + super Prod + readable writable var _n_in_language: nullable AInLanguage = null + readable writable var _n_extern_code_segment: TExternCodeSegment + init do end end class AQualified super Prod - readable var _n_id: List[TId] = new List[TId] - readable var _n_classid: nullable TClassid = null + readable writable var _n_quad: nullable TQuad = null + readable var _n_id: ANodes[TId] = new ANodes[TId](self) + readable writable var _n_classid: nullable TClassid = null + init do end end + +# A documentation of a definition +# It contains the block of comments just above the declaration class ADoc super Prod - readable var _n_comment: List[TComment] = new List[TComment] + readable var _n_comment: ANodes[TComment] = new ANodes[TComment](self) + init do end +end + +class AAnnotations + super Prod + readable writable var _n_at: nullable TAt = null + readable writable var _n_opar: nullable TOpar = null + readable var _n_items: ANodes[AAnnotation] = new ANodes[AAnnotation](self) + readable writable var _n_cpar: nullable TCpar = null + init do end +end +class AAnnotation + super Prod + readable writable var _n_atid: AAtid + readable writable var _n_opar: nullable TOpar = null + readable var _n_args: ANodes[AAtArg] = new ANodes[AAtArg](self) + readable writable var _n_cpar: nullable TCpar = null + init do end +end +abstract class AAtArg + super Prod +end +class ATypeAtArg + super AAtArg + readable writable var _n_type: AType + init do end +end +class AExprAtArg + super AAtArg + readable writable var _n_expr: AExpr + init do end +end +class AAtAtArg + super AAtArg +end +abstract class AAtid + super Prod + readable writable var _n_id: Token + init do end +end +class AIdAtid + super AAtid +end +class AKwexternAtid + super AAtid +end +class AKwinternAtid + super AAtid +end +class AKwreadableAtid + super AAtid +end +class AKwwritableAtid + super AAtid +end +class AKwimportAtid + super AAtid end +# The root of the AST class Start super Prod - readable var _n_base: nullable AModule - readable var _n_eof: EOF + readable writable var _n_base: nullable AModule + readable writable var _n_eof: EOF + init(n_base: nullable AModule, n_eof: EOF) + do + self._n_base = n_base + self._n_eof = n_eof + end end