X-Git-Url: http://nitlanguage.org?ds=sidebyside

diff --git a/src/parser/parser_prod.nit b/src/parser/parser_prod.nit
index 5ca9042..027dc59 100644
--- a/src/parser/parser_prod.nit
+++ b/src/parser/parser_prod.nit
@@ -1451,479 +1451,595 @@ redef class AIdMethid
 end
 redef class APlusMethid
 	init init_aplusmethid (
-		n_plus: nullable TPlus
+		n_op: nullable TPlus
 	)
 	do
-		_n_plus = n_plus.as(not null)
-		n_plus.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_plus == old_child then
-			n_plus = new_child.as(TPlus)
+		if _n_op == old_child then
+			n_op = new_child.as(TPlus)
 			return
 		end
 	end
 
-	redef fun n_plus=(node)
+	redef fun n_op=(node)
 	do
-		_n_plus = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_plus)
+		v.enter_visit(_n_op)
 	end
 end
 redef class AMinusMethid
 	init init_aminusmethid (
-		n_minus: nullable TMinus
+		n_op: nullable TMinus
 	)
 	do
-		_n_minus = n_minus.as(not null)
-		n_minus.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_minus == old_child then
-			n_minus = new_child.as(TMinus)
+		if _n_op == old_child then
+			n_op = new_child.as(TMinus)
 			return
 		end
 	end
 
-	redef fun n_minus=(node)
+	redef fun n_op=(node)
 	do
-		_n_minus = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_minus)
+		v.enter_visit(_n_op)
 	end
 end
 redef class AStarMethid
 	init init_astarmethid (
-		n_star: nullable TStar
+		n_op: nullable TStar
 	)
 	do
-		_n_star = n_star.as(not null)
-		n_star.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_star == old_child then
-			n_star = new_child.as(TStar)
+		if _n_op == old_child then
+			n_op = new_child.as(TStar)
 			return
 		end
 	end
 
-	redef fun n_star=(node)
+	redef fun n_op=(node)
 	do
-		_n_star = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_star)
+		v.enter_visit(_n_op)
 	end
 end
 redef class AStarstarMethid
 	init init_astarstarmethid (
-		n_starstar: nullable TStarstar
+		n_op: nullable TStarstar
 	)
 	do
-		_n_starstar = n_starstar.as(not null)
-		n_starstar.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_starstar == old_child then
-			n_starstar = new_child.as(TStarstar)
+		if _n_op == old_child then
+			n_op = new_child.as(TStarstar)
 			return
 		end
 	end
 
-	redef fun n_starstar=(node)
+	redef fun n_op=(node)
 	do
-		_n_starstar = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_starstar)
+		v.enter_visit(_n_op)
 	end
 end
 redef class ASlashMethid
 	init init_aslashmethid (
-		n_slash: nullable TSlash
+		n_op: nullable TSlash
 	)
 	do
-		_n_slash = n_slash.as(not null)
-		n_slash.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_slash == old_child then
-			n_slash = new_child.as(TSlash)
+		if _n_op == old_child then
+			n_op = new_child.as(TSlash)
 			return
 		end
 	end
 
-	redef fun n_slash=(node)
+	redef fun n_op=(node)
 	do
-		_n_slash = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_slash)
+		v.enter_visit(_n_op)
 	end
 end
 redef class APercentMethid
 	init init_apercentmethid (
-		n_percent: nullable TPercent
+		n_op: nullable TPercent
 	)
 	do
-		_n_percent = n_percent.as(not null)
-		n_percent.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_percent == old_child then
-			n_percent = new_child.as(TPercent)
+		if _n_op == old_child then
+			n_op = new_child.as(TPercent)
 			return
 		end
 	end
 
-	redef fun n_percent=(node)
+	redef fun n_op=(node)
 	do
-		_n_percent = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_percent)
+		v.enter_visit(_n_op)
 	end
 end
 redef class AEqMethid
 	init init_aeqmethid (
-		n_eq: nullable TEq
+		n_op: nullable TEq
 	)
 	do
