nitlanguage / nit.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
Rename REAMDE to README.md
[nit.git] / src / parser / parser_prod.nit
diff --git a/src/parser/parser_prod.nit b/src/parser/parser_prod.nit
index 9964ed8..8743717 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
@@ -387,10 +387,10 @@ redef class AStdClassdef
                n_visibility: nullable AVisibility,
                n_classkind: nullable AClasskind,
                n_id: nullable TClassid,
+               n_obra: nullable TObra,
                n_formaldefs: Collection[Object], # Should be Collection[AFormaldef]
-               n_annotations: nullable AAnnotations,
+               n_cbra: nullable TCbra,
                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
        )
@@ -405,12 +405,13 @@ redef class AStdClassdef
                n_classkind.parent = self
                _n_id = n_id
                if n_id != null then n_id.parent = self
+               _n_obra = n_obra
+               if n_obra != null then n_obra.parent = self
                self.n_formaldefs.unsafe_add_all(n_formaldefs)
-               _n_annotations = n_annotations
-               if n_annotations != null then n_annotations.parent = self
+               _n_cbra = n_cbra
+               if n_cbra != null then n_cbra.parent = self
                _n_extern_code_block = n_extern_code_block
                if n_extern_code_block != null then n_extern_code_block.parent = self
-               self.n_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
@@ -438,16 +439,19 @@ redef class AStdClassdef
                        n_id = new_child.as(nullable TClassid)
                        return
                end
+               if _n_obra == old_child then
+                       n_obra = new_child.as(nullable TObra)
+                       return
+               end
                if n_formaldefs.replace_child(old_child, new_child) then return
-               if _n_annotations == old_child then
-                       n_annotations = new_child.as(nullable AAnnotations)
+               if _n_cbra == old_child then
+                       n_cbra = new_child.as(nullable TCbra)
                        return
                end
                if _n_extern_code_block == old_child then
                        n_extern_code_block = new_child.as(nullable AExternCodeBlock)
                        return
                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,9 +484,14 @@ redef class AStdClassdef
                _n_id = node
                if node != null then node.parent = self
        end
-       redef fun n_annotations=(node)
+       redef fun n_obra=(node)
        do
-               _n_annotations = node
+               _n_obra = node
+               if node != null then node.parent = self
+       end
+       redef fun n_cbra=(node)
+       do
+               _n_cbra = node
                if node != null then node.parent = self
        end
        redef fun n_extern_code_block=(node)
@@ -504,10 +513,10 @@ redef class AStdClassdef
                v.enter_visit(_n_visibility)
                v.enter_visit(_n_classkind)
                v.enter_visit(_n_id)
+               v.enter_visit(_n_obra)
                n_formaldefs.visit_all(v)
-               v.enter_visit(_n_annotations)
+               v.enter_visit(_n_cbra)
                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 +787,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,
@@ -841,9 +795,12 @@ redef class AAttrPropdef
                n_kwvar: nullable TKwvar,
                n_id2: nullable TId,
                n_type: nullable AType,
+               n_assign: nullable TAssign,
                n_expr: nullable AExpr,
                n_annotations: nullable AAnnotations,
-               n_block: nullable AExpr
+               n_kwdo: nullable TKwdo,
+               n_block: nullable AExpr,
+               n_kwend: nullable TKwend
        )
        do
                _n_doc = n_doc
@@ -858,12 +815,18 @@ redef class AAttrPropdef
                n_id2.parent = self
                _n_type = n_type
                if n_type != null then n_type.parent = self
+               _n_assign = n_assign
+               if n_assign != null then n_assign.parent = self
                _n_expr = n_expr
                if n_expr != null then n_expr.parent = self
                _n_annotations = n_annotations
                if n_annotations != null then n_annotations.parent = self
+               _n_kwdo = n_kwdo
+               if n_kwdo != null then n_kwdo.parent = self
                _n_block = n_block
                if n_block != null then n_block.parent = self
+               _n_kwend = n_kwend
+               if n_kwend != null then n_kwend.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
@@ -892,6 +855,10 @@ redef class AAttrPropdef
                        n_type = new_child.as(nullable AType)
                        return
                end
+               if _n_assign == old_child then
+                       n_assign = new_child.as(nullable TAssign)
+                       return
+               end
                if _n_expr == old_child then
                        n_expr = new_child.as(nullable AExpr)
                        return
@@ -900,10 +867,18 @@ redef class AAttrPropdef
                        n_annotations = new_child.as(nullable AAnnotations)
                        return
                end
+               if _n_kwdo == old_child then
+                       n_kwdo = new_child.as(nullable TKwdo)
+                       return
+               end
                if _n_block == old_child then
                        n_block = new_child.as(nullable AExpr)
                        return
                end
+               if _n_kwend == old_child then
+                       n_kwend = new_child.as(nullable TKwend)
+                       return
+               end
        end
 
        redef fun n_doc=(node)
@@ -936,6 +911,11 @@ redef class AAttrPropdef
                _n_type = node
                if node != null then node.parent = self
        end
+       redef fun n_assign=(node)
+       do
+               _n_assign = node
+               if node != null then node.parent = self
+       end
        redef fun n_expr=(node)
        do
                _n_expr = node
@@ -946,11 +926,21 @@ redef class AAttrPropdef
                _n_annotations = node
                if node != null then node.parent = self
        end
+       redef fun n_kwdo=(node)
+       do
+               _n_kwdo = node
+               if node != null then node.parent = self
+       end
        redef fun n_block=(node)
        do
                _n_block = node
                if node != null then node.parent = self
        end
+       redef fun n_kwend=(node)
+       do
+               _n_kwend = node
+               if node != null then node.parent = self
+       end
 
 
        redef fun visit_all(v: Visitor)
