parser: regenerate with lambda
[nit.git] / src / parser / parser_prod.nit
index a7d94da..f1bd5d9 100644 (file)
@@ -1,6 +1,6 @@
 # Production AST nodes full definition.
 # This file was generated by SableCC (http://www.sablecc.org/).
-module parser_prod is no_warning("missing-doc")
+module parser_prod is generated, no_warning("missing-doc")
 
 import lexer
 intrude import parser_nodes
@@ -732,6 +732,35 @@ redef class AExternClasskind
                v.enter_visit(_n_kwclass)
        end
 end
+redef class ASubsetClasskind
+       init init_asubsetclasskind (
+               n_kwsubset: nullable TKwsubset
+       )
+       do
+               _n_kwsubset = n_kwsubset.as(not null)
+               n_kwsubset.parent = self
+       end
+
+       redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+       do
+               if _n_kwsubset == old_child then
+                       n_kwsubset = new_child.as(TKwsubset)
+                       return
+               end
+       end
+
+       redef fun n_kwsubset=(node)
+       do
+               _n_kwsubset = node
+               node.parent = self
+       end
+
+
+       redef fun visit_all(v: Visitor)
+       do
+               v.enter_visit(_n_kwsubset)
+       end
+end
 redef class AFormaldef
        init init_aformaldef (
                n_id: nullable TClassid,
@@ -1115,6 +1144,7 @@ redef class AMethPropdef
                n_visibility: nullable AVisibility,
                n_kwmeth: nullable TKwmeth,
                n_kwinit: nullable TKwinit,
+               n_kwisa: nullable TKwisa,
                n_kwnew: nullable TKwnew,
                n_methid: nullable AMethid,
                n_signature: nullable ASignature,
@@ -1136,6 +1166,8 @@ redef class AMethPropdef
                if n_kwmeth != null then n_kwmeth.parent = self
                _n_kwinit = n_kwinit
                if n_kwinit != null then n_kwinit.parent = self
+               _n_kwisa = n_kwisa
+               if n_kwisa != null then n_kwisa.parent = self
                _n_kwnew = n_kwnew
                if n_kwnew != null then n_kwnew.parent = self
                _n_methid = n_methid
@@ -1178,6 +1210,10 @@ redef class AMethPropdef
                        n_kwinit = new_child.as(nullable TKwinit)
                        return
                end
+               if _n_kwisa == old_child then
+                       n_kwisa = new_child.as(nullable TKwisa)
+                       return
+               end
                if _n_kwnew == old_child then
                        n_kwnew = new_child.as(nullable TKwnew)
                        return
@@ -1241,6 +1277,11 @@ redef class AMethPropdef
                _n_kwinit = node
                if node != null then node.parent = self
        end
+       redef fun n_kwisa=(node)
+       do
+               _n_kwisa = node
+               if node != null then node.parent = self
+       end
        redef fun n_kwnew=(node)
        do
                _n_kwnew = node
@@ -1295,6 +1336,7 @@ redef class AMethPropdef
                v.enter_visit(_n_visibility)
                v.enter_visit(_n_kwmeth)
                v.enter_visit(_n_kwinit)
+               v.enter_visit(_n_kwisa)
                v.enter_visit(_n_kwnew)
                v.enter_visit(_n_methid)
                v.enter_visit(_n_signature)
@@ -2737,6 +2779,48 @@ redef class AReturnExpr
                v.enter_visit(_n_expr)
        end
 end
+redef class AYieldExpr
+       init init_ayieldexpr (
+               n_kwyield: nullable TKwyield,
+               n_expr: nullable AExpr
+       )
+       do
+               _n_kwyield = n_kwyield.as(not null)
+               n_kwyield.parent = self
+               _n_expr = n_expr.as(not null)
+               n_expr.parent = self
+       end
+
+       redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+       do
+               if _n_kwyield == old_child then
+                       n_kwyield = new_child.as(TKwyield)
+                       return
+               end
+               if _n_expr == old_child then
+                       n_expr = new_child.as(AExpr)
+                       return
+               end
+       end
+
+       redef fun n_kwyield=(node)
+       do
+               _n_kwyield = node
+               node.parent = self
+       end
+       redef fun n_expr=(node)
+       do
+               _n_expr = node
+               node.parent = self
+       end
+
+
+       redef fun visit_all(v: Visitor)
+       do
+               v.enter_visit(_n_kwyield)
+               v.enter_visit(_n_expr)
+       end
+end
 redef class ABreakExpr
        init init_abreakexpr (
                n_kwbreak: nullable TKwbreak,
@@ -2854,6 +2938,8 @@ redef class ADoExpr
        init init_adoexpr (
                n_kwdo: nullable TKwdo,
                n_block: nullable AExpr,
+               n_kwcatch: nullable TKwcatch,
+               n_catch: nullable AExpr,
                n_label: nullable ALabel
        )
        do
@@ -2861,6 +2947,10 @@ redef class ADoExpr
                n_kwdo.parent = self
                _n_block = n_block
                if n_block != null then n_block.parent = self
+               _n_kwcatch = n_kwcatch
+               if n_kwcatch != null then n_kwcatch.parent = self
+               _n_catch = n_catch
+               if n_catch != null then n_catch.parent = self
                _n_label = n_label
                if n_label != null then n_label.parent = self
        end
@@ -2875,6 +2965,14 @@ redef class ADoExpr
                        n_block = new_child.as(nullable AExpr)
                        return
                end
+               if _n_kwcatch == old_child then
+                       n_kwcatch = new_child.as(nullable TKwcatch)
+                       return
+               end
+               if _n_catch == old_child then
+                       n_catch = new_child.as(nullable AExpr)
+                       return
+               end
                if _n_label == old_child then
                        n_label = new_child.as(nullable ALabel)
                        return
@@ -2891,6 +2989,16 @@ redef class ADoExpr
                _n_block = node
                if node != null then node.parent = self
        end
+       redef fun n_kwcatch=(node)
+       do
+               _n_kwcatch = node
+               if node != null then node.parent = self
+       end
+       redef fun n_catch=(node)
+       do
+               _n_catch = node
+               if node != null then node.parent = self
+       end
        redef fun n_label=(node)
        do
                _n_label = node
@@ -2902,6 +3010,8 @@ redef class ADoExpr
        do
                v.enter_visit(_n_kwdo)
                v.enter_visit(_n_block)
+               v.enter_visit(_n_kwcatch)
+               v.enter_visit(_n_catch)
                v.enter_visit(_n_label)
        end
 end
@@ -5323,6 +5433,74 @@ redef class ACallExpr
                v.enter_visit(_n_args)
        end
 end
+redef class ACallrefExpr
+       init init_acallrefexpr (
+               n_amp: nullable TAmp,
+               n_expr: nullable AExpr,
+               n_qid: nullable AQid,
+               n_args: nullable AExprs
+       )
+       do
+               _n_amp = n_amp.as(not null)
+               n_amp.parent = self
+               _n_expr = n_expr.as(not null)
+               n_expr.parent = self
+               _n_qid = n_qid.as(not null)
+               n_qid.parent = self
+               _n_args = n_args.as(not null)
+               n_args.parent = self
+       end
+
+       redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+       do
+               if _n_amp == old_child then
+                       n_amp = new_child.as(TAmp)
+                       return
+               end
+               if _n_expr == old_child then
+                       n_expr = new_child.as(AExpr)
+                       return
+               end
+               if _n_qid == old_child then
+                       n_qid = new_child.as(AQid)
+                       return
+               end
+               if _n_args == old_child then
+                       n_args = new_child.as(AExprs)
+                       return
+               end
+       end
+
+       redef fun n_amp=(node)
+       do
+               _n_amp = node
+               node.parent = self
+       end
+       redef fun n_expr=(node)
+       do
+               _n_expr = node
+               node.parent = self
+       end
+       redef fun n_qid=(node)
+       do
+               _n_qid = node
+               node.parent = self
+       end
+       redef fun n_args=(node)
+       do
+               _n_args = node
+               node.parent = self
+       end
+
+
+       redef fun visit_all(v: Visitor)
+       do
+               v.enter_visit(_n_amp)
+               v.enter_visit(_n_expr)
+               v.enter_visit(_n_qid)
+               v.enter_visit(_n_args)
+       end
+end
 redef class ACallAssignExpr
        init init_acallassignexpr (
                n_expr: nullable AExpr,
@@ -6698,6 +6876,74 @@ redef class ASuperstringExpr
                v.enter_visit(_n_annotations)
        end
 end
+redef class ALambdaExpr
+       init init_alambdaexpr (
+               n_kwmeth: nullable TKwmeth,
+               n_signature: nullable ASignature,
+               n_kwdo: nullable TKwdo,
+               n_expr: nullable AExpr
+       )
+       do
+               _n_kwmeth = n_kwmeth.as(not null)
+               n_kwmeth.parent = self
+               _n_signature = n_signature.as(not null)
+               n_signature.parent = self
+               _n_kwdo = n_kwdo.as(not null)
+               n_kwdo.parent = self
+               _n_expr = n_expr.as(not null)
+               n_expr.parent = self
+       end
+
+       redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+       do
+               if _n_kwmeth == old_child then
+                       n_kwmeth = new_child.as(TKwmeth)
+                       return
+               end
+               if _n_signature == old_child then
+                       n_signature = new_child.as(ASignature)
+                       return
+               end
+               if _n_kwdo == old_child then
+                       n_kwdo = new_child.as(TKwdo)
+                       return
+               end
+               if _n_expr == old_child then
+                       n_expr = new_child.as(AExpr)
+                       return
+               end
+       end
+
+       redef fun n_kwmeth=(node)
+       do
+               _n_kwmeth = node
+               node.parent = self
+       end
+       redef fun n_signature=(node)
+       do
+               _n_signature = node
+               node.parent = self
+       end
+       redef fun n_kwdo=(node)
+       do
+               _n_kwdo = node
+               node.parent = self
+       end
+       redef fun n_expr=(node)
+       do
+               _n_expr = node
+               node.parent = self
+       end
+
+
+       redef fun visit_all(v: Visitor)
+       do
+               v.enter_visit(_n_kwmeth)
+               v.enter_visit(_n_signature)
+               v.enter_visit(_n_kwdo)
+               v.enter_visit(_n_expr)
+       end
+end
 redef class AParExpr
        init init_aparexpr (
                n_opar: nullable TOpar,
@@ -7161,6 +7407,48 @@ redef class ANamedargExpr
                v.enter_visit(_n_expr)
        end
 end
+redef class ASafeExpr
+       init init_asafeexpr (
+               n_expr: nullable AExpr,
+               n_quest: nullable TQuest
+       )
+       do
+               _n_expr = n_expr.as(not null)
+               n_expr.parent = self
+               _n_quest = n_quest.as(not null)
+               n_quest.parent = self
+       end
+
+       redef fun replace_child(old_child: ANode, new_child: nullable ANode)
+       do
+               if _n_expr == old_child then
+                       n_expr = new_child.as(AExpr)
+                       return
+               end
+               if _n_quest == old_child then
+                       n_quest = new_child.as(TQuest)
+                       return
+               end
+       end
+
+       redef fun n_expr=(node)
+       do
+               _n_expr = node
+               node.parent = self
+       end
+       redef fun n_quest=(node)
+       do
+               _n_quest = node
+               node.parent = self
+       end
+
+
+       redef fun visit_all(v: Visitor)
+       do
+               v.enter_visit(_n_expr)
+               v.enter_visit(_n_quest)
+       end
+end
 redef class ATypeExpr
        init init_atypeexpr (
                n_type: nullable AType