parser: also visit EOF token
[nit.git] / src / parser / parser_prod.nit
index 576dd4f..d9929e7 100644 (file)
@@ -1,25 +1,25 @@
 # Production AST nodes full definition.
-# This file was generated by SableCC (http://www.sablecc.org/). 
+# This file was generated by SableCC (http://www.sablecc.org/).
 package parser_prod
 
 import lexer
 intrude import parser_nodes
 
-redef class PNode
+redef class ANode
        # Parent of the node in the AST
-       readable writable var _parent: nullable PNode
+       readable writable var _parent: nullable ANode
 
        # Remove a child from the AST
-       fun remove_child(child: PNode)
+       fun remove_child(child: ANode)
        do
                replace_child(child, null)
        end
 
        # Replace a child with an other node in the AST
-       fun replace_child(old_child: PNode, new_child: nullable PNode) is abstract
+       fun replace_child(old_child: ANode, new_child: nullable ANode) is abstract
 
        # Replace itself with an other node in the AST
-       fun replace_with(node: PNode)
+       fun replace_with(node: ANode)
        do
                if (_parent != null) then
                        _parent.replace_child(self, node)
@@ -33,33 +33,12 @@ redef class PNode
        # Visit all nodes in reverse order.
        # Thus, call "v.visit(e)" for each node e starting from the last child
        fun visit_all_reverse(v: Visitor) is abstract
-
-       # Give a human readable location of the node.
-       fun locate: String
-       do
-               if location == null then
-                       return "????"
-               end
-               return location.to_s
-       end
-
-
-       # Return only the line number of the node
-       fun line_number: Int is abstract
-
-       # Debug method: output a message prefixed with the location.
-       fun printl(str: String)
-       do
-               print("{locate}: {str}\n")
-       end
 end
 
 redef class Token
        redef fun visit_all(v: Visitor) do end
        redef fun visit_all_reverse(v: Visitor) do end
-       redef fun replace_child(old_child: PNode, new_child: nullable PNode) do end
-
-       redef fun line_number do return line
+       redef fun replace_child(old_child: ANode, new_child: nullable ANode) do end
 end
 
 redef class Prod
@@ -69,31 +48,35 @@ redef class Prod
        # The last token of the production node
        readable writable var _last_token: nullable Token
 
-       redef fun replace_with(n: PNode)
+       redef fun replace_with(n: ANode)
         do
                 super
                 assert n isa Prod
                 n.first_token = first_token
                 n.last_token = last_token
-                n._location = location
+                n.location = location
         end
-
-       redef fun line_number
-       do
-               if first_token != null then
-                       return first_token.line
-               else
-                       return 0
-               end
-       end
 end
 
 # Abstract standard visitor
 class Visitor
+       # What the visitor do when a node is visited
+        # Concrete visitors should redefine this method.
+        protected fun visit(e: nullable ANode) is abstract
+
         # Ask the visitor to visit a given node.
         # Usually automatically called by visit_all* methods.
-        # Concrete visitors should redefine this method.
-        fun visit(e: nullable PNode) is abstract
+       # This methos should not be redefined
+        fun enter_visit(e: nullable ANode)
+       do
+               var old = _current_node
+               _current_node = e
+               visit(e)
+               _current_node = old
+       end
+
+       # The current visited node
+       readable var _current_node: nullable ANode = null
 end
 
 redef class AModule
@@ -108,9 +91,9 @@ redef class AModule
     private init empty_init do end
 
     init init_amodule (
-            n_packagedecl: nullable PPackagedecl ,
-            n_imports: Collection[Object] , # Should be Collection[PImport]
-            n_classdefs: Collection[Object]  # Should be Collection[PClassdef]
+            n_packagedecl: nullable APackagedecl,
+            n_imports: Collection[Object], # Should be Collection[AImport]
+            n_classdefs: Collection[Object] # Should be Collection[AClassdef]
     )
     do
         empty_init
@@ -119,23 +102,23 @@ redef class AModule
                n_packagedecl.parent = self
        end
        for n in n_imports do
-               assert n isa PImport
+               assert n isa AImport
                _n_imports.add(n)
                n.parent = self
        end
        for n in n_classdefs do
-               assert n isa PClassdef
+               assert n isa AClassdef
                _n_classdefs.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_packagedecl == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PPackagedecl
+               assert new_child isa APackagedecl
                 _n_packagedecl = new_child
            else
                _n_packagedecl = null
@@ -145,7 +128,7 @@ redef class AModule
         for i in [0.._n_imports.length[ do
             if _n_imports[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PImport
+                   assert new_child isa AImport
                     _n_imports[i] = new_child
                     new_child.parent = self
                 else
@@ -157,7 +140,7 @@ redef class AModule
         for i in [0.._n_classdefs.length[ do
             if _n_classdefs[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PClassdef
+                   assert new_child isa AClassdef
                     _n_classdefs[i] = new_child
                     new_child.parent = self
                 else
@@ -171,32 +154,32 @@ redef class AModule
     redef fun visit_all(v: Visitor)
     do
         if _n_packagedecl != null then
-            v.visit(_n_packagedecl.as(not null))
+            v.enter_visit(_n_packagedecl.as(not null))
         end
             for n in _n_imports do
-                v.visit(n)
+                v.enter_visit(n)
            end
             for n in _n_classdefs do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_packagedecl != null then
-            v.visit(_n_packagedecl.as(not null))
+            v.enter_visit(_n_packagedecl.as(not null))
         end
        do
            var i = _n_imports.length
             while i >= 0 do
-                v.visit(_n_imports[i])
+                v.enter_visit(_n_imports[i])
                i = i - 1
            end
        end
        do
            var i = _n_classdefs.length
             while i >= 0 do
-                v.visit(_n_classdefs[i])
+                v.enter_visit(_n_classdefs[i])
                i = i - 1
            end
        end
@@ -224,9 +207,9 @@ redef class APackagedecl
     private init empty_init do end
 
     init init_apackagedecl (
-            n_doc: nullable PDoc ,
-            n_kwpackage: nullable TKwpackage ,
-            n_id: nullable TId 
+            n_doc: nullable ADoc,
+            n_kwpackage: nullable TKwpackage,
+            n_id: nullable TId
     )
     do
         empty_init
@@ -240,12 +223,12 @@ redef class APackagedecl
        n_id.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_doc == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PDoc
+               assert new_child isa ADoc
                 _n_doc = new_child
            else
                _n_doc = null
@@ -277,22 +260,22 @@ redef class APackagedecl
     redef fun visit_all(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
-        v.visit(_n_kwpackage)
-        v.visit(_n_id)
+        v.enter_visit(_n_kwpackage)
+        v.enter_visit(_n_id)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
-        v.visit(_n_kwpackage)
-        v.visit(_n_id)
+        v.enter_visit(_n_kwpackage)
+        v.enter_visit(_n_id)
     end
 end
-redef class AImport
+redef class AStdImport
     redef fun n_visibility=(n)
     do
         _n_visibility = n
@@ -311,10 +294,10 @@ redef class AImport
 
     private init empty_init do end
 
-    init init_aimport (
-            n_visibility: nullable PVisibility ,
-            n_kwimport: nullable TKwimport ,
-            n_id: nullable TId 
+    init init_astdimport (
+            n_visibility: nullable AVisibility,
+            n_kwimport: nullable TKwimport,
+            n_id: nullable TId
     )
     do
         empty_init
@@ -326,12 +309,12 @@ redef class AImport
        n_id.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_visibility == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PVisibility
+               assert new_child isa AVisibility
                 _n_visibility = new_child
            else
                abort
@@ -362,16 +345,16 @@ redef class AImport
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_visibility)
-        v.visit(_n_kwimport)
-        v.visit(_n_id)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwimport)
+        v.enter_visit(_n_id)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_visibility)
-        v.visit(_n_kwimport)
-        v.visit(_n_id)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwimport)
+        v.enter_visit(_n_id)
     end
 end
 redef class ANoImport
@@ -394,9 +377,9 @@ redef class ANoImport
     private init empty_init do end
 
     init init_anoimport (
-            n_visibility: nullable PVisibility ,
-            n_kwimport: nullable TKwimport ,
-            n_kwend: nullable TKwend 
+            n_visibility: nullable AVisibility,
+            n_kwimport: nullable TKwimport,
+            n_kwend: nullable TKwend
     )
     do
         empty_init
@@ -408,12 +391,12 @@ redef class ANoImport
        n_kwend.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_visibility == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PVisibility
+               assert new_child isa AVisibility
                 _n_visibility = new_child
            else
                abort
@@ -444,16 +427,16 @@ redef class ANoImport
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_visibility)
-        v.visit(_n_kwimport)
-        v.visit(_n_kwend)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwimport)
+        v.enter_visit(_n_kwend)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_visibility)
-        v.visit(_n_kwimport)
-        v.visit(_n_kwend)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwimport)
+        v.enter_visit(_n_kwend)
     end
 end
 redef class APublicVisibility
@@ -465,7 +448,7 @@ redef class APublicVisibility
         empty_init
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
     end
 
@@ -487,7 +470,7 @@ redef class APrivateVisibility
     private init empty_init do end
 
     init init_aprivatevisibility (
-            n_kwprivate: nullable TKwprivate 
+            n_kwprivate: nullable TKwprivate
     )
     do
         empty_init
@@ -495,7 +478,7 @@ redef class APrivateVisibility
        n_kwprivate.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwprivate == old_child then
             if new_child != null then
@@ -511,12 +494,12 @@ redef class APrivateVisibility
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwprivate)
+        v.enter_visit(_n_kwprivate)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwprivate)
+        v.enter_visit(_n_kwprivate)
     end
 end
 redef class AProtectedVisibility
@@ -529,7 +512,7 @@ redef class AProtectedVisibility
     private init empty_init do end
 
     init init_aprotectedvisibility (
-            n_kwprotected: nullable TKwprotected 
+            n_kwprotected: nullable TKwprotected
     )
     do
         empty_init
@@ -537,7 +520,7 @@ redef class AProtectedVisibility
        n_kwprotected.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwprotected == old_child then
             if new_child != null then
@@ -553,12 +536,12 @@ redef class AProtectedVisibility
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwprotected)
+        v.enter_visit(_n_kwprotected)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwprotected)
+        v.enter_visit(_n_kwprotected)
     end
 end
 redef class AIntrudeVisibility
@@ -571,7 +554,7 @@ redef class AIntrudeVisibility
     private init empty_init do end
 
     init init_aintrudevisibility (
-            n_kwintrude: nullable TKwintrude 
+            n_kwintrude: nullable TKwintrude
     )
     do
         empty_init
@@ -579,7 +562,7 @@ redef class AIntrudeVisibility
        n_kwintrude.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwintrude == old_child then
             if new_child != null then
@@ -595,15 +578,15 @@ redef class AIntrudeVisibility
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwintrude)
+        v.enter_visit(_n_kwintrude)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwintrude)
+        v.enter_visit(_n_kwintrude)
     end
 end
-redef class AClassdef
+redef class AStdClassdef
     redef fun n_doc=(n)
     do
         _n_doc = n
@@ -638,15 +621,15 @@ redef class AClassdef
 
     private init empty_init do end
 