@@ -961,9 +951,12 @@ redef class AAttrPropdef
                v.enter_visit(_n_kwvar)
                v.enter_visit(_n_id2)
                v.enter_visit(_n_type)
+               v.enter_visit(_n_assign)
                v.enter_visit(_n_expr)
                v.enter_visit(_n_annotations)
+               v.enter_visit(_n_kwdo)
                v.enter_visit(_n_block)
+               v.enter_visit(_n_kwend)
        end
 end
 redef class AMainMethPropdef
@@ -1128,7 +1121,9 @@ redef class AMethPropdef
                n_annotations: nullable AAnnotations,
                n_extern_calls: nullable AExternCalls,
                n_extern_code_block: nullable AExternCodeBlock,
-               n_block: nullable AExpr
+               n_kwdo: nullable TKwdo,
+               n_block: nullable AExpr,
+               n_kwend: nullable TKwend
        )
        do
                _n_doc = n_doc
@@ -1153,8 +1148,12 @@ redef class AMethPropdef
                if n_extern_calls != null then n_extern_calls.parent = self
                _n_extern_code_block = n_extern_code_block
                if n_extern_code_block != null then n_extern_code_block.parent = self
+               _n_kwdo = n_kwdo
+               if n_kwdo != null then n_kwdo.parent = self
                _n_block = n_block
                if n_block != null then n_block.parent = self
+               _n_kwend = n_kwend
+               if n_kwend != null then n_kwend.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
@@ -1203,10 +1202,18 @@ redef class AMethPropdef
                        n_extern_code_block = new_child.as(nullable AExternCodeBlock)
                        return
                end
+               if _n_kwdo == old_child then
+                       n_kwdo = new_child.as(nullable TKwdo)
+                       return
+               end
                if _n_block == old_child then
                        n_block = new_child.as(nullable AExpr)
                        return
                end
+               if _n_kwend == old_child then
+                       n_kwend = new_child.as(nullable TKwend)
+                       return
+               end
        end
 
        redef fun n_doc=(node)
@@ -1264,11 +1271,21 @@ redef class AMethPropdef
                _n_extern_code_block = node
                if node != null then node.parent = self
        end
+       redef fun n_kwdo=(node)
+       do
+               _n_kwdo = node
+               if node != null then node.parent = self
+       end
        redef fun n_block=(node)
        do
                _n_block = node
                if node != null then node.parent = self
        end
+       redef fun n_kwend=(node)
+       do
+               _n_kwend = node
+               if node != null then node.parent = self
+       end
 
 
        redef fun visit_all(v: Visitor)
@@ -1284,513 +1301,836 @@ redef class AMethPropdef
                v.enter_visit(_n_annotations)
                v.enter_visit(_n_extern_calls)
                v.enter_visit(_n_extern_code_block)
+               v.enter_visit(_n_kwdo)
                v.enter_visit(_n_block)
+               v.enter_visit(_n_kwend)
        end
 end
-redef class 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
-       end
-
-       redef fun n_minus=(node)
+               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_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_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_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 AIdMethid
+       init init_aidmethid (
+               n_id: nullable TId
+       )
+       do
+               _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_id == old_child then
+                       n_id = new_child.as(TId)
+                       return
+               end
+       end
+
+       redef fun n_id=(node)
+       do
+               _n_id = node
+               node.parent = self
+       end
+
+
+       redef fun visit_all(v: Visitor)
+       do
+               v.enter_visit(_n_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_minus = node
+               _n_op = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_minus)
+               v.enter_visit(_n_op)
        end
 end
 redef class AStarMethid
        init init_astarmethid (
-               n_star: nullable TStar
+               n_op: nullable TStar
        )
        do
-               _n_star = n_star.as(not null)
-               n_star.parent = self
+               _n_op = n_op.as(not null)
+               n_op.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_star == old_child then
-                       n_star = new_child.as(TStar)
+               if _n_op == old_child then
+                       n_op = new_child.as(TStar)
                        return
                end
        end
 
-       redef fun n_star=(node)
+       redef fun n_op=(node)
        do
-               _n_star = node
+               _n_op = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_star)
+               v.enter_visit(_n_op)
        end
 end
 redef class AStarstarMethid
        init init_astarstarmethid (
-               n_starstar: nullable TStarstar
+               n_op: nullable TStarstar
        )
        do
-               _n_starstar = n_starstar.as(not null)
-               n_starstar.parent = self
+               _n_op = n_op.as(not null)
+               n_op.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_starstar == old_child then
-                       n_starstar = new_child.as(TStarstar)
+               if _n_op == old_child then
+                       n_op = new_child.as(TStarstar)
                        return
                end
        end
 
-       redef fun n_starstar=(node)
+       redef fun n_op=(node)
        do
-               _n_starstar = node
+               _n_op = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_starstar)
+               v.enter_visit(_n_op)
        end
 end
 redef class ASlashMethid
        init init_aslashmethid (
-               n_slash: nullable TSlash
+               n_op: nullable TSlash
        )
        do
-               _n_slash = n_slash.as(not null)
-               n_slash.parent = self
+               _n_op = n_op.as(not null)
+               n_op.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_slash == old_child then
-                       n_slash = new_child.as(TSlash)
+               if _n_op == old_child then
+                       n_op = new_child.as(TSlash)
                        return
                end
        end
 
-       redef fun n_slash=(node)
+       redef fun n_op=(node)
        do
-               _n_slash = node
+               _n_op = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_slash)
+               v.enter_visit(_n_op)
        end
 end
 redef class APercentMethid
        init init_apercentmethid (
-               n_percent: nullable TPercent
+               n_op: nullable TPercent
        )
        do
-               _n_percent = n_percent.as(not null)
-               n_percent.parent = self
+               _n_op = n_op.as(not null)
+               n_op.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_percent == old_child then
-                       n_percent = new_child.as(TPercent)
+               if _n_op == old_child then
+                       n_op = new_child.as(TPercent)
                        return
                end
        end
 