-		_n_eq = n_eq.as(not null)
-		n_eq.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_eq == old_child then
-			n_eq = new_child.as(TEq)
+		if _n_op == old_child then
+			n_op = new_child.as(TEq)
 			return
 		end
 	end
 
-	redef fun n_eq=(node)
+	redef fun n_op=(node)
 	do
-		_n_eq = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_eq)
+		v.enter_visit(_n_op)
 	end
 end
 redef class ANeMethid
 	init init_anemethid (
-		n_ne: nullable TNe
+		n_op: nullable TNe
 	)
 	do
-		_n_ne = n_ne.as(not null)
-		n_ne.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_ne == old_child then
-			n_ne = new_child.as(TNe)
+		if _n_op == old_child then
+			n_op = new_child.as(TNe)
 			return
 		end
 	end
 
-	redef fun n_ne=(node)
+	redef fun n_op=(node)
 	do
-		_n_ne = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_ne)
+		v.enter_visit(_n_op)
 	end
 end
 redef class ALeMethid
 	init init_alemethid (
-		n_le: nullable TLe
+		n_op: nullable TLe
 	)
 	do
-		_n_le = n_le.as(not null)
-		n_le.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_le == old_child then
-			n_le = new_child.as(TLe)
+		if _n_op == old_child then
+			n_op = new_child.as(TLe)
 			return
 		end
 	end
 
-	redef fun n_le=(node)
+	redef fun n_op=(node)
 	do
-		_n_le = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_le)
+		v.enter_visit(_n_op)
 	end
 end
 redef class AGeMethid
 	init init_agemethid (
-		n_ge: nullable TGe
+		n_op: nullable TGe
 	)
 	do
-		_n_ge = n_ge.as(not null)
-		n_ge.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_ge == old_child then
-			n_ge = new_child.as(TGe)
+		if _n_op == old_child then
+			n_op = new_child.as(TGe)
 			return
 		end
 	end
 
-	redef fun n_ge=(node)
+	redef fun n_op=(node)
 	do
-		_n_ge = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_ge)
+		v.enter_visit(_n_op)
 	end
 end
 redef class ALtMethid
 	init init_altmethid (
-		n_lt: nullable TLt
+		n_op: nullable TLt
 	)
 	do
-		_n_lt = n_lt.as(not null)
-		n_lt.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_lt == old_child then
-			n_lt = new_child.as(TLt)
+		if _n_op == old_child then
+			n_op = new_child.as(TLt)
 			return
 		end
 	end
 
-	redef fun n_lt=(node)
+	redef fun n_op=(node)
 	do
-		_n_lt = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_lt)
+		v.enter_visit(_n_op)
 	end
 end
 redef class AGtMethid
 	init init_agtmethid (
-		n_gt: nullable TGt
+		n_op: nullable TGt
 	)
 	do
-		_n_gt = n_gt.as(not null)
-		n_gt.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_gt == old_child then
-			n_gt = new_child.as(TGt)
+		if _n_op == old_child then
+			n_op = new_child.as(TGt)
 			return
 		end
 	end
 
-	redef fun n_gt=(node)
+	redef fun n_op=(node)
 	do
-		_n_gt = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_gt)
+		v.enter_visit(_n_op)
 	end
 end
 redef class ALlMethid
 	init init_allmethid (
-		n_ll: nullable TLl
+		n_op: nullable TLl
 	)
 	do
-		_n_ll = n_ll.as(not null)
-		n_ll.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_ll == old_child then
-			n_ll = new_child.as(TLl)
+		if _n_op == old_child then
+			n_op = new_child.as(TLl)
 			return
 		end
 	end
 
-	redef fun n_ll=(node)
+	redef fun n_op=(node)
 	do
-		_n_ll = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_ll)
+		v.enter_visit(_n_op)
 	end
 end
 redef class AGgMethid
 	init init_aggmethid (
-		n_gg: nullable TGg
+		n_op: nullable TGg
 	)
 	do
