X-Git-Url: http://nitlanguage.org diff --git a/src/parser/parser_prod.nit b/src/parser/parser_prod.nit index 0c9f9d7..740278e 100644 --- a/src/parser/parser_prod.nit +++ b/src/parser/parser_prod.nit @@ -387,7 +387,9 @@ redef class AStdClassdef n_visibility: nullable AVisibility, n_classkind: nullable AClasskind, n_id: nullable TClassid, + n_obra: nullable TObra, n_formaldefs: Collection[Object], # Should be Collection[AFormaldef] + n_cbra: nullable TCbra, n_extern_code_block: nullable AExternCodeBlock, n_propdefs: Collection[Object], # Should be Collection[APropdef] n_kwend: nullable TKwend @@ -403,7 +405,11 @@ redef class AStdClassdef n_classkind.parent = self _n_id = n_id if n_id != null then n_id.parent = self + _n_obra = n_obra + if n_obra != null then n_obra.parent = self self.n_formaldefs.unsafe_add_all(n_formaldefs) + _n_cbra = n_cbra + if n_cbra != null then n_cbra.parent = self _n_extern_code_block = n_extern_code_block if n_extern_code_block != null then n_extern_code_block.parent = self self.n_propdefs.unsafe_add_all(n_propdefs) @@ -433,7 +439,15 @@ redef class AStdClassdef n_id = new_child.as(nullable TClassid) return end + if _n_obra == old_child then + n_obra = new_child.as(nullable TObra) + return + end if n_formaldefs.replace_child(old_child, new_child) then return + if _n_cbra == old_child then + n_cbra = new_child.as(nullable TCbra) + return + end if _n_extern_code_block == old_child then n_extern_code_block = new_child.as(nullable AExternCodeBlock) return @@ -470,6 +484,16 @@ redef class AStdClassdef _n_id = node if node != null then node.parent = self end + redef fun n_obra=(node) + do + _n_obra = node + if node != null then node.parent = self + end + redef fun n_cbra=(node) + do + _n_cbra = node + if node != null then node.parent = self + end redef fun n_extern_code_block=(node) do _n_extern_code_block = node @@ -489,7 +513,9 @@ redef class AStdClassdef v.enter_visit(_n_visibility) v.enter_visit(_n_classkind) v.enter_visit(_n_id) + v.enter_visit(_n_obra) n_formaldefs.visit_all(v) + v.enter_visit(_n_cbra) v.enter_visit(_n_extern_code_block) n_propdefs.visit_all(v) v.enter_visit(_n_kwend) @@ -769,9 +795,12 @@ redef class AAttrPropdef n_kwvar: nullable TKwvar, n_id2: nullable TId, n_type: nullable AType, + n_assign: nullable TAssign, n_expr: nullable AExpr, n_annotations: nullable AAnnotations, - n_block: nullable AExpr + n_kwdo: nullable TKwdo, + n_block: nullable AExpr, + n_kwend: nullable TKwend ) do _n_doc = n_doc @@ -786,12 +815,18 @@ redef class AAttrPropdef n_id2.parent = self _n_type = n_type if n_type != null then n_type.parent = self + _n_assign = n_assign + if n_assign != null then n_assign.parent = self _n_expr = n_expr if n_expr != null then n_expr.parent = self _n_annotations = n_annotations if n_annotations != null then n_annotations.parent = self + _n_kwdo = n_kwdo + if n_kwdo != null then n_kwdo.parent = self _n_block = n_block if n_block != null then n_block.parent = self + _n_kwend = n_kwend + if n_kwend != null then n_kwend.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) @@ -820,6 +855,10 @@ redef class AAttrPropdef n_type = new_child.as(nullable AType) return end + if _n_assign == old_child then + n_assign = new_child.as(nullable TAssign) + return + end if _n_expr == old_child then n_expr = new_child.as(nullable AExpr) return @@ -828,10 +867,18 @@ redef class AAttrPropdef n_annotations = new_child.as(nullable AAnnotations) return end + if _n_kwdo == old_child then + n_kwdo = new_child.as(nullable TKwdo) + return + end if _n_block == old_child then n_block = new_child.as(nullable AExpr) return end + if _n_kwend == old_child then + n_kwend = new_child.as(nullable TKwend) + return + end end redef fun n_doc=(node) @@ -864,6 +911,11 @@ redef class AAttrPropdef _n_type = node if node != null then node.parent = self end + redef fun n_assign=(node) + do + _n_assign = node + if node != null then node.parent = self + end redef fun n_expr=(node) do _n_expr = node @@ -874,11 +926,21 @@ redef class AAttrPropdef _n_annotations = node if node != null then node.parent = self end + redef fun n_kwdo=(node) + do + _n_kwdo = node + if node != null then node.parent = self + end redef fun n_block=(node) do _n_block = node if node != null then node.parent = self end + redef fun n_kwend=(node) + do + _n_kwend = node + if node != null then node.parent = self + end redef fun visit_all(v: Visitor) @@ -889,9 +951,12 @@ redef class AAttrPropdef v.enter_visit(_n_kwvar) v.enter_visit(_n_id2) v.enter_visit(_n_type) + v.enter_visit(_n_assign) v.enter_visit(_n_expr) v.enter_visit(_n_annotations) + v.enter_visit(_n_kwdo) v.enter_visit(_n_block) + v.enter_visit(_n_kwend) end end redef class AMainMethPropdef @@ -1056,7 +1121,9 @@ redef class AMethPropdef n_annotations: nullable AAnnotations, n_extern_calls: nullable AExternCalls, n_extern_code_block: nullable AExternCodeBlock, - n_block: nullable AExpr + n_kwdo: nullable TKwdo, + n_block: nullable AExpr, + n_kwend: nullable TKwend ) do _n_doc = n_doc @@ -1081,8 +1148,12 @@ redef class AMethPropdef if n_extern_calls != null then n_extern_calls.parent = self _n_extern_code_block = n_extern_code_block if n_extern_code_block != null then n_extern_code_block.parent = self + _n_kwdo = n_kwdo + if n_kwdo != null then n_kwdo.parent = self _n_block = n_block if n_block != null then n_block.parent = self + _n_kwend = n_kwend + if n_kwend != null then n_kwend.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) @@ -1131,10 +1202,18 @@ redef class AMethPropdef n_extern_code_block = new_child.as(nullable AExternCodeBlock) return end + if _n_kwdo == old_child then + n_kwdo = new_child.as(nullable TKwdo) + return + end if _n_block == old_child then n_block = new_child.as(nullable AExpr) return end + if _n_kwend == old_child then + n_kwend = new_child.as(nullable TKwend) + return + end end redef fun n_doc=(node) @@ -1192,11 +1271,21 @@ redef class AMethPropdef _n_extern_code_block = node if node != null then node.parent = self end + redef fun n_kwdo=(node) + do + _n_kwdo = node + if node != null then node.parent = self + end redef fun n_block=(node) do _n_block = node if node != null then node.parent = self end + redef fun n_kwend=(node) + do + _n_kwend = node + if node != null then node.parent = self + end redef fun visit_all(v: Visitor) @@ -1212,7 +1301,9 @@ redef class AMethPropdef v.enter_visit(_n_annotations) v.enter_visit(_n_extern_calls) v.enter_visit(_n_extern_code_block) + v.enter_visit(_n_kwdo) v.enter_visit(_n_block) + v.enter_visit(_n_kwend) end end redef class ASuperPropdef @@ -1451,479 +1542,595 @@ redef class AIdMethid end redef class APlusMethid init init_aplusmethid ( - n_plus: nullable TPlus + n_op: nullable TPlus ) do - _n_plus = n_plus.as(not null) - n_plus.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_plus == old_child then - n_plus = new_child.as(TPlus) + if _n_op == old_child then + n_op = new_child.as(TPlus) return end end - redef fun n_plus=(node) + redef fun n_op=(node) do - _n_plus = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_plus) + v.enter_visit(_n_op) end end redef class AMinusMethid init init_aminusmethid ( - n_minus: nullable TMinus + n_op: nullable TMinus ) do - _n_minus = n_minus.as(not null) - n_minus.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_minus == old_child then - n_minus = new_child.as(TMinus) + if _n_op == old_child then + n_op = new_child.as(TMinus) return end end - redef fun n_minus=(node) + redef fun n_op=(node) do - _n_minus = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_minus) + v.enter_visit(_n_op) end end redef class AStarMethid init init_astarmethid ( - n_star: nullable TStar + n_op: nullable TStar ) do - _n_star = n_star.as(not null) - n_star.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_star == old_child then - n_star = new_child.as(TStar) + if _n_op == old_child then + n_op = new_child.as(TStar) return end end - redef fun n_star=(node) + redef fun n_op=(node) do - _n_star = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_star) + v.enter_visit(_n_op) end end redef class AStarstarMethid init init_astarstarmethid ( - n_starstar: nullable TStarstar + n_op: nullable TStarstar ) do - _n_starstar = n_starstar.as(not null) - n_starstar.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_starstar == old_child then - n_starstar = new_child.as(TStarstar) + if _n_op == old_child then + n_op = new_child.as(TStarstar) return end end - redef fun n_starstar=(node) + redef fun n_op=(node) do - _n_starstar = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_starstar) + v.enter_visit(_n_op) end end redef class ASlashMethid init init_aslashmethid ( - n_slash: nullable TSlash + n_op: nullable TSlash ) do - _n_slash = n_slash.as(not null) - n_slash.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_slash == old_child then - n_slash = new_child.as(TSlash) + if _n_op == old_child then + n_op = new_child.as(TSlash) return end end - redef fun n_slash=(node) + redef fun n_op=(node) do - _n_slash = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_slash) + v.enter_visit(_n_op) end end redef class APercentMethid init init_apercentmethid ( - n_percent: nullable TPercent + n_op: nullable TPercent ) do - _n_percent = n_percent.as(not null) - n_percent.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_percent == old_child then - n_percent = new_child.as(TPercent) + if _n_op == old_child then + n_op = new_child.as(TPercent) return end end - redef fun n_percent=(node) + redef fun n_op=(node) do - _n_percent = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_percent) + v.enter_visit(_n_op) end end redef class AEqMethid init init_aeqmethid ( - n_eq: nullable TEq + n_op: nullable TEq ) do - _n_eq = n_eq.as(not null) - n_eq.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_eq == old_child then - n_eq = new_child.as(TEq) + if _n_op == old_child then + n_op = new_child.as(TEq) return end end - redef fun n_eq=(node) + redef fun n_op=(node) do - _n_eq = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_eq) + v.enter_visit(_n_op) end end redef class ANeMethid init init_anemethid ( - n_ne: nullable TNe + n_op: nullable TNe ) do - _n_ne = n_ne.as(not null) - n_ne.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_ne == old_child then - n_ne = new_child.as(TNe) + if _n_op == old_child then + n_op = new_child.as(TNe) return end end - redef fun n_ne=(node) + redef fun n_op=(node) do - _n_ne = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_ne) + v.enter_visit(_n_op) end end redef class ALeMethid init init_alemethid ( - n_le: nullable TLe + n_op: nullable TLe ) do - _n_le = n_le.as(not null) - n_le.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_le == old_child then - n_le = new_child.as(TLe) + if _n_op == old_child then + n_op = new_child.as(TLe) return end end - redef fun n_le=(node) + redef fun n_op=(node) do - _n_le = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_le) + v.enter_visit(_n_op) end end redef class AGeMethid init init_agemethid ( - n_ge: nullable TGe + n_op: nullable TGe ) do - _n_ge = n_ge.as(not null) - n_ge.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_ge == old_child then - n_ge = new_child.as(TGe) + if _n_op == old_child then + n_op = new_child.as(TGe) return end end - redef fun n_ge=(node) + redef fun n_op=(node) do - _n_ge = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_ge) + v.enter_visit(_n_op) end end redef class ALtMethid init init_altmethid ( - n_lt: nullable TLt + n_op: nullable TLt ) do - _n_lt = n_lt.as(not null) - n_lt.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_lt == old_child then - n_lt = new_child.as(TLt) + if _n_op == old_child then + n_op = new_child.as(TLt) return end end - redef fun n_lt=(node) + redef fun n_op=(node) do - _n_lt = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_lt) + v.enter_visit(_n_op) end end redef class AGtMethid init init_agtmethid ( - n_gt: nullable TGt + n_op: nullable TGt ) do - _n_gt = n_gt.as(not null) - n_gt.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_gt == old_child then - n_gt = new_child.as(TGt) + if _n_op == old_child then + n_op = new_child.as(TGt) return end end - redef fun n_gt=(node) + redef fun n_op=(node) do - _n_gt = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_gt) + v.enter_visit(_n_op) end end redef class ALlMethid init init_allmethid ( - n_ll: nullable TLl + n_op: nullable TLl ) do - _n_ll = n_ll.as(not null) - n_ll.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_ll == old_child then - n_ll = new_child.as(TLl) + if _n_op == old_child then + n_op = new_child.as(TLl) return end end - redef fun n_ll=(node) + redef fun n_op=(node) do - _n_ll = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_ll) + v.enter_visit(_n_op) end end redef class AGgMethid init init_aggmethid ( - n_gg: nullable TGg + n_op: nullable TGg ) do - _n_gg = n_gg.as(not null) - n_gg.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_gg == old_child then - n_gg = new_child.as(TGg) + if _n_op == old_child then + n_op = new_child.as(TGg) return end end - redef fun n_gg=(node) + redef fun n_op=(node) do - _n_gg = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_gg) + v.enter_visit(_n_op) end end -redef class ABraMethid - init init_abramethid ( - n_obra: nullable TObra, - n_cbra: nullable TCbra +redef class AStarshipMethid + init init_astarshipmethid ( + n_op: nullable TStarship ) do - _n_obra = n_obra.as(not null) - n_obra.parent = self - _n_cbra = n_cbra.as(not null) - n_cbra.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_obra == old_child then - n_obra = new_child.as(TObra) + if _n_op == old_child then + n_op = new_child.as(TStarship) return end - if _n_cbra == old_child then - n_cbra = new_child.as(TCbra) + end + + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_op) + end +end +redef class APipeMethid + init init_apipemethid ( + n_op: nullable TPipe + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TPipe) return end end - redef fun n_obra=(node) + redef fun n_op=(node) do - _n_obra = node + _n_op = node node.parent = self end - redef fun n_cbra=(node) + + + redef fun visit_all(v: Visitor) do - _n_cbra = node + v.enter_visit(_n_op) + end +end +redef class ACaretMethid + init init_acaretmethid ( + n_op: nullable TCaret + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TCaret) + return + end + end + + redef fun n_op=(node) + do + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_obra) - v.enter_visit(_n_cbra) + v.enter_visit(_n_op) end end -redef class AStarshipMethid - init init_astarshipmethid ( - n_starship: nullable TStarship +redef class AAmpMethid + init init_aampmethid ( + n_op: nullable TAmp + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TAmp) + return + end + end + + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_op) + end +end +redef class ATildeMethid + init init_atildemethid ( + n_op: nullable TTilde + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TTilde) + return + end + end + + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_op) + end +end +redef class ABraMethid + init init_abramethid ( + n_obra: nullable TObra, + n_cbra: nullable TCbra ) do - _n_starship = n_starship.as(not null) - n_starship.parent = self + _n_obra = n_obra.as(not null) + n_obra.parent = self + _n_cbra = n_cbra.as(not null) + n_cbra.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_starship == old_child then - n_starship = new_child.as(TStarship) + if _n_obra == old_child then + n_obra = new_child.as(TObra) + return + end + if _n_cbra == old_child then + n_cbra = new_child.as(TCbra) return end end - redef fun n_starship=(node) + redef fun n_obra=(node) + do + _n_obra = node + node.parent = self + end + redef fun n_cbra=(node) do - _n_starship = node + _n_cbra = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_starship) + v.enter_visit(_n_obra) + v.enter_visit(_n_cbra) end end redef class AAssignMethid @@ -2023,6 +2230,48 @@ redef class ABraassignMethid v.enter_visit(_n_assign) end end +redef class AQid + init init_aqid ( + n_qualified: nullable AQualified, + n_id: nullable TId + ) + do + _n_qualified = n_qualified + if n_qualified != null then n_qualified.parent = self + _n_id = n_id.as(not null) + n_id.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_qualified == old_child then + n_qualified = new_child.as(nullable AQualified) + return + end + if _n_id == old_child then + n_id = new_child.as(TId) + return + end + end + + redef fun n_qualified=(node) + do + _n_qualified = node + if node != null then node.parent = self + end + redef fun n_id=(node) + do + _n_id = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_qualified) + v.enter_visit(_n_id) + end +end redef class ASignature init init_asignature ( n_opar: nullable TOpar, @@ -2154,7 +2403,9 @@ redef class AType init init_atype ( n_kwnullable: nullable TKwnullable, n_id: nullable TClassid, + n_obra: nullable TObra, n_types: Collection[Object], # Should be Collection[AType] + n_cbra: nullable TCbra, n_annotations: nullable AAnnotations ) do @@ -2162,7 +2413,11 @@ redef class AType if n_kwnullable != null then n_kwnullable.parent = self _n_id = n_id.as(not null) n_id.parent = self + _n_obra = n_obra + if n_obra != null then n_obra.parent = self self.n_types.unsafe_add_all(n_types) + _n_cbra = n_cbra + if n_cbra != null then n_cbra.parent = self _n_annotations = n_annotations if n_annotations != null then n_annotations.parent = self end @@ -2177,7 +2432,15 @@ redef class AType n_id = new_child.as(TClassid) return end + if _n_obra == old_child then + n_obra = new_child.as(nullable TObra) + return + end if n_types.replace_child(old_child, new_child) then return + if _n_cbra == old_child then + n_cbra = new_child.as(nullable TCbra) + return + end if _n_annotations == old_child then n_annotations = new_child.as(nullable AAnnotations) return @@ -2194,18 +2457,30 @@ redef class AType _n_id = node node.parent = self end - redef fun n_annotations=(node) + redef fun n_obra=(node) do - _n_annotations = node + _n_obra = node if node != null then node.parent = self end - - - redef fun visit_all(v: Visitor) + redef fun n_cbra=(node) do - v.enter_visit(_n_kwnullable) + _n_cbra = node + if node != null then node.parent = self + end + redef fun n_annotations=(node) + do + _n_annotations = node + if node != null then node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_kwnullable) v.enter_visit(_n_id) + v.enter_visit(_n_obra) n_types.visit_all(v) + v.enter_visit(_n_cbra) v.enter_visit(_n_annotations) end end @@ -2294,8 +2569,8 @@ redef class AVardeclExpr n_annotations: nullable AAnnotations ) do - _n_kwvar = n_kwvar.as(not null) - n_kwvar.parent = self + _n_kwvar = n_kwvar + if n_kwvar != null then n_kwvar.parent = self _n_id = n_id.as(not null) n_id.parent = self _n_type = n_type @@ -2311,7 +2586,7 @@ redef class AVardeclExpr redef fun replace_child(old_child: ANode, new_child: nullable ANode) do if _n_kwvar == old_child then - n_kwvar = new_child.as(TKwvar) + n_kwvar = new_child.as(nullable TKwvar) return end if _n_id == old_child then @@ -2339,7 +2614,7 @@ redef class AVardeclExpr redef fun n_kwvar=(node) do _n_kwvar = node - node.parent = self + if node != null then node.parent = self end redef fun n_id=(node) do @@ -2592,7 +2867,9 @@ redef class AIfExpr init init_aifexpr ( n_kwif: nullable TKwif, n_expr: nullable AExpr, + n_kwthen: nullable TKwthen, n_then: nullable AExpr, + n_kwelse: nullable TKwelse, n_else: nullable AExpr ) do @@ -2600,8 +2877,12 @@ redef class AIfExpr n_kwif.parent = self _n_expr = n_expr.as(not null) n_expr.parent = self + _n_kwthen = n_kwthen.as(not null) + n_kwthen.parent = self _n_then = n_then if n_then != null then n_then.parent = self + _n_kwelse = n_kwelse + if n_kwelse != null then n_kwelse.parent = self _n_else = n_else if n_else != null then n_else.parent = self end @@ -2616,10 +2897,18 @@ redef class AIfExpr n_expr = new_child.as(AExpr) return end + if _n_kwthen == old_child then + n_kwthen = new_child.as(TKwthen) + return + end if _n_then == old_child then n_then = new_child.as(nullable AExpr) return end + if _n_kwelse == old_child then + n_kwelse = new_child.as(nullable TKwelse) + return + end if _n_else == old_child then n_else = new_child.as(nullable AExpr) return @@ -2636,11 +2925,21 @@ redef class AIfExpr _n_expr = node node.parent = self end + redef fun n_kwthen=(node) + do + _n_kwthen = node + node.parent = self + end redef fun n_then=(node) do _n_then = node if node != null then node.parent = self end + redef fun n_kwelse=(node) + do + _n_kwelse = node + if node != null then node.parent = self + end redef fun n_else=(node) do _n_else = node @@ -2652,7 +2951,9 @@ redef class AIfExpr do v.enter_visit(_n_kwif) v.enter_visit(_n_expr) + v.enter_visit(_n_kwthen) v.enter_visit(_n_then) + v.enter_visit(_n_kwelse) v.enter_visit(_n_else) end end @@ -2889,8 +3190,7 @@ end redef class AForExpr init init_aforexpr ( n_kwfor: nullable TKwfor, - n_ids: Collection[Object], # Should be Collection[TId] - n_expr: nullable AExpr, + n_groups: Collection[Object], # Should be Collection[AForGroup] n_kwdo: nullable TKwdo, n_block: nullable AExpr, n_label: nullable ALabel @@ -2898,9 +3198,7 @@ redef class AForExpr do _n_kwfor = n_kwfor.as(not null) n_kwfor.parent = self - self.n_ids.unsafe_add_all(n_ids) - _n_expr = n_expr.as(not null) - n_expr.parent = self + self.n_groups.unsafe_add_all(n_groups) _n_kwdo = n_kwdo.as(not null) n_kwdo.parent = self _n_block = n_block @@ -2915,7 +3213,79 @@ redef class AForExpr n_kwfor = new_child.as(TKwfor) return end - if n_ids.replace_child(old_child, new_child) then return + if n_groups.replace_child(old_child, new_child) then return + if _n_kwdo == old_child then + n_kwdo = new_child.as(TKwdo) + return + end + if _n_block == old_child then + n_block = new_child.as(nullable AExpr) + return + end + if _n_label == old_child then + n_label = new_child.as(nullable ALabel) + return + end + end + + redef fun n_kwfor=(node) + do + _n_kwfor = node + node.parent = self + end + redef fun n_kwdo=(node) + do + _n_kwdo = node + node.parent = self + end + redef fun n_block=(node) + do + _n_block = node + if node != null then node.parent = self + end + redef fun n_label=(node) + do + _n_label = node + if node != null then node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_kwfor) + n_groups.visit_all(v) + v.enter_visit(_n_kwdo) + v.enter_visit(_n_block) + v.enter_visit(_n_label) + end +end +redef class AWithExpr + init init_awithexpr ( + n_kwwith: nullable TKwwith, + n_expr: nullable AExpr, + n_kwdo: nullable TKwdo, + n_block: nullable AExpr, + n_label: nullable ALabel + ) + do + _n_kwwith = n_kwwith.as(not null) + n_kwwith.parent = self + _n_expr = n_expr.as(not null) + n_expr.parent = self + _n_kwdo = n_kwdo.as(not null) + n_kwdo.parent = self + _n_block = n_block + if n_block != null then n_block.parent = self + _n_label = n_label + if n_label != null then n_label.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_kwwith == old_child then + n_kwwith = new_child.as(TKwwith) + return + end if _n_expr == old_child then n_expr = new_child.as(AExpr) return @@ -2934,9 +3304,9 @@ redef class AForExpr end end - redef fun n_kwfor=(node) + redef fun n_kwwith=(node) do - _n_kwfor = node + _n_kwwith = node node.parent = self end redef fun n_expr=(node) @@ -2963,8 +3333,7 @@ redef class AForExpr redef fun visit_all(v: Visitor) do - v.enter_visit(_n_kwfor) - n_ids.visit_all(v) + v.enter_visit(_n_kwwith) v.enter_visit(_n_expr) v.enter_visit(_n_kwdo) v.enter_visit(_n_block) @@ -2976,6 +3345,7 @@ redef class AAssertExpr n_kwassert: nullable TKwassert, n_id: nullable TId, n_expr: nullable AExpr, + n_kwelse: nullable TKwelse, n_else: nullable AExpr ) do @@ -2985,6 +3355,8 @@ redef class AAssertExpr if n_id != null then n_id.parent = self _n_expr = n_expr.as(not null) n_expr.parent = self + _n_kwelse = n_kwelse + if n_kwelse != null then n_kwelse.parent = self _n_else = n_else if n_else != null then n_else.parent = self end @@ -3003,6 +3375,10 @@ redef class AAssertExpr n_expr = new_child.as(AExpr) return end + if _n_kwelse == old_child then + n_kwelse = new_child.as(nullable TKwelse) + return + end if _n_else == old_child then n_else = new_child.as(nullable AExpr) return @@ -3024,6 +3400,11 @@ redef class AAssertExpr _n_expr = node node.parent = self end + redef fun n_kwelse=(node) + do + _n_kwelse = node + if node != null then node.parent = self + end redef fun n_else=(node) do _n_else = node @@ -3036,6 +3417,7 @@ redef class AAssertExpr v.enter_visit(_n_kwassert) v.enter_visit(_n_id) v.enter_visit(_n_expr) + v.enter_visit(_n_kwelse) v.enter_visit(_n_else) end end @@ -3155,11 +3537,14 @@ end redef class AOrExpr init init_aorexpr ( n_expr: nullable AExpr, + n_op: nullable TKwor, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3170,6 +3555,10 @@ redef class AOrExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TKwor) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3181,6 +3570,11 @@ redef class AOrExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3191,17 +3585,21 @@ redef class AOrExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class AAndExpr init init_aandexpr ( n_expr: nullable AExpr, + n_op: nullable TKwand, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3212,6 +3610,10 @@ redef class AAndExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TKwand) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3223,6 +3625,11 @@ redef class AAndExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3233,17 +3640,24 @@ redef class AAndExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class AOrElseExpr init init_aorelseexpr ( n_expr: nullable AExpr, + n_op: nullable TKwor, + n_kwelse: nullable TKwelse, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self + _n_kwelse = n_kwelse.as(not null) + n_kwelse.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3254,6 +3668,14 @@ redef class AOrElseExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TKwor) + return + end + if _n_kwelse == old_child then + n_kwelse = new_child.as(TKwelse) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3265,6 +3687,16 @@ redef class AOrElseExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + redef fun n_kwelse=(node) + do + _n_kwelse = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3275,17 +3707,22 @@ redef class AOrElseExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) + v.enter_visit(_n_kwelse) v.enter_visit(_n_expr2) end end redef class AImpliesExpr init init_aimpliesexpr ( n_expr: nullable AExpr, + n_op: nullable TKwimplies, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3296,6 +3733,10 @@ redef class AImpliesExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TKwimplies) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3307,6 +3748,11 @@ redef class AImpliesExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3317,6 +3763,7 @@ redef class AImpliesExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end @@ -3365,11 +3812,14 @@ end redef class AEqExpr init init_aeqexpr ( n_expr: nullable AExpr, + n_op: nullable TEq, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3380,6 +3830,10 @@ redef class AEqExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TEq) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3391,6 +3845,11 @@ redef class AEqExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3401,17 +3860,21 @@ redef class AEqExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class ANeExpr init init_aneexpr ( n_expr: nullable AExpr, + n_op: nullable TNe, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3422,6 +3885,10 @@ redef class ANeExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TNe) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3433,6 +3900,11 @@ redef class ANeExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3443,17 +3915,21 @@ redef class ANeExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class ALtExpr init init_altexpr ( n_expr: nullable AExpr, + n_op: nullable TLt, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3464,6 +3940,10 @@ redef class ALtExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TLt) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3475,6 +3955,11 @@ redef class ALtExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3485,17 +3970,21 @@ redef class ALtExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class ALeExpr init init_aleexpr ( n_expr: nullable AExpr, + n_op: nullable TLe, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3506,6 +3995,10 @@ redef class ALeExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TLe) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3517,6 +4010,11 @@ redef class ALeExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3527,17 +4025,21 @@ redef class ALeExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class ALlExpr init init_allexpr ( n_expr: nullable AExpr, + n_op: nullable TLl, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3548,6 +4050,10 @@ redef class ALlExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TLl) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3559,6 +4065,11 @@ redef class ALlExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3569,17 +4080,21 @@ redef class ALlExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class AGtExpr init init_agtexpr ( n_expr: nullable AExpr, + n_op: nullable TGt, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3590,6 +4105,10 @@ redef class AGtExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TGt) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3601,6 +4120,11 @@ redef class AGtExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3611,17 +4135,21 @@ redef class AGtExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class AGeExpr init init_ageexpr ( n_expr: nullable AExpr, + n_op: nullable TGe, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3632,6 +4160,10 @@ redef class AGeExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TGe) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3643,6 +4175,11 @@ redef class AGeExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3653,17 +4190,21 @@ redef class AGeExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class AGgExpr init init_aggexpr ( n_expr: nullable AExpr, + n_op: nullable TGg, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3674,6 +4215,10 @@ redef class AGgExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TGg) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3685,6 +4230,11 @@ redef class AGgExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3695,17 +4245,21 @@ redef class AGgExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class AIsaExpr init init_aisaexpr ( n_expr: nullable AExpr, + n_kwisa: nullable TKwisa, n_type: nullable AType ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_kwisa = n_kwisa.as(not null) + n_kwisa.parent = self _n_type = n_type.as(not null) n_type.parent = self end @@ -3716,6 +4270,10 @@ redef class AIsaExpr n_expr = new_child.as(AExpr) return end + if _n_kwisa == old_child then + n_kwisa = new_child.as(TKwisa) + return + end if _n_type == old_child then n_type = new_child.as(AType) return @@ -3727,6 +4285,11 @@ redef class AIsaExpr _n_expr = node node.parent = self end + redef fun n_kwisa=(node) + do + _n_kwisa = node + node.parent = self + end redef fun n_type=(node) do _n_type = node @@ -3737,17 +4300,21 @@ redef class AIsaExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_kwisa) v.enter_visit(_n_type) end end redef class APlusExpr init init_aplusexpr ( n_expr: nullable AExpr, + n_op: nullable TPlus, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3758,6 +4325,10 @@ redef class APlusExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TPlus) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3769,6 +4340,11 @@ redef class APlusExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3779,17 +4355,21 @@ redef class APlusExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class AMinusExpr init init_aminusexpr ( n_expr: nullable AExpr, + n_op: nullable TMinus, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3800,6 +4380,10 @@ redef class AMinusExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TMinus) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3811,6 +4395,11 @@ redef class AMinusExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3821,17 +4410,21 @@ redef class AMinusExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class AStarshipExpr init init_astarshipexpr ( n_expr: nullable AExpr, + n_op: nullable TStarship, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3842,6 +4435,10 @@ redef class AStarshipExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TStarship) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3853,6 +4450,11 @@ redef class AStarshipExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3863,17 +4465,21 @@ redef class AStarshipExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class AStarExpr init init_astarexpr ( n_expr: nullable AExpr, + n_op: nullable TStar, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3884,6 +4490,10 @@ redef class AStarExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TStar) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3895,6 +4505,11 @@ redef class AStarExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3905,17 +4520,21 @@ redef class AStarExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class AStarstarExpr init init_astarstarexpr ( n_expr: nullable AExpr, + n_op: nullable TStarstar, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3926,6 +4545,10 @@ redef class AStarstarExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TStarstar) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3937,6 +4560,11 @@ redef class AStarstarExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3947,17 +4575,21 @@ redef class AStarstarExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class ASlashExpr init init_aslashexpr ( n_expr: nullable AExpr, + n_op: nullable TSlash, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -3968,6 +4600,10 @@ redef class ASlashExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TSlash) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -3979,6 +4615,11 @@ redef class ASlashExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -3989,17 +4630,21 @@ redef class ASlashExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end redef class APercentExpr init init_apercentexpr ( n_expr: nullable AExpr, + n_op: nullable TPercent, n_expr2: nullable AExpr ) do _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self end @@ -4010,6 +4655,10 @@ redef class APercentExpr n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TPercent) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -4021,6 +4670,11 @@ redef class APercentExpr _n_expr = node node.parent = self end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -4031,36 +4685,286 @@ redef class APercentExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) + v.enter_visit(_n_op) v.enter_visit(_n_expr2) end end -redef class AUminusExpr - init init_auminusexpr ( - n_minus: nullable TMinus, - n_expr: nullable AExpr +redef class APipeExpr + init init_apipeexpr ( + n_expr: nullable AExpr, + n_op: nullable TPipe, + n_expr2: nullable AExpr ) do - _n_minus = n_minus.as(not null) - n_minus.parent = self _n_expr = n_expr.as(not null) n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self + _n_expr2 = n_expr2.as(not null) + n_expr2.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_minus == old_child then - n_minus = new_child.as(TMinus) - return - end if _n_expr == old_child then n_expr = new_child.as(AExpr) return end + if _n_op == old_child then + n_op = new_child.as(TPipe) + return + end + if _n_expr2 == old_child then + n_expr2 = new_child.as(AExpr) + return + end end - redef fun n_minus=(node) + redef fun n_expr=(node) do - _n_minus = node + _n_expr = node + node.parent = self + end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + redef fun n_expr2=(node) + do + _n_expr2 = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_expr) + v.enter_visit(_n_op) + v.enter_visit(_n_expr2) + end +end +redef class ACaretExpr + init init_acaretexpr ( + n_expr: nullable AExpr, + n_op: nullable TCaret, + n_expr2: nullable AExpr + ) + do + _n_expr = n_expr.as(not null) + n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self + _n_expr2 = n_expr2.as(not null) + n_expr2.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_expr == old_child then + n_expr = new_child.as(AExpr) + return + end + if _n_op == old_child then + n_op = new_child.as(TCaret) + return + end + if _n_expr2 == old_child then + n_expr2 = new_child.as(AExpr) + return + end + end + + redef fun n_expr=(node) + do + _n_expr = node + node.parent = self + end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + redef fun n_expr2=(node) + do + _n_expr2 = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_expr) + v.enter_visit(_n_op) + v.enter_visit(_n_expr2) + end +end +redef class AAmpExpr + init init_aampexpr ( + n_expr: nullable AExpr, + n_op: nullable TAmp, + n_expr2: nullable AExpr + ) + do + _n_expr = n_expr.as(not null) + n_expr.parent = self + _n_op = n_op.as(not null) + n_op.parent = self + _n_expr2 = n_expr2.as(not null) + n_expr2.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_expr == old_child then + n_expr = new_child.as(AExpr) + return + end + if _n_op == old_child then + n_op = new_child.as(TAmp) + return + end + if _n_expr2 == old_child then + n_expr2 = new_child.as(AExpr) + return + end + end + + redef fun n_expr=(node) + do + _n_expr = node + node.parent = self + end + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + redef fun n_expr2=(node) + do + _n_expr2 = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_expr) + v.enter_visit(_n_op) + v.enter_visit(_n_expr2) + end +end +redef class AUminusExpr + init init_auminusexpr ( + n_op: nullable TMinus, + n_expr: nullable AExpr + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + _n_expr = n_expr.as(not null) + n_expr.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TMinus) + return + end + if _n_expr == old_child then + n_expr = new_child.as(AExpr) + return + end + end + + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + redef fun n_expr=(node) + do + _n_expr = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_op) + v.enter_visit(_n_expr) + end +end +redef class AUplusExpr + init init_auplusexpr ( + n_op: nullable TPlus, + n_expr: nullable AExpr + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + _n_expr = n_expr.as(not null) + n_expr.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TPlus) + return + end + if _n_expr == old_child then + n_expr = new_child.as(AExpr) + return + end + end + + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + redef fun n_expr=(node) + do + _n_expr = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_op) + v.enter_visit(_n_expr) + end +end +redef class AUtildeExpr + init init_autildeexpr ( + n_op: nullable TTilde, + n_expr: nullable AExpr + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + _n_expr = n_expr.as(not null) + n_expr.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TTilde) + return + end + if _n_expr == old_child then + n_expr = new_child.as(AExpr) + return + end + end + + redef fun n_op=(node) + do + _n_op = node node.parent = self end redef fun n_expr=(node) @@ -4072,7 +4976,7 @@ redef class AUminusExpr redef fun visit_all(v: Visitor) do - v.enter_visit(_n_minus) + v.enter_visit(_n_op) v.enter_visit(_n_expr) end end @@ -4080,7 +4984,7 @@ redef class ANewExpr init init_anewexpr ( n_kwnew: nullable TKwnew, n_type: nullable AType, - n_id: nullable TId, + n_qid: nullable AQid, n_args: nullable AExprs ) do @@ -4088,8 +4992,8 @@ redef class ANewExpr n_kwnew.parent = self _n_type = n_type.as(not null) n_type.parent = self - _n_id = n_id - if n_id != null then n_id.parent = self + _n_qid = n_qid + if n_qid != null then n_qid.parent = self _n_args = n_args.as(not null) n_args.parent = self end @@ -4104,8 +5008,8 @@ redef class ANewExpr n_type = new_child.as(AType) return end - if _n_id == old_child then - n_id = new_child.as(nullable TId) + if _n_qid == old_child then + n_qid = new_child.as(nullable AQid) return end if _n_args == old_child then @@ -4124,9 +5028,9 @@ redef class ANewExpr _n_type = node node.parent = self end - redef fun n_id=(node) + redef fun n_qid=(node) do - _n_id = node + _n_qid = node if node != null then node.parent = self end redef fun n_args=(node) @@ -4140,7 +5044,7 @@ redef class ANewExpr do v.enter_visit(_n_kwnew) v.enter_visit(_n_type) - v.enter_visit(_n_id) + v.enter_visit(_n_qid) v.enter_visit(_n_args) end end @@ -4325,14 +5229,14 @@ end redef class ACallExpr init init_acallexpr ( n_expr: nullable AExpr, - n_id: nullable TId, + n_qid: nullable AQid, n_args: nullable AExprs ) do _n_expr = n_expr.as(not null) n_expr.parent = self - _n_id = n_id.as(not null) - n_id.parent = self + _n_qid = n_qid.as(not null) + n_qid.parent = self _n_args = n_args.as(not null) n_args.parent = self end @@ -4343,8 +5247,8 @@ redef class ACallExpr n_expr = new_child.as(AExpr) return end - if _n_id == old_child then - n_id = new_child.as(TId) + if _n_qid == old_child then + n_qid = new_child.as(AQid) return end if _n_args == old_child then @@ -4358,9 +5262,9 @@ redef class ACallExpr _n_expr = node node.parent = self end - redef fun n_id=(node) + redef fun n_qid=(node) do - _n_id = node + _n_qid = node node.parent = self end redef fun n_args=(node) @@ -4373,14 +5277,14 @@ redef class ACallExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) - v.enter_visit(_n_id) + v.enter_visit(_n_qid) v.enter_visit(_n_args) end end redef class ACallAssignExpr init init_acallassignexpr ( n_expr: nullable AExpr, - n_id: nullable TId, + n_qid: nullable AQid, n_args: nullable AExprs, n_assign: nullable TAssign, n_value: nullable AExpr @@ -4388,8 +5292,8 @@ redef class ACallAssignExpr do _n_expr = n_expr.as(not null) n_expr.parent = self - _n_id = n_id.as(not null) - n_id.parent = self + _n_qid = n_qid.as(not null) + n_qid.parent = self _n_args = n_args.as(not null) n_args.parent = self _n_assign = n_assign.as(not null) @@ -4404,8 +5308,8 @@ redef class ACallAssignExpr n_expr = new_child.as(AExpr) return end - if _n_id == old_child then - n_id = new_child.as(TId) + if _n_qid == old_child then + n_qid = new_child.as(AQid) return end if _n_args == old_child then @@ -4427,9 +5331,9 @@ redef class ACallAssignExpr _n_expr = node node.parent = self end - redef fun n_id=(node) + redef fun n_qid=(node) do - _n_id = node + _n_qid = node node.parent = self end redef fun n_args=(node) @@ -4452,7 +5356,7 @@ redef class ACallAssignExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) - v.enter_visit(_n_id) + v.enter_visit(_n_qid) v.enter_visit(_n_args) v.enter_visit(_n_assign) v.enter_visit(_n_value) @@ -4461,7 +5365,7 @@ end redef class ACallReassignExpr init init_acallreassignexpr ( n_expr: nullable AExpr, - n_id: nullable TId, + n_qid: nullable AQid, n_args: nullable AExprs, n_assign_op: nullable AAssignOp, n_value: nullable AExpr @@ -4469,8 +5373,8 @@ redef class ACallReassignExpr do _n_expr = n_expr.as(not null) n_expr.parent = self - _n_id = n_id.as(not null) - n_id.parent = self + _n_qid = n_qid.as(not null) + n_qid.parent = self _n_args = n_args.as(not null) n_args.parent = self _n_assign_op = n_assign_op.as(not null) @@ -4485,8 +5389,8 @@ redef class ACallReassignExpr n_expr = new_child.as(AExpr) return end - if _n_id == old_child then - n_id = new_child.as(TId) + if _n_qid == old_child then + n_qid = new_child.as(AQid) return end if _n_args == old_child then @@ -4508,9 +5412,9 @@ redef class ACallReassignExpr _n_expr = node node.parent = self end - redef fun n_id=(node) + redef fun n_qid=(node) do - _n_id = node + _n_qid = node node.parent = self end redef fun n_args=(node) @@ -4533,7 +5437,7 @@ redef class ACallReassignExpr redef fun visit_all(v: Visitor) do v.enter_visit(_n_expr) - v.enter_visit(_n_id) + v.enter_visit(_n_qid) v.enter_visit(_n_args) v.enter_visit(_n_assign_op) v.enter_visit(_n_value) @@ -5025,6 +5929,7 @@ redef class ACrangeExpr init init_acrangeexpr ( n_obra: nullable TObra, n_expr: nullable AExpr, + n_dotdot: nullable TDotdot, n_expr2: nullable AExpr, n_cbra: nullable TCbra, n_annotations: nullable AAnnotations @@ -5034,6 +5939,8 @@ redef class ACrangeExpr n_obra.parent = self _n_expr = n_expr.as(not null) n_expr.parent = self + _n_dotdot = n_dotdot.as(not null) + n_dotdot.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self _n_cbra = n_cbra.as(not null) @@ -5052,6 +5959,10 @@ redef class ACrangeExpr n_expr = new_child.as(AExpr) return end + if _n_dotdot == old_child then + n_dotdot = new_child.as(TDotdot) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -5076,6 +5987,11 @@ redef class ACrangeExpr _n_expr = node node.parent = self end + redef fun n_dotdot=(node) + do + _n_dotdot = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -5097,6 +6013,7 @@ redef class ACrangeExpr do v.enter_visit(_n_obra) v.enter_visit(_n_expr) + v.enter_visit(_n_dotdot) v.enter_visit(_n_expr2) v.enter_visit(_n_cbra) v.enter_visit(_n_annotations) @@ -5106,6 +6023,7 @@ redef class AOrangeExpr init init_aorangeexpr ( n_obra: nullable TObra, n_expr: nullable AExpr, + n_dotdot: nullable TDotdot, n_expr2: nullable AExpr, n_cbra: nullable TObra, n_annotations: nullable AAnnotations @@ -5115,6 +6033,8 @@ redef class AOrangeExpr n_obra.parent = self _n_expr = n_expr.as(not null) n_expr.parent = self + _n_dotdot = n_dotdot.as(not null) + n_dotdot.parent = self _n_expr2 = n_expr2.as(not null) n_expr2.parent = self _n_cbra = n_cbra.as(not null) @@ -5133,6 +6053,10 @@ redef class AOrangeExpr n_expr = new_child.as(AExpr) return end + if _n_dotdot == old_child then + n_dotdot = new_child.as(TDotdot) + return + end if _n_expr2 == old_child then n_expr2 = new_child.as(AExpr) return @@ -5157,6 +6081,11 @@ redef class AOrangeExpr _n_expr = node node.parent = self end + redef fun n_dotdot=(node) + do + _n_dotdot = node + node.parent = self + end redef fun n_expr2=(node) do _n_expr2 = node @@ -5178,6 +6107,7 @@ redef class AOrangeExpr do v.enter_visit(_n_obra) v.enter_visit(_n_expr) + v.enter_visit(_n_dotdot) v.enter_visit(_n_expr2) v.enter_visit(_n_cbra) v.enter_visit(_n_annotations) @@ -5438,22 +6368,22 @@ redef class ANullExpr v.enter_visit(_n_annotations) end end -redef class ADecIntExpr - init init_adecintexpr ( - n_number: nullable TNumber, +redef class AIntegerExpr + init init_aintegerexpr ( + n_integer: nullable TInteger, n_annotations: nullable AAnnotations ) do - _n_number = n_number.as(not null) - n_number.parent = self + _n_integer = n_integer.as(not null) + n_integer.parent = self _n_annotations = n_annotations if n_annotations != null then n_annotations.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_number == old_child then - n_number = new_child.as(TNumber) + if _n_integer == old_child then + n_integer = new_child.as(TInteger) return end if _n_annotations == old_child then @@ -5462,9 +6392,9 @@ redef class ADecIntExpr end end - redef fun n_number=(node) + redef fun n_integer=(node) do - _n_number = node + _n_integer = node node.parent = self end redef fun n_annotations=(node) @@ -5476,26 +6406,26 @@ redef class ADecIntExpr redef fun visit_all(v: Visitor) do - v.enter_visit(_n_number) + v.enter_visit(_n_integer) v.enter_visit(_n_annotations) end end -redef class AHexIntExpr - init init_ahexintexpr ( - n_hex_number: nullable THexNumber, +redef class AFloatExpr + init init_afloatexpr ( + n_float: nullable TFloat, n_annotations: nullable AAnnotations ) do - _n_hex_number = n_hex_number.as(not null) - n_hex_number.parent = self + _n_float = n_float.as(not null) + n_float.parent = self _n_annotations = n_annotations if n_annotations != null then n_annotations.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_hex_number == old_child then - n_hex_number = new_child.as(THexNumber) + if _n_float == old_child then + n_float = new_child.as(TFloat) return end if _n_annotations == old_child then @@ -5504,9 +6434,9 @@ redef class AHexIntExpr end end - redef fun n_hex_number=(node) + redef fun n_float=(node) do - _n_hex_number = node + _n_float = node node.parent = self end redef fun n_annotations=(node) @@ -5518,60 +6448,18 @@ redef class AHexIntExpr redef fun visit_all(v: Visitor) do - v.enter_visit(_n_hex_number) + v.enter_visit(_n_float) v.enter_visit(_n_annotations) end end -redef class AFloatExpr - init init_afloatexpr ( - n_float: nullable TFloat, +redef class ACharExpr + init init_acharexpr ( + n_char: nullable TChar, n_annotations: nullable AAnnotations ) do - _n_float = n_float.as(not null) - n_float.parent = self - _n_annotations = n_annotations - if n_annotations != null then n_annotations.parent = self - end - - redef fun replace_child(old_child: ANode, new_child: nullable ANode) - do - if _n_float == old_child then - n_float = new_child.as(TFloat) - return - end - if _n_annotations == old_child then - n_annotations = new_child.as(nullable AAnnotations) - return - end - end - - redef fun n_float=(node) - do - _n_float = node - node.parent = self - end - redef fun n_annotations=(node) - do - _n_annotations = node - if node != null then node.parent = self - end - - - redef fun visit_all(v: Visitor) - do - v.enter_visit(_n_float) - v.enter_visit(_n_annotations) - end -end -redef class ACharExpr - init init_acharexpr ( - n_char: nullable TChar, - n_annotations: nullable AAnnotations - ) - do - _n_char = n_char.as(not null) - n_char.parent = self + _n_char = n_char.as(not null) + n_char.parent = self _n_annotations = n_annotations if n_annotations != null then n_annotations.parent = self end @@ -6176,6 +7064,61 @@ redef class AVarargExpr v.enter_visit(_n_dotdotdot) end end +redef class ANamedargExpr + init init_anamedargexpr ( + n_id: nullable TId, + n_assign: nullable TAssign, + n_expr: nullable AExpr + ) + do + _n_id = n_id.as(not null) + n_id.parent = self + _n_assign = n_assign.as(not null) + n_assign.parent = self + _n_expr = n_expr.as(not null) + n_expr.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_id == old_child then + n_id = new_child.as(TId) + return + end + if _n_assign == old_child then + n_assign = new_child.as(TAssign) + return + end + if _n_expr == old_child then + n_expr = new_child.as(AExpr) + return + end + end + + redef fun n_id=(node) + do + _n_id = node + node.parent = self + end + redef fun n_assign=(node) + do + _n_assign = node + node.parent = self + end + redef fun n_expr=(node) + do + _n_expr = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_id) + v.enter_visit(_n_assign) + v.enter_visit(_n_expr) + end +end redef class ATypeExpr init init_atypeexpr ( n_type: nullable AType @@ -6410,60 +7353,367 @@ redef class ABraExprs end redef class APlusAssignOp init init_aplusassignop ( - n_pluseq: nullable TPluseq + n_op: nullable TPluseq ) do - _n_pluseq = n_pluseq.as(not null) - n_pluseq.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_pluseq == old_child then - n_pluseq = new_child.as(TPluseq) + if _n_op == old_child then + n_op = new_child.as(TPluseq) return end end - redef fun n_pluseq=(node) + redef fun n_op=(node) do - _n_pluseq = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_pluseq) + v.enter_visit(_n_op) end end redef class AMinusAssignOp init init_aminusassignop ( - n_minuseq: nullable TMinuseq + n_op: nullable TMinuseq + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TMinuseq) + return + end + end + + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_op) + end +end +redef class AStarAssignOp + init init_astarassignop ( + n_op: nullable TStareq + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TStareq) + return + end + end + + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_op) + end +end +redef class ASlashAssignOp + init init_aslashassignop ( + n_op: nullable TSlasheq ) do - _n_minuseq = n_minuseq.as(not null) - n_minuseq.parent = self + _n_op = n_op.as(not null) + n_op.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do - if _n_minuseq == old_child then - n_minuseq = new_child.as(TMinuseq) + if _n_op == old_child then + n_op = new_child.as(TSlasheq) return end end - redef fun n_minuseq=(node) + redef fun n_op=(node) do - _n_minuseq = node + _n_op = node node.parent = self end redef fun visit_all(v: Visitor) do - v.enter_visit(_n_minuseq) + v.enter_visit(_n_op) + end +end +redef class APercentAssignOp + init init_apercentassignop ( + n_op: nullable TPercenteq + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TPercenteq) + return + end + end + + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_op) + end +end +redef class AStarstarAssignOp + init init_astarstarassignop ( + n_op: nullable TStarstareq + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TStarstareq) + return + end + end + + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_op) + end +end +redef class APipeAssignOp + init init_apipeassignop ( + n_op: nullable TPipeeq + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TPipeeq) + return + end + end + + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_op) + end +end +redef class ACaretAssignOp + init init_acaretassignop ( + n_op: nullable TCareteq + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TCareteq) + return + end + end + + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_op) + end +end +redef class AAmpAssignOp + init init_aampassignop ( + n_op: nullable TAmpeq + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TAmpeq) + return + end + end + + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_op) + end +end +redef class ALlAssignOp + init init_allassignop ( + n_op: nullable TLleq + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TLleq) + return + end + end + + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_op) + end +end +redef class AGgAssignOp + init init_aggassignop ( + n_op: nullable TGgeq + ) + do + _n_op = n_op.as(not null) + n_op.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if _n_op == old_child then + n_op = new_child.as(TGgeq) + return + end + end + + redef fun n_op=(node) + do + _n_op = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + v.enter_visit(_n_op) + end +end +redef class AForGroup + init init_aforgroup ( + n_ids: Collection[Object], # Should be Collection[TId] + n_kwin: nullable TKwin, + n_expr: nullable AExpr + ) + do + self.n_ids.unsafe_add_all(n_ids) + _n_kwin = n_kwin.as(not null) + n_kwin.parent = self + _n_expr = n_expr.as(not null) + n_expr.parent = self + end + + redef fun replace_child(old_child: ANode, new_child: nullable ANode) + do + if n_ids.replace_child(old_child, new_child) then return + if _n_kwin == old_child then + n_kwin = new_child.as(TKwin) + return + end + if _n_expr == old_child then + n_expr = new_child.as(AExpr) + return + end + end + + redef fun n_kwin=(node) + do + _n_kwin = node + node.parent = self + end + redef fun n_expr=(node) + do + _n_expr = node + node.parent = self + end + + + redef fun visit_all(v: Visitor) + do + n_ids.visit_all(v) + v.enter_visit(_n_kwin) + v.enter_visit(_n_expr) end end redef class AModuleName @@ -7032,12 +8282,16 @@ redef class ADoc end redef class AAnnotations init init_aannotations ( + n_kwis: nullable TKwis, n_at: nullable TAt, n_opar: nullable TOpar, n_items: Collection[Object], # Should be Collection[AAnnotation] - n_cpar: nullable TCpar + n_cpar: nullable TCpar, + n_kwend: nullable TKwend ) do + _n_kwis = n_kwis + if n_kwis != null then n_kwis.parent = self _n_at = n_at if n_at != null then n_at.parent = self _n_opar = n_opar @@ -7045,10 +8299,16 @@ redef class AAnnotations self.n_items.unsafe_add_all(n_items) _n_cpar = n_cpar if n_cpar != null then n_cpar.parent = self + _n_kwend = n_kwend + if n_kwend != null then n_kwend.parent = self end redef fun replace_child(old_child: ANode, new_child: nullable ANode) do + if _n_kwis == old_child then + n_kwis = new_child.as(nullable TKwis) + return + end if _n_at == old_child then n_at = new_child.as(nullable TAt) return @@ -7062,8 +8322,17 @@ redef class AAnnotations n_cpar = new_child.as(nullable TCpar) return end + if _n_kwend == old_child then + n_kwend = new_child.as(nullable TKwend) + return + end end + redef fun n_kwis=(node) + do + _n_kwis = node + if node != null then node.parent = self + end redef fun n_at=(node) do _n_at = node @@ -7079,14 +8348,21 @@ redef class AAnnotations _n_cpar = node if node != null then node.parent = self end + redef fun n_kwend=(node) + do + _n_kwend = node + if node != null then node.parent = self + end redef fun visit_all(v: Visitor) do + v.enter_visit(_n_kwis) v.enter_visit(_n_at) v.enter_visit(_n_opar) n_items.visit_all(v) v.enter_visit(_n_cpar) + v.enter_visit(_n_kwend) end end redef class AAnnotation