-       redef fun n_percent=(node)
+       redef fun n_op=(node)
        do
-               _n_percent = node
+               _n_op = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_percent)
+               v.enter_visit(_n_op)
        end
 end
 redef class AEqMethid
        init init_aeqmethid (
-               n_eq: nullable TEq
+               n_op: nullable TEq
        )
        do
-               _n_eq = n_eq.as(not null)
-               n_eq.parent = self
+               _n_op = n_op.as(not null)
+               n_op.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_eq == old_child then
-                       n_eq = new_child.as(TEq)
+               if _n_op == old_child then
+                       n_op = new_child.as(TEq)
                        return
                end
        end
 
-       redef fun n_eq=(node)
+       redef fun n_op=(node)
        do
-               _n_eq = node
+               _n_op = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_eq)
+               v.enter_visit(_n_op)
        end
 end
 redef class ANeMethid
        init init_anemethid (
-               n_ne: nullable TNe
+               n_op: nullable TNe
        )
        do
-               _n_ne = n_ne.as(not null)
-               n_ne.parent = self
+               _n_op = n_op.as(not null)
+               n_op.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_ne == old_child then
-                       n_ne = new_child.as(TNe)
+               if _n_op == old_child then
+                       n_op = new_child.as(TNe)
                        return
                end
        end
 
-       redef fun n_ne=(node)
+       redef fun n_op=(node)
        do
-               _n_ne = node
+               _n_op = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_ne)
+               v.enter_visit(_n_op)
        end
 end
 redef class ALeMethid
        init init_alemethid (
-               n_le: nullable TLe
+               n_op: nullable TLe
        )
        do
-               _n_le = n_le.as(not null)
-               n_le.parent = self
+               _n_op = n_op.as(not null)
+               n_op.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_le == old_child then
-                       n_le = new_child.as(TLe)
+               if _n_op == old_child then
+                       n_op = new_child.as(TLe)
                        return
                end
        end
 
-       redef fun n_le=(node)
+       redef fun n_op=(node)
        do
-               _n_le = node
+               _n_op = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_le)
+               v.enter_visit(_n_op)
        end
 end
 redef class AGeMethid
        init init_agemethid (
-               n_ge: nullable TGe
+               n_op: nullable TGe
        )
        do
-               _n_ge = n_ge.as(not null)
-               n_ge.parent = self
+               _n_op = n_op.as(not null)
+               n_op.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_ge == old_child then
-                       n_ge = new_child.as(TGe)
+               if _n_op == old_child then
+                       n_op = new_child.as(TGe)
                        return
                end
        end
 
-       redef fun n_ge=(node)
+       redef fun n_op=(node)
        do
-               _n_ge = node
+               _n_op = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_ge)
+               v.enter_visit(_n_op)
        end
 end
 redef class ALtMethid
        init init_altmethid (
-               n_lt: nullable TLt
+               n_op: nullable TLt
        )
        do
-               _n_lt = n_lt.as(not null)
-               n_lt.parent = self
+               _n_op = n_op.as(not null)
+               n_op.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_lt == old_child then
-                       n_lt = new_child.as(TLt)
+               if _n_op == old_child then
+                       n_op = new_child.as(TLt)
                        return
                end
        end
 
-       redef fun n_lt=(node)
+       redef fun n_op=(node)
        do
-               _n_lt = node
+               _n_op = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_lt)
+               v.enter_visit(_n_op)
        end
 end
 redef class AGtMethid
        init init_agtmethid (
-               n_gt: nullable TGt
+               n_op: nullable TGt
        )
        do
-               _n_gt = n_gt.as(not null)
-               n_gt.parent = self
+               _n_op = n_op.as(not null)
+               n_op.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_gt == old_child then
-                       n_gt = new_child.as(TGt)
+               if _n_op == old_child then
+                       n_op = new_child.as(TGt)
                        return
                end
        end
 
-       redef fun n_gt=(node)
+       redef fun n_op=(node)
        do
-               _n_gt = node
+               _n_op = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_gt)
+               v.enter_visit(_n_op)
        end
 end
 redef class ALlMethid
        init init_allmethid (
-               n_ll: nullable TLl
+               n_op: nullable TLl
        )
        do
-               _n_ll = n_ll.as(not null)
-               n_ll.parent = self
+               _n_op = n_op.as(not null)
+               n_op.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_ll == old_child then
-                       n_ll = new_child.as(TLl)
+               if _n_op == old_child then
+                       n_op = new_child.as(TLl)
                        return
                end
        end
 
-       redef fun n_ll=(node)
+       redef fun n_op=(node)
        do
-               _n_ll = node
+               _n_op = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_ll)
+               v.enter_visit(_n_op)
        end
 end
 redef class AGgMethid
        init init_aggmethid (
-               n_gg: nullable TGg
+               n_op: nullable TGg
        )
        do
-               _n_gg = n_gg.as(not null)
-               n_gg.parent = self
+               _n_op = n_op.as(not null)
+               n_op.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_gg == old_child then
-                       n_gg = new_child.as(TGg)
+               if _n_op == old_child then
+                       n_op = new_child.as(TGg)
                        return
                end
        end
 
-       redef fun n_gg=(node)
+       redef fun n_op=(node)
        do
-               _n_gg = node
+               _n_op = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_gg)
+               v.enter_visit(_n_op)
        end
 end
