X-Git-Url: http://nitlanguage.org

diff --git a/src/parser/parser_prod.nit b/src/parser/parser_prod.nit
index 5ca9042..f3826dc 100644
--- a/src/parser/parser_prod.nit
+++ b/src/parser/parser_prod.nit
@@ -387,7 +387,9 @@ redef class AStdClassdef
 		n_visibility: nullable AVisibility,
 		n_classkind: nullable AClasskind,
 		n_id: nullable TClassid,
+		n_obra: nullable TObra,
 		n_formaldefs: Collection[Object], # Should be Collection[AFormaldef]
+		n_cbra: nullable TCbra,
 		n_extern_code_block: nullable AExternCodeBlock,
 		n_propdefs: Collection[Object], # Should be Collection[APropdef]
 		n_kwend: nullable TKwend
@@ -403,7 +405,11 @@ redef class AStdClassdef
 		n_classkind.parent = self
 		_n_id = n_id
 		if n_id != null then n_id.parent = self
+		_n_obra = n_obra
+		if n_obra != null then n_obra.parent = self
 		self.n_formaldefs.unsafe_add_all(n_formaldefs)
+		_n_cbra = n_cbra
+		if n_cbra != null then n_cbra.parent = self
 		_n_extern_code_block = n_extern_code_block
 		if n_extern_code_block != null then n_extern_code_block.parent = self
 		self.n_propdefs.unsafe_add_all(n_propdefs)
@@ -433,7 +439,15 @@ redef class AStdClassdef
 			n_id = new_child.as(nullable TClassid)
 			return
 		end
+		if _n_obra == old_child then
+			n_obra = new_child.as(nullable TObra)
+			return
+		end
 		if n_formaldefs.replace_child(old_child, new_child) then return
+		if _n_cbra == old_child then
+			n_cbra = new_child.as(nullable TCbra)
+			return
+		end
 		if _n_extern_code_block == old_child then
 			n_extern_code_block = new_child.as(nullable AExternCodeBlock)
 			return
@@ -470,6 +484,16 @@ redef class AStdClassdef
 		_n_id = node
 		if node != null then node.parent = self
 	end
+	redef fun n_obra=(node)
+	do
+		_n_obra = node
+		if node != null then node.parent = self
+	end
+	redef fun n_cbra=(node)
+	do
+		_n_cbra = node
+		if node != null then node.parent = self
+	end
 	redef fun n_extern_code_block=(node)
 	do
 		_n_extern_code_block = node
@@ -489,7 +513,9 @@ redef class AStdClassdef
 		v.enter_visit(_n_visibility)
 		v.enter_visit(_n_classkind)
 		v.enter_visit(_n_id)
+		v.enter_visit(_n_obra)
 		n_formaldefs.visit_all(v)
+		v.enter_visit(_n_cbra)
 		v.enter_visit(_n_extern_code_block)
 		n_propdefs.visit_all(v)
 		v.enter_visit(_n_kwend)
@@ -769,9 +795,12 @@ redef class AAttrPropdef
 		n_kwvar: nullable TKwvar,
 		n_id2: nullable TId,
 		n_type: nullable AType,
+		n_assign: nullable TAssign,
 		n_expr: nullable AExpr,
 		n_annotations: nullable AAnnotations,
-		n_block: nullable AExpr
+		n_kwdo: nullable TKwdo,
+		n_block: nullable AExpr,
+		n_kwend: nullable TKwend
 	)
 	do
 		_n_doc = n_doc
@@ -786,12 +815,18 @@ redef class AAttrPropdef
 		n_id2.parent = self
 		_n_type = n_type
 		if n_type != null then n_type.parent = self
+		_n_assign = n_assign
+		if n_assign != null then n_assign.parent = self
 		_n_expr = n_expr
 		if n_expr != null then n_expr.parent = self
 		_n_annotations = n_annotations
 		if n_annotations != null then n_annotations.parent = self
+		_n_kwdo = n_kwdo
+		if n_kwdo != null then n_kwdo.parent = self
 		_n_block = n_block
 		if n_block != null then n_block.parent = self
+		_n_kwend = n_kwend
+		if n_kwend != null then n_kwend.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
@@ -820,6 +855,10 @@ redef class AAttrPropdef
 			n_type = new_child.as(nullable AType)
 			return
 		end
+		if _n_assign == old_child then
+			n_assign = new_child.as(nullable TAssign)
+			return
+		end
 		if _n_expr == old_child then
 			n_expr = new_child.as(nullable AExpr)
 			return
@@ -828,10 +867,18 @@ redef class AAttrPropdef
 			n_annotations = new_child.as(nullable AAnnotations)
 			return
 		end
+		if _n_kwdo == old_child then
+			n_kwdo = new_child.as(nullable TKwdo)
+			return
+		end
 		if _n_block == old_child then
 			n_block = new_child.as(nullable AExpr)
 			return
 		end
+		if _n_kwend == old_child then
+			n_kwend = new_child.as(nullable TKwend)
+			return
+		end
 	end
 
 	redef fun n_doc=(node)
@@ -864,6 +911,11 @@ redef class AAttrPropdef
 		_n_type = node
 		if node != null then node.parent = self
 	end
+	redef fun n_assign=(node)
+	do
+		_n_assign = node
+		if node != null then node.parent = self
+	end
 	redef fun n_expr=(node)
 	do
 		_n_expr = node