-		_n_gg = n_gg.as(not null)
-		n_gg.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_gg == old_child then
-			n_gg = new_child.as(TGg)
+		if _n_op == old_child then
+			n_op = new_child.as(TGg)
 			return
 		end
 	end
 
-	redef fun n_gg=(node)
+	redef fun n_op=(node)
 	do
-		_n_gg = node
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_gg)
+		v.enter_visit(_n_op)
 	end
 end
-redef class ABraMethid
-	init init_abramethid (
-		n_obra: nullable TObra,
-		n_cbra: nullable TCbra
+redef class AStarshipMethid
+	init init_astarshipmethid (
+		n_op: nullable TStarship
 	)
 	do
-		_n_obra = n_obra.as(not null)
-		n_obra.parent = self
-		_n_cbra = n_cbra.as(not null)
-		n_cbra.parent = self
+		_n_op = n_op.as(not null)
+		n_op.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
 	do
-		if _n_obra == old_child then
-			n_obra = new_child.as(TObra)
+		if _n_op == old_child then
+			n_op = new_child.as(TStarship)
 			return
 		end
-		if _n_cbra == old_child then
-			n_cbra = new_child.as(TCbra)
+	end
+
+	redef fun n_op=(node)
+	do
+		_n_op = node
+		node.parent = self
+	end
+
+
+	redef fun visit_all(v: Visitor)
+	do
+		v.enter_visit(_n_op)
+	end
+end
+redef class APipeMethid
+	init init_apipemethid (
+		n_op: nullable TPipe
+	)
+	do
+		_n_op = n_op.as(not null)
+		n_op.parent = self
+	end
+
+	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+	do
+		if _n_op == old_child then
+			n_op = new_child.as(TPipe)
 			return
 		end
 	end
 
-	redef fun n_obra=(node)
+	redef fun n_op=(node)
 	do
-		_n_obra = node
+		_n_op = node
 		node.parent = self
 	end
-	redef fun n_cbra=(node)
+
+
+	redef fun visit_all(v: Visitor)
 	do
-		_n_cbra = node
+		v.enter_visit(_n_op)
+	end
+end
+redef class ACaretMethid
+	init init_acaretmethid (
+		n_op: nullable TCaret
+	)
+	do
+		_n_op = n_op.as(not null)
+		n_op.parent = self
+	end
+
+	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+	do
+		if _n_op == old_child then
+			n_op = new_child.as(TCaret)
+			return
+		end
+	end
+
+	redef fun n_op=(node)
+	do
+		_n_op = node
 		node.parent = self
 	end
 
 
 	redef fun visit_all(v: Visitor)
 	do
-		v.enter_visit(_n_obra)
-		v.enter_visit(_n_cbra)
+		v.enter_visit(_n_op)
 	end
 end
-redef class AStarshipMethid
-	init init_astarshipmethid (
-		n_starship: nullable TStarship
+redef class AAmpMethid
+	init init_aampmethid (
+		n_op: nullable TAmp
+	)
+	do
+		_n_op = n_op.as(not null)
+		n_op.parent = self
+	end
+
+	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+	do
+		if _n_op == old_child then
+			n_op = new_child.as(TAmp)
+			return
+		end
+	end
+
+	redef fun n_op=(node)
+	do
+		_n_op = node
+		node.parent = self
+	end
+
+
+	redef fun visit_all(v: Visitor)
+	do
+		v.enter_visit(_n_op)
+	end
+end
+redef class ATildeMethid
+	init init_atildemethid (
+		n_op: nullable TTilde
 	)
 	do
-		_n_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(TTilde)
 			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 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
@@ -3737,10 +3853,230 @@ redef class ALlExpr
 	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
+		_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(TLl)
+			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 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
+
+	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(TGt)
+			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 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
+
+	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(TGe)
+			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 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
+
+	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(TGg)
+			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 AIsaExpr
+	init init_aisaexpr (
+		n_expr: nullable AExpr,
+		n_kwisa: nullable TKwisa,
+		n_type: nullable AType
+	)
+	do
+		_n_expr = n_expr.as(not null)
+		n_expr.parent = self
+		_n_kwisa = n_kwisa.as(not null)
+		n_kwisa.parent = self
+		_n_type = n_type.as(not null)
+		n_type.parent = self
 	end
 
 	redef fun replace_child(old_child: ANode, new_child: nullable ANode)
@@ -3749,12 +4085,12 @@ redef class ALlExpr
 			n_expr = new_child.as(AExpr)
 			return
 		end
-		if _n_op == old_child then
-			n_op = new_child.as(TLl)
+		if _n_kwisa == old_child then
+			n_kwisa = new_child.as(TKwisa)
 			return
 		end
-		if _n_expr2 == old_child then
-			n_expr2 = new_child.as(AExpr)
+		if _n_type == old_child then
+			n_type = new_child.as(AType)
 			return
 		end
 	end
@@ -3764,14 +4100,14 @@ redef class ALlExpr
 		_n_expr = node
 		node.parent = self
 	end
-	redef fun n_op=(node)
+	redef fun n_kwisa=(node)
 	do
-		_n_op = node
+		_n_kwisa = node
 		node.parent = self
 	end
-	redef fun n_expr2=(node)
+	redef fun n_type=(node)
 	do
-		_n_expr2 = node
+		_n_type = node
 		node.parent = self
 	end
 
@@ -3779,14 +4115,14 @@ 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)
+		v.enter_visit(_n_kwisa)
+		v.enter_visit(_n_type)
 	end
 end
-redef class AGtExpr
-	init init_agtexpr (
+redef class APlusExpr
+	init init_aplusexpr (
 		n_expr: nullable AExpr,
-		n_op: nullable TGt,
+		n_op: nullable TPlus,
 		n_expr2: nullable AExpr
 	)
 	do
@@ -3805,7 +4141,7 @@ redef class AGtExpr
 			return
 		end
 		if _n_op == old_child then
-			n_op = new_child.as(TGt)
+			n_op = new_child.as(TPlus)
 			return
 		end
 		if _n_expr2 == old_child then
@@ -3838,10 +4174,10 @@ redef class AGtExpr
 		v.enter_visit(_n_expr2)
 	end
 end
-redef class AGeExpr
-	init init_ageexpr (
+redef class AMinusExpr
+	init init_aminusexpr (
 		n_expr: nullable AExpr,
-		n_op: nullable TGe,
+		n_op: nullable TMinus,
 		n_expr2: nullable AExpr
 	)
 	do
@@ -3860,7 +4196,7 @@ redef class AGeExpr
 			return
 		end
 		if _n_op == old_child then
-			n_op = new_child.as(TGe)
+			n_op = new_child.as(TMinus)
 			return
 		end
 		if _n_expr2 == old_child then
@@ -3893,10 +4229,10 @@ redef class AGeExpr
 		v.enter_visit(_n_expr2)
 	end
 end
-redef class AGgExpr
-	init init_aggexpr (
+redef class AStarshipExpr
+	init init_astarshipexpr (
 		n_expr: nullable AExpr,
-		n_op: nullable TGg,
+		n_op: nullable TStarship,
 		n_expr2: nullable AExpr
 	)
 	do
@@ -3915,7 +4251,7 @@ redef class AGgExpr
 			return
 		end
 		if _n_op == old_child then
-			n_op = new_child.as(TGg)
+			n_op = new_child.as(TStarship)
 			return
 		end
 		if _n_expr2 == old_child then
@@ -3948,19 +4284,19 @@ redef class AGgExpr
 		v.enter_visit(_n_expr2)
 	end
 end
-redef class AIsaExpr
-	init init_aisaexpr (
+redef class AStarExpr
+	init init_astarexpr (
 		n_expr: nullable AExpr,
-		n_kwisa: nullable TKwisa,
-		n_type: nullable AType
+		n_op: nullable TStar,
+		n_expr2: nullable AExpr
 	)
 	do
 		_n_expr = n_expr.as(not null)
 		n_expr.parent = self
-		_n_kwisa = n_kwisa.as(not null)
-		n_kwisa.parent = self
-		_n_type = n_type.as(not null)
-		n_type.parent = self
+		_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)
@@ -3969,12 +4305,12 @@ redef class AIsaExpr
 			n_expr = new_child.as(AExpr)
 			return
 		end
-		if _n_kwisa == old_child then
-			n_kwisa = new_child.as(TKwisa)
+		if _n_op == old_child then
+			n_op = new_child.as(TStar)
 			return
 		end
-		if _n_type == old_child then
-			n_type = new_child.as(AType)
+		if _n_expr2 == old_child then
+			n_expr2 = new_child.as(AExpr)
 			return
 		end
 	end
@@ -3984,14 +4320,14 @@ redef class AIsaExpr
 		_n_expr = node
 		node.parent = self
 	end
-	redef fun n_kwisa=(node)
+	redef fun n_op=(node)
 	do
-		_n_kwisa = node
+		_n_op = node
 		node.parent = self
 	end
-	redef fun n_type=(node)
+	redef fun n_expr2=(node)
 	do
-		_n_type = node
+		_n_expr2 = node
 		node.parent = self
 	end
 
@@ -3999,14 +4335,14 @@ redef class AIsaExpr
 	redef fun visit_all(v: Visitor)
 	do
 		v.enter_visit(_n_expr)
-		v.enter_visit(_n_kwisa)
-		v.enter_visit(_n_type)
+		v.enter_visit(_n_op)
+		v.enter_visit(_n_expr2)
 	end
 end
-redef class APlusExpr
-	init init_aplusexpr (
+redef class AStarstarExpr
+	init init_astarstarexpr (
 		n_expr: nullable AExpr,
-		n_op: nullable TPlus,
+		n_op: nullable TStarstar,
 		n_expr2: nullable AExpr
 	)
 	do
@@ -4025,7 +4361,7 @@ redef class APlusExpr
 			return
 		end
 		if _n_op == old_child then
-			n_op = new_child.as(TPlus)
+			n_op = new_child.as(TStarstar)
 			return
 		end
 		if _n_expr2 == old_child then
@@ -4058,10 +4394,10 @@ redef class APlusExpr
 		v.enter_visit(_n_expr2)
 	end
 end
-redef class AMinusExpr
-	init init_aminusexpr (
+redef class ASlashExpr
+	init init_aslashexpr (
 		n_expr: nullable AExpr,
-		n_op: nullable TMinus,
+		n_op: nullable TSlash,
 		n_expr2: nullable AExpr
 	)
 	do
@@ -4080,7 +4416,7 @@ redef class AMinusExpr
 			return
 		end
 		if _n_op == old_child then
-			n_op = new_child.as(TMinus)
+			n_op = new_child.as(TSlash)
 			return
 		end
 		if _n_expr2 == old_child then
@@ -4113,10 +4449,10 @@ redef class AMinusExpr
 		v.enter_visit(_n_expr2)
 	end
 end
-redef class AStarshipExpr
-	init init_astarshipexpr (
+redef class APercentExpr
+	init init_apercentexpr (
 		n_expr: nullable AExpr,
-		n_op: nullable TStarship,
+		n_op: nullable TPercent,
 		n_expr2: nullable AExpr
 	)
 	do
@@ -4135,7 +4471,7 @@ redef class AStarshipExpr
 			return
 		end
 		if _n_op == old_child then
-			n_op = new_child.as(TStarship)
+			n_op = new_child.as(TPercent)
 			return
 		end
 		if _n_expr2 == old_child then
@@ -4168,10 +4504,10 @@ redef class AStarshipExpr
 		v.enter_visit(_n_expr2)
 	end
 end
-redef class AStarExpr
-	init init_astarexpr (
+redef class APipeExpr
+	init init_apipeexpr (
 		n_expr: nullable AExpr,
-		n_op: nullable TStar,
+		n_op: nullable TPipe,
 		n_expr2: nullable AExpr
 	)
 	do
@@ -4190,7 +4526,7 @@ redef class AStarExpr
 			return
 		end
 		if _n_op == old_child then
-			n_op = new_child.as(TStar)
+			n_op = new_child.as(TPipe)
 			return
 		end
 		if _n_expr2 == old_child then
@@ -4223,10 +4559,10 @@ redef class AStarExpr
 		v.enter_visit(_n_expr2)
 	end
 end
-redef class AStarstarExpr
-	init init_astarstarexpr (
+redef class ACaretExpr
+	init init_acaretexpr (
 		n_expr: nullable AExpr,
-		n_op: nullable TStarstar,
+		n_op: nullable TCaret,
 		n_expr2: nullable AExpr
 	)
 	do
@@ -4245,7 +4581,7 @@ redef class AStarstarExpr
 			return
 		end
 		if _n_op == old_child then
-			n_op = new_child.as(TStarstar)
+			n_op = new_child.as(TCaret)
 			return
 		end
 		if _n_expr2 == old_child then
@@ -4278,10 +4614,10 @@ redef class AStarstarExpr
 		v.enter_visit(_n_expr2)
 	end
 end
-redef class ASlashExpr
-	init init_aslashexpr (
+redef class AAmpExpr
+	init init_aampexpr (
 		n_expr: nullable AExpr,
-		n_op: nullable TSlash,
+		n_op: nullable TAmp,
 		n_expr2: nullable AExpr
 	)
 	do
@@ -4300,7 +4636,7 @@ redef class ASlashExpr
 			return
 		end
 		if _n_op == old_child then
-			n_op = new_child.as(TSlash)
+			n_op = new_child.as(TAmp)
 			return
 		end
 		if _n_expr2 == old_child then
@@ -4333,77 +4669,64 @@ redef class ASlashExpr
 		v.enter_visit(_n_expr2)
 	end
 end
-redef class APercentExpr
-	init init_apercentexpr (
-		n_expr: nullable AExpr,
-		n_op: nullable TPercent,
-		n_expr2: nullable AExpr
+redef class AUminusExpr
+	init init_auminusexpr (
+		n_op: nullable TMinus,
+		n_expr: 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
+		_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_expr == old_child then
-			n_expr = new_child.as(AExpr)
-			return
-		end
 		if _n_op == old_child then
-			n_op = new_child.as(TPercent)
+			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)
-	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)
+	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_expr)
 		v.enter_visit(_n_op)
-		v.enter_visit(_n_expr2)
+		v.enter_visit(_n_expr)
 	end
 end
-redef class AUminusExpr
-	init init_auminusexpr (
-		n_minus: nullable TMinus,
+redef class AUplusExpr
+	init init_auplusexpr (
+		n_op: nullable TPlus,
 		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(TPlus)
 			return
 		end
 		if _n_expr == old_child then
@@ -4412,9 +4735,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)
@@ -4426,26 +4749,26 @@ 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
-redef class AUplusExpr
-	init init_auplusexpr (
-		n_plus: nullable TPlus,
+redef class AUtildeExpr
+	init init_autildeexpr (
+		n_op: nullable TTilde,
 		n_expr: nullable AExpr
 	)
 	do
-		_n_plus = n_plus.as(not null)
-		n_plus.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_plus == old_child then
-			n_plus = new_child.as(TPlus)
+		if _n_op == old_child then
+			n_op = new_child.as(TTilde)
 			return
 		end
 		if _n_expr == old_child then
@@ -4454,9 +4777,9 @@ redef class AUplusExpr
 		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 n_expr=(node)
@@ -4468,7 +4791,7 @@ 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
@@ -6978,6 +7301,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