-redef class ABraMethid
-       init init_abramethid (
-               n_obra: nullable TObra,
-               n_cbra: nullable TCbra
+redef class AStarshipMethid
+       init init_astarshipmethid (
+               n_op: nullable TStarship
        )
        do
-               _n_obra = n_obra.as(not null)
-               n_obra.parent = self
-               _n_cbra = n_cbra.as(not null)
-               n_cbra.parent = self
+               _n_op = n_op.as(not null)
+               n_op.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_obra == old_child then
-                       n_obra = new_child.as(TObra)
+               if _n_op == old_child then
+                       n_op = new_child.as(TStarship)
                        return
                end
-               if _n_cbra == old_child then
-                       n_cbra = new_child.as(TCbra)
+       end
+
+       redef fun n_op=(node)
+       do
+               _n_op = node
+               node.parent = self
+       end
+
+
+       redef fun visit_all(v: Visitor)
+       do
+               v.enter_visit(_n_op)
+       end
+end
+redef class APipeMethid
+       init init_apipemethid (
+               n_op: nullable TPipe
+       )
+       do
+               _n_op = n_op.as(not null)
+               n_op.parent = self
+       end
+
+       redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+       do
+               if _n_op == old_child then
+                       n_op = new_child.as(TPipe)
                        return
                end
        end
 
-       redef fun n_obra=(node)
+       redef fun n_op=(node)
        do
-               _n_obra = node
+               _n_op = node
                node.parent = self
        end
-       redef fun n_cbra=(node)
+
+
+       redef fun visit_all(v: Visitor)
        do
-               _n_cbra = node
+               v.enter_visit(_n_op)
+       end
+end
+redef class ACaretMethid
+       init init_acaretmethid (
+               n_op: nullable TCaret
+       )
+       do
+               _n_op = n_op.as(not null)
+               n_op.parent = self
+       end
+
+       redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+       do
+               if _n_op == old_child then
+                       n_op = new_child.as(TCaret)
+                       return
+               end
+       end
+
+       redef fun n_op=(node)
+       do
+               _n_op = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_obra)
-               v.enter_visit(_n_cbra)
+               v.enter_visit(_n_op)
        end
 end
-redef class AStarshipMethid
-       init init_astarshipmethid (
-               n_starship: nullable TStarship
+redef class AAmpMethid
+       init init_aampmethid (
+               n_op: nullable TAmp
+       )
+       do
+               _n_op = n_op.as(not null)
+               n_op.parent = self
+       end
+
+       redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+       do
+               if _n_op == old_child then
+                       n_op = new_child.as(TAmp)
+                       return
+               end
+       end
+
+       redef fun n_op=(node)
+       do
+               _n_op = node
+               node.parent = self
+       end
+
+
+       redef fun visit_all(v: Visitor)
+       do
+               v.enter_visit(_n_op)
+       end
+end
+redef class ATildeMethid
+       init init_atildemethid (
+               n_op: nullable TTilde
+       )
+       do
+               _n_op = n_op.as(not null)
+               n_op.parent = self
+       end
+
+       redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+       do
+               if _n_op == old_child then
+                       n_op = new_child.as(TTilde)
+                       return
+               end
+       end
+
+       redef fun n_op=(node)
+       do
+               _n_op = node
+               node.parent = self
+       end
+
+
+       redef fun visit_all(v: Visitor)
+       do
+               v.enter_visit(_n_op)
+       end
+end
+redef class ABraMethid
+       init init_abramethid (
+               n_obra: nullable TObra,
+               n_cbra: nullable TCbra
        )
        do
-               _n_starship = n_starship.as(not null)
-               n_starship.parent = self
+               _n_obra = n_obra.as(not null)
+               n_obra.parent = self
+               _n_cbra = n_cbra.as(not null)
+               n_cbra.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_starship == old_child then
-                       n_starship = new_child.as(TStarship)
+               if _n_obra == old_child then
+                       n_obra = new_child.as(TObra)
+                       return
+               end
+               if _n_cbra == old_child then
+                       n_cbra = new_child.as(TCbra)
                        return
                end
        end
 
-       redef fun n_starship=(node)
+       redef fun n_obra=(node)
+       do
+               _n_obra = node
+               node.parent = self
+       end
+       redef fun n_cbra=(node)
        do
-               _n_starship = node
+               _n_cbra = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_starship)
+               v.enter_visit(_n_obra)
+               v.enter_visit(_n_cbra)
        end
 end
 redef class AAssignMethid
@@ -2021,7 +2361,9 @@ redef class AType
        init init_atype (
                n_kwnullable: nullable TKwnullable,
                n_id: nullable TClassid,
+               n_obra: nullable TObra,
                n_types: Collection[Object], # Should be Collection[AType]
+               n_cbra: nullable TCbra,
                n_annotations: nullable AAnnotations
        )
        do
@@ -2029,7 +2371,11 @@ redef class AType
                if n_kwnullable != null then n_kwnullable.parent = self
                _n_id = n_id.as(not null)
                n_id.parent = self
+               _n_obra = n_obra
+               if n_obra != null then n_obra.parent = self
                self.n_types.unsafe_add_all(n_types)
+               _n_cbra = n_cbra
+               if n_cbra != null then n_cbra.parent = self
                _n_annotations = n_annotations
                if n_annotations != null then n_annotations.parent = self
        end
@@ -2044,7 +2390,15 @@ redef class AType
                        n_id = new_child.as(TClassid)
                        return
                end
+               if _n_obra == old_child then
+                       n_obra = new_child.as(nullable TObra)
+                       return
+               end
                if n_types.replace_child(old_child, new_child) then return
+               if _n_cbra == old_child then
+                       n_cbra = new_child.as(nullable TCbra)
+                       return
+               end
                if _n_annotations == old_child then
                        n_annotations = new_child.as(nullable AAnnotations)
                        return
@@ -2061,6 +2415,16 @@ redef class AType
                _n_id = node
                node.parent = self
        end
+       redef fun n_obra=(node)
+       do
+               _n_obra = node
+               if node != null then node.parent = self
+       end
+       redef fun n_cbra=(node)
+       do
+               _n_cbra = node
+               if node != null then node.parent = self
+       end
        redef fun n_annotations=(node)
        do
                _n_annotations = node