@@ -874,11 +926,21 @@ redef class AAttrPropdef
 		_n_annotations = node
 		if node != null then node.parent = self
 	end
+	redef fun n_kwdo=(node)
+	do
+		_n_kwdo = node
+		if node != null then node.parent = self
+	end
 	redef fun n_block=(node)
 	do
 		_n_block = node
 		if node != null then node.parent = self
 	end
+	redef fun n_kwend=(node)
+	do
+		_n_kwend = node
+		if node != null then node.parent = self
+	end
 
 
 	redef fun visit_all(v: Visitor)
@@ -889,9 +951,12 @@ redef class AAttrPropdef
 		v.enter_visit(_n_kwvar)
 		v.enter_visit(_n_id2)
 		v.enter_visit(_n_type)
+		v.enter_visit(_n_assign)
 		v.enter_visit(_n_expr)
 		v.enter_visit(_n_annotations)
+		v.enter_visit(_n_kwdo)
 		v.enter_visit(_n_block)
+		v.enter_visit(_n_kwend)
 	end
 end
 redef class AMainMethPropdef
@@ -1056,7 +1121,9 @@ redef class AMethPropdef
 		n_annotations: nullable AAnnotations,
 		n_extern_calls: nullable AExternCalls,
 		n_extern_code_block: nullable AExternCodeBlock,
-		n_block: nullable AExpr
+		n_kwdo: nullable TKwdo,
+		n_block: nullable AExpr,
+		n_kwend: nullable TKwend
 	)
 	do
 		_n_doc = n_doc
@@ -1081,8 +1148,12 @@ redef class AMethPropdef
 		if n_extern_calls != null then n_extern_calls.parent = self
 		_n_extern_code_block = n_extern_code_block
 		if n_extern_code_block != null then n_extern_code_block.parent = self
+		_n_kwdo = n_kwdo
+		if n_kwdo != null then n_kwdo.parent = self
 		_n_block = n_block
 		if n_block != null then n_block.parent = self
+		_n_kwend = n_kwend
+		if n_kwend != null then n_kwend.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
@@ -1131,10 +1202,18 @@ redef class AMethPropdef
 			n_extern_code_block = new_child.as(nullable AExternCodeBlock)
 			return
 		end
+		if _n_kwdo == old_child then
+			n_kwdo = new_child.as(nullable TKwdo)
+			return
+		end
 		if _n_block == old_child then
 			n_block = new_child.as(nullable AExpr)
 			return
 		end
+		if _n_kwend == old_child then
+			n_kwend = new_child.as(nullable TKwend)
+			return
+		end
 	end
 
 	redef fun n_doc=(node)
@@ -1192,11 +1271,21 @@ redef class AMethPropdef
 		_n_extern_code_block = node
 		if node != null then node.parent = self
 	end
+	redef fun n_kwdo=(node)
+	do
+		_n_kwdo = node
+		if node != null then node.parent = self
+	end
 	redef fun n_block=(node)
 	do
 		_n_block = node
 		if node != null then node.parent = self
 	end
+	redef fun n_kwend=(node)
+	do
+		_n_kwend = node
+		if node != null then node.parent = self
+	end
 
 
 	redef fun visit_all(v: Visitor)
@@ -1212,7 +1301,9 @@ redef class AMethPropdef
 		v.enter_visit(_n_annotations)
 		v.enter_visit(_n_extern_calls)
 		v.enter_visit(_n_extern_code_block)
+		v.enter_visit(_n_kwdo)
 		v.enter_visit(_n_block)
+		v.enter_visit(_n_kwend)
 	end
 end
 redef class ASuperPropdef
@@ -1451,531 +1542,647 @@ redef class AIdMethid
 end
 redef class APlusMethid
 	init init_aplusmethid (
-		n_plus: nullable TPlus
+		n_op: nullable TPlus
 	)
 	do
-		_n_plus = n_plus.as(not null)
-		n_plus.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_plus == old_child then
-			n_plus = new_child.as(TPlus)
+		if _n_op == old_child then
+			n_op = new_child.as(TPlus)
 			return
 		end
 	end
 
-	redef fun n_plus=(node)
+	redef fun n_op=(node)
 	do
-		_n_plus = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_plus)
+		v.enter_visit(_n_op)
 	end
 end
 redef class AMinusMethid
 	init init_aminusmethid (
-		n_minus: nullable TMinus
+		n_op: nullable TMinus
 	)
 	do
-		_n_minus = n_minus.as(not null)
-		n_minus.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_minus == old_child then
-			n_minus = new_child.as(TMinus)
+		if _n_op == old_child then
+			n_op = new_child.as(TMinus)
 			return
 		end
 	end
 
-	redef fun n_minus=(node)
+	redef fun n_op=(node)
 	do
-		_n_minus = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_minus)
+		v.enter_visit(_n_op)
 	end
 end
 redef class AStarMethid
 	init init_astarmethid (
-		n_star: nullable TStar
+		n_op: nullable TStar
 	)
 	do
-		_n_star = n_star.as(not null)
-		n_star.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_star == old_child then
-			n_star = new_child.as(TStar)
+		if _n_op == old_child then
+			n_op = new_child.as(TStar)
 			return
 		end
 	end
 
-	redef fun n_star=(node)
+	redef fun n_op=(node)
 	do
