+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_eq)
+ end
+end
+redef class ANeMethid
+ init init_anemethid (
+ n_ne: nullable TNe
+ )
+ do
+ _n_ne = n_ne.as(not null)
+ n_ne.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)
+ return
+ end
+ end
+
+ redef fun n_ne=(node)
+ do
+ _n_ne = node
+ node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_ne)
+ end
+end
+redef class ALeMethid
+ init init_alemethid (
+ n_le: nullable TLe
+ )
+ do
+ _n_le = n_le.as(not null)
+ n_le.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)
+ return
+ end
+ end
+
+ redef fun n_le=(node)
+ do
+ _n_le = node
+ node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_le)
+ end
+end
+redef class AGeMethid
+ init init_agemethid (
+ n_ge: nullable TGe
+ )
+ do
+ _n_ge = n_ge.as(not null)
+ n_ge.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)
+ return
+ end
+ end
+
+ redef fun n_ge=(node)
+ do
+ _n_ge = node
+ node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_ge)
+ end
+end
+redef class ALtMethid
+ init init_altmethid (
+ n_lt: nullable TLt
+ )
+ do
+ _n_lt = n_lt.as(not null)
+ n_lt.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)
+ return
+ end
+ end
+
+ redef fun n_lt=(node)
+ do
+ _n_lt = node
+ node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_lt)
+ end
+end
+redef class AGtMethid
+ init init_agtmethid (
+ n_gt: nullable TGt
+ )
+ do
+ _n_gt = n_gt.as(not null)
+ n_gt.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)
+ return
+ end
+ end
+
+ redef fun n_gt=(node)
+ do
+ _n_gt = node
+ node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_gt)
+ end
+end
+redef class ALlMethid
+ init init_allmethid (
+ n_ll: nullable TLl
+ )
+ do
+ _n_ll = n_ll.as(not null)
+ n_ll.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)
+ return
+ end
+ end
+
+ redef fun n_ll=(node)
+ do
+ _n_ll = node
+ node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_ll)
+ end
+end
+redef class AGgMethid
+ init init_aggmethid (
+ n_gg: nullable TGg
+ )
+ do
+ _n_gg = n_gg.as(not null)
+ n_gg.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)
+ return
+ end
+ end
+
+ redef fun n_gg=(node)
+ do
+ _n_gg = node
+ node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_gg)
+ end
+end
+redef class ABraMethid
+ init init_abramethid (
+ n_obra: nullable TObra,
+ n_cbra: nullable TCbra
+ )
+ do
+ _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_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_obra=(node)
+ do
+ _n_obra = node
+ node.parent = self
+ end
+ redef fun n_cbra=(node)
+ do
+ _n_cbra = node
+ node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_obra)
+ v.enter_visit(_n_cbra)
+ end
+end
+redef class AStarshipMethid
+ init init_astarshipmethid (
+ n_starship: nullable TStarship
+ )
+ do
+ _n_starship = n_starship.as(not null)
+ n_starship.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)
+ return
+ end
+ end
+
+ redef fun n_starship=(node)
+ do
+ _n_starship = node
+ node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_starship)
+ end
+end
+redef class AAssignMethid
+ init init_aassignmethid (
+ n_id: nullable TId,
+ n_assign: nullable TAssign
+ )
+ do
+ _n_id = n_id.as(not null)
+ n_id.parent = self
+ _n_assign = n_assign.as(not null)
+ n_assign.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
+ 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 visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_id)
+ v.enter_visit(_n_assign)
+ end
+end
+redef class ABraassignMethid
+ init init_abraassignmethid (
+ n_obra: nullable TObra,
+ n_cbra: nullable TCbra,
+ n_assign: nullable TAssign
+ )
+ do
+ _n_obra = n_obra.as(not null)
+ n_obra.parent = self
+ _n_cbra = n_cbra.as(not null)
+ n_cbra.parent = self
+ _n_assign = n_assign.as(not null)
+ n_assign.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)
+ return
+ end
+ if _n_cbra == old_child then
+ n_cbra = new_child.as(TCbra)
+ return
+ end
+ if _n_assign == old_child then
+ n_assign = new_child.as(TAssign)
+ return
+ end
+ end
+
+ redef fun n_obra=(node)
+ do
+ _n_obra = node
+ node.parent = self
+ end
+ redef fun n_cbra=(node)
+ do
+ _n_cbra = node
+ node.parent = self
+ end
+ redef fun n_assign=(node)
+ do
+ _n_assign = 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_assign)
+ end
+end
+redef class ASignature
+ init init_asignature (
+ n_opar: nullable TOpar,
+ n_params: Collection[Object], # Should be Collection[AParam]
+ n_cpar: nullable TCpar,
+ n_type: nullable AType
+ )
+ do
+ _n_opar = n_opar
+ if n_opar != null then n_opar.parent = self
+ self.n_params.unsafe_add_all(n_params)
+ _n_cpar = n_cpar
+ if n_cpar != null then n_cpar.parent = self
+ _n_type = n_type
+ if n_type != null then n_type.parent = self
+ end
+
+ redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+ do
+ if _n_opar == old_child then
+ n_opar = new_child.as(nullable TOpar)
+ return
+ end
+ if n_params.replace_child(old_child, new_child) then return
+ if _n_cpar == old_child then
+ n_cpar = new_child.as(nullable TCpar)
+ return
+ end
+ if _n_type == old_child then
+ n_type = new_child.as(nullable AType)
+ return
+ end
+ end
+
+ redef fun n_opar=(node)
+ do
+ _n_opar = node
+ if node != null then node.parent = self
+ end
+ redef fun n_cpar=(node)
+ do
+ _n_cpar = node
+ if node != null then node.parent = self
+ end
+ redef fun n_type=(node)
+ do
+ _n_type = node
+ if node != null then node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_opar)
+ n_params.visit_all(v)
+ v.enter_visit(_n_cpar)
+ v.enter_visit(_n_type)
+ end
+end
+redef class AParam
+ init init_aparam (
+ n_id: nullable TId,
+ n_type: nullable AType,
+ n_dotdotdot: nullable TDotdotdot,
+ n_annotations: nullable AAnnotations
+ )
+ do
+ _n_id = n_id.as(not null)
+ n_id.parent = self
+ _n_type = n_type
+ if n_type != null then n_type.parent = self
+ _n_dotdotdot = n_dotdotdot
+ if n_dotdotdot != null then n_dotdotdot.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_id == old_child then
+ n_id = new_child.as(TId)
+ return
+ end
+ if _n_type == old_child then
+ n_type = new_child.as(nullable AType)
+ return
+ end
+ if _n_dotdotdot == old_child then
+ n_dotdotdot = new_child.as(nullable TDotdotdot)
+ return
+ end
+ if _n_annotations == old_child then
+ n_annotations = new_child.as(nullable AAnnotations)
+ return
+ end
+ end
+
+ redef fun n_id=(node)
+ do
+ _n_id = node
+ node.parent = self
+ end
+ redef fun n_type=(node)
+ do
+ _n_type = node
+ if node != null then node.parent = self
+ end
+ redef fun n_dotdotdot=(node)
+ do
+ _n_dotdotdot = 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_id)
+ v.enter_visit(_n_type)
+ v.enter_visit(_n_dotdotdot)
+ v.enter_visit(_n_annotations)
+ end
+end
+redef class AType
+ init init_atype (
+ n_kwnullable: nullable TKwnullable,
+ n_id: nullable TClassid,
+ n_types: Collection[Object], # Should be Collection[AType]
+ n_annotations: nullable AAnnotations
+ )
+ do
+ _n_kwnullable = n_kwnullable
+ if n_kwnullable != null then n_kwnullable.parent = self
+ _n_id = n_id.as(not null)
+ n_id.parent = self
+ self.n_types.unsafe_add_all(n_types)
+ _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_kwnullable == old_child then
+ n_kwnullable = new_child.as(nullable TKwnullable)
+ return
+ end
+ if _n_id == old_child then
+ n_id = new_child.as(TClassid)
+ return
+ end
+ if n_types.replace_child(old_child, new_child) then return
+ if _n_annotations == old_child then
+ n_annotations = new_child.as(nullable AAnnotations)
+ return
+ end
+ end
+
+ redef fun n_kwnullable=(node)
+ do
+ _n_kwnullable = node
+ if node != null then node.parent = self
+ end
+ redef fun n_id=(node)
+ do
+ _n_id = 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_kwnullable)
+ v.enter_visit(_n_id)
+ n_types.visit_all(v)
+ v.enter_visit(_n_annotations)
+ end
+end
+redef class ALabel
+ init init_alabel (
+ n_kwlabel: nullable TKwlabel,
+ n_id: nullable TId
+ )
+ do
+ _n_kwlabel = n_kwlabel.as(not null)
+ n_kwlabel.parent = self
+ _n_id = n_id
+ if n_id != null then n_id.parent = self
+ end
+
+ redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+ do
+ if _n_kwlabel == old_child then
+ n_kwlabel = new_child.as(TKwlabel)
+ return
+ end
+ if _n_id == old_child then
+ n_id = new_child.as(nullable TId)
+ return
+ end
+ end
+
+ redef fun n_kwlabel=(node)
+ do
+ _n_kwlabel = node
+ node.parent = self
+ end
+ redef fun n_id=(node)
+ do
+ _n_id = node
+ if node != null then node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_kwlabel)
+ v.enter_visit(_n_id)
+ end
+end
+redef class ABlockExpr
+ init init_ablockexpr (
+ n_expr: Collection[Object], # Should be Collection[AExpr]
+ n_kwend: nullable TKwend
+ )
+ do
+ self.n_expr.unsafe_add_all(n_expr)
+ _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_expr.replace_child(old_child, new_child) then return
+ if _n_kwend == old_child then
+ n_kwend = new_child.as(nullable TKwend)
+ return
+ end
+ 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
+ n_expr.visit_all(v)
+ v.enter_visit(_n_kwend)
+ end
+end
+redef class AVardeclExpr
+ init init_avardeclexpr (
+ n_kwvar: nullable TKwvar,
+ n_id: nullable TId,
+ n_type: nullable AType,
+ n_assign: nullable TAssign,
+ n_expr: nullable AExpr,
+ n_annotations: nullable AAnnotations
+ )
+ do
+ _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
+ 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
+ end
+
+ redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+ do
+ if _n_kwvar == old_child then
+ n_kwvar = new_child.as(nullable TKwvar)
+ return
+ end
+ if _n_id == old_child then
+ n_id = new_child.as(TId)
+ return
+ end
+ if _n_type == old_child then
+ 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
+ end
+ if _n_annotations == old_child then
+ n_annotations = new_child.as(nullable AAnnotations)
+ return
+ end
+ end
+
+ redef fun n_kwvar=(node)
+ do
+ _n_kwvar = node
+ if node != null then node.parent = self
+ end
+ redef fun n_id=(node)
+ do
+ _n_id = node
+ node.parent = self
+ end
+ redef fun n_type=(node)
+ do
+ _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
+ 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_kwvar)
+ v.enter_visit(_n_id)
+ v.enter_visit(_n_type)
+ v.enter_visit(_n_assign)
+ v.enter_visit(_n_expr)
+ v.enter_visit(_n_annotations)
+ end
+end
+redef class AReturnExpr
+ init init_areturnexpr (
+ n_kwreturn: nullable TKwreturn,
+ n_expr: nullable AExpr
+ )
+ do
+ _n_kwreturn = n_kwreturn
+ if n_kwreturn != null then n_kwreturn.parent = self
+ _n_expr = n_expr
+ if n_expr != null then n_expr.parent = self
+ end
+
+ redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+ do
+ if _n_kwreturn == old_child then
+ n_kwreturn = new_child.as(nullable TKwreturn)
+ return
+ end
+ if _n_expr == old_child then
+ n_expr = new_child.as(nullable AExpr)
+ return
+ end
+ end
+
+ redef fun n_kwreturn=(node)
+ do
+ _n_kwreturn = node
+ if node != null then node.parent = self
+ end
+ redef fun n_expr=(node)
+ do
+ _n_expr = node
+ if node != null then node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_kwreturn)
+ v.enter_visit(_n_expr)
+ end
+end
+redef class ABreakExpr
+ init init_abreakexpr (
+ n_kwbreak: nullable TKwbreak,
+ n_label: nullable ALabel
+ )
+ do
+ _n_kwbreak = n_kwbreak.as(not null)
+ n_kwbreak.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_kwbreak == old_child then
+ n_kwbreak = new_child.as(TKwbreak)
+ return
+ end
+ if _n_label == old_child then
+ n_label = new_child.as(nullable ALabel)
+ return
+ end
+ end
+
+ redef fun n_kwbreak=(node)
+ do
+ _n_kwbreak = node
+ 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_kwbreak)
+ v.enter_visit(_n_label)
+ end
+end
+redef class AAbortExpr
+ init init_aabortexpr (
+ n_kwabort: nullable TKwabort
+ )
+ do
+ _n_kwabort = n_kwabort.as(not null)
+ n_kwabort.parent = self
+ end
+
+ redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+ do
+ if _n_kwabort == old_child then
+ n_kwabort = new_child.as(TKwabort)
+ return
+ end
+ end
+
+ redef fun n_kwabort=(node)
+ do
+ _n_kwabort = node
+ node.parent = self
+ end
+
+
+ redef fun visit_all(v: Visitor)
+ do
+ v.enter_visit(_n_kwabort)
+ end
+end
+redef class AContinueExpr
+ init init_acontinueexpr (
+ n_kwcontinue: nullable TKwcontinue,
+ n_label: nullable ALabel
+ )
+ do
+ _n_kwcontinue = n_kwcontinue
+ if n_kwcontinue != null then n_kwcontinue.parent = self
+ _n_label = n_label
+ if n_label != null then n_label.parent = self