@@ -2072,7 +2436,9 @@ redef class AType
        do
                v.enter_visit(_n_kwnullable)
                v.enter_visit(_n_id)
+               v.enter_visit(_n_obra)
                n_types.visit_all(v)
+               v.enter_visit(_n_cbra)
                v.enter_visit(_n_annotations)
        end
 end
@@ -2161,8 +2527,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 +2544,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 +2572,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
@@ -2459,7 +2825,9 @@ redef class AIfExpr
        init init_aifexpr (
                n_kwif: nullable TKwif,
                n_expr: nullable AExpr,
+               n_kwthen: nullable TKwthen,
                n_then: nullable AExpr,
+               n_kwelse: nullable TKwelse,
                n_else: nullable AExpr
        )
        do
@@ -2467,8 +2835,12 @@ redef class AIfExpr
                n_kwif.parent = self
                _n_expr = n_expr.as(not null)
                n_expr.parent = self
+               _n_kwthen = n_kwthen.as(not null)
+               n_kwthen.parent = self
                _n_then = n_then
                if n_then != null then n_then.parent = self
+               _n_kwelse = n_kwelse
+               if n_kwelse != null then n_kwelse.parent = self
                _n_else = n_else
                if n_else != null then n_else.parent = self
        end
@@ -2483,10 +2855,18 @@ redef class AIfExpr
                        n_expr = new_child.as(AExpr)
                        return
                end
+               if _n_kwthen == old_child then
+                       n_kwthen = new_child.as(TKwthen)
+                       return
+               end
                if _n_then == old_child then
                        n_then = new_child.as(nullable AExpr)
                        return
                end
+               if _n_kwelse == old_child then
+                       n_kwelse = new_child.as(nullable TKwelse)
+                       return
+               end
                if _n_else == old_child then
                        n_else = new_child.as(nullable AExpr)
                        return
@@ -2503,11 +2883,21 @@ redef class AIfExpr
                _n_expr = node
                node.parent = self
        end
+       redef fun n_kwthen=(node)
+       do
+               _n_kwthen = node
+               node.parent = self
+       end
        redef fun n_then=(node)
        do
                _n_then = node
                if node != null then node.parent = self
        end
+       redef fun n_kwelse=(node)
+       do
+               _n_kwelse = node
+               if node != null then node.parent = self
+       end
        redef fun n_else=(node)
        do
                _n_else = node
@@ -2519,7 +2909,9 @@ redef class AIfExpr
        do
                v.enter_visit(_n_kwif)
                v.enter_visit(_n_expr)
+               v.enter_visit(_n_kwthen)
                v.enter_visit(_n_then)
+               v.enter_visit(_n_kwelse)
                v.enter_visit(_n_else)
        end
 end
@@ -2757,6 +3149,7 @@ redef class AForExpr
        init init_aforexpr (
                n_kwfor: nullable TKwfor,
                n_ids: Collection[Object], # Should be Collection[TId]
+               n_kwin: nullable TKwin,
                n_expr: nullable AExpr,
                n_kwdo: nullable TKwdo,
                n_block: nullable AExpr,
@@ -2766,6 +3159,8 @@ redef class AForExpr
                _n_kwfor = n_kwfor.as(not null)
                n_kwfor.parent = self
                self.n_ids.unsafe_add_all(n_ids)
+               _n_kwin = n_kwin.as(not null)
+               n_kwin.parent = self
                _n_expr = n_expr.as(not null)
                n_expr.parent = self
                _n_kwdo = n_kwdo.as(not null)
@@ -2783,6 +3178,10 @@ redef class AForExpr
                        return
                end
                if n_ids.replace_child(old_child, new_child) then return
+               if _n_kwin == old_child then
+                       n_kwin = new_child.as(TKwin)
+                       return
+               end
                if _n_expr == old_child then
                        n_expr = new_child.as(AExpr)
                        return
@@ -2806,6 +3205,11 @@ redef class AForExpr
                _n_kwfor = node
                node.parent = self
        end
+       redef fun n_kwin=(node)
+       do
+               _n_kwin = node
+               node.parent = self
+       end
        redef fun n_expr=(node)
        do
                _n_expr = node
@@ -2832,6 +3236,88 @@ redef class AForExpr
        do
                v.enter_visit(_n_kwfor)
                n_ids.visit_all(v)
+               v.enter_visit(_n_kwin)
+               v.enter_visit(_n_expr)
+               v.enter_visit(_n_kwdo)
+               v.enter_visit(_n_block)
+               v.enter_visit(_n_label)
+       end
+end
+redef class AWithExpr
+       init init_awithexpr (
+               n_kwwith: nullable TKwwith,
+               n_expr: nullable AExpr,
+               n_kwdo: nullable TKwdo,
+               n_block: nullable AExpr,
+               n_label: nullable ALabel
+       )
+       do
+               _n_kwwith = n_kwwith.as(not null)
+               n_kwwith.parent = self
+               _n_expr = n_expr.as(not null)
+               n_expr.parent = self
+               _n_kwdo = n_kwdo.as(not null)
+               n_kwdo.parent = self
+               _n_block = n_block
+               if n_block != null then n_block.parent = self
+               _n_label = n_label
+               if n_label != null then n_label.parent = self
+       end
+
+       redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+       do
+               if _n_kwwith == old_child then
+                       n_kwwith = new_child.as(TKwwith)
+                       return
+               end
+               if _n_expr == old_child then
+                       n_expr = new_child.as(AExpr)
+                       return
+               end
+               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_kwwith=(node)
+       do
+               _n_kwwith = node
+               node.parent = self
+       end
+       redef fun n_expr=(node)
+       do
+               _n_expr = node
+               node.parent = self
+       end
+       redef fun n_kwdo=(node)
+       do
+               _n_kwdo = node
+               node.parent = self
+       end
+       redef fun n_block=(node)
+       do
+               _n_block = node
+               if node != null then node.parent = self
+       end
+       redef fun n_label=(node)
+       do
+               _n_label = node
+               if node != null then node.parent = self
+       end
+
+
+       redef fun visit_all(v: Visitor)
+       do
+               v.enter_visit(_n_kwwith)
                v.enter_visit(_n_expr)
                v.enter_visit(_n_kwdo)
                v.enter_visit(_n_block)
@@ -2843,6 +3329,7 @@ redef class AAssertExpr
                n_kwassert: nullable TKwassert,
                n_id: nullable TId,
                n_expr: nullable AExpr,
+               n_kwelse: nullable TKwelse,
                n_else: nullable AExpr
        )
        do