-		_n_star = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_star)
+		v.enter_visit(_n_op)
 	end
 end
 redef class AStarstarMethid
 	init init_astarstarmethid (
-		n_starstar: nullable TStarstar
+		n_op: nullable TStarstar
 	)
 	do
-		_n_starstar = n_starstar.as(not null)
-		n_starstar.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_starstar == old_child then
-			n_starstar = new_child.as(TStarstar)
+		if _n_op == old_child then
+			n_op = new_child.as(TStarstar)
 			return
 		end
 	end
 
-	redef fun n_starstar=(node)
+	redef fun n_op=(node)
 	do
-		_n_starstar = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_starstar)
+		v.enter_visit(_n_op)
 	end
 end
 redef class ASlashMethid
 	init init_aslashmethid (
-		n_slash: nullable TSlash
+		n_op: nullable TSlash
 	)
 	do
-		_n_slash = n_slash.as(not null)
-		n_slash.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_slash == old_child then
-			n_slash = new_child.as(TSlash)
+		if _n_op == old_child then
+			n_op = new_child.as(TSlash)
 			return
 		end
 	end
 
-	redef fun n_slash=(node)
+	redef fun n_op=(node)
 	do
-		_n_slash = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_slash)
+		v.enter_visit(_n_op)
 	end
 end
 redef class APercentMethid
 	init init_apercentmethid (
-		n_percent: nullable TPercent
+		n_op: nullable TPercent
 	)
 	do
-		_n_percent = n_percent.as(not null)
-		n_percent.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_percent == old_child then
-			n_percent = new_child.as(TPercent)
+		if _n_op == old_child then
+			n_op = new_child.as(TPercent)
 			return
 		end
 	end
 
-	redef fun n_percent=(node)
+	redef fun n_op=(node)
 	do
-		_n_percent = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_percent)
+		v.enter_visit(_n_op)
 	end
 end
 redef class AEqMethid
 	init init_aeqmethid (
-		n_eq: nullable TEq
+		n_op: nullable TEq
 	)
 	do
-		_n_eq = n_eq.as(not null)
-		n_eq.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_eq == old_child then
-			n_eq = new_child.as(TEq)
+		if _n_op == old_child then
+			n_op = new_child.as(TEq)
 			return
 		end
 	end
 
-	redef fun n_eq=(node)
+	redef fun n_op=(node)
 	do
-		_n_eq = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_eq)
+		v.enter_visit(_n_op)
 	end
 end
 redef class ANeMethid
 	init init_anemethid (
-		n_ne: nullable TNe
+		n_op: nullable TNe
 	)
 	do
-		_n_ne = n_ne.as(not null)
-		n_ne.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_ne == old_child then
-			n_ne = new_child.as(TNe)
+		if _n_op == old_child then
+			n_op = new_child.as(TNe)
 			return
 		end
 	end
 
-	redef fun n_ne=(node)
+	redef fun n_op=(node)
 	do
-		_n_ne = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_ne)
+		v.enter_visit(_n_op)
 	end
 end
 redef class ALeMethid
 	init init_alemethid (
-		n_le: nullable TLe
+		n_op: nullable TLe
 	)
 	do
-		_n_le = n_le.as(not null)
-		n_le.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_le == old_child then
-			n_le = new_child.as(TLe)
+		if _n_op == old_child then
+			n_op = new_child.as(TLe)
 			return
 		end
 	end
 
-	redef fun n_le=(node)
+	redef fun n_op=(node)
 	do
-		_n_le = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_le)
+		v.enter_visit(_n_op)
 	end
 end
 redef class AGeMethid
 	init init_agemethid (
-		n_ge: nullable TGe
+		n_op: nullable TGe
 	)
 	do
-		_n_ge = n_ge.as(not null)
-		n_ge.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_ge == old_child then
-			n_ge = new_child.as(TGe)
+		if _n_op == old_child then
+			n_op = new_child.as(TGe)
 			return
 		end
 	end
 
-	redef fun n_ge=(node)
+	redef fun n_op=(node)
 	do
-		_n_ge = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_ge)
+		v.enter_visit(_n_op)
 	end
 end
 redef class ALtMethid
 	init init_altmethid (
-		n_lt: nullable TLt
+		n_op: nullable TLt
 	)
 	do
-		_n_lt = n_lt.as(not null)
-		n_lt.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_lt == old_child then
-			n_lt = new_child.as(TLt)
+		if _n_op == old_child then
+			n_op = new_child.as(TLt)
 			return
 		end
 	end
 
-	redef fun n_lt=(node)
+	redef fun n_op=(node)
 	do
-		_n_lt = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_lt)
+		v.enter_visit(_n_op)
 	end
 end
 redef class AGtMethid
 	init init_agtmethid (
-		n_gt: nullable TGt
+		n_op: nullable TGt
 	)
 	do
-		_n_gt = n_gt.as(not null)
-		n_gt.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_gt == old_child then
-			n_gt = new_child.as(TGt)
+		if _n_op == old_child then
+			n_op = new_child.as(TGt)
 			return
 		end
 	end
 
-	redef fun n_gt=(node)
+	redef fun n_op=(node)
 	do
-		_n_gt = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_gt)
+		v.enter_visit(_n_op)
 	end
 end
 redef class ALlMethid
 	init init_allmethid (
-		n_ll: nullable TLl
+		n_op: nullable TLl
 	)
 	do