-    init init_aclassdef (
-            n_doc: nullable PDoc ,
-            n_kwredef: nullable TKwredef ,
-            n_visibility: nullable PVisibility ,
-            n_classkind: nullable PClasskind ,
-            n_id: nullable TClassid ,
-            n_formaldefs: Collection[Object] , # Should be Collection[PFormaldef]
-            n_superclasses: Collection[Object] , # Should be Collection[PSuperclass]
-            n_propdefs: Collection[Object]  # Should be Collection[PPropdef]
+    init init_astdclassdef (
+            n_doc: nullable ADoc,
+            n_kwredef: nullable TKwredef,
+            n_visibility: nullable AVisibility,
+            n_classkind: nullable AClasskind,
+            n_id: nullable TClassid,
+            n_formaldefs: Collection[Object], # Should be Collection[AFormaldef]
+            n_superclasses: Collection[Object], # Should be Collection[ASuperclass]
+            n_propdefs: Collection[Object] # Should be Collection[APropdef]
     )
     do
         empty_init
@@ -667,28 +650,28 @@ redef class AClassdef
                n_id.parent = self
        end
        for n in n_formaldefs do
-               assert n isa PFormaldef
+               assert n isa AFormaldef
                _n_formaldefs.add(n)
                n.parent = self
        end
        for n in n_superclasses do
-               assert n isa PSuperclass
+               assert n isa ASuperclass
                _n_superclasses.add(n)
                n.parent = self
        end
        for n in n_propdefs do
-               assert n isa PPropdef
+               assert n isa APropdef
                _n_propdefs.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_doc == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PDoc
+               assert new_child isa ADoc
                 _n_doc = new_child
            else
                _n_doc = null
@@ -708,7 +691,7 @@ redef class AClassdef
         if _n_visibility == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PVisibility
+               assert new_child isa AVisibility
                 _n_visibility = new_child
            else
                abort
@@ -718,7 +701,7 @@ redef class AClassdef
         if _n_classkind == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PClasskind
+               assert new_child isa AClasskind
                 _n_classkind = new_child
            else
                abort
@@ -738,7 +721,7 @@ redef class AClassdef
         for i in [0.._n_formaldefs.length[ do
             if _n_formaldefs[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PFormaldef
+                   assert new_child isa AFormaldef
                     _n_formaldefs[i] = new_child
                     new_child.parent = self
                 else
@@ -750,7 +733,7 @@ redef class AClassdef
         for i in [0.._n_superclasses.length[ do
             if _n_superclasses[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PSuperclass
+                   assert new_child isa ASuperclass
                     _n_superclasses[i] = new_child
                     new_child.parent = self
                 else
@@ -762,7 +745,7 @@ redef class AClassdef
         for i in [0.._n_propdefs.length[ do
             if _n_propdefs[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PPropdef
+                   assert new_child isa APropdef
                     _n_propdefs[i] = new_child
                     new_child.parent = self
                 else
@@ -776,58 +759,58 @@ redef class AClassdef
     redef fun visit_all(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_classkind)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_classkind)
         if _n_id != null then
-            v.visit(_n_id.as(not null))
+            v.enter_visit(_n_id.as(not null))
         end
             for n in _n_formaldefs do
-                v.visit(n)
+                v.enter_visit(n)
            end
             for n in _n_superclasses do
-                v.visit(n)
+                v.enter_visit(n)
            end
             for n in _n_propdefs do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_classkind)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_classkind)
         if _n_id != null then
-            v.visit(_n_id.as(not null))
+            v.enter_visit(_n_id.as(not null))
         end
        do
            var i = _n_formaldefs.length
             while i >= 0 do
-                v.visit(_n_formaldefs[i])
+                v.enter_visit(_n_formaldefs[i])
                i = i - 1
            end
        end
        do
            var i = _n_superclasses.length
             while i >= 0 do
-                v.visit(_n_superclasses[i])
+                v.enter_visit(_n_superclasses[i])
                i = i - 1
            end
        end
        do
            var i = _n_propdefs.length
             while i >= 0 do
-                v.visit(_n_propdefs[i])
+                v.enter_visit(_n_propdefs[i])
                i = i - 1
            end
        end
@@ -838,23 +821,23 @@ redef class ATopClassdef
     private init empty_init do end
 
     init init_atopclassdef (
-            n_propdefs: Collection[Object]  # Should be Collection[PPropdef]
+            n_propdefs: Collection[Object] # Should be Collection[APropdef]
     )
     do
         empty_init
        for n in n_propdefs do
-               assert n isa PPropdef
+               assert n isa APropdef
                _n_propdefs.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         for i in [0.._n_propdefs.length[ do
             if _n_propdefs[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PPropdef
+                   assert new_child isa APropdef
                     _n_propdefs[i] = new_child
                     new_child.parent = self
                 else
@@ -868,7 +851,7 @@ redef class ATopClassdef
     redef fun visit_all(v: Visitor)
     do
             for n in _n_propdefs do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
@@ -877,7 +860,7 @@ redef class ATopClassdef
        do
            var i = _n_propdefs.length
             while i >= 0 do
-                v.visit(_n_propdefs[i])
+                v.enter_visit(_n_propdefs[i])
                i = i - 1
            end
        end
@@ -888,23 +871,23 @@ redef class AMainClassdef
     private init empty_init do end
 
     init init_amainclassdef (
-            n_propdefs: Collection[Object]  # Should be Collection[PPropdef]
+            n_propdefs: Collection[Object] # Should be Collection[APropdef]
     )
     do
         empty_init
        for n in n_propdefs do
-               assert n isa PPropdef
+               assert n isa APropdef
                _n_propdefs.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         for i in [0.._n_propdefs.length[ do
             if _n_propdefs[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PPropdef
+                   assert new_child isa APropdef
                     _n_propdefs[i] = new_child
                     new_child.parent = self
                 else
@@ -918,7 +901,7 @@ redef class AMainClassdef
     redef fun visit_all(v: Visitor)
     do
             for n in _n_propdefs do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
@@ -927,7 +910,7 @@ redef class AMainClassdef
        do
            var i = _n_propdefs.length
             while i >= 0 do
-                v.visit(_n_propdefs[i])
+                v.enter_visit(_n_propdefs[i])
                i = i - 1
            end
        end
@@ -943,7 +926,7 @@ redef class AConcreteClasskind
     private init empty_init do end
 
     init init_aconcreteclasskind (
-            n_kwclass: nullable TKwclass 
+            n_kwclass: nullable TKwclass
     )
     do
         empty_init
@@ -951,7 +934,7 @@ redef class AConcreteClasskind
        n_kwclass.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwclass == old_child then
             if new_child != null then
@@ -967,12 +950,12 @@ redef class AConcreteClasskind
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwclass)
+        v.enter_visit(_n_kwclass)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwclass)
+        v.enter_visit(_n_kwclass)
     end
 end
 redef class AAbstractClasskind
@@ -990,8 +973,8 @@ redef class AAbstractClasskind
     private init empty_init do end
 
     init init_aabstractclasskind (
-            n_kwabstract: nullable TKwabstract ,
-            n_kwclass: nullable TKwclass 
+            n_kwabstract: nullable TKwabstract,
+            n_kwclass: nullable TKwclass
     )
     do
         empty_init
@@ -1001,7 +984,7 @@ redef class AAbstractClasskind
        n_kwclass.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwabstract == old_child then
             if new_child != null then
@@ -1027,14 +1010,14 @@ redef class AAbstractClasskind
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwabstract)
-        v.visit(_n_kwclass)
+        v.enter_visit(_n_kwabstract)
+        v.enter_visit(_n_kwclass)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwabstract)
-        v.visit(_n_kwclass)
+        v.enter_visit(_n_kwabstract)
+        v.enter_visit(_n_kwclass)
     end
 end
 redef class AInterfaceClasskind
@@ -1047,7 +1030,7 @@ redef class AInterfaceClasskind
     private init empty_init do end
 
     init init_ainterfaceclasskind (
-            n_kwinterface: nullable TKwinterface 
+            n_kwinterface: nullable TKwinterface
     )
     do
         empty_init
@@ -1055,7 +1038,7 @@ redef class AInterfaceClasskind
        n_kwinterface.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwinterface == old_child then
             if new_child != null then
@@ -1071,12 +1054,12 @@ redef class AInterfaceClasskind
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwinterface)
+        v.enter_visit(_n_kwinterface)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwinterface)
+        v.enter_visit(_n_kwinterface)
     end
 end
 redef class AUniversalClasskind
@@ -1089,7 +1072,7 @@ redef class AUniversalClasskind
     private init empty_init do end
 
     init init_auniversalclasskind (
-            n_kwuniversal: nullable TKwuniversal 
+            n_kwuniversal: nullable TKwuniversal
     )
     do
         empty_init
@@ -1097,7 +1080,7 @@ redef class AUniversalClasskind
        n_kwuniversal.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwuniversal == old_child then
             if new_child != null then
@@ -1113,12 +1096,12 @@ redef class AUniversalClasskind
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwuniversal)
+        v.enter_visit(_n_kwuniversal)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwuniversal)
+        v.enter_visit(_n_kwuniversal)
     end
 end
 redef class AFormaldef
@@ -1138,8 +1121,8 @@ redef class AFormaldef
     private init empty_init do end
 
     init init_aformaldef (
-            n_id: nullable TClassid ,
-            n_type: nullable PType 
+            n_id: nullable TClassid,
+            n_type: nullable AType
     )
     do
         empty_init
@@ -1151,7 +1134,7 @@ redef class AFormaldef
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_id == old_child then
             if new_child != null then
@@ -1166,7 +1149,7 @@ redef class AFormaldef
         if _n_type == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PType
+               assert new_child isa AType
                 _n_type = new_child
            else
                _n_type = null
@@ -1177,17 +1160,17 @@ redef class AFormaldef
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_id)
+        v.enter_visit(_n_id)
         if _n_type != null then
-            v.visit(_n_type.as(not null))
+            v.enter_visit(_n_type.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_id)
+        v.enter_visit(_n_id)
         if _n_type != null then
-            v.visit(_n_type.as(not null))
+            v.enter_visit(_n_type.as(not null))
         end
     end
 end
@@ -1206,8 +1189,8 @@ redef class ASuperclass
     private init empty_init do end
 
     init init_asuperclass (
-            n_kwspecial: nullable TKwspecial ,
-            n_type: nullable PType 
+            n_kwspecial: nullable TKwspecial,
+            n_type: nullable AType
     )
     do
         empty_init
@@ -1217,7 +1200,7 @@ redef class ASuperclass
        n_type.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwspecial == old_child then
             if new_child != null then
@@ -1232,7 +1215,7 @@ redef class ASuperclass
         if _n_type == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PType
+               assert new_child isa AType
                 _n_type = new_child
            else
                abort
@@ -1243,14 +1226,14 @@ redef class ASuperclass
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwspecial)
-        v.visit(_n_type)
+        v.enter_visit(_n_kwspecial)
+        v.enter_visit(_n_type)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwspecial)
-        v.visit(_n_type)
+        v.enter_visit(_n_kwspecial)
+        v.enter_visit(_n_type)
     end
 end
 redef class AAttrPropdef
@@ -1324,16 +1307,16 @@ redef class AAttrPropdef
     private init empty_init do end
 
     init init_aattrpropdef (
-            n_doc: nullable PDoc ,
-            n_readable: nullable PAble ,
-            n_writable: nullable PAble ,
-            n_kwredef: nullable TKwredef ,
-            n_visibility: nullable PVisibility ,
-            n_kwattr: nullable TKwattr ,
-            n_kwvar: nullable TKwvar ,
-            n_id: nullable TAttrid ,
-            n_type: nullable PType ,
-            n_expr: nullable PExpr 
+            n_doc: nullable ADoc,
+            n_readable: nullable AAble,
+            n_writable: nullable AAble,
+            n_kwredef: nullable TKwredef,
+            n_visibility: nullable AVisibility,
+            n_kwattr: nullable TKwattr,
+            n_kwvar: nullable TKwvar,
+            n_id: nullable TAttrid,
+            n_type: nullable AType,
+            n_expr: nullable AExpr
     )
     do
         empty_init
@@ -1375,12 +1358,12 @@ redef class AAttrPropdef
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_doc == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PDoc
+               assert new_child isa ADoc
                 _n_doc = new_child
            else
                _n_doc = null
@@ -1390,7 +1373,7 @@ redef class AAttrPropdef
         if _n_readable == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PAble
+               assert new_child isa AAble
                 _n_readable = new_child
            else
                _n_readable = null
@@ -1400,7 +1383,7 @@ redef class AAttrPropdef
         if _n_writable == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PAble
+               assert new_child isa AAble
                 _n_writable = new_child
            else
                _n_writable = null
@@ -1420,7 +1403,7 @@ redef class AAttrPropdef
         if _n_visibility == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PVisibility
+               assert new_child isa AVisibility
                 _n_visibility = new_child
            else
                abort
@@ -1460,7 +1443,7 @@ redef class AAttrPropdef
         if _n_type == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PType
+               assert new_child isa AType
                 _n_type = new_child
            else
                _n_type = null
@@ -1470,7 +1453,7 @@ redef class AAttrPropdef
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                _n_expr = null
@@ -1482,60 +1465,60 @@ redef class AAttrPropdef
     redef fun visit_all(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_readable != null then
-            v.visit(_n_readable.as(not null))
+            v.enter_visit(_n_readable.as(not null))
         end
         if _n_writable != null then
-            v.visit(_n_writable.as(not null))
+            v.enter_visit(_n_writable.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
+        v.enter_visit(_n_visibility)
         if _n_kwattr != null then
-            v.visit(_n_kwattr.as(not null))
+            v.enter_visit(_n_kwattr.as(not null))
         end
         if _n_kwvar != null then
-            v.visit(_n_kwvar.as(not null))
+            v.enter_visit(_n_kwvar.as(not null))
         end
-        v.visit(_n_id)
+        v.enter_visit(_n_id)
         if _n_type != null then
-            v.visit(_n_type.as(not null))
+            v.enter_visit(_n_type.as(not null))
         end
         if _n_expr != null then
-            v.visit(_n_expr.as(not null))
+            v.enter_visit(_n_expr.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_readable != null then
-            v.visit(_n_readable.as(not null))
+            v.enter_visit(_n_readable.as(not null))
         end
         if _n_writable != null then
-            v.visit(_n_writable.as(not null))
+            v.enter_visit(_n_writable.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
+        v.enter_visit(_n_visibility)
         if _n_kwattr != null then
-            v.visit(_n_kwattr.as(not null))
+            v.enter_visit(_n_kwattr.as(not null))
         end
         if _n_kwvar != null then
-            v.visit(_n_kwvar.as(not null))
+            v.enter_visit(_n_kwvar.as(not null))
         end
-        v.visit(_n_id)
+        v.enter_visit(_n_id)
         if _n_type != null then
-            v.visit(_n_type.as(not null))
+            v.enter_visit(_n_type.as(not null))
         end
         if _n_expr != null then
-            v.visit(_n_expr.as(not null))
+            v.enter_visit(_n_expr.as(not null))
         end
     end
 end
@@ -1573,11 +1556,11 @@ redef class AMethPropdef
     private init empty_init do end
 
     init init_amethpropdef (
-            n_doc: nullable PDoc ,
-            n_kwredef: nullable TKwredef ,
-            n_visibility: nullable PVisibility ,
-            n_methid: nullable PMethid ,
-            n_signature: nullable PSignature 
+            n_doc: nullable ADoc,
+            n_kwredef: nullable TKwredef,
+            n_visibility: nullable AVisibility,
+            n_methid: nullable AMethid,
+            n_signature: nullable ASignature
     )
     do
         empty_init
@@ -1597,12 +1580,12 @@ redef class AMethPropdef
        n_signature.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_doc == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PDoc
+               assert new_child isa ADoc
                 _n_doc = new_child
            else
                _n_doc = null
@@ -1622,7 +1605,7 @@ redef class AMethPropdef
         if _n_visibility == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PVisibility
+               assert new_child isa AVisibility
                 _n_visibility = new_child
            else
                abort
@@ -1632,7 +1615,7 @@ redef class AMethPropdef
         if _n_methid == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PMethid
+               assert new_child isa AMethid
                 _n_methid = new_child
            else
                abort
@@ -1642,7 +1625,7 @@ redef class AMethPropdef
         if _n_signature == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PSignature
+               assert new_child isa ASignature
                 _n_signature = new_child
            else
                abort
@@ -1654,27 +1637,27 @@ redef class AMethPropdef
     redef fun visit_all(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_methid)
-        v.visit(_n_signature)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_methid)
+        v.enter_visit(_n_signature)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_methid)
-        v.visit(_n_signature)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_methid)
+        v.enter_visit(_n_signature)
     end
 end
 redef class ADeferredMethPropdef
@@ -1716,12 +1699,12 @@ redef class ADeferredMethPropdef
     private init empty_init do end
 
     init init_adeferredmethpropdef (
-            n_doc: nullable PDoc ,
-            n_kwredef: nullable TKwredef ,
-            n_visibility: nullable PVisibility ,
-            n_kwmeth: nullable TKwmeth ,
-            n_methid: nullable PMethid ,
-            n_signature: nullable PSignature 
+            n_doc: nullable ADoc,
+            n_kwredef: nullable TKwredef,
+            n_visibility: nullable AVisibility,
+            n_kwmeth: nullable TKwmeth,
+            n_methid: nullable AMethid,
+            n_signature: nullable ASignature
     )
     do
         empty_init
@@ -1743,12 +1726,12 @@ redef class ADeferredMethPropdef
        n_signature.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_doc == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PDoc
+               assert new_child isa ADoc
                 _n_doc = new_child
            else
                _n_doc = null
@@ -1768,7 +1751,7 @@ redef class ADeferredMethPropdef
         if _n_visibility == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PVisibility
+               assert new_child isa AVisibility
                 _n_visibility = new_child
            else
                abort
@@ -1788,7 +1771,7 @@ redef class ADeferredMethPropdef
         if _n_methid == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PMethid
+               assert new_child isa AMethid
                 _n_methid = new_child
            else
                abort
@@ -1798,7 +1781,7 @@ redef class ADeferredMethPropdef
         if _n_signature == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PSignature
+               assert new_child isa ASignature
                 _n_signature = new_child
            else
                abort
@@ -1810,29 +1793,29 @@ redef class ADeferredMethPropdef
     redef fun visit_all(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_kwmeth)
-        v.visit(_n_methid)
-        v.visit(_n_signature)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwmeth)
+        v.enter_visit(_n_methid)
+        v.enter_visit(_n_signature)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_kwmeth)
-        v.visit(_n_methid)
-        v.visit(_n_signature)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwmeth)
+        v.enter_visit(_n_methid)
+        v.enter_visit(_n_signature)
     end
 end
 redef class AInternMethPropdef
@@ -1874,12 +1857,12 @@ redef class AInternMethPropdef
     private init empty_init do end
 
     init init_ainternmethpropdef (
-            n_doc: nullable PDoc ,
-            n_kwredef: nullable TKwredef ,
-            n_visibility: nullable PVisibility ,
-            n_kwmeth: nullable TKwmeth ,
-            n_methid: nullable PMethid ,
-            n_signature: nullable PSignature 
+            n_doc: nullable ADoc,
+            n_kwredef: nullable TKwredef,
+            n_visibility: nullable AVisibility,
+            n_kwmeth: nullable TKwmeth,
+            n_methid: nullable AMethid,
+            n_signature: nullable ASignature
     )
     do
         empty_init
@@ -1901,12 +1884,12 @@ redef class AInternMethPropdef
        n_signature.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_doc == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PDoc
+               assert new_child isa ADoc
                 _n_doc = new_child
            else
                _n_doc = null
@@ -1926,7 +1909,7 @@ redef class AInternMethPropdef
         if _n_visibility == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PVisibility
+               assert new_child isa AVisibility
                 _n_visibility = new_child
            else
                abort
@@ -1946,7 +1929,7 @@ redef class AInternMethPropdef
         if _n_methid == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PMethid
+               assert new_child isa AMethid
                 _n_methid = new_child
            else
                abort
@@ -1956,7 +1939,7 @@ redef class AInternMethPropdef
         if _n_signature == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PSignature
+               assert new_child isa ASignature
                 _n_signature = new_child
            else
                abort
@@ -1968,29 +1951,29 @@ redef class AInternMethPropdef
     redef fun visit_all(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_kwmeth)
-        v.visit(_n_methid)
-        v.visit(_n_signature)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwmeth)
+        v.enter_visit(_n_methid)
+        v.enter_visit(_n_signature)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_kwmeth)
-        v.visit(_n_methid)
-        v.visit(_n_signature)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwmeth)
+        v.enter_visit(_n_methid)
+        v.enter_visit(_n_signature)
     end
 end
 redef class AExternMethPropdef
@@ -2039,13 +2022,13 @@ redef class AExternMethPropdef
     private init empty_init do end
 
     init init_aexternmethpropdef (
-            n_doc: nullable PDoc ,
-            n_kwredef: nullable TKwredef ,
-            n_visibility: nullable PVisibility ,
-            n_kwmeth: nullable TKwmeth ,
-            n_methid: nullable PMethid ,
-            n_signature: nullable PSignature ,
-            n_extern: nullable TString 
+            n_doc: nullable ADoc,
+            n_kwredef: nullable TKwredef,
+            n_visibility: nullable AVisibility,
+            n_kwmeth: nullable TKwmeth,
+            n_methid: nullable AMethid,
+            n_signature: nullable ASignature,
+            n_extern: nullable TString
     )
     do
         empty_init
@@ -2071,12 +2054,12 @@ redef class AExternMethPropdef
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_doc == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PDoc
+               assert new_child isa ADoc
                 _n_doc = new_child
            else
                _n_doc = null
@@ -2096,7 +2079,7 @@ redef class AExternMethPropdef
         if _n_visibility == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PVisibility
+               assert new_child isa AVisibility
                 _n_visibility = new_child
            else
                abort
@@ -2116,7 +2099,7 @@ redef class AExternMethPropdef
         if _n_methid == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PMethid
+               assert new_child isa AMethid
                 _n_methid = new_child
            else
                abort
@@ -2126,7 +2109,7 @@ redef class AExternMethPropdef
         if _n_signature == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PSignature
+               assert new_child isa ASignature
                 _n_signature = new_child
            else
                abort
@@ -2148,34 +2131,34 @@ redef class AExternMethPropdef
     redef fun visit_all(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_kwmeth)
-        v.visit(_n_methid)
-        v.visit(_n_signature)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwmeth)
+        v.enter_visit(_n_methid)
+        v.enter_visit(_n_signature)
         if _n_extern != null then
-            v.visit(_n_extern.as(not null))
+            v.enter_visit(_n_extern.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_kwmeth)
-        v.visit(_n_methid)
-        v.visit(_n_signature)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwmeth)
+        v.enter_visit(_n_methid)
+        v.enter_visit(_n_signature)
         if _n_extern != null then
-            v.visit(_n_extern.as(not null))
+            v.enter_visit(_n_extern.as(not null))
         end
     end
 end