@@ -2852,6 +3339,8 @@ redef class AAssertExpr
                if n_id != null then n_id.parent = self
                _n_expr = n_expr.as(not null)
                n_expr.parent = self
+               _n_kwelse = n_kwelse
+               if n_kwelse != null then n_kwelse.parent = self
                _n_else = n_else
                if n_else != null then n_else.parent = self
        end
@@ -2870,6 +3359,10 @@ redef class AAssertExpr
                        n_expr = new_child.as(AExpr)
                        return
                end
+               if _n_kwelse == old_child then
+                       n_kwelse = new_child.as(nullable TKwelse)
+                       return
+               end
                if _n_else == old_child then
                        n_else = new_child.as(nullable AExpr)
                        return
@@ -2891,6 +3384,11 @@ redef class AAssertExpr
                _n_expr = node
                node.parent = self
        end
+       redef fun n_kwelse=(node)
+       do
+               _n_kwelse = node
+               if node != null then node.parent = self
+       end
        redef fun n_else=(node)
        do
                _n_else = node
@@ -2903,6 +3401,7 @@ redef class AAssertExpr
                v.enter_visit(_n_kwassert)
                v.enter_visit(_n_id)
                v.enter_visit(_n_expr)
+               v.enter_visit(_n_kwelse)
                v.enter_visit(_n_else)
        end
 end