-		_n_ll = n_ll.as(not null)
-		n_ll.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_ll == old_child then
-			n_ll = new_child.as(TLl)
+		if _n_op == old_child then
+			n_op = new_child.as(TLl)
 			return
 		end
 	end
 
-	redef fun n_ll=(node)
+	redef fun n_op=(node)
 	do
-		_n_ll = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_ll)
+		v.enter_visit(_n_op)
 	end
 end
 redef class AGgMethid
 	init init_aggmethid (
-		n_gg: nullable TGg
+		n_op: nullable TGg
 	)
 	do
-		_n_gg = n_gg.as(not null)
-		n_gg.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_gg == old_child then
-			n_gg = new_child.as(TGg)
+		if _n_op == old_child then
+			n_op = new_child.as(TGg)
 			return
 		end
 	end
 
-	redef fun n_gg=(node)
+	redef fun n_op=(node)
 	do
-		_n_gg = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_gg)
+		v.enter_visit(_n_op)
 	end
 end
-redef class ABraMethid
-	init init_abramethid (
-		n_obra: nullable TObra,
-		n_cbra: nullable TCbra
+redef class AStarshipMethid
+	init init_astarshipmethid (
+		n_op: nullable TStarship
 	)
 	do
-		_n_obra = n_obra.as(not null)
-		n_obra.parent = self
-		_n_cbra = n_cbra.as(not null)
-		n_cbra.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_obra == old_child then
-			n_obra = new_child.as(TObra)
-			return
-		end
-		if _n_cbra == old_child then
-			n_cbra = new_child.as(TCbra)
+		if _n_op == old_child then
+			n_op = new_child.as(TStarship)
 			return
 		end
 	end
 
-	redef fun n_obra=(node)
-	do
-		_n_obra = node
-		node.parent = self
-	end
-	redef fun n_cbra=(node)
+	redef fun n_op=(node)
 	do
-		_n_cbra = node
+		_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 APipeMethid
+	init init_apipemethid (
+		n_op: nullable TPipe
 	)
 	do
-		_n_starship = n_starship.as(not null)
-		n_starship.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_starship == old_child then
-			n_starship = new_child.as(TStarship)
+		if _n_op == old_child then
+			n_op = new_child.as(TPipe)
 			return
 		end
 	end
 
-	redef fun n_starship=(node)
+	redef fun n_op=(node)
 	do
-		_n_starship = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_starship)
+		v.enter_visit(_n_op)
 	end
 end
-redef class AAssignMethid
-	init init_aassignmethid (
-		n_id: nullable TId,
-		n_assign: nullable TAssign
+redef class ACaretMethid
+	init init_acaretmethid (
+		n_op: nullable TCaret
 	)
 	do
-		_n_id = n_id.as(not null)
-		n_id.parent = self
-		_n_assign = n_assign.as(not null)
-		n_assign.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_id == old_child then
-			n_id = new_child.as(TId)
-			return
-		end
-		if _n_assign == old_child then
-			n_assign = new_child.as(TAssign)
+		if _n_op == old_child then
+			n_op = new_child.as(TCaret)
 			return
 		end
 	end
 
-	redef fun n_id=(node)
-	do
-		_n_id = node
-		node.parent = self
-	end
-	redef fun n_assign=(node)
+	redef fun n_op=(node)
 	do
-		_n_assign = node
+		_n_op = 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_op)
 	end
 end
-redef class ABraassignMethid
-	init init_abraassignmethid (
-		n_obra: nullable TObra,
-		n_cbra: nullable TCbra,
-		n_assign: nullable TAssign
+redef class AAmpMethid
+	init init_aampmethid (
+		n_op: nullable TAmp
 	)
 	do
-		_n_obra = n_obra.as(not null)
+		_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_obra = n_obra.as(not null)
+		n_obra.parent = self
+		_n_cbra = n_cbra.as(not null)
+		n_cbra.parent = self
+	end
+
+	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+	do
+		if _n_obra == old_child then
+			n_obra = new_child.as(TObra)
+			return
+		end
+		if _n_cbra == old_child then
+			n_cbra = new_child.as(TCbra)
+			return
+		end
+	end
+
+	redef fun n_obra=(node)
+	do
+		_n_obra = node
+		node.parent = self
+	end
+	redef fun n_cbra=(node)
+	do
+		_n_cbra = node
+		node.parent = self
+	end
+
+
+	redef fun visit_all(v: Visitor)
+	do
+		v.enter_visit(_n_obra)
+		v.enter_visit(_n_cbra)
+	end
+end
+redef class AAssignMethid
+	init init_aassignmethid (
+		n_id: nullable TId,
+		n_assign: nullable TAssign
+	)
+	do
+		_n_id = n_id.as(not null)
+		n_id.parent = self
+		_n_assign = n_assign.as(not null)
+		n_assign.parent = self
+	end
+
+	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+	do
+		if _n_id == old_child then
+			n_id = new_child.as(TId)
+			return
+		end
+		if _n_assign == old_child then
+			n_assign = new_child.as(TAssign)
+			return
+		end
+	end
+
+	redef fun n_id=(node)
+	do
+		_n_id = node
+		node.parent = self
+	end
+	redef fun n_assign=(node)
+	do
+		_n_assign = node
+		node.parent = self
+	end
+
+
+	redef fun visit_all(v: Visitor)
+	do
+		v.enter_visit(_n_id)
+		v.enter_visit(_n_assign)
+	end
+end
+redef class ABraassignMethid
+	init init_abraassignmethid (
+		n_obra: nullable TObra,
+		n_cbra: nullable TCbra,
+		n_assign: nullable TAssign
+	)
+	do
+		_n_obra = n_obra.as(not null)
 		n_obra.parent = self
 		_n_cbra = n_cbra.as(not null)
 		n_cbra.parent = self
@@ -2154,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
@@ -2162,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
@@ -2177,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
@@ -2194,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
@@ -2205,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
@@ -2592,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
@@ -2600,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
@@ -2616,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
@@ -2636,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
@@ -2652,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
@@ -2890,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,
@@ -2899,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)
@@ -2916,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
@@ -2939,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
@@ -2965,6 +3236,7 @@ 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)
@@ -3057,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
@@ -3066,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
@@ -3084,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
@@ -3105,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
@@ -3117,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
@@ -4388,75 +4673,240 @@ redef class APercentExpr
 		v.enter_visit(_n_expr2)
 	end
 end