@@ -2225,13 +2208,13 @@ redef class AConcreteMethPropdef
     private init empty_init do end
 
     init init_aconcretemethpropdef (
-            n_doc: nullable PDoc ,
-            n_kwredef: nullable TKwredef ,
-            n_visibility: nullable PVisibility ,
-            n_kwmeth: nullable TKwmeth ,
-            n_methid: nullable PMethid ,
-            n_signature: nullable PSignature ,
-            n_block: nullable PExpr 
+            n_doc: nullable ADoc,
+            n_kwredef: nullable TKwredef,
+            n_visibility: nullable AVisibility,
+            n_kwmeth: nullable TKwmeth,
+            n_methid: nullable AMethid,
+            n_signature: nullable ASignature,
+            n_block: nullable AExpr
     )
     do
         empty_init
@@ -2257,12 +2240,12 @@ redef class AConcreteMethPropdef
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_doc == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PDoc
+               assert new_child isa ADoc
                 _n_doc = new_child
            else
                _n_doc = null
@@ -2282,7 +2265,7 @@ redef class AConcreteMethPropdef
         if _n_visibility == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PVisibility
+               assert new_child isa AVisibility
                 _n_visibility = new_child
            else
                abort
@@ -2302,7 +2285,7 @@ redef class AConcreteMethPropdef
         if _n_methid == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PMethid
+               assert new_child isa AMethid
                 _n_methid = new_child
            else
                abort
@@ -2312,7 +2295,7 @@ redef class AConcreteMethPropdef
         if _n_signature == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PSignature
+               assert new_child isa ASignature
                 _n_signature = new_child
            else
                abort
@@ -2322,7 +2305,7 @@ redef class AConcreteMethPropdef
         if _n_block == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_block = new_child
            else
                _n_block = null
@@ -2334,34 +2317,34 @@ redef class AConcreteMethPropdef
     redef fun visit_all(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_kwmeth)
-        v.visit(_n_methid)
-        v.visit(_n_signature)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwmeth)
+        v.enter_visit(_n_methid)
+        v.enter_visit(_n_signature)
         if _n_block != null then
-            v.visit(_n_block.as(not null))
+            v.enter_visit(_n_block.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_kwmeth)
-        v.visit(_n_methid)
-        v.visit(_n_signature)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwmeth)
+        v.enter_visit(_n_methid)
+        v.enter_visit(_n_signature)
         if _n_block != null then
-            v.visit(_n_block.as(not null))
+            v.enter_visit(_n_block.as(not null))
         end
     end
 end
@@ -2413,13 +2396,13 @@ redef class AConcreteInitPropdef
     private init empty_init do end
 
     init init_aconcreteinitpropdef (
-            n_doc: nullable PDoc ,
-            n_kwredef: nullable TKwredef ,
-            n_visibility: nullable PVisibility ,
-            n_kwinit: nullable TKwinit ,
-            n_methid: nullable PMethid ,
-            n_signature: nullable PSignature ,
-            n_block: nullable PExpr 
+            n_doc: nullable ADoc,
+            n_kwredef: nullable TKwredef,
+            n_visibility: nullable AVisibility,
+            n_kwinit: nullable TKwinit,
+            n_methid: nullable AMethid,
+            n_signature: nullable ASignature,
+            n_block: nullable AExpr
     )
     do
         empty_init
@@ -2447,12 +2430,12 @@ redef class AConcreteInitPropdef
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_doc == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PDoc
+               assert new_child isa ADoc
                 _n_doc = new_child
            else
                _n_doc = null
@@ -2472,7 +2455,7 @@ redef class AConcreteInitPropdef
         if _n_visibility == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PVisibility
+               assert new_child isa AVisibility
                 _n_visibility = new_child
            else
                abort
@@ -2492,7 +2475,7 @@ redef class AConcreteInitPropdef
         if _n_methid == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PMethid
+               assert new_child isa AMethid
                 _n_methid = new_child
            else
                _n_methid = null
@@ -2502,7 +2485,7 @@ redef class AConcreteInitPropdef
         if _n_signature == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PSignature
+               assert new_child isa ASignature
                 _n_signature = new_child
            else
                abort
@@ -2512,7 +2495,7 @@ redef class AConcreteInitPropdef
         if _n_block == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_block = new_child
            else
                _n_block = null
@@ -2524,38 +2507,38 @@ redef class AConcreteInitPropdef
     redef fun visit_all(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_kwinit)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwinit)
         if _n_methid != null then
-            v.visit(_n_methid.as(not null))
+            v.enter_visit(_n_methid.as(not null))
         end
-        v.visit(_n_signature)
+        v.enter_visit(_n_signature)
         if _n_block != null then
-            v.visit(_n_block.as(not null))
+            v.enter_visit(_n_block.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_kwinit)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwinit)
         if _n_methid != null then
-            v.visit(_n_methid.as(not null))
+            v.enter_visit(_n_methid.as(not null))
         end
-        v.visit(_n_signature)
+        v.enter_visit(_n_signature)
         if _n_block != null then
-            v.visit(_n_block.as(not null))
+            v.enter_visit(_n_block.as(not null))
         end
     end
 end
@@ -2578,8 +2561,8 @@ redef class AMainMethPropdef
     private init empty_init do end
 
     init init_amainmethpropdef (
-            n_kwredef: nullable TKwredef ,
-            n_block: nullable PExpr 
+            n_kwredef: nullable TKwredef,
+            n_block: nullable AExpr
     )
     do
         empty_init
@@ -2593,7 +2576,7 @@ redef class AMainMethPropdef
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwredef == old_child then
             if new_child != null then
@@ -2608,7 +2591,7 @@ redef class AMainMethPropdef
         if _n_block == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_block = new_child
            else
                _n_block = null
@@ -2620,20 +2603,20 @@ redef class AMainMethPropdef
     redef fun visit_all(v: Visitor)
     do
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
         if _n_block != null then
-            v.visit(_n_block.as(not null))
+            v.enter_visit(_n_block.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
         if _n_block != null then
-            v.visit(_n_block.as(not null))
+            v.enter_visit(_n_block.as(not null))
         end
     end
 end
@@ -2676,12 +2659,12 @@ redef class ATypePropdef
     private init empty_init do end
 
     init init_atypepropdef (
-            n_doc: nullable PDoc ,
-            n_kwredef: nullable TKwredef ,
-            n_visibility: nullable PVisibility ,
-            n_kwtype: nullable TKwtype ,
-            n_id: nullable TClassid ,
-            n_type: nullable PType 
+            n_doc: nullable ADoc,
+            n_kwredef: nullable TKwredef,
+            n_visibility: nullable AVisibility,
+            n_kwtype: nullable TKwtype,
+            n_id: nullable TClassid,
+            n_type: nullable AType
     )
     do
         empty_init
@@ -2703,12 +2686,12 @@ redef class ATypePropdef
        n_type.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_doc == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PDoc
+               assert new_child isa ADoc
                 _n_doc = new_child
            else
                _n_doc = null
@@ -2728,7 +2711,7 @@ redef class ATypePropdef
         if _n_visibility == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PVisibility
+               assert new_child isa AVisibility
                 _n_visibility = new_child
            else
                abort
@@ -2758,7 +2741,7 @@ redef class ATypePropdef
         if _n_type == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PType
+               assert new_child isa AType
                 _n_type = new_child
            else
                abort
@@ -2770,29 +2753,29 @@ redef class ATypePropdef
     redef fun visit_all(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_kwtype)
-        v.visit(_n_id)
-        v.visit(_n_type)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwtype)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_type)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_doc != null then
-            v.visit(_n_doc.as(not null))
+            v.enter_visit(_n_doc.as(not null))
         end
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_visibility)
-        v.visit(_n_kwtype)
-        v.visit(_n_id)
-        v.visit(_n_type)
+        v.enter_visit(_n_visibility)
+        v.enter_visit(_n_kwtype)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_type)
     end
 end
 redef class AReadAble
@@ -2812,8 +2795,8 @@ redef class AReadAble
     private init empty_init do end
 
     init init_areadable (
-            n_kwredef: nullable TKwredef ,
-            n_kwreadable: nullable TKwreadable 
+            n_kwredef: nullable TKwredef,
+            n_kwreadable: nullable TKwreadable
     )
     do
         empty_init
@@ -2825,7 +2808,7 @@ redef class AReadAble
        n_kwreadable.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwredef == old_child then
             if new_child != null then
@@ -2852,17 +2835,17 @@ redef class AReadAble
     redef fun visit_all(v: Visitor)
     do
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_kwreadable)
+        v.enter_visit(_n_kwreadable)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_kwreadable)
+        v.enter_visit(_n_kwreadable)
     end
 end
 redef class AWriteAble
@@ -2882,8 +2865,8 @@ redef class AWriteAble
     private init empty_init do end
 
     init init_awriteable (
-            n_kwredef: nullable TKwredef ,
-            n_kwwritable: nullable TKwwritable 
+            n_kwredef: nullable TKwredef,
+            n_kwwritable: nullable TKwwritable
     )
     do
         empty_init
@@ -2895,7 +2878,7 @@ redef class AWriteAble
        n_kwwritable.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwredef == old_child then
             if new_child != null then
@@ -2922,17 +2905,17 @@ redef class AWriteAble
     redef fun visit_all(v: Visitor)
     do
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_kwwritable)
+        v.enter_visit(_n_kwwritable)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_kwredef != null then
-            v.visit(_n_kwredef.as(not null))
+            v.enter_visit(_n_kwredef.as(not null))
         end
-        v.visit(_n_kwwritable)
+        v.enter_visit(_n_kwwritable)
     end
 end
 redef class AIdMethid
@@ -2945,7 +2928,7 @@ redef class AIdMethid
     private init empty_init do end
 
     init init_aidmethid (
-            n_id: nullable TId 
+            n_id: nullable TId
     )
     do
         empty_init
@@ -2953,7 +2936,7 @@ redef class AIdMethid
        n_id.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_id == old_child then
             if new_child != null then
@@ -2969,12 +2952,12 @@ redef class AIdMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_id)
+        v.enter_visit(_n_id)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_id)
+        v.enter_visit(_n_id)
     end
 end
 redef class APlusMethid
@@ -2987,7 +2970,7 @@ redef class APlusMethid
     private init empty_init do end
 
     init init_aplusmethid (
-            n_plus: nullable TPlus 
+            n_plus: nullable TPlus
     )
     do
         empty_init
@@ -2995,7 +2978,7 @@ redef class APlusMethid
        n_plus.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_plus == old_child then
             if new_child != null then
@@ -3011,12 +2994,12 @@ redef class APlusMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_plus)
+        v.enter_visit(_n_plus)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_plus)
+        v.enter_visit(_n_plus)
     end
 end
 redef class AMinusMethid
@@ -3029,7 +3012,7 @@ redef class AMinusMethid
     private init empty_init do end
 
     init init_aminusmethid (
-            n_minus: nullable TMinus 
+            n_minus: nullable TMinus
     )
     do
         empty_init
@@ -3037,7 +3020,7 @@ redef class AMinusMethid
        n_minus.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_minus == old_child then
             if new_child != null then
@@ -3053,12 +3036,12 @@ redef class AMinusMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_minus)
+        v.enter_visit(_n_minus)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_minus)
+        v.enter_visit(_n_minus)
     end
 end
 redef class AStarMethid
@@ -3071,7 +3054,7 @@ redef class AStarMethid
     private init empty_init do end
 
     init init_astarmethid (
-            n_star: nullable TStar 
+            n_star: nullable TStar
     )
     do
         empty_init
@@ -3079,7 +3062,7 @@ redef class AStarMethid
        n_star.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_star == old_child then
             if new_child != null then
@@ -3095,12 +3078,12 @@ redef class AStarMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_star)
+        v.enter_visit(_n_star)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_star)
+        v.enter_visit(_n_star)
     end
 end
 redef class ASlashMethid
@@ -3113,7 +3096,7 @@ redef class ASlashMethid
     private init empty_init do end
 
     init init_aslashmethid (
-            n_slash: nullable TSlash 
+            n_slash: nullable TSlash
     )
     do
         empty_init
@@ -3121,7 +3104,7 @@ redef class ASlashMethid
        n_slash.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_slash == old_child then
             if new_child != null then
@@ -3137,12 +3120,12 @@ redef class ASlashMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_slash)
+        v.enter_visit(_n_slash)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_slash)
+        v.enter_visit(_n_slash)
     end
 end
 redef class APercentMethid
@@ -3155,7 +3138,7 @@ redef class APercentMethid
     private init empty_init do end
 
     init init_apercentmethid (
-            n_percent: nullable TPercent 
+            n_percent: nullable TPercent
     )
     do
         empty_init
@@ -3163,7 +3146,7 @@ redef class APercentMethid
        n_percent.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_percent == old_child then
             if new_child != null then
@@ -3179,12 +3162,12 @@ redef class APercentMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_percent)
+        v.enter_visit(_n_percent)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_percent)
+        v.enter_visit(_n_percent)
     end
 end
 redef class AEqMethid
@@ -3197,7 +3180,7 @@ redef class AEqMethid
     private init empty_init do end
 
     init init_aeqmethid (
-            n_eq: nullable TEq 
+            n_eq: nullable TEq
     )
     do
         empty_init
@@ -3205,7 +3188,7 @@ redef class AEqMethid
        n_eq.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_eq == old_child then
             if new_child != null then
@@ -3221,12 +3204,12 @@ redef class AEqMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_eq)
+        v.enter_visit(_n_eq)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_eq)
+        v.enter_visit(_n_eq)
     end
 end
 redef class ANeMethid
@@ -3239,7 +3222,7 @@ redef class ANeMethid
     private init empty_init do end
 
     init init_anemethid (
-            n_ne: nullable TNe 
+            n_ne: nullable TNe
     )
     do
         empty_init
@@ -3247,7 +3230,7 @@ redef class ANeMethid
        n_ne.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_ne == old_child then
             if new_child != null then
@@ -3263,12 +3246,12 @@ redef class ANeMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_ne)
+        v.enter_visit(_n_ne)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_ne)
+        v.enter_visit(_n_ne)
     end
 end
 redef class ALeMethid
@@ -3281,7 +3264,7 @@ redef class ALeMethid
     private init empty_init do end
 
     init init_alemethid (
-            n_le: nullable TLe 
+            n_le: nullable TLe
     )
     do
         empty_init
@@ -3289,7 +3272,7 @@ redef class ALeMethid
        n_le.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_le == old_child then
             if new_child != null then
@@ -3305,12 +3288,12 @@ redef class ALeMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_le)
+        v.enter_visit(_n_le)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_le)
+        v.enter_visit(_n_le)
     end
 end
 redef class AGeMethid
@@ -3323,7 +3306,7 @@ redef class AGeMethid
     private init empty_init do end
 
     init init_agemethid (
-            n_ge: nullable TGe 
+            n_ge: nullable TGe
     )
     do
         empty_init
@@ -3331,7 +3314,7 @@ redef class AGeMethid
        n_ge.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_ge == old_child then
             if new_child != null then
@@ -3347,12 +3330,12 @@ redef class AGeMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_ge)
+        v.enter_visit(_n_ge)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_ge)
+        v.enter_visit(_n_ge)
     end
 end
 redef class ALtMethid
@@ -3365,7 +3348,7 @@ redef class ALtMethid
     private init empty_init do end
 
     init init_altmethid (
-            n_lt: nullable TLt 
+            n_lt: nullable TLt
     )
     do
         empty_init
@@ -3373,7 +3356,7 @@ redef class ALtMethid
        n_lt.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_lt == old_child then
             if new_child != null then
@@ -3389,12 +3372,12 @@ redef class ALtMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_lt)
+        v.enter_visit(_n_lt)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_lt)
+        v.enter_visit(_n_lt)
     end
 end
 redef class AGtMethid
@@ -3407,7 +3390,7 @@ redef class AGtMethid
     private init empty_init do end
 
     init init_agtmethid (
-            n_gt: nullable TGt 
+            n_gt: nullable TGt
     )
     do
         empty_init
@@ -3415,7 +3398,7 @@ redef class AGtMethid
        n_gt.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_gt == old_child then
             if new_child != null then
@@ -3431,12 +3414,12 @@ redef class AGtMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_gt)
+        v.enter_visit(_n_gt)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_gt)
+        v.enter_visit(_n_gt)
     end
 end
 redef class ABraMethid
@@ -3454,8 +3437,8 @@ redef class ABraMethid
     private init empty_init do end
 
     init init_abramethid (
-            n_obra: nullable TObra ,
-            n_cbra: nullable TCbra 
+            n_obra: nullable TObra,
+            n_cbra: nullable TCbra
     )
     do
         empty_init
@@ -3465,7 +3448,7 @@ redef class ABraMethid
        n_cbra.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_obra == old_child then
             if new_child != null then
@@ -3491,14 +3474,14 @@ redef class ABraMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_obra)
-        v.visit(_n_cbra)
+        v.enter_visit(_n_obra)
+        v.enter_visit(_n_cbra)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_obra)
-        v.visit(_n_cbra)
+        v.enter_visit(_n_obra)
+        v.enter_visit(_n_cbra)
     end
 end
 redef class AStarshipMethid
