parser: regenerate

[nit.git] / src / parser / parser_prod.nit

diff --git a/src/parser/parser_prod.nit b/src/parser/parser_prod.nit
index 9964ed8..027dc59 100644 (file)
--- a/src/parser/parser_prod.nit
+++ b/src/parser/parser_prod.nit
@@ -1,6 +1,6 @@
 # Production AST nodes full definition.
 # This file was generated by SableCC (http://www.sablecc.org/).
-module parser_prod
+module parser_prod is no_warning("missing-doc")
 
 import lexer
 intrude import parser_nodes
@@ -388,9 +388,7 @@ redef class AStdClassdef
                n_classkind: nullable AClasskind,
                n_id: nullable TClassid,
                n_formaldefs: Collection[Object], # Should be Collection[AFormaldef]
-               n_annotations: nullable AAnnotations,
                n_extern_code_block: nullable AExternCodeBlock,
-               n_superclasses: Collection[Object], # Should be Collection[ASuperclass]
                n_propdefs: Collection[Object], # Should be Collection[APropdef]
                n_kwend: nullable TKwend
        )
@@ -406,11 +404,8 @@ redef class AStdClassdef
                _n_id = n_id
                if n_id != null then n_id.parent = self
                self.n_formaldefs.unsafe_add_all(n_formaldefs)
-               _n_annotations = n_annotations
-               if n_annotations != null then n_annotations.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_superclasses.unsafe_add_all(n_superclasses)
                self.n_propdefs.unsafe_add_all(n_propdefs)
                _n_kwend = n_kwend.as(not null)
                n_kwend.parent = self
@@ -439,15 +434,10 @@ redef class AStdClassdef
                        return
                end
                if n_formaldefs.replace_child(old_child, new_child) then return
-               if _n_annotations == old_child then
-                       n_annotations = new_child.as(nullable AAnnotations)
-                       return
-               end
                if _n_extern_code_block == old_child then
                        n_extern_code_block = new_child.as(nullable AExternCodeBlock)
                        return
                end
-               if n_superclasses.replace_child(old_child, new_child) then return
                if n_propdefs.replace_child(old_child, new_child) then return
                if _n_kwend == old_child then
                        n_kwend = new_child.as(TKwend)
@@ -480,11 +470,6 @@ redef class AStdClassdef
                _n_id = 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 n_extern_code_block=(node)
        do
                _n_extern_code_block = node
@@ -505,9 +490,7 @@ redef class AStdClassdef
                v.enter_visit(_n_classkind)
                v.enter_visit(_n_id)
                n_formaldefs.visit_all(v)
-               v.enter_visit(_n_annotations)
                v.enter_visit(_n_extern_code_block)
-               n_superclasses.visit_all(v)
                n_propdefs.visit_all(v)
                v.enter_visit(_n_kwend)
        end
@@ -778,61 +761,6 @@ redef class AFormaldef
                v.enter_visit(_n_annotations)
        end
 end