@@ -3022,11 +3521,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 +3539,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 +3554,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 +3569,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 +3594,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 +3609,286 @@ 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
+               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 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
+
+       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(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
+               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_kwelse=(node)
+       do
+               _n_kwelse = 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_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
+
+       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(TKwimplies)
+                       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 ANotExpr
+       init init_anotexpr (
+               n_kwnot: nullable TKwnot,
+               n_expr: nullable AExpr
+       )
+       do
+               _n_kwnot = n_kwnot.as(not null)
+               n_kwnot.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_kwnot == old_child then
+                       n_kwnot = new_child.as(TKwnot)
+                       return
+               end
+               if _n_expr == old_child then
+                       n_expr = new_child.as(AExpr)
+                       return
+               end
+       end
+
+       redef fun n_kwnot=(node)
+       do
+               _n_kwnot = node
+               node.parent = self
+       end
+       redef fun n_expr=(node)
+       do
+               _n_expr = node
+               node.parent = self
+       end
+
+
+       redef fun visit_all(v: Visitor)
+       do
+               v.enter_visit(_n_kwnot)
+               v.enter_visit(_n_expr)
+       end
+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
+
+       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(TEq)
+                       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 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
+
+       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(TNe)
+                       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
@@ -3100,17 +3899,21 @@ 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 (
+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
@@ -3121,6 +3924,10 @@ redef class AOrElseExpr
                        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
@@ -3132,6 +3939,11 @@ 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_expr2=(node)
        do
                _n_expr2 = node
@@ -3142,17 +3954,21 @@ redef class AOrElseExpr
        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 AImpliesExpr
-       init init_aimpliesexpr (
+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
@@ -3163,6 +3979,10 @@ redef class AImpliesExpr
                        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
@@ -3174,6 +3994,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,59 +4009,76 @@ 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
-redef class ANotExpr
-       init init_anotexpr (
-               n_kwnot: nullable TKwnot,
-               n_expr: nullable AExpr
+redef class ALlExpr
+       init init_allexpr (
+               n_expr: nullable AExpr,
+               n_op: nullable TLl,
+               n_expr2: nullable AExpr
        )
        do
-               _n_kwnot = n_kwnot.as(not null)
-               n_kwnot.parent = self
                _n_expr = n_expr.as(not null)
                n_expr.parent = self
+               _n_op = n_op.as(not null)
+               n_op.parent = self
+               _n_expr2 = n_expr2.as(not null)
+               n_expr2.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
-               if _n_kwnot == old_child then
-                       n_kwnot = new_child.as(TKwnot)
-                       return
-               end
                if _n_expr == old_child then
                        n_expr = new_child.as(AExpr)
                        return
                end
+               if _n_op == old_child then
+                       n_op = new_child.as(TLl)
+                       return
+               end
+               if _n_expr2 == old_child then
+                       n_expr2 = new_child.as(AExpr)
+                       return
+               end
        end
 
-       redef fun n_kwnot=(node)
+       redef fun n_expr=(node)
        do
-               _n_kwnot = node
+               _n_expr = node
                node.parent = self
        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)
+       do
+               _n_expr2 = node
                node.parent = self
        end
 
 
        redef fun visit_all(v: Visitor)
        do
-               v.enter_visit(_n_kwnot)
                v.enter_visit(_n_expr)
+               v.enter_visit(_n_op)
+               v.enter_visit(_n_expr2)
        end
 end
-redef class AEqExpr
-       init init_aeqexpr (
+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
@@ -3247,6 +4089,10 @@ redef class AEqExpr
                        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
@@ -3258,6 +4104,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 +4119,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 (
+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
@@ -3289,6 +4144,10 @@ redef class ANeExpr
                        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
@@ -3300,6 +4159,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 +4174,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 (
+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
@@ -3331,6 +4199,10 @@ redef class ALtExpr
                        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
@@ -3342,6 +4214,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,19 +4229,23 @@ 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 (
+redef class AIsaExpr
+       init init_aisaexpr (
                n_expr: nullable AExpr,
-               n_expr2: nullable AExpr
+               n_kwisa: nullable TKwisa,
+               n_type: nullable AType
        )
        do
                _n_expr = n_expr.as(not null)
                n_expr.parent = self
-               _n_expr2 = n_expr2.as(not null)
-               n_expr2.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
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
@@ -3373,8 +4254,12 @@ redef class ALeExpr
                        n_expr = new_child.as(AExpr)
                        return
                end
-               if _n_expr2 == old_child then
-                       n_expr2 = new_child.as(AExpr)
+               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
                end
        end
@@ -3384,9 +4269,14 @@ redef class ALeExpr
                _n_expr = node
                node.parent = self
        end
-       redef fun n_expr2=(node)
+       redef fun n_kwisa=(node)
        do
-               _n_expr2 = node
+               _n_kwisa = node
+               node.parent = self
+       end
+       redef fun n_type=(node)
+       do
+               _n_type = node
                node.parent = self
        end
 
@@ -3394,17 +4284,21 @@ redef class ALeExpr
        redef fun visit_all(v: Visitor)
        do
                v.enter_visit(_n_expr)
-               v.enter_visit(_n_expr2)
+               v.enter_visit(_n_kwisa)
+               v.enter_visit(_n_type)
        end
 end
-redef class ALlExpr
-       init init_allexpr (
+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
@@ -3415,6 +4309,10 @@ redef class ALlExpr
                        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
@@ -3426,6 +4324,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 +4339,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 (
+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
@@ -3457,6 +4364,10 @@ redef class AGtExpr
                        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
@@ -3468,6 +4379,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 +4394,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 (
+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
@@ -3499,6 +4419,10 @@ redef class AGeExpr
                        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
@@ -3510,6 +4434,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 +4449,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 (
+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
@@ -3541,6 +4474,10 @@ redef class AGgExpr
                        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
@@ -3552,6 +4489,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,19 +4504,23 @@ 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 (
+redef class AStarstarExpr
+       init init_astarstarexpr (
                n_expr: nullable AExpr,
-               n_type: nullable AType
+               n_op: nullable TStarstar,
+               n_expr2: nullable AExpr
        )
        do
                _n_expr = n_expr.as(not null)
                n_expr.parent = self
-               _n_type = n_type.as(not null)
-               n_type.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)
@@ -3583,8 +4529,12 @@ redef class AIsaExpr
                        n_expr = new_child.as(AExpr)
                        return
                end
-               if _n_type == old_child then
-                       n_type = new_child.as(AType)
+               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
@@ -3594,9 +4544,14 @@ redef class AIsaExpr
                _n_expr = node
                node.parent = self
        end
-       redef fun n_type=(node)
+       redef fun n_op=(node)
        do
-               _n_type = node
+               _n_op = node
+               node.parent = self
+       end
+       redef fun n_expr2=(node)
+       do
+               _n_expr2 = node
                node.parent = self
        end
 
@@ -3604,17 +4559,21 @@ redef class AIsaExpr
        redef fun visit_all(v: Visitor)
        do
                v.enter_visit(_n_expr)
-               v.enter_visit(_n_type)
+               v.enter_visit(_n_op)
+               v.enter_visit(_n_expr2)
        end
 end
-redef class APlusExpr
-       init init_aplusexpr (
+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
@@ -3625,6 +4584,10 @@ redef class APlusExpr
                        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
@@ -3636,6 +4599,11 @@ redef class APlusExpr
                _n_expr = node
                node.parent = self
        end
+       redef fun n_op=(node)
+       do
+               _n_op = node
+               node.parent = self
+       end
        redef fun n_expr2=(node)
        do
                _n_expr2 = node
@@ -3646,17 +4614,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 +4639,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 +4654,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 +4669,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 +4694,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 +4709,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 +4724,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 +4749,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 +4764,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 +4779,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 +4804,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 +4819,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 +4834,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 +4946,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 +4960,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
@@ -4892,6 +5913,7 @@ redef class ACrangeExpr
        init init_acrangeexpr (
                n_obra: nullable TObra,
                n_expr: nullable AExpr,
+               n_dotdot: nullable TDotdot,
                n_expr2: nullable AExpr,
                n_cbra: nullable TCbra,
                n_annotations: nullable AAnnotations
@@ -4901,6 +5923,8 @@ redef class ACrangeExpr
                n_obra.parent = self
                _n_expr = n_expr.as(not null)
                n_expr.parent = self
+               _n_dotdot = n_dotdot.as(not null)
+               n_dotdot.parent = self
                _n_expr2 = n_expr2.as(not null)
                n_expr2.parent = self
                _n_cbra = n_cbra.as(not null)
@@ -4919,6 +5943,10 @@ redef class ACrangeExpr
                        n_expr = new_child.as(AExpr)
                        return
                end
+               if _n_dotdot == old_child then
+                       n_dotdot = new_child.as(TDotdot)
+                       return
+               end
                if _n_expr2 == old_child then
                        n_expr2 = new_child.as(AExpr)
                        return
@@ -4943,6 +5971,11 @@ redef class ACrangeExpr
                _n_expr = node
                node.parent = self
        end
+       redef fun n_dotdot=(node)
+       do
+               _n_dotdot = node
+               node.parent = self
+       end
        redef fun n_expr2=(node)
        do
                _n_expr2 = node
@@ -4964,6 +5997,7 @@ redef class ACrangeExpr
        do
                v.enter_visit(_n_obra)
                v.enter_visit(_n_expr)
+               v.enter_visit(_n_dotdot)
                v.enter_visit(_n_expr2)
                v.enter_visit(_n_cbra)
                v.enter_visit(_n_annotations)
@@ -4973,6 +6007,7 @@ redef class AOrangeExpr
        init init_aorangeexpr (
                n_obra: nullable TObra,
                n_expr: nullable AExpr,
+               n_dotdot: nullable TDotdot,
                n_expr2: nullable AExpr,
                n_cbra: nullable TObra,
                n_annotations: nullable AAnnotations
@@ -4982,6 +6017,8 @@ redef class AOrangeExpr
                n_obra.parent = self
                _n_expr = n_expr.as(not null)
                n_expr.parent = self
+               _n_dotdot = n_dotdot.as(not null)
+               n_dotdot.parent = self
                _n_expr2 = n_expr2.as(not null)
                n_expr2.parent = self
                _n_cbra = n_cbra.as(not null)
@@ -5000,6 +6037,10 @@ redef class AOrangeExpr
                        n_expr = new_child.as(AExpr)
                        return
                end
+               if _n_dotdot == old_child then
+                       n_dotdot = new_child.as(TDotdot)
+                       return
+               end
                if _n_expr2 == old_child then
                        n_expr2 = new_child.as(AExpr)
                        return
@@ -5024,6 +6065,11 @@ redef class AOrangeExpr
                _n_expr = node
                node.parent = self
        end
+       redef fun n_dotdot=(node)
+       do
+               _n_dotdot = node
+               node.parent = self
+       end
        redef fun n_expr2=(node)
        do
                _n_expr2 = node
@@ -5045,6 +6091,7 @@ redef class AOrangeExpr
        do
                v.enter_visit(_n_obra)
                v.enter_visit(_n_expr)
+               v.enter_visit(_n_dotdot)
                v.enter_visit(_n_expr2)
                v.enter_visit(_n_cbra)
                v.enter_visit(_n_annotations)
@@ -5053,7 +6100,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 +6108,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 +6123,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 +6143,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 +6163,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)
@@ -6052,6 +7090,61 @@ redef class AVarargExpr
                v.enter_visit(_n_dotdotdot)
        end
 end
+redef class ANamedargExpr
+       init init_anamedargexpr (
+               n_id: nullable TId,
+               n_assign: nullable TAssign,
+               n_expr: nullable AExpr
+       )
+       do
+               _n_id = n_id.as(not null)
+               n_id.parent = self
+               _n_assign = n_assign.as(not null)
+               n_assign.parent = self
+               _n_expr = n_expr.as(not null)
+               n_expr.parent = self
+       end
+
+       redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+       do
+               if _n_id == old_child then
+                       n_id = new_child.as(TId)
+                       return
+               end
+               if _n_assign == old_child then
+                       n_assign = new_child.as(TAssign)
+                       return
+               end
+               if _n_expr == old_child then
+                       n_expr = new_child.as(AExpr)
+                       return
+               end
+       end
+
+       redef fun n_id=(node)
+       do
+               _n_id = node
+               node.parent = self
+       end
+       redef fun n_assign=(node)
+       do
+               _n_assign = node
+               node.parent = self
+       end
+       redef fun n_expr=(node)
+       do
+               _n_expr = node
+               node.parent = self
+       end
+
+
+       redef fun visit_all(v: Visitor)
+       do
+               v.enter_visit(_n_id)
+               v.enter_visit(_n_assign)
+               v.enter_visit(_n_expr)
+       end
+end
 redef class ATypeExpr
        init init_atypeexpr (
                n_type: nullable AType
@@ -6286,60 +7379,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
@@ -6908,12 +8262,16 @@ redef class ADoc
 end
 redef class AAnnotations
        init init_aannotations (
+               n_kwis: nullable TKwis,
                n_at: nullable TAt,
                n_opar: nullable TOpar,
                n_items: Collection[Object], # Should be Collection[AAnnotation]
-               n_cpar: nullable TCpar
+               n_cpar: nullable TCpar,
+               n_kwend: nullable TKwend
        )
        do
+               _n_kwis = n_kwis
+               if n_kwis != null then n_kwis.parent = self
                _n_at = n_at
                if n_at != null then n_at.parent = self
                _n_opar = n_opar
@@ -6921,10 +8279,16 @@ redef class AAnnotations
                self.n_items.unsafe_add_all(n_items)
                _n_cpar = n_cpar
                if n_cpar != null then n_cpar.parent = self
+               _n_kwend = n_kwend
+               if n_kwend != null then n_kwend.parent = self
        end
 
        redef fun replace_child(old_child: ANode, new_child: nullable ANode)
        do
+               if _n_kwis == old_child then
+                       n_kwis = new_child.as(nullable TKwis)
+                       return
+               end
                if _n_at == old_child then
                        n_at = new_child.as(nullable TAt)
                        return
@@ -6938,8 +8302,17 @@ redef class AAnnotations
                        n_cpar = new_child.as(nullable TCpar)
                        return
                end
+               if _n_kwend == old_child then
+                       n_kwend = new_child.as(nullable TKwend)
+                       return
+               end
        end
 
+       redef fun n_kwis=(node)
+       do
+               _n_kwis = node
+               if node != null then node.parent = self
+       end
        redef fun n_at=(node)
        do
                _n_at = node
@@ -6955,14 +8328,21 @@ redef class AAnnotations
                _n_cpar = node
                if node != null then node.parent = self
        end
+       redef fun n_kwend=(node)
+       do
+               _n_kwend = node
+               if node != null then node.parent = self
+       end
 
 
        redef fun visit_all(v: Visitor)
        do
+               v.enter_visit(_n_kwis)
                v.enter_visit(_n_at)
                v.enter_visit(_n_opar)
                n_items.visit_all(v)
                v.enter_visit(_n_cpar)
+               v.enter_visit(_n_kwend)
        end
 end
 redef class AAnnotation
Nit language project; an oo programing language and its tool suite.