@@ -3511,7 +3494,7 @@ redef class AStarshipMethid
     private init empty_init do end
 
     init init_astarshipmethid (
-            n_starship: nullable TStarship 
+            n_starship: nullable TStarship
     )
     do
         empty_init
@@ -3519,7 +3502,7 @@ redef class AStarshipMethid
        n_starship.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_starship == old_child then
             if new_child != null then
@@ -3535,12 +3518,12 @@ redef class AStarshipMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_starship)
+        v.enter_visit(_n_starship)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_starship)
+        v.enter_visit(_n_starship)
     end
 end
 redef class AAssignMethid
@@ -3558,8 +3541,8 @@ redef class AAssignMethid
     private init empty_init do end
 
     init init_aassignmethid (
-            n_id: nullable TId ,
-            n_assign: nullable TAssign 
+            n_id: nullable TId,
+            n_assign: nullable TAssign
     )
     do
         empty_init
@@ -3569,7 +3552,7 @@ redef class AAssignMethid
        n_assign.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_id == old_child then
             if new_child != null then
@@ -3595,14 +3578,14 @@ redef class AAssignMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_id)
-        v.visit(_n_assign)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_assign)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_id)
-        v.visit(_n_assign)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_assign)
     end
 end
 redef class ABraassignMethid
@@ -3625,9 +3608,9 @@ redef class ABraassignMethid
     private init empty_init do end
 
     init init_abraassignmethid (
-            n_obra: nullable TObra ,
-            n_cbra: nullable TCbra ,
-            n_assign: nullable TAssign 
+            n_obra: nullable TObra,
+            n_cbra: nullable TCbra,
+            n_assign: nullable TAssign
     )
     do
         empty_init
@@ -3639,7 +3622,7 @@ redef class ABraassignMethid
        n_assign.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_obra == old_child then
             if new_child != null then
@@ -3675,16 +3658,16 @@ redef class ABraassignMethid
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_obra)
-        v.visit(_n_cbra)
-        v.visit(_n_assign)
+        v.enter_visit(_n_obra)
+        v.enter_visit(_n_cbra)
+        v.enter_visit(_n_assign)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_obra)
-        v.visit(_n_cbra)
-        v.visit(_n_assign)
+        v.enter_visit(_n_obra)
+        v.enter_visit(_n_cbra)
+        v.enter_visit(_n_assign)
     end
 end
 redef class ASignature
@@ -3699,14 +3682,14 @@ redef class ASignature
     private init empty_init do end
 
     init init_asignature (
-            n_params: Collection[Object] , # Should be Collection[PParam]
-            n_type: nullable PType ,
-            n_closure_decls: Collection[Object]  # Should be Collection[PClosureDecl]
+            n_params: Collection[Object], # Should be Collection[AParam]
+            n_type: nullable AType,
+            n_closure_decls: Collection[Object] # Should be Collection[AClosureDecl]
     )
     do
         empty_init
        for n in n_params do
-               assert n isa PParam
+               assert n isa AParam
                _n_params.add(n)
                n.parent = self
        end
@@ -3715,18 +3698,18 @@ redef class ASignature
                n_type.parent = self
        end
        for n in n_closure_decls do
-               assert n isa PClosureDecl
+               assert n isa AClosureDecl
                _n_closure_decls.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         for i in [0.._n_params.length[ do
             if _n_params[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PParam
+                   assert new_child isa AParam
                     _n_params[i] = new_child
                     new_child.parent = self
                 else
@@ -3738,7 +3721,7 @@ redef class ASignature
         if _n_type == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PType
+               assert new_child isa AType
                 _n_type = new_child
            else
                _n_type = null
@@ -3748,7 +3731,7 @@ redef class ASignature
         for i in [0.._n_closure_decls.length[ do
             if _n_closure_decls[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PClosureDecl
+                   assert new_child isa AClosureDecl
                     _n_closure_decls[i] = new_child
                     new_child.parent = self
                 else
@@ -3762,13 +3745,13 @@ redef class ASignature
     redef fun visit_all(v: Visitor)
     do
             for n in _n_params do
-                v.visit(n)
+                v.enter_visit(n)
            end
         if _n_type != null then
-            v.visit(_n_type.as(not null))
+            v.enter_visit(_n_type.as(not null))
         end
             for n in _n_closure_decls do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
@@ -3777,17 +3760,17 @@ redef class ASignature
        do
            var i = _n_params.length
             while i >= 0 do
-                v.visit(_n_params[i])
+                v.enter_visit(_n_params[i])
                i = i - 1
            end
        end
         if _n_type != null then
-            v.visit(_n_type.as(not null))
+            v.enter_visit(_n_type.as(not null))
         end
        do
            var i = _n_closure_decls.length
             while i >= 0 do
-                v.visit(_n_closure_decls[i])
+                v.enter_visit(_n_closure_decls[i])
                i = i - 1
            end
        end
@@ -3817,9 +3800,9 @@ redef class AParam
     private init empty_init do end
 
     init init_aparam (
-            n_id: nullable TId ,
-            n_type: nullable PType ,
-            n_dotdotdot: nullable TDotdotdot 
+            n_id: nullable TId,
+            n_type: nullable AType,
+            n_dotdotdot: nullable TDotdotdot
     )
     do
         empty_init
@@ -3835,7 +3818,7 @@ redef class AParam
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_id == old_child then
             if new_child != null then
@@ -3850,7 +3833,7 @@ redef class AParam
         if _n_type == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PType
+               assert new_child isa AType
                 _n_type = new_child
            else
                _n_type = null
@@ -3871,23 +3854,23 @@ redef class AParam
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_id)
+        v.enter_visit(_n_id)
         if _n_type != null then
-            v.visit(_n_type.as(not null))
+            v.enter_visit(_n_type.as(not null))
         end
         if _n_dotdotdot != null then
-            v.visit(_n_dotdotdot.as(not null))
+            v.enter_visit(_n_dotdotdot.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_id)
+        v.enter_visit(_n_id)
         if _n_type != null then
-            v.visit(_n_type.as(not null))
+            v.enter_visit(_n_type.as(not null))
         end
         if _n_dotdotdot != null then
-            v.visit(_n_dotdotdot.as(not null))
+            v.enter_visit(_n_dotdotdot.as(not null))
         end
     end
 end
@@ -3925,11 +3908,11 @@ redef class AClosureDecl
     private init empty_init do end
 
     init init_aclosuredecl (
-            n_kwwith: nullable TKwwith ,
-            n_kwbreak: nullable TKwbreak ,
-            n_id: nullable TId ,
-            n_signature: nullable PSignature ,
-            n_expr: nullable PExpr 
+            n_kwwith: nullable TKwwith,
+            n_kwbreak: nullable TKwbreak,
+            n_id: nullable TId,
+            n_signature: nullable ASignature,
+            n_expr: nullable AExpr
     )
     do
         empty_init
@@ -3949,7 +3932,7 @@ redef class AClosureDecl
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwwith == old_child then
             if new_child != null then
@@ -3984,7 +3967,7 @@ redef class AClosureDecl
         if _n_signature == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PSignature
+               assert new_child isa ASignature
                 _n_signature = new_child
            else
                abort
@@ -3994,7 +3977,7 @@ redef class AClosureDecl
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                _n_expr = null
@@ -4005,27 +3988,27 @@ redef class AClosureDecl
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwwith)
+        v.enter_visit(_n_kwwith)
         if _n_kwbreak != null then
-            v.visit(_n_kwbreak.as(not null))
+            v.enter_visit(_n_kwbreak.as(not null))
         end
-        v.visit(_n_id)
-        v.visit(_n_signature)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_signature)
         if _n_expr != null then
-            v.visit(_n_expr.as(not null))
+            v.enter_visit(_n_expr.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwwith)
+        v.enter_visit(_n_kwwith)
         if _n_kwbreak != null then
-            v.visit(_n_kwbreak.as(not null))
+            v.enter_visit(_n_kwbreak.as(not null))
         end
-        v.visit(_n_id)
-        v.visit(_n_signature)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_signature)
         if _n_expr != null then
-            v.visit(_n_expr.as(not null))
+            v.enter_visit(_n_expr.as(not null))
         end
     end
 end
@@ -4046,9 +4029,9 @@ redef class AType
     private init empty_init do end
 
     init init_atype (
-            n_kwnullable: nullable TKwnullable ,
-            n_id: nullable TClassid ,
-            n_types: Collection[Object]  # Should be Collection[PType]
+            n_kwnullable: nullable TKwnullable,
+            n_id: nullable TClassid,
+            n_types: Collection[Object] # Should be Collection[AType]
     )
     do
         empty_init
@@ -4059,13 +4042,13 @@ redef class AType
         _n_id = n_id.as(not null)
        n_id.parent = self
        for n in n_types do
-               assert n isa PType
+               assert n isa AType
                _n_types.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwnullable == old_child then
             if new_child != null then
@@ -4090,7 +4073,7 @@ redef class AType
         for i in [0.._n_types.length[ do
             if _n_types[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PType
+                   assert new_child isa AType
                     _n_types[i] = new_child
                     new_child.parent = self
                 else
@@ -4104,51 +4087,113 @@ redef class AType
     redef fun visit_all(v: Visitor)
     do
         if _n_kwnullable != null then
-            v.visit(_n_kwnullable.as(not null))
+            v.enter_visit(_n_kwnullable.as(not null))
         end
-        v.visit(_n_id)
+        v.enter_visit(_n_id)
             for n in _n_types do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_kwnullable != null then
-            v.visit(_n_kwnullable.as(not null))
+            v.enter_visit(_n_kwnullable.as(not null))
         end
-        v.visit(_n_id)
+        v.enter_visit(_n_id)
        do
            var i = _n_types.length
             while i >= 0 do
-                v.visit(_n_types[i])
+                v.enter_visit(_n_types[i])
                i = i - 1
            end
        end
     end
 end
+redef class ALabel
+    redef fun n_kwlabel=(n)
+    do
+        _n_kwlabel = n
+       n.parent = self
+    end
+    redef fun n_id=(n)
+    do
+        _n_id = n
+       n.parent = self
+    end
+
+    private init empty_init do end
+
+    init init_alabel (
+            n_kwlabel: nullable TKwlabel,
+            n_id: nullable TId
+    )
+    do
+        empty_init
+        _n_kwlabel = n_kwlabel.as(not null)
+       n_kwlabel.parent = self
+        _n_id = n_id.as(not null)
+       n_id.parent = self
+    end
+
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+    do
+        if _n_kwlabel == old_child then
+            if new_child != null then
+                new_child.parent = self
+               assert new_child isa TKwlabel
+                _n_kwlabel = new_child
+           else
+               abort
+            end
+            return
+       end
+        if _n_id == old_child then
+            if new_child != null then
+                new_child.parent = self
+               assert new_child isa TId
+                _n_id = new_child
+           else
+               abort
+            end
+            return
+       end
+    end
+
+    redef fun visit_all(v: Visitor)
+    do
+        v.enter_visit(_n_kwlabel)
+        v.enter_visit(_n_id)
+    end
+
+    redef fun visit_all_reverse(v: Visitor)
+    do
+        v.enter_visit(_n_kwlabel)
+        v.enter_visit(_n_id)
+    end
+end
 redef class ABlockExpr
 
     private init empty_init do end
 
     init init_ablockexpr (
-            n_expr: Collection[Object]  # Should be Collection[PExpr]
+            n_expr: Collection[Object] # Should be Collection[AExpr]
     )
     do
         empty_init
        for n in n_expr do
-               assert n isa PExpr
+               assert n isa AExpr
                _n_expr.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         for i in [0.._n_expr.length[ do
             if _n_expr[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PExpr
+                   assert new_child isa AExpr
                     _n_expr[i] = new_child
                     new_child.parent = self
                 else
@@ -4162,7 +4207,7 @@ redef class ABlockExpr
     redef fun visit_all(v: Visitor)
     do
             for n in _n_expr do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
@@ -4171,7 +4216,7 @@ redef class ABlockExpr
        do
            var i = _n_expr.length
             while i >= 0 do
-                v.visit(_n_expr[i])
+                v.enter_visit(_n_expr[i])
                i = i - 1
            end
        end
@@ -4213,11 +4258,11 @@ redef class AVardeclExpr
     private init empty_init do end
 
     init init_avardeclexpr (
-            n_kwvar: nullable TKwvar ,
-            n_id: nullable TId ,
-            n_type: nullable PType ,
-            n_assign: nullable TAssign ,
-            n_expr: nullable PExpr 
+            n_kwvar: nullable TKwvar,
+            n_id: nullable TId,
+            n_type: nullable AType,
+            n_assign: nullable TAssign,
+            n_expr: nullable AExpr
     )
     do
         empty_init
@@ -4239,7 +4284,7 @@ redef class AVardeclExpr
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwvar == old_child then
             if new_child != null then
@@ -4264,7 +4309,7 @@ redef class AVardeclExpr
         if _n_type == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PType
+               assert new_child isa AType
                 _n_type = new_child
            else
                _n_type = null
@@ -4284,7 +4329,7 @@ redef class AVardeclExpr
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                _n_expr = null
@@ -4295,31 +4340,31 @@ redef class AVardeclExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwvar)
-        v.visit(_n_id)
+        v.enter_visit(_n_kwvar)
+        v.enter_visit(_n_id)
         if _n_type != null then
-            v.visit(_n_type.as(not null))
+            v.enter_visit(_n_type.as(not null))
         end
         if _n_assign != null then
-            v.visit(_n_assign.as(not null))
+            v.enter_visit(_n_assign.as(not null))
         end
         if _n_expr != null then
-            v.visit(_n_expr.as(not null))
+            v.enter_visit(_n_expr.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwvar)
-        v.visit(_n_id)
+        v.enter_visit(_n_kwvar)
+        v.enter_visit(_n_id)
         if _n_type != null then
-            v.visit(_n_type.as(not null))
+            v.enter_visit(_n_type.as(not null))
         end
         if _n_assign != null then
-            v.visit(_n_assign.as(not null))
+            v.enter_visit(_n_assign.as(not null))
         end
         if _n_expr != null then
-            v.visit(_n_expr.as(not null))
+            v.enter_visit(_n_expr.as(not null))
         end
     end
 end
@@ -4340,8 +4385,8 @@ redef class AReturnExpr
     private init empty_init do end
 
     init init_areturnexpr (
-            n_kwreturn: nullable TKwreturn ,
-            n_expr: nullable PExpr 
+            n_kwreturn: nullable TKwreturn,
+            n_expr: nullable AExpr
     )
     do
         empty_init
@@ -4353,7 +4398,7 @@ redef class AReturnExpr
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwreturn == old_child then
             if new_child != null then
@@ -4368,7 +4413,7 @@ redef class AReturnExpr
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                _n_expr = null
@@ -4379,17 +4424,17 @@ redef class AReturnExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwreturn)
+        v.enter_visit(_n_kwreturn)
         if _n_expr != null then
-            v.visit(_n_expr.as(not null))
+            v.enter_visit(_n_expr.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwreturn)
+        v.enter_visit(_n_kwreturn)
         if _n_expr != null then
-            v.visit(_n_expr.as(not null))
+            v.enter_visit(_n_expr.as(not null))
         end
     end
 end
@@ -4399,6 +4444,13 @@ redef class ABreakExpr
         _n_kwbreak = n
        n.parent = self
     end
+    redef fun n_label=(n)
+    do
+        _n_label = n
+        if n != null then
+           n.parent = self
+        end
+    end
     redef fun n_expr=(n)
     do
         _n_expr = n
@@ -4410,20 +4462,25 @@ redef class ABreakExpr
     private init empty_init do end
 
     init init_abreakexpr (
-            n_kwbreak: nullable TKwbreak ,
-            n_expr: nullable PExpr 
+            n_kwbreak: nullable TKwbreak,
+            n_label: nullable ALabel,
+            n_expr: nullable AExpr
     )
     do
         empty_init
         _n_kwbreak = n_kwbreak.as(not null)
        n_kwbreak.parent = self
+        _n_label = n_label
+       if n_label != null then
+               n_label.parent = self
+       end
         _n_expr = n_expr
        if n_expr != null then
                n_expr.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwbreak == old_child then
             if new_child != null then
@@ -4435,10 +4492,20 @@ redef class ABreakExpr
             end
             return
        end
+        if _n_label == old_child then
+            if new_child != null then
+                new_child.parent = self
+               assert new_child isa ALabel
+                _n_label = new_child
+           else
+               _n_label = null
+            end
+            return
+       end
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                _n_expr = null
@@ -4449,17 +4516,23 @@ redef class ABreakExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwbreak)
+        v.enter_visit(_n_kwbreak)
+        if _n_label != null then
+            v.enter_visit(_n_label.as(not null))
+        end
         if _n_expr != null then
-            v.visit(_n_expr.as(not null))
+            v.enter_visit(_n_expr.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwbreak)
+        v.enter_visit(_n_kwbreak)
+        if _n_label != null then
+            v.enter_visit(_n_label.as(not null))
+        end
         if _n_expr != null then
-            v.visit(_n_expr.as(not null))
+            v.enter_visit(_n_expr.as(not null))
         end
     end
 end
@@ -4473,7 +4546,7 @@ redef class AAbortExpr
     private init empty_init do end
 
     init init_aabortexpr (
-            n_kwabort: nullable TKwabort 
+            n_kwabort: nullable TKwabort
     )
     do
         empty_init
@@ -4481,7 +4554,7 @@ redef class AAbortExpr
        n_kwabort.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwabort == old_child then
             if new_child != null then
@@ -4497,12 +4570,12 @@ redef class AAbortExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwabort)
+        v.enter_visit(_n_kwabort)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwabort)
+        v.enter_visit(_n_kwabort)
     end
 end
 redef class AContinueExpr
@@ -4511,6 +4584,13 @@ redef class AContinueExpr
         _n_kwcontinue = n
        n.parent = self
     end
+    redef fun n_label=(n)
+    do
+        _n_label = n
+        if n != null then
+           n.parent = self
+        end
+    end
     redef fun n_expr=(n)
     do
         _n_expr = n
@@ -4522,20 +4602,25 @@ redef class AContinueExpr
     private init empty_init do end
 
     init init_acontinueexpr (
-            n_kwcontinue: nullable TKwcontinue ,
-            n_expr: nullable PExpr 
+            n_kwcontinue: nullable TKwcontinue,
+            n_label: nullable ALabel,
+            n_expr: nullable AExpr
     )
     do
         empty_init
         _n_kwcontinue = n_kwcontinue.as(not null)
        n_kwcontinue.parent = self
+        _n_label = n_label
+       if n_label != null then
+               n_label.parent = self
+       end
         _n_expr = n_expr
        if n_expr != null then
                n_expr.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwcontinue == old_child then
             if new_child != null then
@@ -4547,10 +4632,20 @@ redef class AContinueExpr
             end
             return
        end
+        if _n_label == old_child then
+            if new_child != null then
+                new_child.parent = self
+               assert new_child isa ALabel
+                _n_label = new_child
+           else
+               _n_label = null
+            end
+            return
+       end
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                _n_expr = null
@@ -4561,17 +4656,23 @@ redef class AContinueExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwcontinue)
+        v.enter_visit(_n_kwcontinue)
+        if _n_label != null then
+            v.enter_visit(_n_label.as(not null))
+        end
         if _n_expr != null then
-            v.visit(_n_expr.as(not null))
+            v.enter_visit(_n_expr.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwcontinue)
+        v.enter_visit(_n_kwcontinue)
+        if _n_label != null then
+            v.enter_visit(_n_label.as(not null))
+        end
         if _n_expr != null then
-            v.visit(_n_expr.as(not null))
+            v.enter_visit(_n_expr.as(not null))
         end
     end
 end
@@ -4588,12 +4689,20 @@ redef class ADoExpr
            n.parent = self
         end
     end
+    redef fun n_label=(n)
+    do
+        _n_label = n
+        if n != null then
+           n.parent = self
+        end
+    end
 
     private init empty_init do end
 
     init init_adoexpr (
-            n_kwdo: nullable TKwdo ,
-            n_block: nullable PExpr 
+            n_kwdo: nullable TKwdo,
+            n_block: nullable AExpr,
+            n_label: nullable ALabel
     )
     do
         empty_init
@@ -4603,9 +4712,13 @@ redef class ADoExpr
        if n_block != null then
                n_block.parent = self
        end
+        _n_label = n_label
+       if n_label != null then
+               n_label.parent = self
+       end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwdo == old_child then
             if new_child != null then
@@ -4620,28 +4733,44 @@ redef class ADoExpr
         if _n_block == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_block = new_child
            else
                _n_block = null
             end
             return
        end
+        if _n_label == old_child then
+            if new_child != null then
+                new_child.parent = self
+               assert new_child isa ALabel
+                _n_label = new_child
+           else
+               _n_label = null
+            end
+            return
+       end
     end
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwdo)
+        v.enter_visit(_n_kwdo)
         if _n_block != null then
-            v.visit(_n_block.as(not null))
+            v.enter_visit(_n_block.as(not null))
+        end
+        if _n_label != null then
+            v.enter_visit(_n_label.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwdo)
+        v.enter_visit(_n_kwdo)
         if _n_block != null then
-            v.visit(_n_block.as(not null))
+            v.enter_visit(_n_block.as(not null))
+        end
+        if _n_label != null then
+            v.enter_visit(_n_label.as(not null))
         end
     end
 end
@@ -4674,10 +4803,10 @@ redef class AIfExpr
     private init empty_init do end
 
     init init_aifexpr (
-            n_kwif: nullable TKwif ,
-            n_expr: nullable PExpr ,
-            n_then: nullable PExpr ,
-            n_else: nullable PExpr 
+            n_kwif: nullable TKwif,
+            n_expr: nullable AExpr,
+            n_then: nullable AExpr,
+            n_else: nullable AExpr
     )
     do
         empty_init
@@ -4695,7 +4824,7 @@ redef class AIfExpr
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwif == old_child then
             if new_child != null then
@@ -4710,7 +4839,7 @@ redef class AIfExpr
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -4720,7 +4849,7 @@ redef class AIfExpr
         if _n_then == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_then = new_child
            else
                _n_then = null
@@ -4730,7 +4859,7 @@ redef class AIfExpr
         if _n_else == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_else = new_child
            else
                _n_else = null
@@ -4741,25 +4870,25 @@ redef class AIfExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwif)
-        v.visit(_n_expr)
+        v.enter_visit(_n_kwif)
+        v.enter_visit(_n_expr)
         if _n_then != null then