-redef class AUminusExpr
-	init init_auminusexpr (
-		n_minus: nullable TMinus,
-		n_expr: nullable AExpr
+redef class APipeExpr
+	init init_apipeexpr (
+		n_expr: nullable AExpr,
+		n_op: nullable TPipe,
+		n_expr2: nullable AExpr
 	)
 	do
-		_n_minus = n_minus.as(not null)
-		n_minus.parent = self
 		_n_expr = n_expr.as(not null)
 		n_expr.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
+		_n_expr2 = n_expr2.as(not null)
+		n_expr2.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_minus == old_child then
-			n_minus = new_child.as(TMinus)
-			return
-		end
 		if _n_expr == old_child then
 			n_expr = new_child.as(AExpr)
 			return
 		end
+		if _n_op == old_child then
+			n_op = new_child.as(TPipe)
+			return
+		end
+		if _n_expr2 == old_child then
+			n_expr2 = new_child.as(AExpr)
+			return
+		end
 	end
 
-	redef fun n_minus=(node)
+	redef fun n_expr=(node)
 	do
-		_n_minus = node
+		_n_expr = node
 		node.parent = self
 	end
-	redef fun n_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_minus)
 		v.enter_visit(_n_expr)
+		v.enter_visit(_n_op)
+		v.enter_visit(_n_expr2)
 	end
 end
-redef class AUplusExpr
-	init init_auplusexpr (
-		n_plus: nullable TPlus,
-		n_expr: nullable AExpr
+redef class ACaretExpr
+	init init_acaretexpr (
+		n_expr: nullable AExpr,
+		n_op: nullable TCaret,
+		n_expr2: nullable AExpr
 	)
 	do
-		_n_plus = n_plus.as(not null)
-		n_plus.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_plus == old_child then
-			n_plus = new_child.as(TPlus)
-			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(TCaret)
+			return
+		end
+		if _n_expr2 == old_child then
+			n_expr2 = new_child.as(AExpr)
+			return
+		end
 	end
 
-	redef fun n_plus=(node)
+	redef fun n_expr=(node)
 	do
-		_n_plus = node
+		_n_expr = node
+		node.parent = self
+	end
+	redef fun n_op=(node)
+	do
+		_n_op = node
+		node.parent = self
+	end
+	redef fun n_expr2=(node)
+	do
+		_n_expr2 = node
+		node.parent = self
+	end
+
+
+	redef fun visit_all(v: Visitor)
+	do
+		v.enter_visit(_n_expr)
+		v.enter_visit(_n_op)
+		v.enter_visit(_n_expr2)
+	end
+end
+redef class AAmpExpr
+	init init_aampexpr (
+		n_expr: nullable AExpr,
+		n_op: nullable TAmp,
+		n_expr2: nullable AExpr
+	)
+	do
+		_n_expr = n_expr.as(not null)
+		n_expr.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
+		_n_expr2 = n_expr2.as(not null)
+		n_expr2.parent = self
+	end
+
+	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+	do
+		if _n_expr == old_child then
+			n_expr = new_child.as(AExpr)
+			return
+		end
+		if _n_op == old_child then
+			n_op = new_child.as(TAmp)
+			return
+		end
+		if _n_expr2 == old_child then
+			n_expr2 = new_child.as(AExpr)
+			return
+		end
+	end
+
+	redef fun n_expr=(node)
+	do
+		_n_expr = node
+		node.parent = self
+	end
+	redef fun n_op=(node)
+	do
+		_n_op = node
+		node.parent = self
+	end
+	redef fun n_expr2=(node)
+	do
+		_n_expr2 = node
+		node.parent = self
+	end
+
+
+	redef fun visit_all(v: Visitor)
+	do
+		v.enter_visit(_n_expr)
+		v.enter_visit(_n_op)
+		v.enter_visit(_n_expr2)
+	end
+end
+redef class AUminusExpr
+	init init_auminusexpr (
+		n_op: nullable TMinus,
+		n_expr: nullable AExpr
+	)
+	do
+		_n_op = n_op.as(not null)
+		n_op.parent = self
+		_n_expr = n_expr.as(not null)
+		n_expr.parent = self
+	end
+
+	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+	do
+		if _n_op == old_child then
+			n_op = new_child.as(TMinus)
+			return
+		end
+		if _n_expr == old_child then
+			n_expr = new_child.as(AExpr)
+			return
+		end
+	end
+
+	redef fun n_op=(node)
+	do
+		_n_op = node
+		node.parent = self
+	end
+	redef fun n_expr=(node)
+	do
+		_n_expr = node
+		node.parent = self
+	end
+
+
+	redef fun visit_all(v: Visitor)
+	do
+		v.enter_visit(_n_op)
+		v.enter_visit(_n_expr)
+	end
+end
+redef class AUplusExpr
+	init init_auplusexpr (
+		n_op: nullable TPlus,
+		n_expr: nullable AExpr
+	)
+	do
+		_n_op = n_op.as(not null)
+		n_op.parent = self
+		_n_expr = n_expr.as(not null)
+		n_expr.parent = self
+	end
+
+	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+	do
+		if _n_op == old_child then
+			n_op = new_child.as(TPlus)
+			return
+		end
+		if _n_expr == old_child then
+			n_expr = new_child.as(AExpr)
+			return
+		end
+	end
+
+	redef fun n_op=(node)
+	do
+		_n_op = node
 		node.parent = self
 	end
 	redef fun n_expr=(node)
@@ -4468,7 +4918,49 @@ redef class AUplusExpr
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_plus)
+		v.enter_visit(_n_op)
+		v.enter_visit(_n_expr)
+	end
+end
+redef class AUtildeExpr
+	init init_autildeexpr (
+		n_op: nullable TTilde,
+		n_expr: nullable AExpr
+	)
+	do
+		_n_op = n_op.as(not null)
+		n_op.parent = self
+		_n_expr = n_expr.as(not null)
+		n_expr.parent = self
+	end
+
+	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+	do
+		if _n_op == old_child then
+			n_op = new_child.as(TTilde)
+			return
+		end
+		if _n_expr == old_child then
+			n_expr = new_child.as(AExpr)
+			return
+		end
+	end
+
+	redef fun n_op=(node)
+	do
+		_n_op = node
+		node.parent = self
+	end
+	redef fun n_expr=(node)
+	do
+		_n_expr = node
+		node.parent = self
+	end
+
+
+	redef fun visit_all(v: Visitor)
+	do
+		v.enter_visit(_n_op)
 		v.enter_visit(_n_expr)
 	end
 end