-redef class ASuperclass
-       init init_asuperclass (
-               n_kwsuper: nullable TKwsuper,
-               n_type: nullable AType,
-               n_annotations: nullable AAnnotations
-       )
-       do
-               _n_kwsuper = n_kwsuper.as(not null)
-               n_kwsuper.parent = self
-               _n_type = n_type.as(not null)
-               n_type.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_kwsuper == old_child then
-                       n_kwsuper = new_child.as(TKwsuper)
-                       return
-               end
-               if _n_type == old_child then
-                       n_type = new_child.as(AType)
-                       return
-               end
-               if _n_annotations == old_child then
-                       n_annotations = new_child.as(nullable AAnnotations)
-                       return
-               end
-       end
-
-       redef fun n_kwsuper=(node)
-       do
-               _n_kwsuper = node
-               node.parent = self
-       end
-       redef fun n_type=(node)
-       do
-               _n_type = 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_kwsuper)
-               v.enter_visit(_n_type)
-               v.enter_visit(_n_annotations)
-       end
-end
 redef class AAttrPropdef
        init init_aattrpropdef (
                n_doc: nullable ADoc,
@@ -1287,510 +1215,831 @@ redef class AMethPropdef
                v.enter_visit(_n_block)
        end
 end
-redef class AIdMethid
-       init init_aidmethid (
-               n_id: nullable TId
+redef class ASuperPropdef
+       init init_asuperpropdef (
+               n_doc: nullable ADoc,
+               n_kwredef: nullable TKwredef,
+               n_visibility: nullable AVisibility,
+               n_kwsuper: nullable TKwsuper,
+               n_type: nullable AType,
+               n_annotations: nullable AAnnotations
        )
        do
-               _n_id = n_id.as(not null)
-               n_id.parent = self
+               _n_doc = n_doc
+               if n_doc != null then n_doc.parent = self
+               _n_kwredef = n_kwredef
+               if n_kwredef != null then n_kwredef.parent = self
+               _n_visibility = n_visibility.as(not null)
+               n_visibility.parent = self
+               _n_kwsuper = n_kwsuper.as(not null)
+               n_kwsuper.parent = self
+               _n_type = n_type.as(not null)
+               n_type.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)
+               if _n_doc == old_child then
+                       n_doc = new_child.as(nullable ADoc)
+                       return
+               end
+               if _n_kwredef == old_child then
+                       n_kwredef = new_child.as(nullable TKwredef)
+                       return
+               end
+               if _n_visibility == old_child then
+                       n_visibility = new_child.as(AVisibility)
+                       return
+               end
+               if _n_kwsuper == old_child then
+                       n_kwsuper = new_child.as(TKwsuper)
+                       return
+               end
+               if _n_type == old_child then
+                       n_type = new_child.as(AType)
+                       return
+               end
+               if _n_annotations == old_child then
+                       n_annotations = new_child.as(nullable AAnnotations)
                        return
                end
        end
 
-       redef fun n_id=(node)
+       redef fun n_doc=(node)
        do
-               _n_id = node
-               node.parent = self
+               _n_doc = node
+               if node != null then node.parent = self
        end
-
-
-       redef fun visit_all(v: Visitor)
+       redef fun n_kwredef=(node)
        do
-               v.enter_visit(_n_id)
+               _n_kwredef = node
+               if node != null then node.parent = self
        end
-end
-redef class APlusMethid
-       init init_aplusmethid (
-               n_plus: nullable TPlus
-       )
+       redef fun n_visibility=(node)
        do
-               _n_plus = n_plus.as(not null)
-               n_plus.parent = self
+               _n_visibility = node
+               node.parent = self
        end
-
-       redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+       redef fun n_kwsuper=(node)
        do
-               if _n_plus == old_child then
-                       n_plus = new_child.as(TPlus)
-                       return
-               end
+               _n_kwsuper = node
+               node.parent = self
        end
-
-       redef fun n_plus=(node)
+       redef fun n_type=(node)
        do
-               _n_plus = node
+               _n_type = 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_plus)
+               v.enter_visit(_n_doc)
+               v.enter_visit(_n_kwredef)
+               v.enter_visit(_n_visibility)
+               v.enter_visit(_n_kwsuper)
+               v.enter_visit(_n_type)
+               v.enter_visit(_n_annotations)
        end
 end
-redef class AMinusMethid
-       init init_aminusmethid (
-               n_minus: nullable TMinus
+redef class AAnnotPropdef
+       init init_aannotpropdef (
+               n_doc: nullable ADoc,
+               n_kwredef: nullable TKwredef,
+               n_visibility: nullable AVisibility,
+               n_atid: nullable AAtid,
+               n_opar: nullable TOpar,
+               n_args: Collection[Object], # Should be Collection[AExpr]
+               n_cpar: nullable TCpar,
+               n_annotations: nullable AAnnotations
        )
        do
-               _n_minus = n_minus.as(not null)
-               n_minus.parent = self
+               _n_doc = n_doc
+               if n_doc != null then n_doc.parent = self
+               _n_kwredef = n_kwredef
+               if n_kwredef != null then n_kwredef.parent = self
+               _n_visibility = n_visibility
+               if n_visibility != null then n_visibility.parent = self
+               _n_atid = n_atid.as(not null)
+               n_atid.parent = self
+               _n_opar = n_opar
+               if n_opar != null then n_opar.parent = self
+               self.n_args.unsafe_add_all(n_args)
+               _n_cpar = n_cpar
+               if n_cpar != null then n_cpar.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_minus == old_child then
-                       n_minus = new_child.as(TMinus)
+               if _n_doc == old_child then
+                       n_doc = new_child.as(nullable ADoc)
+                       return
+               end
+               if _n_kwredef == old_child then
+                       n_kwredef = new_child.as(nullable TKwredef)
+                       return
+               end
+               if _n_visibility == old_child then
+                       n_visibility = new_child.as(nullable AVisibility)
+                       return
+               end
+               if _n_atid == old_child then
+                       n_atid = new_child.as(AAtid)
+                       return
+               end
+               if _n_opar == old_child then
+                       n_opar = new_child.as(nullable TOpar)
+                       return
+               end
+               if n_args.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_annotations == old_child then
+                       n_annotations = new_child.as(nullable AAnnotations)
                        return
                end
        end
 
-       redef fun n_minus=(node)
+       redef fun n_doc=(node)
+       do
+               _n_doc = node
+               if node != null then node.parent = self
+       end
+       redef fun n_kwredef=(node)
+       do
+               _n_kwredef = node
+               if node != null then node.parent = self
+       end
+       redef fun n_visibility=(node)
+       do
+               _n_visibility = node
+               if node != null then node.parent = self
+       end
+       redef fun n_atid=(node)
        do
-               _n_minus = node
+               _n_atid = node
                node.parent = self
        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_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_minus)