-            v.visit(_n_then.as(not null))
+            v.enter_visit(_n_then.as(not null))
         end
         if _n_else != null then
-            v.visit(_n_else.as(not null))
+            v.enter_visit(_n_else.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwif)
-        v.visit(_n_expr)
+        v.enter_visit(_n_kwif)
+        v.enter_visit(_n_expr)
         if _n_then != null then
-            v.visit(_n_then.as(not null))
+            v.enter_visit(_n_then.as(not null))
         end
         if _n_else != null then
-            v.visit(_n_else.as(not null))
+            v.enter_visit(_n_else.as(not null))
         end
     end
 end
@@ -4798,12 +4927,12 @@ redef class AIfexprExpr
     private init empty_init do end
 
     init init_aifexprexpr (
-            n_kwif: nullable TKwif ,
-            n_expr: nullable PExpr ,
-            n_kwthen: nullable TKwthen ,
-            n_then: nullable PExpr ,
-            n_kwelse: nullable TKwelse ,
-            n_else: nullable PExpr 
+            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
         empty_init
@@ -4821,7 +4950,7 @@ redef class AIfexprExpr
        n_else.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwif == old_child then
             if new_child != null then
@@ -4836,7 +4965,7 @@ redef class AIfexprExpr
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -4856,7 +4985,7 @@ redef class AIfexprExpr
         if _n_then == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_then = new_child
            else
                abort
@@ -4876,7 +5005,7 @@ redef class AIfexprExpr
         if _n_else == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_else = new_child
            else
                abort
@@ -4887,22 +5016,22 @@ redef class AIfexprExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwif)
-        v.visit(_n_expr)
-        v.visit(_n_kwthen)
-        v.visit(_n_then)
-        v.visit(_n_kwelse)
-        v.visit(_n_else)
+        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
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwif)
-        v.visit(_n_expr)
-        v.visit(_n_kwthen)
-        v.visit(_n_then)
-        v.visit(_n_kwelse)
-        v.visit(_n_else)
+        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
 redef class AWhileExpr
@@ -4928,14 +5057,22 @@ redef class AWhileExpr
            n.parent = self
         end
     end
+    redef fun n_label=(n)
+    do
+        _n_label = n
+        if n != null then
+           n.parent = self
+        end
+    end
 
     private init empty_init do end
 
     init init_awhileexpr (
-            n_kwwhile: nullable TKwwhile ,
-            n_expr: nullable PExpr ,
-            n_kwdo: nullable TKwdo ,
-            n_block: nullable PExpr 
+            n_kwwhile: nullable TKwwhile,
+            n_expr: nullable AExpr,
+            n_kwdo: nullable TKwdo,
+            n_block: nullable AExpr,
+            n_label: nullable ALabel
     )
     do
         empty_init
@@ -4949,9 +5086,13 @@ redef class AWhileExpr
        if n_block != null then
                n_block.parent = self
        end
+        _n_label = n_label
+       if n_label != null then
+               n_label.parent = self
+       end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwwhile == old_child then
             if new_child != null then
@@ -4966,7 +5107,7 @@ redef class AWhileExpr
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -4986,32 +5127,48 @@ redef class AWhileExpr
         if _n_block == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_block = new_child
            else
                _n_block = null
             end
             return
        end
+        if _n_label == old_child then
+            if new_child != null then
+                new_child.parent = self
+               assert new_child isa ALabel
+                _n_label = new_child
+           else
+               _n_label = null
+            end
+            return
+       end
     end
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwwhile)
-        v.visit(_n_expr)
-        v.visit(_n_kwdo)
+        v.enter_visit(_n_kwwhile)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_kwdo)
         if _n_block != null then
-            v.visit(_n_block.as(not null))
+            v.enter_visit(_n_block.as(not null))
+        end
+        if _n_label != null then
+            v.enter_visit(_n_label.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwwhile)
-        v.visit(_n_expr)
-        v.visit(_n_kwdo)
+        v.enter_visit(_n_kwwhile)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_kwdo)
         if _n_block != null then
-            v.visit(_n_block.as(not null))
+            v.enter_visit(_n_block.as(not null))
+        end
+        if _n_label != null then
+            v.enter_visit(_n_label.as(not null))
         end
     end
 end
@@ -5043,15 +5200,23 @@ redef class AForExpr
            n.parent = self
         end
     end
+    redef fun n_label=(n)
+    do
+        _n_label = n
+        if n != null then
+           n.parent = self
+        end
+    end
 
     private init empty_init do end
 
     init init_aforexpr (
-            n_kwfor: nullable TKwfor ,
-            n_id: nullable TId ,
-            n_expr: nullable PExpr ,
-            n_kwdo: nullable TKwdo ,
-            n_block: nullable PExpr 
+            n_kwfor: nullable TKwfor,
+            n_id: nullable TId,
+            n_expr: nullable AExpr,
+            n_kwdo: nullable TKwdo,
+            n_block: nullable AExpr,
+            n_label: nullable ALabel
     )
     do
         empty_init
@@ -5067,9 +5232,13 @@ redef class AForExpr
        if n_block != null then
                n_block.parent = self
        end
+        _n_label = n_label
+       if n_label != null then
+               n_label.parent = self
+       end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwfor == old_child then
             if new_child != null then
@@ -5094,7 +5263,7 @@ redef class AForExpr
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -5114,34 +5283,50 @@ redef class AForExpr
         if _n_block == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_block = new_child
            else
                _n_block = null
             end
             return
        end
+        if _n_label == old_child then
+            if new_child != null then
+                new_child.parent = self
+               assert new_child isa ALabel
+                _n_label = new_child
+           else
+               _n_label = null
+            end
+            return
+       end
     end
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwfor)
-        v.visit(_n_id)
-        v.visit(_n_expr)
-        v.visit(_n_kwdo)
+        v.enter_visit(_n_kwfor)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_kwdo)
         if _n_block != null then
-            v.visit(_n_block.as(not null))
+            v.enter_visit(_n_block.as(not null))
+        end
+        if _n_label != null then
+            v.enter_visit(_n_label.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwfor)
-        v.visit(_n_id)
-        v.visit(_n_expr)
-        v.visit(_n_kwdo)
+        v.enter_visit(_n_kwfor)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_kwdo)
         if _n_block != null then
-            v.visit(_n_block.as(not null))
+            v.enter_visit(_n_block.as(not null))
+        end
+        if _n_label != null then
+            v.enter_visit(_n_label.as(not null))
         end
     end
 end
@@ -5167,9 +5352,9 @@ redef class AAssertExpr
     private init empty_init do end
 
     init init_aassertexpr (
-            n_kwassert: nullable TKwassert ,
-            n_id: nullable TId ,
-            n_expr: nullable PExpr 
+            n_kwassert: nullable TKwassert,
+            n_id: nullable TId,
+            n_expr: nullable AExpr
     )
     do
         empty_init
@@ -5183,7 +5368,7 @@ redef class AAssertExpr
        n_expr.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwassert == old_child then
             if new_child != null then
@@ -5208,7 +5393,7 @@ redef class AAssertExpr
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -5219,20 +5404,20 @@ redef class AAssertExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwassert)
+        v.enter_visit(_n_kwassert)
         if _n_id != null then
-            v.visit(_n_id.as(not null))
+            v.enter_visit(_n_id.as(not null))
         end
-        v.visit(_n_expr)
+        v.enter_visit(_n_expr)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwassert)
+        v.enter_visit(_n_kwassert)
         if _n_id != null then
-            v.visit(_n_id.as(not null))
+            v.enter_visit(_n_id.as(not null))
         end
-        v.visit(_n_expr)
+        v.enter_visit(_n_expr)
     end
 end
 redef class AOnceExpr
@@ -5250,8 +5435,8 @@ redef class AOnceExpr
     private init empty_init do end
 
     init init_aonceexpr (
-            n_kwonce: nullable TKwonce ,
-            n_expr: nullable PExpr 
+            n_kwonce: nullable TKwonce,
+            n_expr: nullable AExpr
     )
     do
         empty_init
@@ -5261,7 +5446,7 @@ redef class AOnceExpr
        n_expr.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwonce == old_child then
             if new_child != null then
@@ -5276,7 +5461,7 @@ redef class AOnceExpr
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -5287,14 +5472,14 @@ redef class AOnceExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwonce)
-        v.visit(_n_expr)
+        v.enter_visit(_n_kwonce)
+        v.enter_visit(_n_expr)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwonce)
-        v.visit(_n_expr)
+        v.enter_visit(_n_kwonce)
+        v.enter_visit(_n_expr)
     end
 end
 redef class ASendExpr
@@ -5307,7 +5492,7 @@ redef class ASendExpr
     private init empty_init do end
 
     init init_asendexpr (
-            n_expr: nullable PExpr 
+            n_expr: nullable AExpr
     )
     do
         empty_init
@@ -5315,12 +5500,12 @@ redef class ASendExpr
        n_expr.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -5331,12 +5516,12 @@ redef class ASendExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
+        v.enter_visit(_n_expr)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
+        v.enter_visit(_n_expr)
     end
 end
 redef class ABinopExpr
@@ -5354,8 +5539,8 @@ redef class ABinopExpr
     private init empty_init do end
 
     init init_abinopexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -5365,12 +5550,12 @@ redef class ABinopExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -5380,7 +5565,7 @@ redef class ABinopExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -5391,14 +5576,14 @@ redef class ABinopExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class AOrExpr
@@ -5416,8 +5601,8 @@ redef class AOrExpr
     private init empty_init do end
 
     init init_aorexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -5427,12 +5612,12 @@ redef class AOrExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -5442,7 +5627,7 @@ redef class AOrExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -5453,14 +5638,14 @@ redef class AOrExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class AAndExpr
@@ -5478,8 +5663,8 @@ redef class AAndExpr
     private init empty_init do end
 
     init init_aandexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -5489,12 +5674,12 @@ redef class AAndExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -5504,7 +5689,7 @@ redef class AAndExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -5515,14 +5700,14 @@ redef class AAndExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class ANotExpr
@@ -5540,8 +5725,8 @@ redef class ANotExpr
     private init empty_init do end
 
     init init_anotexpr (
-            n_kwnot: nullable TKwnot ,
-            n_expr: nullable PExpr 
+            n_kwnot: nullable TKwnot,
+            n_expr: nullable AExpr
     )
     do
         empty_init
@@ -5551,7 +5736,7 @@ redef class ANotExpr
        n_expr.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwnot == old_child then
             if new_child != null then
@@ -5566,7 +5751,7 @@ redef class ANotExpr
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -5577,14 +5762,14 @@ redef class ANotExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwnot)
-        v.visit(_n_expr)
+        v.enter_visit(_n_kwnot)
+        v.enter_visit(_n_expr)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwnot)
-        v.visit(_n_expr)
+        v.enter_visit(_n_kwnot)
+        v.enter_visit(_n_expr)
     end
 end
 redef class AEqExpr
@@ -5602,8 +5787,8 @@ redef class AEqExpr
     private init empty_init do end
 
     init init_aeqexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -5613,12 +5798,12 @@ redef class AEqExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -5628,7 +5813,7 @@ redef class AEqExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -5639,14 +5824,14 @@ redef class AEqExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class AEeExpr
@@ -5664,8 +5849,8 @@ redef class AEeExpr
     private init empty_init do end
 
     init init_aeeexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -5675,12 +5860,12 @@ redef class AEeExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -5690,7 +5875,7 @@ redef class AEeExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -5701,14 +5886,14 @@ redef class AEeExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class ANeExpr
@@ -5726,8 +5911,8 @@ redef class ANeExpr
     private init empty_init do end
 
     init init_aneexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -5737,12 +5922,12 @@ redef class ANeExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -5752,7 +5937,7 @@ redef class ANeExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -5763,14 +5948,14 @@ redef class ANeExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class ALtExpr