@@ -5421,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
@@ -5430,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)
@@ -5448,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
@@ -5472,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
@@ -5493,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)
@@ -5502,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
@@ -5511,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)
@@ -5529,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
@@ -5553,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
@@ -5574,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)
@@ -5630,9 +6148,237 @@ redef class AArrayExpr
 		_n_type = node
 		if node != null then node.parent = self
 	end
-	redef fun n_cbra=(node)
+	redef fun n_cbra=(node)
+	do
+		_n_cbra = 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_obra)
+		n_exprs.visit_all(v)
+		v.enter_visit(_n_type)
+		v.enter_visit(_n_cbra)
+		v.enter_visit(_n_annotations)
+	end
+end
+redef class ASelfExpr
+	init init_aselfexpr (
+		n_kwself: nullable TKwself,
+		n_annotations: nullable AAnnotations
+	)
+	do
+		_n_kwself = n_kwself.as(not null)
+		n_kwself.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_kwself == old_child then
+			n_kwself = new_child.as(TKwself)
+			return
+		end
+		if _n_annotations == old_child then
+			n_annotations = new_child.as(nullable AAnnotations)
+			return
+		end
+	end
+
+	redef fun n_kwself=(node)
+	do
+		_n_kwself = 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_kwself)
+		v.enter_visit(_n_annotations)
+	end
+end
+redef class AImplicitSelfExpr
+	init init_aimplicitselfexpr
+	do
+	end
+
+	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+	do
+	end
+
+
+
+	redef fun visit_all(v: Visitor)
+	do
+	end
+end
+redef class ATrueExpr
+	init init_atrueexpr (
+		n_kwtrue: nullable TKwtrue,
+		n_annotations: nullable AAnnotations
+	)
+	do
+		_n_kwtrue = n_kwtrue.as(not null)
+		n_kwtrue.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_kwtrue == old_child then
+			n_kwtrue = new_child.as(TKwtrue)
+			return
+		end
+		if _n_annotations == old_child then
+			n_annotations = new_child.as(nullable AAnnotations)
+			return
+		end
+	end
+
+	redef fun n_kwtrue=(node)
+	do
+		_n_kwtrue = 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_kwtrue)
+		v.enter_visit(_n_annotations)
+	end
+end
+redef class AFalseExpr
+	init init_afalseexpr (
+		n_kwfalse: nullable TKwfalse,
+		n_annotations: nullable AAnnotations
+	)
+	do
+		_n_kwfalse = n_kwfalse.as(not null)
+		n_kwfalse.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_kwfalse == old_child then
+			n_kwfalse = new_child.as(TKwfalse)
+			return
+		end
+		if _n_annotations == old_child then
+			n_annotations = new_child.as(nullable AAnnotations)
+			return
+		end
+	end
+
+	redef fun n_kwfalse=(node)
+	do
+		_n_kwfalse = 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_kwfalse)
+		v.enter_visit(_n_annotations)
+	end
+end
+redef class ANullExpr
+	init init_anullexpr (
+		n_kwnull: nullable TKwnull,
+		n_annotations: nullable AAnnotations
+	)
+	do
+		_n_kwnull = n_kwnull.as(not null)
+		n_kwnull.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_kwnull == old_child then
+			n_kwnull = new_child.as(TKwnull)
+			return
+		end
+		if _n_annotations == old_child then
+			n_annotations = new_child.as(nullable AAnnotations)
+			return
+		end
+	end
+
+	redef fun n_kwnull=(node)
+	do
+		_n_kwnull = 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_kwnull)
+		v.enter_visit(_n_annotations)
+	end
+end
+redef class ADecIntExpr
+	init init_adecintexpr (
+		n_number: nullable TNumber,
+		n_annotations: nullable AAnnotations
+	)
+	do
+		_n_number = n_number.as(not null)
+		n_number.parent = self
+		_n_annotations = n_annotations
+		if n_annotations != null then n_annotations.parent = self
+	end
+
+	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+	do
+		if _n_number == old_child then
+			n_number = new_child.as(TNumber)
+			return
+		end
+		if _n_annotations == old_child then
+			n_annotations = new_child.as(nullable AAnnotations)
+			return
+		end
+	end
+
+	redef fun n_number=(node)
 	do