+               v.enter_visit(_n_doc)
+               v.enter_visit(_n_kwredef)
+               v.enter_visit(_n_visibility)
+               v.enter_visit(_n_atid)
+               v.enter_visit(_n_opar)
+               n_args.visit_all(v)
+               v.enter_visit(_n_cpar)
+               v.enter_visit(_n_annotations)
        end
 end
-redef class AStarMethid
-       init init_astarmethid (
-               n_star: nullable TStar
+redef class AIdMethid
+       init init_aidmethid (
+               n_id: nullable TId
        )
        do
-               _n_star = n_star.as(not null)
-               n_star.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_star == old_child then
-                       n_star = new_child.as(TStar)
+               if _n_id == old_child then
+                       n_id = new_child.as(TId)
                        return
                end
        end
 
-       redef fun n_star=(node)
+       redef fun n_id=(node)
        do
-               _n_star = node
+               _n_id = node
+               node.parent = self
+       end
+
+
+       redef fun visit_all(v: Visitor)
+       do
+               v.enter_visit(_n_id)
+       end
+end
+redef class APlusMethid
+       init init_aplusmethid (
+               n_op: nullable TPlus
+       )
+       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(TPlus)
+                       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 AMinusMethid
+       init init_aminusmethid (
+               n_op: nullable TMinus
+       )
+       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(TMinus)
+                       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 AStarMethid
+       init init_astarmethid (
+               n_op: nullable TStar
+       )
+       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(TStar)
+                       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_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
@@ -2161,8 +2410,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
@@ -2178,7 +2427,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
@@ -2206,7 +2455,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
@@ -2838,79 +3087,160 @@ redef class AForExpr
                v.enter_visit(_n_label)
        end
 end
-redef class AAssertExpr
-       init init_aassertexpr (
-               n_kwassert: nullable TKwassert,
-               n_id: nullable TId,
+redef class AWithExpr
+       init init_awithexpr (
+               n_kwwith: nullable TKwwith,
                n_expr: nullable AExpr,
-               n_else: nullable AExpr
+               n_kwdo: nullable TKwdo,
+               n_block: nullable AExpr,
+               n_label: nullable ALabel
        )
        do
-               _n_kwassert = n_kwassert.as(not null)
-               n_kwassert.parent = self
-               _n_id = n_id
-               if n_id != null then n_id.parent = self
+               _n_kwwith = n_kwwith.as(not null)
+               n_kwwith.parent = self
                _n_expr = n_expr.as(not null)
                n_expr.parent = self
-               _n_else = n_else
-               if n_else != null then n_else.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_kwassert == old_child then
-                       n_kwassert = new_child.as(TKwassert)
-                       return
-               end
-               if _n_id == old_child then
-                       n_id = new_child.as(nullable TId)
+               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
                end
-               if _n_else == old_child then
-                       n_else = new_child.as(nullable AExpr)
+               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_kwassert=(node)
+       redef fun n_kwwith=(node)
        do
-               _n_kwassert = node
+               _n_kwwith = node
                node.parent = self
        end
-       redef fun n_id=(node)
-       do
-               _n_id = node
-               if node != null then node.parent = self
-       end
        redef fun n_expr=(node)
        do
                _n_expr = node
                node.parent = self
        end
-       redef fun n_else=(node)
+       redef fun n_kwdo=(node)
        do
-               _n_else = node
+               _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_kwassert)
-               v.enter_visit(_n_id)
+               v.enter_visit(_n_kwwith)
                v.enter_visit(_n_expr)
-               v.enter_visit(_n_else)
+               v.enter_visit(_n_kwdo)
+               v.enter_visit(_n_block)
+               v.enter_visit(_n_label)
        end
 end
-redef class AOnceExpr
-       init init_aonceexpr (
-               n_kwonce: nullable TKwonce,
-               n_expr: nullable AExpr
-       )
+redef class AAssertExpr
+       init init_aassertexpr (
+               n_kwassert: nullable TKwassert,
+               n_id: nullable TId,
+               n_expr: nullable AExpr,
+               n_else: nullable AExpr
+       )
+       do
+               _n_kwassert = n_kwassert.as(not null)
+               n_kwassert.parent = self
+               _n_id = n_id
+               if n_id != null then n_id.parent = self
+               _n_expr = n_expr.as(not null)
+               n_expr.parent = self
+               _n_else = n_else
+               if n_else != null then n_else.parent = self
+       end
+
+       redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+       do
+               if _n_kwassert == old_child then
+                       n_kwassert = new_child.as(TKwassert)
+                       return
+               end
+               if _n_id == old_child then
+                       n_id = new_child.as(nullable TId)
+                       return
+               end
+               if _n_expr == old_child then
+                       n_expr = new_child.as(AExpr)
+                       return
+               end
+               if _n_else == old_child then
+                       n_else = new_child.as(nullable AExpr)
+                       return
+               end
+       end
+
+       redef fun n_kwassert=(node)
+       do
+               _n_kwassert = node
+               node.parent = self
+       end
+       redef fun n_id=(node)
+       do
+               _n_id = node
+               if node != null then node.parent = self
+       end
+       redef fun n_expr=(node)
+       do
+               _n_expr = node
+               node.parent = self
+       end
+       redef fun n_else=(node)
+       do
+               _n_else = node
+               if node != null then node.parent = self
+       end
+
+
+       redef fun visit_all(v: Visitor)
+       do
+               v.enter_visit(_n_kwassert)
+               v.enter_visit(_n_id)
+               v.enter_visit(_n_expr)
+               v.enter_visit(_n_else)
+       end
+end
+redef class AOnceExpr
+       init init_aonceexpr (
+               n_kwonce: nullable TKwonce,
+               n_expr: nullable AExpr
+       )
        do
                _n_kwonce = n_kwonce.as(not null)
                n_kwonce.parent = self
@@ -3022,11 +3352,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
@@ -3037,6 +3370,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
@@ -3048,6 +3385,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
@@ -3058,17 +3400,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
@@ -3079,6 +3425,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
@@ -3090,6 +3440,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
@@ -3100,17 +3455,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
@@ -3121,6 +3483,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
@@ -3132,6 +3502,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
@@ -3142,17 +3522,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
@@ -3163,6 +3548,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
@@ -3174,6 +3563,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
@@ -3184,6 +3578,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
@@ -3232,11 +3627,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
@@ -3247,6 +3645,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
@@ -3258,6 +3660,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
@@ -3268,17 +3675,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
@@ -3289,6 +3700,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
@@ -3300,6 +3715,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
@@ -3310,17 +3730,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
@@ -3331,6 +3755,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
@@ -3342,6 +3770,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
@@ -3352,17 +3785,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
@@ -3373,6 +3810,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
@@ -3384,6 +3825,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
@@ -3394,17 +3840,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
@@ -3415,6 +3865,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
@@ -3426,6 +3880,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
@@ -3436,17 +3895,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
@@ -3457,6 +3920,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
@@ -3468,6 +3935,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
@@ -3478,17 +3950,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
@@ -3499,6 +3975,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
@@ -3510,6 +3990,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
@@ -3520,17 +4005,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
@@ -3541,6 +4030,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
@@ -3552,6 +4045,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
@@ -3562,17 +4060,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
@@ -3583,6 +4085,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
@@ -3594,6 +4100,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
@@ -3604,17 +4115,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
@@ -3625,6 +4140,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
@@ -3633,7 +4152,287 @@ redef class APlusExpr
 
        redef fun n_expr=(node)
        do
-               _n_expr = 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 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
+
+       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(TMinus)
+                       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 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
+
+       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(TStarship)
+                       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 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
+
+       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(TStar)
+                       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 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
+
+       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(TStarstar)
+                       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 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
+
+       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(TSlash)
+                       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)
@@ -3646,17 +4445,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 (
+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
@@ -3667,6 +4470,10 @@ redef class AMinusExpr
                        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
@@ -3678,6 +4485,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
@@ -3688,17 +4500,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 (
+redef class APipeExpr
+       init init_apipeexpr (
                n_expr: nullable AExpr,
+               n_op: nullable TPipe,
                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
@@ -3709,6 +4525,10 @@ redef class AStarshipExpr
                        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
@@ -3720,6 +4540,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
@@ -3730,17 +4555,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 (
+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
@@ -3751,6 +4580,10 @@ redef class AStarExpr
                        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
@@ -3762,6 +4595,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
@@ -3772,17 +4610,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 (
+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
@@ -3793,6 +4635,10 @@ redef class AStarstarExpr
                        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
@@ -3804,6 +4650,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
@@ -3814,109 +4665,110 @@ 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_expr2: nullable AExpr
+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
-               _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)
+               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)
+               if _n_expr == old_child then
+                       n_expr = new_child.as(AExpr)
                        return
                end
        end
 
-       redef fun n_expr=(node)
+       redef fun n_op=(node)
        do
-               _n_expr = node
+               _n_op = node
                node.parent = self
        end
-       redef fun n_expr2=(node)
+       redef fun n_expr=(node)
        do
-               _n_expr2 = node
+               _n_expr = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
+               v.enter_visit(_n_op)
                v.enter_visit(_n_expr)
-               v.enter_visit(_n_expr2)
        end
 end
-redef class APercentExpr
-       init init_apercentexpr (
-               n_expr: nullable AExpr,
-               n_expr2: nullable AExpr
+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
-               _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)
+               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)
+               if _n_expr == old_child then
+                       n_expr = new_child.as(AExpr)
                        return
                end
        end
 
-       redef fun n_expr=(node)
+       redef fun n_op=(node)
        do
-               _n_expr = node
+               _n_op = node
                node.parent = self
        end
-       redef fun n_expr2=(node)
+       redef fun n_expr=(node)
        do
-               _n_expr2 = node
+               _n_expr = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
+               v.enter_visit(_n_op)
                v.enter_visit(_n_expr)
-               v.enter_visit(_n_expr2)
        end
 end
-redef class AUminusExpr
-       init init_auminusexpr (
-               n_minus: nullable TMinus,
+redef class AUtildeExpr
+       init init_autildeexpr (
+               n_op: nullable TTilde,
                n_expr: nullable AExpr
        )
        do
-               _n_minus = n_minus.as(not null)
-               n_minus.parent = self
+               _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_minus == old_child then
-                       n_minus = new_child.as(TMinus)
+               if _n_op == old_child then
+                       n_op = new_child.as(TTilde)
                        return
                end
                if _n_expr == old_child then
@@ -3925,9 +4777,9 @@ redef class AUminusExpr
                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 n_expr=(node)
@@ -3939,7 +4791,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
@@ -5053,7 +5905,7 @@ end
 redef class AArrayExpr
        init init_aarrayexpr (
                n_obra: nullable TObra,
-               n_exprs: nullable AExprs,
+               n_exprs: Collection[Object], # Should be Collection[AExpr]
                n_type: nullable AType,
                n_cbra: nullable TCbra,
                n_annotations: nullable AAnnotations
@@ -5061,8 +5913,7 @@ redef class AArrayExpr
        do
                _n_obra = n_obra.as(not null)
                n_obra.parent = self
-               _n_exprs = n_exprs.as(not null)
-               n_exprs.parent = self
+               self.n_exprs.unsafe_add_all(n_exprs)
                _n_type = n_type
                if n_type != null then n_type.parent = self
                _n_cbra = n_cbra.as(not null)
@@ -5077,10 +5928,7 @@ redef class AArrayExpr
                        n_obra = new_child.as(TObra)
                        return
                end
-               if _n_exprs == old_child then
-                       n_exprs = new_child.as(AExprs)
-                       return
-               end
+               if n_exprs.replace_child(old_child, new_child) then return
                if _n_type == old_child then
                        n_type = new_child.as(nullable AType)
                        return
@@ -5100,11 +5948,6 @@ redef class AArrayExpr
                _n_obra = node
                node.parent = self
        end
-       redef fun n_exprs=(node)
-       do
-               _n_exprs = node
-               node.parent = self
-       end
        redef fun n_type=(node)
        do
                _n_type = node
@@ -5125,7 +5968,7 @@ redef class AArrayExpr
        redef fun visit_all(v: Visitor)
        do
                v.enter_visit(_n_obra)
-               v.enter_visit(_n_exprs)
+               n_exprs.visit_all(v)
                v.enter_visit(_n_type)
                v.enter_visit(_n_cbra)
                v.enter_visit(_n_annotations)
@@ -6286,60 +7129,321 @@ 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_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(TSlasheq)
+                       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 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_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(TGgeq)
                        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 AModuleName