@@ -5788,8 +5973,8 @@ redef class ALtExpr
     private init empty_init do end
 
     init init_altexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -5799,12 +5984,12 @@ redef class ALtExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -5814,7 +5999,7 @@ redef class ALtExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -5825,14 +6010,14 @@ redef class ALtExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class ALeExpr
@@ -5850,8 +6035,8 @@ redef class ALeExpr
     private init empty_init do end
 
     init init_aleexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -5861,12 +6046,12 @@ redef class ALeExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -5876,7 +6061,7 @@ redef class ALeExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -5887,14 +6072,14 @@ redef class ALeExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class AGtExpr
@@ -5912,8 +6097,8 @@ redef class AGtExpr
     private init empty_init do end
 
     init init_agtexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -5923,12 +6108,12 @@ redef class AGtExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -5938,7 +6123,7 @@ redef class AGtExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -5949,14 +6134,14 @@ redef class AGtExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class AGeExpr
@@ -5974,8 +6159,8 @@ redef class AGeExpr
     private init empty_init do end
 
     init init_ageexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -5985,12 +6170,12 @@ redef class AGeExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -6000,7 +6185,7 @@ redef class AGeExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -6011,14 +6196,14 @@ redef class AGeExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class AIsaExpr
@@ -6036,8 +6221,8 @@ redef class AIsaExpr
     private init empty_init do end
 
     init init_aisaexpr (
-            n_expr: nullable PExpr ,
-            n_type: nullable PType 
+            n_expr: nullable AExpr,
+            n_type: nullable AType
     )
     do
         empty_init
@@ -6047,12 +6232,12 @@ redef class AIsaExpr
        n_type.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -6062,7 +6247,7 @@ redef class AIsaExpr
         if _n_type == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PType
+               assert new_child isa AType
                 _n_type = new_child
            else
                abort
@@ -6073,14 +6258,14 @@ redef class AIsaExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_type)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_type)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_type)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_type)
     end
 end
 redef class APlusExpr
@@ -6098,8 +6283,8 @@ redef class APlusExpr
     private init empty_init do end
 
     init init_aplusexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -6109,12 +6294,12 @@ redef class APlusExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -6124,7 +6309,7 @@ redef class APlusExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -6135,14 +6320,14 @@ redef class APlusExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class AMinusExpr
@@ -6160,8 +6345,8 @@ redef class AMinusExpr
     private init empty_init do end
 
     init init_aminusexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -6171,12 +6356,12 @@ redef class AMinusExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -6186,7 +6371,7 @@ redef class AMinusExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -6197,14 +6382,14 @@ redef class AMinusExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class AStarshipExpr
@@ -6222,8 +6407,8 @@ redef class AStarshipExpr
     private init empty_init do end
 
     init init_astarshipexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -6233,12 +6418,12 @@ redef class AStarshipExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -6248,7 +6433,7 @@ redef class AStarshipExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -6259,14 +6444,14 @@ redef class AStarshipExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class AStarExpr
@@ -6284,8 +6469,8 @@ redef class AStarExpr
     private init empty_init do end
 
     init init_astarexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -6295,12 +6480,12 @@ redef class AStarExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -6310,7 +6495,7 @@ redef class AStarExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -6321,14 +6506,14 @@ redef class AStarExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class ASlashExpr
@@ -6346,8 +6531,8 @@ redef class ASlashExpr
     private init empty_init do end
 
     init init_aslashexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -6357,12 +6542,12 @@ redef class ASlashExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -6372,7 +6557,7 @@ redef class ASlashExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -6383,14 +6568,14 @@ redef class ASlashExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class APercentExpr
@@ -6408,8 +6593,8 @@ redef class APercentExpr
     private init empty_init do end
 
     init init_apercentexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -6419,12 +6604,12 @@ redef class APercentExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -6434,7 +6619,7 @@ redef class APercentExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -6445,14 +6630,14 @@ redef class APercentExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class AUminusExpr
@@ -6470,8 +6655,8 @@ redef class AUminusExpr
     private init empty_init do end
 
     init init_auminusexpr (
-            n_minus: nullable TMinus ,
-            n_expr: nullable PExpr 
+            n_minus: nullable TMinus,
+            n_expr: nullable AExpr
     )
     do
         empty_init
@@ -6481,7 +6666,7 @@ redef class AUminusExpr
        n_expr.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_minus == old_child then
             if new_child != null then
@@ -6496,7 +6681,7 @@ redef class AUminusExpr
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -6507,14 +6692,14 @@ redef class AUminusExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_minus)
-        v.visit(_n_expr)
+        v.enter_visit(_n_minus)
+        v.enter_visit(_n_expr)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_minus)
-        v.visit(_n_expr)
+        v.enter_visit(_n_minus)
+        v.enter_visit(_n_expr)
     end
 end
 redef class ANewExpr
@@ -6539,10 +6724,10 @@ redef class ANewExpr
     private init empty_init do end
 
     init init_anewexpr (
-            n_kwnew: nullable TKwnew ,
-            n_type: nullable PType ,
-            n_id: nullable TId ,
-            n_args: Collection[Object]  # Should be Collection[PExpr]
+            n_kwnew: nullable TKwnew,
+            n_type: nullable AType,
+            n_id: nullable TId,
+            n_args: Collection[Object] # Should be Collection[AExpr]
     )
     do
         empty_init
@@ -6555,13 +6740,13 @@ redef class ANewExpr
                n_id.parent = self
        end
        for n in n_args do
-               assert n isa PExpr
+               assert n isa AExpr
                _n_args.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwnew == old_child then
             if new_child != null then
@@ -6576,7 +6761,7 @@ redef class ANewExpr
         if _n_type == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PType
+               assert new_child isa AType
                 _n_type = new_child
            else
                abort
@@ -6596,7 +6781,7 @@ redef class ANewExpr
         for i in [0.._n_args.length[ do
             if _n_args[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PExpr
+                   assert new_child isa AExpr
                     _n_args[i] = new_child
                     new_child.parent = self
                 else
@@ -6609,27 +6794,27 @@ redef class ANewExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwnew)
-        v.visit(_n_type)
+        v.enter_visit(_n_kwnew)
+        v.enter_visit(_n_type)
         if _n_id != null then
-            v.visit(_n_id.as(not null))
+            v.enter_visit(_n_id.as(not null))
         end
             for n in _n_args do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwnew)
-        v.visit(_n_type)
+        v.enter_visit(_n_kwnew)
+        v.enter_visit(_n_type)
         if _n_id != null then
-            v.visit(_n_id.as(not null))
+            v.enter_visit(_n_id.as(not null))
         end
        do
            var i = _n_args.length
             while i >= 0 do
-                v.visit(_n_args[i])
+                v.enter_visit(_n_args[i])
                i = i - 1
            end
        end
@@ -6650,8 +6835,8 @@ redef class AAttrExpr
     private init empty_init do end
 
     init init_aattrexpr (
-            n_expr: nullable PExpr ,
-            n_id: nullable TAttrid 
+            n_expr: nullable AExpr,
+            n_id: nullable TAttrid
     )
     do
         empty_init
@@ -6661,12 +6846,12 @@ redef class AAttrExpr
        n_id.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -6687,14 +6872,14 @@ redef class AAttrExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_id)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_id)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_id)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_id)
     end
 end
 redef class AAttrAssignExpr
@@ -6722,10 +6907,10 @@ redef class AAttrAssignExpr
     private init empty_init do end
 
     init init_aattrassignexpr (
-            n_expr: nullable PExpr ,
-            n_id: nullable TAttrid ,
-            n_assign: nullable TAssign ,
-            n_value: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_id: nullable TAttrid,
+            n_assign: nullable TAssign,
+            n_value: nullable AExpr
     )
     do
         empty_init
@@ -6739,12 +6924,12 @@ redef class AAttrAssignExpr
        n_value.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -6774,7 +6959,7 @@ redef class AAttrAssignExpr
         if _n_value == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_value = new_child
            else
                abort
@@ -6785,18 +6970,18 @@ redef class AAttrAssignExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_id)
-        v.visit(_n_assign)
-        v.visit(_n_value)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_assign)
+        v.enter_visit(_n_value)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_id)
-        v.visit(_n_assign)
-        v.visit(_n_value)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_assign)
+        v.enter_visit(_n_value)
     end
 end
 redef class AAttrReassignExpr
@@ -6824,10 +7009,10 @@ redef class AAttrReassignExpr
     private init empty_init do end
 
     init init_aattrreassignexpr (
-            n_expr: nullable PExpr ,
-            n_id: nullable TAttrid ,
-            n_assign_op: nullable PAssignOp ,
-            n_value: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_id: nullable TAttrid,
+            n_assign_op: nullable AAssignOp,
+            n_value: nullable AExpr
     )
     do
         empty_init
@@ -6841,12 +7026,12 @@ redef class AAttrReassignExpr
        n_value.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -6866,7 +7051,7 @@ redef class AAttrReassignExpr
         if _n_assign_op == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PAssignOp
+               assert new_child isa AAssignOp
                 _n_assign_op = new_child
            else
                abort
@@ -6876,7 +7061,7 @@ redef class AAttrReassignExpr
         if _n_value == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_value = new_child
            else
                abort
@@ -6887,18 +7072,18 @@ redef class AAttrReassignExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_id)
-        v.visit(_n_assign_op)
-        v.visit(_n_value)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_assign_op)
+        v.enter_visit(_n_value)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_id)
-        v.visit(_n_assign_op)
-        v.visit(_n_value)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_assign_op)
+        v.enter_visit(_n_value)
     end
 end
 redef class ACallExpr
@@ -6916,10 +7101,10 @@ redef class ACallExpr
     private init empty_init do end
 
     init init_acallexpr (
-            n_expr: nullable PExpr ,
-            n_id: nullable TId ,
-            n_args: Collection[Object] , # Should be Collection[PExpr]
-            n_closure_defs: Collection[Object]  # Should be Collection[PClosureDef]
+            n_expr: nullable AExpr,
+            n_id: nullable TId,
+            n_args: Collection[Object], # Should be Collection[AExpr]
+            n_closure_defs: Collection[Object] # Should be Collection[AClosureDef]
     )
     do
         empty_init
@@ -6928,23 +7113,23 @@ redef class ACallExpr
         _n_id = n_id.as(not null)
        n_id.parent = self
        for n in n_args do
-               assert n isa PExpr
+               assert n isa AExpr
                _n_args.add(n)
                n.parent = self
        end
        for n in n_closure_defs do
-               assert n isa PClosureDef
+               assert n isa AClosureDef
                _n_closure_defs.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -6964,7 +7149,7 @@ redef class ACallExpr
         for i in [0.._n_args.length[ do
             if _n_args[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PExpr
+                   assert new_child isa AExpr
                     _n_args[i] = new_child
                     new_child.parent = self
                 else
@@ -6976,7 +7161,7 @@ redef class ACallExpr
         for i in [0.._n_closure_defs.length[ do
             if _n_closure_defs[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PClosureDef
+                   assert new_child isa AClosureDef
                     _n_closure_defs[i] = new_child
                     new_child.parent = self
                 else
@@ -6989,31 +7174,31 @@ redef class ACallExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_id)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_id)
             for n in _n_args do
-                v.visit(n)
+                v.enter_visit(n)
            end
             for n in _n_closure_defs do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_id)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_id)
        do
            var i = _n_args.length
             while i >= 0 do
-                v.visit(_n_args[i])
+                v.enter_visit(_n_args[i])
                i = i - 1
            end
        end
        do
            var i = _n_closure_defs.length
             while i >= 0 do
-                v.visit(_n_closure_defs[i])
+                v.enter_visit(_n_closure_defs[i])
                i = i - 1
            end
        end
@@ -7044,11 +7229,11 @@ redef class ACallAssignExpr
     private init empty_init do end
 
     init init_acallassignexpr (
-            n_expr: nullable PExpr ,
-            n_id: nullable TId ,
-            n_args: Collection[Object] , # Should be Collection[PExpr]
-            n_assign: nullable TAssign ,
-            n_value: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_id: nullable TId,
+            n_args: Collection[Object], # Should be Collection[AExpr]
+            n_assign: nullable TAssign,
+            n_value: nullable AExpr
     )
     do
         empty_init
@@ -7057,7 +7242,7 @@ redef class ACallAssignExpr
         _n_id = n_id.as(not null)
        n_id.parent = self
        for n in n_args do
-               assert n isa PExpr
+               assert n isa AExpr
                _n_args.add(n)
                n.parent = self
        end
@@ -7067,12 +7252,12 @@ redef class ACallAssignExpr
        n_value.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -7092,7 +7277,7 @@ redef class ACallAssignExpr
         for i in [0.._n_args.length[ do
             if _n_args[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PExpr
+                   assert new_child isa AExpr
                     _n_args[i] = new_child
                     new_child.parent = self
                 else
@@ -7114,7 +7299,7 @@ redef class ACallAssignExpr
         if _n_value == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_value = new_child
            else
                abort
@@ -7125,28 +7310,28 @@ redef class ACallAssignExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_id)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_id)
             for n in _n_args do
-                v.visit(n)
+                v.enter_visit(n)
            end
-        v.visit(_n_assign)
-        v.visit(_n_value)
+        v.enter_visit(_n_assign)
+        v.enter_visit(_n_value)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_id)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_id)
        do
            var i = _n_args.length
             while i >= 0 do
-                v.visit(_n_args[i])
+                v.enter_visit(_n_args[i])
                i = i - 1
            end
        end
-        v.visit(_n_assign)
-        v.visit(_n_value)
+        v.enter_visit(_n_assign)
+        v.enter_visit(_n_value)
     end
 end
 redef class ACallReassignExpr
@@ -7174,11 +7359,11 @@ redef class ACallReassignExpr
     private init empty_init do end
 
     init init_acallreassignexpr (
-            n_expr: nullable PExpr ,
-            n_id: nullable TId ,
-            n_args: Collection[Object] , # Should be Collection[PExpr]
-            n_assign_op: nullable PAssignOp ,
-            n_value: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_id: nullable TId,
+            n_args: Collection[Object], # Should be Collection[AExpr]
+            n_assign_op: nullable AAssignOp,
+            n_value: nullable AExpr
     )
     do
         empty_init
@@ -7187,7 +7372,7 @@ redef class ACallReassignExpr
         _n_id = n_id.as(not null)
        n_id.parent = self
        for n in n_args do
-               assert n isa PExpr
+               assert n isa AExpr
                _n_args.add(n)
                n.parent = self
        end
@@ -7197,12 +7382,12 @@ redef class ACallReassignExpr
        n_value.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -7222,7 +7407,7 @@ redef class ACallReassignExpr
         for i in [0.._n_args.length[ do
             if _n_args[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PExpr
+                   assert new_child isa AExpr
                     _n_args[i] = new_child
                     new_child.parent = self
                 else
@@ -7234,7 +7419,7 @@ redef class ACallReassignExpr
         if _n_assign_op == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PAssignOp
+               assert new_child isa AAssignOp
                 _n_assign_op = new_child
            else
                abort
@@ -7244,7 +7429,7 @@ redef class ACallReassignExpr
         if _n_value == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_value = new_child
            else
                abort
@@ -7255,28 +7440,28 @@ redef class ACallReassignExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_id)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_id)
             for n in _n_args do
-                v.visit(n)
+                v.enter_visit(n)
            end
-        v.visit(_n_assign_op)
-        v.visit(_n_value)
+        v.enter_visit(_n_assign_op)
+        v.enter_visit(_n_value)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_id)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_id)
        do
            var i = _n_args.length
             while i >= 0 do
-                v.visit(_n_args[i])
+                v.enter_visit(_n_args[i])
                i = i - 1
            end
        end
-        v.visit(_n_assign_op)
-        v.visit(_n_value)
+        v.enter_visit(_n_assign_op)
+        v.enter_visit(_n_value)
     end
 end
 redef class ASuperExpr
@@ -7296,9 +7481,9 @@ redef class ASuperExpr
     private init empty_init do end
 
     init init_asuperexpr (
-            n_qualified: nullable PQualified ,
-            n_kwsuper: nullable TKwsuper ,
-            n_args: Collection[Object]  # Should be Collection[PExpr]
+            n_qualified: nullable AQualified,
+            n_kwsuper: nullable TKwsuper,
+            n_args: Collection[Object] # Should be Collection[AExpr]
     )
     do
         empty_init
@@ -7309,18 +7494,18 @@ redef class ASuperExpr
         _n_kwsuper = n_kwsuper.as(not null)
        n_kwsuper.parent = self
        for n in n_args do
-               assert n isa PExpr
+               assert n isa AExpr
                _n_args.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_qualified == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PQualified
+               assert new_child isa AQualified
                 _n_qualified = new_child
            else
                _n_qualified = null