-		_n_cbra = node
+		_n_number = node
 		node.parent = self
 	end
 	redef fun n_annotations=(node)
@@ -5644,29 +6390,26 @@ redef class AArrayExpr
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_obra)
-		n_exprs.visit_all(v)
-		v.enter_visit(_n_type)
-		v.enter_visit(_n_cbra)
+		v.enter_visit(_n_number)
 		v.enter_visit(_n_annotations)
 	end
 end
-redef class ASelfExpr
-	init init_aselfexpr (
-		n_kwself: nullable TKwself,
+redef class AHexIntExpr
+	init init_ahexintexpr (
+		n_hex_number: nullable THexNumber,
 		n_annotations: nullable AAnnotations
 	)
 	do
-		_n_kwself = n_kwself.as(not null)
-		n_kwself.parent = self
+		_n_hex_number = n_hex_number.as(not null)
+		n_hex_number.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_kwself == old_child then
-			n_kwself = new_child.as(TKwself)
+		if _n_hex_number == old_child then
+			n_hex_number = new_child.as(THexNumber)
 			return
 		end
 		if _n_annotations == old_child then
@@ -5675,9 +6418,9 @@ redef class ASelfExpr
 		end
 	end
 
-	redef fun n_kwself=(node)
+	redef fun n_hex_number=(node)
 	do
-		_n_kwself = node
+		_n_hex_number = node
 		node.parent = self
 	end
 	redef fun n_annotations=(node)
@@ -5689,41 +6432,68 @@ redef class ASelfExpr
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_kwself)
+		v.enter_visit(_n_hex_number)
 		v.enter_visit(_n_annotations)
 	end
 end
-redef class AImplicitSelfExpr
-	init init_aimplicitselfexpr
+redef class ABinIntExpr
+	init init_abinintexpr (
+		n_bin_number: nullable TBinNumber,
+		n_annotations: nullable AAnnotations
+	)
 	do
+		_n_bin_number = n_bin_number.as(not null)
+		n_bin_number.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_bin_number == old_child then
+			n_bin_number = new_child.as(TBinNumber)
+			return
+		end
+		if _n_annotations == old_child then
+			n_annotations = new_child.as(nullable AAnnotations)
+			return
+		end
 	end
 
+	redef fun n_bin_number=(node)
+	do
+		_n_bin_number = 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_bin_number)
+		v.enter_visit(_n_annotations)
 	end
 end
-redef class ATrueExpr
-	init init_atrueexpr (
-		n_kwtrue: nullable TKwtrue,
+redef class AOctIntExpr
+	init init_aoctintexpr (
+		n_oct_number: nullable TOctNumber,
 		n_annotations: nullable AAnnotations
 	)
 	do
-		_n_kwtrue = n_kwtrue.as(not null)
-		n_kwtrue.parent = self
+		_n_oct_number = n_oct_number.as(not null)
+		n_oct_number.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_kwtrue == old_child then
-			n_kwtrue = new_child.as(TKwtrue)
+		if _n_oct_number == old_child then
+			n_oct_number = new_child.as(TOctNumber)
 			return
 		end
 		if _n_annotations == old_child then
@@ -5732,9 +6502,9 @@ redef class ATrueExpr
 		end
 	end
 
-	redef fun n_kwtrue=(node)
+	redef fun n_oct_number=(node)
 	do
-		_n_kwtrue = node
+		_n_oct_number = node
 		node.parent = self
 	end
 	redef fun n_annotations=(node)
@@ -5746,26 +6516,26 @@ redef class ATrueExpr
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_kwtrue)
+		v.enter_visit(_n_oct_number)
 		v.enter_visit(_n_annotations)
 	end
 end
