X-Git-Url: http://nitlanguage.org diff --git a/src/parser/parser_nodes.nit b/src/parser/parser_nodes.nit index 5e905e8..21c6dcd 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,36 +14,298 @@ # 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 - init do end + + # 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 @@ -54,9 +313,14 @@ class TEol 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 + +# A token associated with a keyword abstract class TokenKeyword super Token redef fun to_s @@ -64,6 +328,9 @@ abstract class TokenKeyword return "keyword '{text}'" end end +class TKwpackage + super TokenKeyword +end class TKwmodule super TokenKeyword end @@ -82,9 +349,6 @@ end class TKwenum super TokenKeyword end -class TKwspecial - super TokenKeyword -end class TKwend super TokenKeyword end @@ -121,6 +385,9 @@ end class TKwextern super TokenKeyword end +class TKwpublic + super TokenKeyword +end class TKwprotected super TokenKeyword end @@ -157,6 +424,9 @@ end class TKwor super TokenKeyword end +class TKwimplies + super TokenKeyword +end class TKwnot super TokenKeyword end @@ -211,6 +481,9 @@ end class TKwlabel super TokenKeyword end +class TKwdebug + super Token +end class TOpar super Token end @@ -235,6 +508,8 @@ end class TAssign super Token end + +# A token associated with an operator (and other lookalike symbols) abstract class TokenOperator super Token redef fun to_s @@ -249,13 +524,13 @@ class TMinuseq super TokenOperator end class TDotdotdot - super TokenOperator + super Token end class TDotdot - super TokenOperator + super Token end class TDot - super TokenOperator + super Token end class TPlus super TokenOperator @@ -302,6 +577,11 @@ 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 @@ -309,6 +589,8 @@ class TClassid 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 @@ -316,6 +598,8 @@ class TId do return "identifier '{text}'" end end + +# An attribute identifier. They start with an underscore. class TAttrid super Token redef fun to_s @@ -323,6 +607,8 @@ class TAttrid do return "attribute '{text}'" end end + +# A token of a literal value (string, integer, etc). abstract class TokenLiteral super Token redef fun to_s @@ -333,6 +619,9 @@ end class TNumber super TokenLiteral end +class THexNumber + super TokenLiteral +end class TFloat super TokenLiteral end @@ -349,8 +638,10 @@ class TMidString super TokenLiteral end class TEndString - super Token + super TokenLiteral end + +# A malformed string class TBadString super Token redef fun to_s @@ -358,6 +649,8 @@ class TBadString do return "malformed string {text}" end end + +# A malformed char class TBadChar super Token redef fun to_s @@ -365,827 +658,1315 @@ class TBadChar 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_name: AModuleName + readable writable var _n_doc: nullable ADoc = null + readable writable var _n_kwmodule: TKwmodule + readable writable var _n_name: AModuleName + init do end +end + +# A import clause of a module +abstract class AImport + super Prod end -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_name: AModuleName + 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 -abstract 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 -abstract class AClassdef super Prod - readable var _n_propdefs: List[APropdef] = new List[APropdef] + +# 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_kwend: TKwend - 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 end + +# The implicit class definition of the top-level methods class AMainClassdef super AClassdef end -abstract 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 var _n_kwextern: TKwextern + 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 -abstract 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 + 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 + +# A method of a constructor marked extern abstract class AExternPropdef super AMethPropdef - readable var _n_extern: nullable TString = null - readable var _n_extern_calls: nullable AExternCalls = null end + +# A method marked extern class AExternMethPropdef - super AMethPropdef super AExternPropdef - readable var _n_kwmeth: TKwmeth 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 super AInitPropdef - readable var _n_kwinit: TKwinit - redef fun hot_location do return n_kwinit.location end + +class AInternNewPropdef + super AInternMethPropdef + super AInitPropdef +end + +# A constructor marked extern (defined with the `new` keyword) class AExternInitPropdef super AExternPropdef super AInitPropdef - readable var _n_kwnew: TKwnew end + +# The implicit main method class AMainMethPropdef super AConcreteMethPropdef end + +# Declaration of callbacks for extern methods class AExternCalls super Prod - readable var _n_kwimport: TKwimport - readable var _n_extern_calls: List[AExternCall] = new List[AExternCall] + 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 -special AExternCall + super AExternCall end class ALocalPropExternCall -special APropExternCall - readable var _n_methid: AMethid + super APropExternCall + readable writable var _n_methid: AMethid + init do end end class AFullPropExternCall -special APropExternCall - readable var _n_classid: TClassid - readable var _n_quad: nullable TQuad = null - readable var _n_methid: AMethid + 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 -special APropExternCall - readable var _n_classid: TClassid + super APropExternCall + readable writable var _n_type: AType + init do end end class ASuperExternCall -special AExternCall - readable var _n_kwsuper: TKwsuper + super AExternCall + readable writable var _n_kwsuper: TKwsuper + init do end end abstract class ACastExternCall -special AExternCall + super AExternCall end class ACastAsExternCall -special ACastExternCall - readable var _n_from_type: AType - readable var _n_kwas: TKwas - readable var _n_to_type: AType + 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 -special ACastExternCall - readable var _n_type: AType - readable var _n_kwas: TKwas - readable var _n_kwnullable: TKwnullable + 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 -special ACastExternCall - readable var _n_type: AType - readable var _n_kwas: TKwas - readable var _n_kwnot: TKwnot - readable var _n_kwnullable: TKwnullable + 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 -abstract 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 -abstract 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_opar: nullable TOpar = null - readable var _n_params: List[AParam] = new List[AParam] - readable var _n_cpar: nullable TCpar = null - 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 + +# 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 -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_kwend: nullable TKwend = null + 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 + +# 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 + +# 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 + +# 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 + +# 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 + +# 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 + +# 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: AExprs + 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 + +# 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 + +# 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: AExprs + + # 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 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: AExprs + 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: AExprs + readable writable var _n_kwinit: TKwinit + readable writable var _n_args: AExprs + init do end end + +# Whatever looks-like a call of the brackets `[]` operator. abstract class ABraFormExpr super ASendExpr - readable var _n_args: AExprs + 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 + +# 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 ASendReassignFormExpr end -class AClosureCallExpr - super AExpr - readable var _n_id: TId - readable var _n_args: AExprs - readable var _n_closure_defs: List[AClosureDef] = new List[AClosureDef] -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 + +# 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 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 + +# An open literal range. eg `[x..y[` class AOrangeExpr super ARangeExpr - readable var _n_obra: TObra - readable var _n_cbra: TObra + 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: AExprs + 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 +# 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 var _n_opar: TOpar - readable var _n_cpar: TCpar + readable writable var _n_opar: TOpar + readable writable var _n_cpar: TCpar + init do end end + +# 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_opar: TOpar - readable var _n_type: AType - readable var _n_cpar: TCpar + 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_opar: TOpar - readable var _n_kwnot: TKwnot - readable var _n_kwnull: TKwnull - readable var _n_cpar: TCpar + 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: List[AExpr] = new List[AExpr] + 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 var _n_opar: TOpar - readable var _n_cpar: TCpar + 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 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 + +# A complex assignment operator. eg `+=` +abstract class AAssignOp + super Prod end -abstract 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 - redef fun hot_location do return n_id.location -end -abstract 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 -end -class ABreakClosureId - super AClosureId - readable var _n_kwbreak: TKwbreak +class AInLanguage + super Prod + readable writable var _n_kwin: TKwin + readable writable var _n_string: TString + init do end end -class AModuleName -special Prod - readable var _n_quad: nullable TQuad = null - readable var _n_path: List[TId] = new List[TId] - readable var _n_id: TId +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_quad: nullable TQuad = null - 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 - init(n_base: nullable AModule, n_eof: EOF) - do - self._n_base = n_base - self._n_eof = n_eof - end + 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