@@ -7340,7 +7525,7 @@ redef class ASuperExpr
         for i in [0.._n_args.length[ do
             if _n_args[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PExpr
+                   assert new_child isa AExpr
                     _n_args[i] = new_child
                     new_child.parent = self
                 else
@@ -7354,24 +7539,24 @@ redef class ASuperExpr
     redef fun visit_all(v: Visitor)
     do
         if _n_qualified != null then
-            v.visit(_n_qualified.as(not null))
+            v.enter_visit(_n_qualified.as(not null))
         end
-        v.visit(_n_kwsuper)
+        v.enter_visit(_n_kwsuper)
             for n in _n_args do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
         if _n_qualified != null then
-            v.visit(_n_qualified.as(not null))
+            v.enter_visit(_n_qualified.as(not null))
         end
-        v.visit(_n_kwsuper)
+        v.enter_visit(_n_kwsuper)
        do
            var i = _n_args.length
             while i >= 0 do
-                v.visit(_n_args[i])
+                v.enter_visit(_n_args[i])
                i = i - 1
            end
        end
@@ -7392,9 +7577,9 @@ redef class AInitExpr
     private init empty_init do end
 
     init init_ainitexpr (
-            n_expr: nullable PExpr ,
-            n_kwinit: nullable TKwinit ,
-            n_args: Collection[Object]  # Should be Collection[PExpr]
+            n_expr: nullable AExpr,
+            n_kwinit: nullable TKwinit,
+            n_args: Collection[Object] # Should be Collection[AExpr]
     )
     do
         empty_init
@@ -7403,18 +7588,18 @@ redef class AInitExpr
         _n_kwinit = n_kwinit.as(not null)
        n_kwinit.parent = self
        for n in n_args do
-               assert n isa PExpr
+               assert n isa AExpr
                _n_args.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -7434,7 +7619,7 @@ redef class AInitExpr
         for i in [0.._n_args.length[ do
             if _n_args[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PExpr
+                   assert new_child isa AExpr
                     _n_args[i] = new_child
                     new_child.parent = self
                 else
@@ -7447,21 +7632,21 @@ redef class AInitExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_kwinit)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_kwinit)
             for n in _n_args do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_kwinit)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_kwinit)
        do
            var i = _n_args.length
             while i >= 0 do
-                v.visit(_n_args[i])
+                v.enter_visit(_n_args[i])
                i = i - 1
            end
        end
@@ -7477,32 +7662,32 @@ redef class ABraExpr
     private init empty_init do end
 
     init init_abraexpr (
-            n_expr: nullable PExpr ,
-            n_args: Collection[Object] , # Should be Collection[PExpr]
-            n_closure_defs: Collection[Object]  # Should be Collection[PClosureDef]
+            n_expr: nullable AExpr,
+            n_args: Collection[Object], # Should be Collection[AExpr]
+            n_closure_defs: Collection[Object] # Should be Collection[AClosureDef]
     )
     do
         empty_init
         _n_expr = n_expr.as(not null)
        n_expr.parent = self
        for n in n_args do
-               assert n isa PExpr
+               assert n isa AExpr
                _n_args.add(n)
                n.parent = self
        end
        for n in n_closure_defs do
-               assert n isa PClosureDef
+               assert n isa AClosureDef
                _n_closure_defs.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -7512,7 +7697,7 @@ redef class ABraExpr
         for i in [0.._n_args.length[ do
             if _n_args[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PExpr
+                   assert new_child isa AExpr
                     _n_args[i] = new_child
                     new_child.parent = self
                 else
@@ -7524,7 +7709,7 @@ redef class ABraExpr
         for i in [0.._n_closure_defs.length[ do
             if _n_closure_defs[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PClosureDef
+                   assert new_child isa AClosureDef
                     _n_closure_defs[i] = new_child
                     new_child.parent = self
                 else
@@ -7537,29 +7722,29 @@ redef class ABraExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
+        v.enter_visit(_n_expr)
             for n in _n_args do
-                v.visit(n)
+                v.enter_visit(n)
            end
             for n in _n_closure_defs do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
+        v.enter_visit(_n_expr)
        do
            var i = _n_args.length
             while i >= 0 do
-                v.visit(_n_args[i])
+                v.enter_visit(_n_args[i])
                i = i - 1
            end
        end
        do
            var i = _n_closure_defs.length
             while i >= 0 do
-                v.visit(_n_closure_defs[i])
+                v.enter_visit(_n_closure_defs[i])
                i = i - 1
            end
        end
@@ -7585,17 +7770,17 @@ redef class ABraAssignExpr
     private init empty_init do end
 
     init init_abraassignexpr (
-            n_expr: nullable PExpr ,
-            n_args: Collection[Object] , # Should be Collection[PExpr]
-            n_assign: nullable TAssign ,
-            n_value: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_args: Collection[Object], # Should be Collection[AExpr]
+            n_assign: nullable TAssign,
+            n_value: nullable AExpr
     )
     do
         empty_init
         _n_expr = n_expr.as(not null)
        n_expr.parent = self
        for n in n_args do
-               assert n isa PExpr
+               assert n isa AExpr
                _n_args.add(n)
                n.parent = self
        end
@@ -7605,12 +7790,12 @@ redef class ABraAssignExpr
        n_value.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -7620,7 +7805,7 @@ redef class ABraAssignExpr
         for i in [0.._n_args.length[ do
             if _n_args[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PExpr
+                   assert new_child isa AExpr
                     _n_args[i] = new_child
                     new_child.parent = self
                 else
@@ -7642,7 +7827,7 @@ redef class ABraAssignExpr
         if _n_value == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_value = new_child
            else
                abort
@@ -7653,26 +7838,26 @@ redef class ABraAssignExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
+        v.enter_visit(_n_expr)
             for n in _n_args do
-                v.visit(n)
+                v.enter_visit(n)
            end
-        v.visit(_n_assign)
-        v.visit(_n_value)
+        v.enter_visit(_n_assign)
+        v.enter_visit(_n_value)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
+        v.enter_visit(_n_expr)
        do
            var i = _n_args.length
             while i >= 0 do
-                v.visit(_n_args[i])
+                v.enter_visit(_n_args[i])
                i = i - 1
            end
        end
-        v.visit(_n_assign)
-        v.visit(_n_value)
+        v.enter_visit(_n_assign)
+        v.enter_visit(_n_value)
     end
 end
 redef class ABraReassignExpr
@@ -7695,17 +7880,17 @@ redef class ABraReassignExpr
     private init empty_init do end
 
     init init_abrareassignexpr (
-            n_expr: nullable PExpr ,
-            n_args: Collection[Object] , # Should be Collection[PExpr]
-            n_assign_op: nullable PAssignOp ,
-            n_value: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_args: Collection[Object], # Should be Collection[AExpr]
+            n_assign_op: nullable AAssignOp,
+            n_value: nullable AExpr
     )
     do
         empty_init
         _n_expr = n_expr.as(not null)
        n_expr.parent = self
        for n in n_args do
-               assert n isa PExpr
+               assert n isa AExpr
                _n_args.add(n)
                n.parent = self
        end
@@ -7715,12 +7900,12 @@ redef class ABraReassignExpr
        n_value.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -7730,7 +7915,7 @@ redef class ABraReassignExpr
         for i in [0.._n_args.length[ do
             if _n_args[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PExpr
+                   assert new_child isa AExpr
                     _n_args[i] = new_child
                     new_child.parent = self
                 else
@@ -7742,7 +7927,7 @@ redef class ABraReassignExpr
         if _n_assign_op == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PAssignOp
+               assert new_child isa AAssignOp
                 _n_assign_op = new_child
            else
                abort
@@ -7752,7 +7937,7 @@ redef class ABraReassignExpr
         if _n_value == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_value = new_child
            else
                abort
@@ -7763,26 +7948,26 @@ redef class ABraReassignExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
+        v.enter_visit(_n_expr)
             for n in _n_args do
-                v.visit(n)
+                v.enter_visit(n)
            end
-        v.visit(_n_assign_op)
-        v.visit(_n_value)
+        v.enter_visit(_n_assign_op)
+        v.enter_visit(_n_value)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
+        v.enter_visit(_n_expr)
        do
            var i = _n_args.length
             while i >= 0 do
-                v.visit(_n_args[i])
+                v.enter_visit(_n_args[i])
                i = i - 1
            end
        end
-        v.visit(_n_assign_op)
-        v.visit(_n_value)
+        v.enter_visit(_n_assign_op)
+        v.enter_visit(_n_value)
     end
 end
 redef class AClosureCallExpr
@@ -7795,27 +7980,27 @@ redef class AClosureCallExpr
     private init empty_init do end
 
     init init_aclosurecallexpr (
-            n_id: nullable TId ,
-            n_args: Collection[Object] , # Should be Collection[PExpr]
-            n_closure_defs: Collection[Object]  # Should be Collection[PClosureDef]
+            n_id: nullable TId,
+            n_args: Collection[Object], # Should be Collection[AExpr]
+            n_closure_defs: Collection[Object] # Should be Collection[AClosureDef]
     )
     do
         empty_init
         _n_id = n_id.as(not null)
        n_id.parent = self
        for n in n_args do
-               assert n isa PExpr
+               assert n isa AExpr
                _n_args.add(n)
                n.parent = self
        end
        for n in n_closure_defs do
-               assert n isa PClosureDef
+               assert n isa AClosureDef
                _n_closure_defs.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_id == old_child then
             if new_child != null then
@@ -7830,7 +8015,7 @@ redef class AClosureCallExpr
         for i in [0.._n_args.length[ do
             if _n_args[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PExpr
+                   assert new_child isa AExpr
                     _n_args[i] = new_child
                     new_child.parent = self
                 else
@@ -7842,7 +8027,7 @@ redef class AClosureCallExpr
         for i in [0.._n_closure_defs.length[ do
             if _n_closure_defs[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PClosureDef
+                   assert new_child isa AClosureDef
                     _n_closure_defs[i] = new_child
                     new_child.parent = self
                 else
@@ -7855,29 +8040,29 @@ redef class AClosureCallExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_id)
+        v.enter_visit(_n_id)
             for n in _n_args do
-                v.visit(n)
+                v.enter_visit(n)
            end
             for n in _n_closure_defs do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_id)
+        v.enter_visit(_n_id)
        do
            var i = _n_args.length
             while i >= 0 do
-                v.visit(_n_args[i])
+                v.enter_visit(_n_args[i])
                i = i - 1
            end
        end
        do
            var i = _n_closure_defs.length
             while i >= 0 do
-                v.visit(_n_closure_defs[i])
+                v.enter_visit(_n_closure_defs[i])
                i = i - 1
            end
        end
@@ -7893,7 +8078,7 @@ redef class AVarExpr
     private init empty_init do end
 
     init init_avarexpr (
-            n_id: nullable TId 
+            n_id: nullable TId
     )
     do
         empty_init
@@ -7901,7 +8086,7 @@ redef class AVarExpr
        n_id.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_id == old_child then
             if new_child != null then
@@ -7917,12 +8102,12 @@ redef class AVarExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_id)
+        v.enter_visit(_n_id)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_id)
+        v.enter_visit(_n_id)
     end
 end
 redef class AVarAssignExpr
@@ -7945,9 +8130,9 @@ redef class AVarAssignExpr
     private init empty_init do end
 
     init init_avarassignexpr (
-            n_id: nullable TId ,
-            n_assign: nullable TAssign ,
-            n_value: nullable PExpr 
+            n_id: nullable TId,
+            n_assign: nullable TAssign,
+            n_value: nullable AExpr
     )
     do
         empty_init
@@ -7959,7 +8144,7 @@ redef class AVarAssignExpr
        n_value.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_id == old_child then
             if new_child != null then
@@ -7984,7 +8169,7 @@ redef class AVarAssignExpr
         if _n_value == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_value = new_child
            else
                abort
@@ -7995,16 +8180,16 @@ redef class AVarAssignExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_id)
-        v.visit(_n_assign)
-        v.visit(_n_value)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_assign)
+        v.enter_visit(_n_value)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_id)
-        v.visit(_n_assign)
-        v.visit(_n_value)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_assign)
+        v.enter_visit(_n_value)
     end
 end
 redef class AVarReassignExpr
@@ -8027,9 +8212,9 @@ redef class AVarReassignExpr
     private init empty_init do end
 
     init init_avarreassignexpr (
-            n_id: nullable TId ,
-            n_assign_op: nullable PAssignOp ,
-            n_value: nullable PExpr 
+            n_id: nullable TId,
+            n_assign_op: nullable AAssignOp,
+            n_value: nullable AExpr
     )
     do
         empty_init
@@ -8041,7 +8226,7 @@ redef class AVarReassignExpr
        n_value.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_id == old_child then
             if new_child != null then
@@ -8056,7 +8241,7 @@ redef class AVarReassignExpr
         if _n_assign_op == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PAssignOp
+               assert new_child isa AAssignOp
                 _n_assign_op = new_child
            else
                abort
@@ -8066,7 +8251,7 @@ redef class AVarReassignExpr
         if _n_value == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_value = new_child
            else
                abort
@@ -8077,16 +8262,16 @@ redef class AVarReassignExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_id)
-        v.visit(_n_assign_op)
-        v.visit(_n_value)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_assign_op)
+        v.enter_visit(_n_value)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_id)
-        v.visit(_n_assign_op)
-        v.visit(_n_value)
+        v.enter_visit(_n_id)
+        v.enter_visit(_n_assign_op)
+        v.enter_visit(_n_value)
     end
 end
 redef class ARangeExpr
@@ -8104,8 +8289,8 @@ redef class ARangeExpr
     private init empty_init do end
 
     init init_arangeexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -8115,12 +8300,12 @@ redef class ARangeExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -8130,7 +8315,7 @@ redef class ARangeExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -8141,14 +8326,14 @@ redef class ARangeExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class ACrangeExpr
@@ -8166,8 +8351,8 @@ redef class ACrangeExpr
     private init empty_init do end
 
     init init_acrangeexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -8177,12 +8362,12 @@ redef class ACrangeExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -8192,7 +8377,7 @@ redef class ACrangeExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -8203,14 +8388,14 @@ redef class ACrangeExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class AOrangeExpr
@@ -8228,8 +8413,8 @@ redef class AOrangeExpr
     private init empty_init do end
 
     init init_aorangeexpr (
-            n_expr: nullable PExpr ,
-            n_expr2: nullable PExpr 
+            n_expr: nullable AExpr,
+            n_expr2: nullable AExpr
     )
     do
         empty_init
@@ -8239,12 +8424,12 @@ redef class AOrangeExpr
        n_expr2.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -8254,7 +8439,7 @@ redef class AOrangeExpr
         if _n_expr2 == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr2 = new_child
            else
                abort
@@ -8265,14 +8450,14 @@ redef class AOrangeExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_expr2)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_expr2)
     end
 end
 redef class AArrayExpr
@@ -8280,23 +8465,23 @@ redef class AArrayExpr
     private init empty_init do end
 
     init init_aarrayexpr (
-            n_exprs: Collection[Object]  # Should be Collection[PExpr]
+            n_exprs: Collection[Object] # Should be Collection[AExpr]
     )
     do
         empty_init
        for n in n_exprs do
-               assert n isa PExpr
+               assert n isa AExpr
                _n_exprs.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         for i in [0.._n_exprs.length[ do
             if _n_exprs[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PExpr
+                   assert new_child isa AExpr
                     _n_exprs[i] = new_child
                     new_child.parent = self
                 else
@@ -8310,7 +8495,7 @@ redef class AArrayExpr
     redef fun visit_all(v: Visitor)
     do
             for n in _n_exprs do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
@@ -8319,7 +8504,7 @@ redef class AArrayExpr
        do
            var i = _n_exprs.length
             while i >= 0 do
-                v.visit(_n_exprs[i])
+                v.enter_visit(_n_exprs[i])
                i = i - 1
            end
        end
@@ -8335,7 +8520,7 @@ redef class ASelfExpr
     private init empty_init do end
 
     init init_aselfexpr (
-            n_kwself: nullable TKwself 
+            n_kwself: nullable TKwself
     )
     do
         empty_init
@@ -8343,7 +8528,7 @@ redef class ASelfExpr
        n_kwself.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwself == old_child then
             if new_child != null then
@@ -8359,12 +8544,12 @@ redef class ASelfExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwself)
+        v.enter_visit(_n_kwself)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwself)
+        v.enter_visit(_n_kwself)
     end
 end
 redef class AImplicitSelfExpr
@@ -8376,7 +8561,7 @@ redef class AImplicitSelfExpr
         empty_init
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
     end
 
@@ -8398,7 +8583,7 @@ redef class ATrueExpr
     private init empty_init do end
 
     init init_atrueexpr (
-            n_kwtrue: nullable TKwtrue 
+            n_kwtrue: nullable TKwtrue
     )
     do
         empty_init
@@ -8406,7 +8591,7 @@ redef class ATrueExpr
        n_kwtrue.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwtrue == old_child then
             if new_child != null then
@@ -8422,12 +8607,12 @@ redef class ATrueExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwtrue)
+        v.enter_visit(_n_kwtrue)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwtrue)
+        v.enter_visit(_n_kwtrue)
     end
 end
 redef class AFalseExpr
@@ -8440,7 +8625,7 @@ redef class AFalseExpr
     private init empty_init do end
 
     init init_afalseexpr (
-            n_kwfalse: nullable TKwfalse 
+            n_kwfalse: nullable TKwfalse
     )
     do
         empty_init
@@ -8448,7 +8633,7 @@ redef class AFalseExpr
        n_kwfalse.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwfalse == old_child then
             if new_child != null then
@@ -8464,12 +8649,12 @@ redef class AFalseExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwfalse)
+        v.enter_visit(_n_kwfalse)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwfalse)
+        v.enter_visit(_n_kwfalse)
     end
 end
 redef class ANullExpr
@@ -8482,7 +8667,7 @@ redef class ANullExpr
     private init empty_init do end
 
     init init_anullexpr (
-            n_kwnull: nullable TKwnull 
+            n_kwnull: nullable TKwnull
     )
     do
         empty_init
@@ -8490,7 +8675,7 @@ redef class ANullExpr
        n_kwnull.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwnull == old_child then
             if new_child != null then
@@ -8506,12 +8691,12 @@ redef class ANullExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwnull)
+        v.enter_visit(_n_kwnull)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwnull)
+        v.enter_visit(_n_kwnull)
     end
 end
 redef class AIntExpr
@@ -8524,7 +8709,7 @@ redef class AIntExpr
     private init empty_init do end
 
     init init_aintexpr (
-            n_number: nullable TNumber 
+            n_number: nullable TNumber
     )
     do
         empty_init
@@ -8532,7 +8717,7 @@ redef class AIntExpr
        n_number.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_number == old_child then
             if new_child != null then
@@ -8548,12 +8733,12 @@ redef class AIntExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_number)
+        v.enter_visit(_n_number)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_number)
+        v.enter_visit(_n_number)
     end
 end
 redef class AFloatExpr