-redef class AFalseExpr
-	init init_afalseexpr (
-		n_kwfalse: nullable TKwfalse,
+redef class ADecByteExpr
+	init init_adecbyteexpr (
+		n_bytenum: nullable TBytenum,
 		n_annotations: nullable AAnnotations
 	)
 	do
-		_n_kwfalse = n_kwfalse.as(not null)
-		n_kwfalse.parent = self
+		_n_bytenum = n_bytenum.as(not null)
+		n_bytenum.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_kwfalse == old_child then
-			n_kwfalse = new_child.as(TKwfalse)
+		if _n_bytenum == old_child then
+			n_bytenum = new_child.as(TBytenum)
 			return
 		end
 		if _n_annotations == old_child then
@@ -5774,9 +6544,9 @@ redef class AFalseExpr
 		end
 	end
 
-	redef fun n_kwfalse=(node)
+	redef fun n_bytenum=(node)
 	do
-		_n_kwfalse = node
+		_n_bytenum = node
 		node.parent = self
 	end
 	redef fun n_annotations=(node)
@@ -5788,26 +6558,26 @@ redef class AFalseExpr
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_kwfalse)
+		v.enter_visit(_n_bytenum)
 		v.enter_visit(_n_annotations)
 	end
 end
-redef class ANullExpr
-	init init_anullexpr (
-		n_kwnull: nullable TKwnull,
+redef class AHexByteExpr
+	init init_ahexbyteexpr (
+		n_hex_bytenum: nullable THexBytenum,
 		n_annotations: nullable AAnnotations
 	)
 	do
-		_n_kwnull = n_kwnull.as(not null)
-		n_kwnull.parent = self
+		_n_hex_bytenum = n_hex_bytenum.as(not null)
+		n_hex_bytenum.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_kwnull == old_child then
-			n_kwnull = new_child.as(TKwnull)
+		if _n_hex_bytenum == old_child then
+			n_hex_bytenum = new_child.as(THexBytenum)
 			return
 		end
 		if _n_annotations == old_child then
@@ -5816,9 +6586,9 @@ redef class ANullExpr
 		end
 	end
 
-	redef fun n_kwnull=(node)
+	redef fun n_hex_bytenum=(node)
 	do
-		_n_kwnull = node
+		_n_hex_bytenum = node
 		node.parent = self
 	end
 	redef fun n_annotations=(node)
@@ -5830,26 +6600,26 @@ redef class ANullExpr
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_kwnull)
+		v.enter_visit(_n_hex_bytenum)
 		v.enter_visit(_n_annotations)
 	end
 end
-redef class ADecIntExpr
-	init init_adecintexpr (
-		n_number: nullable TNumber,
+redef class ABinByteExpr
+	init init_abinbyteexpr (
+		n_bin_bytenum: nullable TBinBytenum,
 		n_annotations: nullable AAnnotations
 	)
 	do
-		_n_number = n_number.as(not null)
-		n_number.parent = self
+		_n_bin_bytenum = n_bin_bytenum.as(not null)
+		n_bin_bytenum.parent = self
 		_n_annotations = n_annotations
 		if n_annotations != null then n_annotations.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_number == old_child then
-			n_number = new_child.as(TNumber)
+		if _n_bin_bytenum == old_child then
+			n_bin_bytenum = new_child.as(TBinBytenum)
 			return
 		end
 		if _n_annotations == old_child then
@@ -5858,9 +6628,9 @@ redef class ADecIntExpr
 		end
 	end
 
-	redef fun n_number=(node)
+	redef fun n_bin_bytenum=(node)
 	do
-		_n_number = node
+		_n_bin_bytenum = node
 		node.parent = self
 	end
 	redef fun n_annotations=(node)
@@ -5872,26 +6642,26 @@ redef class ADecIntExpr
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_number)
+		v.enter_visit(_n_bin_bytenum)
 		v.enter_visit(_n_annotations)
 	end
 end
-redef class AHexIntExpr
-	init init_ahexintexpr (
-		n_hex_number: nullable THexNumber,
+redef class AOctByteExpr
+	init init_aoctbyteexpr (
+		n_oct_bytenum: nullable TOctBytenum,
 		n_annotations: nullable AAnnotations
 	)
 	do
-		_n_hex_number = n_hex_number.as(not null)
-		n_hex_number.parent = self
+		_n_oct_bytenum = n_oct_bytenum.as(not null)
+		n_oct_bytenum.parent = self
 		_n_annotations = n_annotations
 		if n_annotations != null then n_annotations.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_hex_number == old_child then
-			n_hex_number = new_child.as(THexNumber)
+		if _n_oct_bytenum == old_child then
+			n_oct_bytenum = new_child.as(TOctBytenum)
 			return
 		end
 		if _n_annotations == old_child then
@@ -5900,9 +6670,9 @@ redef class AHexIntExpr
 		end
 	end
 
-	redef fun n_hex_number=(node)
+	redef fun n_oct_bytenum=(node)
 	do
-		_n_hex_number = node
+		_n_oct_bytenum = node
 		node.parent = self
 	end
 	redef fun n_annotations=(node)
@@ -5914,7 +6684,7 @@ redef class AHexIntExpr
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_hex_number)
+		v.enter_visit(_n_oct_bytenum)
 		v.enter_visit(_n_annotations)
 	end
 end
@@ -6572,6 +7342,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
@@ -6978,6 +7803,93 @@ redef class AStarstarAssignOp
 		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
@@ -7602,12 +8514,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
@@ -7615,10 +8531,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
@@ -7632,8 +8554,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
@@ -7649,14 +8580,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