@@ -8566,7 +8751,7 @@ redef class AFloatExpr
     private init empty_init do end
 
     init init_afloatexpr (
-            n_float: nullable TFloat 
+            n_float: nullable TFloat
     )
     do
         empty_init
@@ -8574,7 +8759,7 @@ redef class AFloatExpr
        n_float.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_float == old_child then
             if new_child != null then
@@ -8590,12 +8775,12 @@ redef class AFloatExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_float)
+        v.enter_visit(_n_float)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_float)
+        v.enter_visit(_n_float)
     end
 end
 redef class ACharExpr
@@ -8608,7 +8793,7 @@ redef class ACharExpr
     private init empty_init do end
 
     init init_acharexpr (
-            n_char: nullable TChar 
+            n_char: nullable TChar
     )
     do
         empty_init
@@ -8616,7 +8801,7 @@ redef class ACharExpr
        n_char.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_char == old_child then
             if new_child != null then
@@ -8632,12 +8817,12 @@ redef class ACharExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_char)
+        v.enter_visit(_n_char)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_char)
+        v.enter_visit(_n_char)
     end
 end
 redef class AStringExpr
@@ -8650,7 +8835,7 @@ redef class AStringExpr
     private init empty_init do end
 
     init init_astringexpr (
-            n_string: nullable TString 
+            n_string: nullable TString
     )
     do
         empty_init
@@ -8658,7 +8843,7 @@ redef class AStringExpr
        n_string.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_string == old_child then
             if new_child != null then
@@ -8674,12 +8859,12 @@ redef class AStringExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_string)
+        v.enter_visit(_n_string)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_string)
+        v.enter_visit(_n_string)
     end
 end
 redef class AStartStringExpr
@@ -8692,7 +8877,7 @@ redef class AStartStringExpr
     private init empty_init do end
 
     init init_astartstringexpr (
-            n_string: nullable TStartString 
+            n_string: nullable TStartString
     )
     do
         empty_init
@@ -8700,7 +8885,7 @@ redef class AStartStringExpr
        n_string.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_string == old_child then
             if new_child != null then
@@ -8716,12 +8901,12 @@ redef class AStartStringExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_string)
+        v.enter_visit(_n_string)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_string)
+        v.enter_visit(_n_string)
     end
 end
 redef class AMidStringExpr
@@ -8734,7 +8919,7 @@ redef class AMidStringExpr
     private init empty_init do end
 
     init init_amidstringexpr (
-            n_string: nullable TMidString 
+            n_string: nullable TMidString
     )
     do
         empty_init
@@ -8742,7 +8927,7 @@ redef class AMidStringExpr
        n_string.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_string == old_child then
             if new_child != null then
@@ -8758,12 +8943,12 @@ redef class AMidStringExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_string)
+        v.enter_visit(_n_string)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_string)
+        v.enter_visit(_n_string)
     end
 end
 redef class AEndStringExpr
@@ -8776,7 +8961,7 @@ redef class AEndStringExpr
     private init empty_init do end
 
     init init_aendstringexpr (
-            n_string: nullable TEndString 
+            n_string: nullable TEndString
     )
     do
         empty_init
@@ -8784,7 +8969,7 @@ redef class AEndStringExpr
        n_string.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_string == old_child then
             if new_child != null then
@@ -8800,12 +8985,12 @@ redef class AEndStringExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_string)
+        v.enter_visit(_n_string)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_string)
+        v.enter_visit(_n_string)
     end
 end
 redef class ASuperstringExpr
@@ -8813,23 +8998,23 @@ redef class ASuperstringExpr
     private init empty_init do end
 
     init init_asuperstringexpr (
-            n_exprs: Collection[Object]  # Should be Collection[PExpr]
+            n_exprs: Collection[Object] # Should be Collection[AExpr]
     )
     do
         empty_init
        for n in n_exprs do
-               assert n isa PExpr
+               assert n isa AExpr
                _n_exprs.add(n)
                n.parent = self
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         for i in [0.._n_exprs.length[ do
             if _n_exprs[i] == old_child then
                 if new_child != null then
-                   assert new_child isa PExpr
+                   assert new_child isa AExpr
                     _n_exprs[i] = new_child
                     new_child.parent = self
                 else
@@ -8843,7 +9028,7 @@ redef class ASuperstringExpr
     redef fun visit_all(v: Visitor)
     do
             for n in _n_exprs do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
@@ -8852,7 +9037,7 @@ redef class ASuperstringExpr
        do
            var i = _n_exprs.length
             while i >= 0 do
-                v.visit(_n_exprs[i])
+                v.enter_visit(_n_exprs[i])
                i = i - 1
            end
        end
@@ -8868,7 +9053,7 @@ redef class AParExpr
     private init empty_init do end
 
     init init_aparexpr (
-            n_expr: nullable PExpr 
+            n_expr: nullable AExpr
     )
     do
         empty_init
@@ -8876,12 +9061,12 @@ redef class AParExpr
        n_expr.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -8892,12 +9077,12 @@ redef class AParExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
+        v.enter_visit(_n_expr)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
+        v.enter_visit(_n_expr)
     end
 end
 redef class AAsCastExpr
@@ -8920,9 +9105,9 @@ redef class AAsCastExpr
     private init empty_init do end
 
     init init_aascastexpr (
-            n_expr: nullable PExpr ,
-            n_kwas: nullable TKwas ,
-            n_type: nullable PType 
+            n_expr: nullable AExpr,
+            n_kwas: nullable TKwas,
+            n_type: nullable AType
     )
     do
         empty_init
@@ -8934,12 +9119,12 @@ redef class AAsCastExpr
        n_type.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -8959,7 +9144,7 @@ redef class AAsCastExpr
         if _n_type == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PType
+               assert new_child isa AType
                 _n_type = new_child
            else
                abort
@@ -8970,16 +9155,16 @@ redef class AAsCastExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_kwas)
-        v.visit(_n_type)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_kwas)
+        v.enter_visit(_n_type)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_kwas)
-        v.visit(_n_type)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_kwas)
+        v.enter_visit(_n_type)
     end
 end
 redef class AAsNotnullExpr
@@ -9007,10 +9192,10 @@ redef class AAsNotnullExpr
     private init empty_init do end
 
     init init_aasnotnullexpr (
-            n_expr: nullable PExpr ,
-            n_kwas: nullable TKwas ,
-            n_kwnot: nullable TKwnot ,
-            n_kwnull: nullable TKwnull 
+            n_expr: nullable AExpr,
+            n_kwas: nullable TKwas,
+            n_kwnot: nullable TKwnot,
+            n_kwnull: nullable TKwnull
     )
     do
         empty_init
@@ -9024,12 +9209,12 @@ redef class AAsNotnullExpr
        n_kwnull.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -9070,18 +9255,18 @@ redef class AAsNotnullExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_kwas)
-        v.visit(_n_kwnot)
-        v.visit(_n_kwnull)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_kwas)
+        v.enter_visit(_n_kwnot)
+        v.enter_visit(_n_kwnull)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_expr)
-        v.visit(_n_kwas)
-        v.visit(_n_kwnot)
-        v.visit(_n_kwnull)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_kwas)
+        v.enter_visit(_n_kwnot)
+        v.enter_visit(_n_kwnull)
     end
 end
 redef class AIssetAttrExpr
@@ -9104,9 +9289,9 @@ redef class AIssetAttrExpr
     private init empty_init do end
 
     init init_aissetattrexpr (
-            n_kwisset: nullable TKwisset ,
-            n_expr: nullable PExpr ,
-            n_id: nullable TAttrid 
+            n_kwisset: nullable TKwisset,
+            n_expr: nullable AExpr,
+            n_id: nullable TAttrid
     )
     do
         empty_init
@@ -9118,7 +9303,7 @@ redef class AIssetAttrExpr
        n_id.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwisset == old_child then
             if new_child != null then
@@ -9133,7 +9318,7 @@ redef class AIssetAttrExpr
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                abort
@@ -9154,16 +9339,16 @@ redef class AIssetAttrExpr
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwisset)
-        v.visit(_n_expr)
-        v.visit(_n_id)
+        v.enter_visit(_n_kwisset)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_id)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwisset)
-        v.visit(_n_expr)
-        v.visit(_n_id)
+        v.enter_visit(_n_kwisset)
+        v.enter_visit(_n_expr)
+        v.enter_visit(_n_id)
     end
 end
 redef class APlusAssignOp
@@ -9176,7 +9361,7 @@ redef class APlusAssignOp
     private init empty_init do end
 
     init init_aplusassignop (
-            n_pluseq: nullable TPluseq 
+            n_pluseq: nullable TPluseq
     )
     do
         empty_init
@@ -9184,7 +9369,7 @@ redef class APlusAssignOp
        n_pluseq.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_pluseq == old_child then
             if new_child != null then
@@ -9200,12 +9385,12 @@ redef class APlusAssignOp
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_pluseq)
+        v.enter_visit(_n_pluseq)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_pluseq)
+        v.enter_visit(_n_pluseq)
     end
 end
 redef class AMinusAssignOp
@@ -9218,7 +9403,7 @@ redef class AMinusAssignOp
     private init empty_init do end
 
     init init_aminusassignop (
-            n_minuseq: nullable TMinuseq 
+            n_minuseq: nullable TMinuseq
     )
     do
         empty_init
@@ -9226,7 +9411,7 @@ redef class AMinusAssignOp
        n_minuseq.parent = self
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_minuseq == old_child then
             if new_child != null then
@@ -9242,12 +9427,12 @@ redef class AMinusAssignOp
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_minuseq)
+        v.enter_visit(_n_minuseq)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_minuseq)
+        v.enter_visit(_n_minuseq)
     end
 end
 redef class AClosureDef
@@ -9268,14 +9453,22 @@ redef class AClosureDef
            n.parent = self
         end
     end
+    redef fun n_label=(n)
+    do
+        _n_label = n
+        if n != null then
+           n.parent = self
+        end
+    end
 
     private init empty_init do end
 
     init init_aclosuredef (
-            n_kwwith: nullable TKwwith ,
-            n_id: Collection[Object] , # Should be Collection[TId]
-            n_kwdo: nullable TKwdo ,
-            n_expr: nullable PExpr 
+            n_kwwith: nullable TKwwith,
+            n_id: Collection[Object], # Should be Collection[TId]
+            n_kwdo: nullable TKwdo,
+            n_expr: nullable AExpr,
+            n_label: nullable ALabel
     )
     do
         empty_init
@@ -9292,9 +9485,13 @@ redef class AClosureDef
        if n_expr != null then
                n_expr.parent = self
        end
+        _n_label = n_label
+       if n_label != null then
+               n_label.parent = self
+       end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_kwwith == old_child then
             if new_child != null then
@@ -9331,40 +9528,56 @@ redef class AClosureDef
         if _n_expr == old_child then
             if new_child != null then
                 new_child.parent = self
-               assert new_child isa PExpr
+               assert new_child isa AExpr
                 _n_expr = new_child
            else
                _n_expr = null
             end
             return
        end
+        if _n_label == old_child then
+            if new_child != null then
+                new_child.parent = self
+               assert new_child isa ALabel
+                _n_label = new_child
+           else
+               _n_label = null
+            end
+            return
+       end
     end
 
     redef fun visit_all(v: Visitor)
     do
-        v.visit(_n_kwwith)
+        v.enter_visit(_n_kwwith)
             for n in _n_id do
-                v.visit(n)
+                v.enter_visit(n)
            end
-        v.visit(_n_kwdo)
+        v.enter_visit(_n_kwdo)
         if _n_expr != null then
-            v.visit(_n_expr.as(not null))
+            v.enter_visit(_n_expr.as(not null))
+        end
+        if _n_label != null then
+            v.enter_visit(_n_label.as(not null))
         end
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
-        v.visit(_n_kwwith)
+        v.enter_visit(_n_kwwith)
        do
            var i = _n_id.length
             while i >= 0 do
-                v.visit(_n_id[i])
+                v.enter_visit(_n_id[i])
                i = i - 1
            end
        end
-        v.visit(_n_kwdo)
+        v.enter_visit(_n_kwdo)
         if _n_expr != null then
-            v.visit(_n_expr.as(not null))
+            v.enter_visit(_n_expr.as(not null))
+        end
+        if _n_label != null then
+            v.enter_visit(_n_label.as(not null))
         end
     end
 end
@@ -9380,8 +9593,8 @@ redef class AQualified
     private init empty_init do end
 
     init init_aqualified (
-            n_id: Collection[Object] , # Should be Collection[TId]
-            n_classid: nullable TClassid 
+            n_id: Collection[Object], # Should be Collection[TId]
+            n_classid: nullable TClassid
     )
     do
         empty_init
@@ -9396,7 +9609,7 @@ redef class AQualified
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         for i in [0.._n_id.length[ do
             if _n_id[i] == old_child then
@@ -9425,10 +9638,10 @@ redef class AQualified
     redef fun visit_all(v: Visitor)
     do
             for n in _n_id do
-                v.visit(n)
+                v.enter_visit(n)
            end
         if _n_classid != null then
-            v.visit(_n_classid.as(not null))
+            v.enter_visit(_n_classid.as(not null))
         end
     end
 
@@ -9437,12 +9650,12 @@ redef class AQualified
        do
            var i = _n_id.length
             while i >= 0 do
-                v.visit(_n_id[i])
+                v.enter_visit(_n_id[i])
                i = i - 1
            end
        end
         if _n_classid != null then
-            v.visit(_n_classid.as(not null))
+            v.enter_visit(_n_classid.as(not null))
         end
     end
 end
@@ -9451,7 +9664,7 @@ redef class ADoc
     private init empty_init do end
 
     init init_adoc (
-            n_comment: Collection[Object]  # Should be Collection[TComment]
+            n_comment: Collection[Object] # Should be Collection[TComment]
     )
     do
         empty_init
@@ -9462,7 +9675,7 @@ redef class ADoc
        end
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         for i in [0.._n_comment.length[ do
             if _n_comment[i] == old_child then
@@ -9481,7 +9694,7 @@ redef class ADoc
     redef fun visit_all(v: Visitor)
     do
             for n in _n_comment do
-                v.visit(n)
+                v.enter_visit(n)
            end
     end
 
@@ -9490,7 +9703,7 @@ redef class ADoc
        do
            var i = _n_comment.length
             while i >= 0 do
-                v.visit(_n_comment[i])
+                v.enter_visit(_n_comment[i])
                i = i - 1
            end
        end
@@ -9499,20 +9712,20 @@ end
 
 redef class Start
     init(
-        n_base: nullable PModule,
+        n_base: nullable AModule,
         n_eof: EOF)
     do
         _n_base = n_base
         _n_eof = n_eof
     end
 
-    redef fun replace_child(old_child: PNode, new_child: nullable PNode)
+    redef fun replace_child(old_child: ANode, new_child: nullable ANode)
     do
         if _n_base == old_child then
             if new_child == null then
             else
                 new_child.parent = self
-               assert new_child isa PModule
+               assert new_child isa AModule
                 _n_base = new_child
             end
             old_child.parent = null
@@ -9523,14 +9736,16 @@ redef class Start
     redef fun visit_all(v: Visitor)
     do
         if _n_base != null then
-            v.visit(_n_base.as(not null))
+            v.enter_visit(_n_base.as(not null))
         end
+       v.enter_visit(_n_eof)
     end
 
     redef fun visit_all_reverse(v: Visitor)
     do
+       v.enter_visit(_n_eof)
         if _n_base != null then
-            v.visit(_n_base.as(not null))
+            v.enter_visit(_n_base.as(not null))
         end
     end
 end