-

git-svn-id: http://caml.inria.fr/svn/ocaml/trunk@4272 f963ae5c-01c2-4b8c-9fe0-0dff7051ff02

4 files changed, 119 insertions, 154 deletions

diff --git a/camlp4/meta/pa_extend.ml b/camlp4/meta/pa_extend.ml
index bbd987a1f..dce3a01fd 100644
--- a/camlp4/meta/pa_extend.ml
+++ b/camlp4/meta/pa_extend.ml
@@ -264,13 +264,7 @@ value mklistpat loc =
 value rec quot_expr e =
   let loc = MLast.loc_of_expr e in
   match e with
-  [ <:expr< match $e$ with [ $list:pel$ ] >> ->
-      let pel = List.map quot_match_case pel in
-      <:expr< match $quot_expr e$ with [ $list:pel$ ] >>
-  | <:expr< let $list:pel$ in $e$ >> ->
-      let pel = List.map quot_let_binding pel in
-      <:expr< let $list:pel$ in $quot_expr e$ >>
-  | <:expr< None >> -> <:expr< Option None >>
+  [ <:expr< None >> -> <:expr< Option None >>
   | <:expr< Some $e$ >> -> <:expr< Option (Some $quot_expr e$) >>
   | <:expr< False >> -> <:expr< Bool False >>
   | <:expr< True >> -> <:expr< Bool True >>
@@ -293,21 +287,6 @@ value rec quot_expr e =
       let el = List.map quot_expr el in
       <:expr< Tuple $mklistexp loc el$ >>
   | _ -> e ]
-and quot_patt p =
-  let loc = MLast.loc_of_patt p in
-  match p with
-  [ <:patt< [$p1$ :: $pl$] >> ->
-      let p1 = quot_patt p1 in
-      match quot_patt pl with
-      [ <:patt< List [$pl$] >> -> <:patt< List [$p1$ :: $pl$] >>
-      | <:patt< List [] >> -> <:patt< List [$p1$] >>
-      | _ -> p ]
-  | <:patt< [] >> -> <:patt< List [] >>
-  | _ -> p ]
-and quot_match_case (p, eo, e) =
-  (quot_patt p, eo, quot_expr e)
-and quot_let_binding (p, e) =
-  (quot_patt p, quot_expr e)
 ;
 
 value symgen = "xx";
@@ -457,19 +436,25 @@ value ssopt loc symb =
   in
   let rl =
     let anti_n =
-      match symb.text "" "" with
-      [ <:expr< Gramext.Stoken ("", $str:n$) >> -> n
-      | _ -> "opt" ]
+      try
+        match symb.text "" "" with
+        [ <:expr< Gramext.Stoken ("", $str:n$) >> -> n
+        | <:expr<
+            Gramext.srules
+              [([Gramext.Stoken ("", $str:n$) :: $_$], $_$)] >>
+          ->
+            if String.length n > 0 then
+              match n.[0] with
+              [ 'A'..'Z' | 'a'..'z' -> n
+              | _ -> raise Not_found ]
+            else raise Not_found
+        | _ -> raise Not_found ]
+      with [ Not_found ->"opt" ]
     in
     let r1 =
       let prod =
-(**)
         let text = stoken loc "ANTIQUOT" <:expr< $str:anti_n$ >> in
         [psymbol <:patt< a >> text <:ctyp< string >>]
-(*
-        let n = mk_name loc <:expr< anti_opt >> in
-        [psymbol <:patt< a >> (snterm loc n None) <:ctyp< ast >>]
-*)
       in
       let act = <:expr< antiquot $str:anti_n$ loc a >> in
       {prod = prod; action = Some act}
diff --git a/camlp4/meta/q_MLast.ml b/camlp4/meta/q_MLast.ml
index 6392829af..aa7eef4b5 100644
--- a/camlp4/meta/q_MLast.ml
+++ b/camlp4/meta/q_MLast.ml
@@ -128,8 +128,7 @@ value mklazy loc e =
           [Loc; Node "ExUid" [Loc; Str "Lazy"];
            Node "ExUid" [Loc; Str "Delayed"]];
         Node "ExFun"
-          [Loc;
-           List [Tuple [Node "PaUid" [Loc; Str "()"]; Option None; e]]]]]
+          [Loc; List [Tuple [Node "PaUid" [Loc; Str "()"]; Option None; e]]]]]
 ;
 
 value neg s = string_of_int (- int_of_string s);
@@ -147,8 +146,8 @@ value warning_seq () =
 ;
 
 EXTEND
-  GLOBAL: sig_item str_item ctyp patt expr module_type module_expr
-    class_type class_expr class_sig_item class_str_item;
+  GLOBAL: sig_item str_item ctyp patt expr module_type module_expr class_type
+    class_expr class_sig_item class_str_item;
   module_expr:
     [ [ "functor"; "("; i = a_UIDENT; ":"; t = module_type; ")"; "->";
         me = SELF ->
@@ -448,7 +447,8 @@ EXTEND
       | ":"; t = ctyp; "="; e = expr -> Node "ExTyc" [Loc; e; t] ] ]
   ;
   match_case:
-    [ [ p = patt; aso = as_opt; w = when_opt; "->"; e = expr ->
+    [ [ p = patt; aso = SOPT [ "as"; p = patt -> p ];
+        w = SOPT [ "when"; e = expr -> e ]; "->"; e = expr ->
           let p =
             match aso with
             [ Option (Some p2) -> Node "PaAli" [Loc; p; p2]
@@ -458,7 +458,7 @@ EXTEND
           Tuple [p; w; e] ] ]
   ;
   label_expr:
-    [ [ i = patt_label_ident; "="; e = expr -> Tuple [i; e] ] ]
+    [ [ i = patt_label_ident; e = fun_binding -> Tuple [i; e] ] ]
   ;
   expr_ident:
     [ RIGHTA
@@ -662,16 +662,6 @@ EXTEND
       | "rec" -> Bool True
       | -> Bool False ] ]
   ;
-  as_opt:
-    [ [ "as"; p = patt -> Option (Some p)
-      | a = anti_as -> a
-      | -> Option None ] ]
-  ;
-  when_opt:
-    [ [ "when"; e = expr -> Option (Some e)
-      | a = anti_when -> a
-      | -> Option None ] ]
-  ;
   mutable_flag:
     [ [ a = anti_mut -> a
       | "mutable" -> Bool True
@@ -780,9 +770,6 @@ EXTEND
   anti_uid:
     [ [ a = ANTIQUOT "uid" -> antiquot "uid" loc a ] ]
   ;
-  anti_when:
-    [ [ a = ANTIQUOT "when" -> antiquot "when" loc a ] ]
-  ;
   (* Compatibility old syntax of sequences *)
   expr: LEVEL "top"
     [ [ "do"; seq = SLIST0 [ e = expr; ";" -> e ]; "return"; e = SELF ->
diff --git a/camlp4/ocaml_src/meta/pa_extend.ml b/camlp4/ocaml_src/meta/pa_extend.ml
index cca061f13..ee755b83a 100644
--- a/camlp4/ocaml_src/meta/pa_extend.ml
+++ b/camlp4/ocaml_src/meta/pa_extend.ml
@@ -605,13 +605,7 @@ let mklistpat loc =
 let rec quot_expr e =
   let loc = MLast.loc_of_expr e in
   match e with
-    MLast.ExMat (_, e, pel) ->
-      let pel = List.map quot_match_case pel in
-      MLast.ExMat (loc, quot_expr e, pel)
-  | MLast.ExLet (_, false, pel, e) ->
-      let pel = List.map quot_let_binding pel in
-      MLast.ExLet (loc, false, pel, quot_expr e)
-  | MLast.ExUid (_, "None") ->
+    MLast.ExUid (_, "None") ->
       MLast.ExApp
         (loc, MLast.ExUid (loc, "Option"), MLast.ExUid (loc, "None"))
   | MLast.ExApp (_, MLast.ExUid (_, "Some"), e) ->
@@ -664,34 +658,7 @@ let rec quot_expr e =
       let el = List.map quot_expr el in
       MLast.ExApp (loc, MLast.ExUid (loc, "Tuple"), mklistexp loc el)
   | _ -> e
-and quot_patt p =
-  let loc = MLast.loc_of_patt p in
-  match p with
-    MLast.PaApp (_, MLast.PaApp (_, MLast.PaUid (_, "::"), p1), pl) ->
-      let p1 = quot_patt p1 in
-      begin match quot_patt pl with
-        MLast.PaApp
-          (_, MLast.PaUid (_, "List"),
-           MLast.PaApp
-             (_, MLast.PaApp (_, MLast.PaUid (_, "::"), pl),
-              MLast.PaUid (_, "[]"))) ->
-          MLast.PaApp
-            (loc, MLast.PaUid (loc, "List"),
-             MLast.PaApp
-               (loc, MLast.PaApp (loc, MLast.PaUid (loc, "::"), p1), pl))
-      | MLast.PaApp (_, MLast.PaUid (_, "List"), MLast.PaUid (_, "[]")) ->
-          MLast.PaApp
-            (loc, MLast.PaUid (loc, "List"),
-             MLast.PaApp
-               (loc, MLast.PaApp (loc, MLast.PaUid (loc, "::"), p1),
-                MLast.PaUid (loc, "[]")))
-      | _ -> p
-      end
-  | MLast.PaUid (_, "[]") ->
-      MLast.PaApp (loc, MLast.PaUid (loc, "List"), MLast.PaUid (loc, "[]"))
-  | _ -> p
-and quot_match_case (p, eo, e) = quot_patt p, eo, quot_expr e
-and quot_let_binding (p, e) = quot_patt p, quot_expr e;;
+;;
 
 let symgen = "xx";;
 
@@ -956,14 +923,48 @@ let ssopt loc symb =
   in
   let rl =
     let anti_n =
-      match symb.text "" "" with
-        MLast.ExApp
-          (_,
-           MLast.ExAcc
-             (_, MLast.ExUid (_, "Gramext"), MLast.ExUid (_, "Stoken")),
-           MLast.ExTup (_, [MLast.ExStr (_, ""); MLast.ExStr (_, n)])) ->
-          n
-      | _ -> "opt"
+      try
+        match symb.text "" "" with
+          MLast.ExApp
+            (_,
+             MLast.ExAcc
+               (_, MLast.ExUid (_, "Gramext"), MLast.ExUid (_, "Stoken")),
+             MLast.ExTup (_, [MLast.ExStr (_, ""); MLast.ExStr (_, n)])) ->
+            n
+        | MLast.ExApp
+            (_,
+             MLast.ExAcc
+               (_, MLast.ExUid (_, "Gramext"), MLast.ExLid (_, "srules")),
+             MLast.ExApp
+               (_,
+                MLast.ExApp
+                  (_, MLast.ExUid (_, "::"),
+                   MLast.ExTup
+                     (_,
+                      [MLast.ExApp
+                         (_,
+                          MLast.ExApp
+                            (_, MLast.ExUid (_, "::"),
+                             MLast.ExApp
+                               (_,
+                                MLast.ExAcc
+                                  (_, MLast.ExUid (_, "Gramext"),
+                                   MLast.ExUid (_, "Stoken")),
+                                MLast.ExTup
+                                  (_,
+                                   [MLast.ExStr (_, "");
+                                    MLast.ExStr (_, n)]))),
+                          _);
+                       _])),
+                MLast.ExUid (_, "[]"))) ->
+            if String.length n > 0 then
+              match n.[0] with
+                'A'..'Z' | 'a'..'z' -> n
+              | _ -> raise Not_found
+            else raise Not_found
+        | _ -> raise Not_found
+      with
+        Not_found -> "opt"
     in
     let r1 =
       let prod =
diff --git a/camlp4/ocaml_src/meta/q_MLast.ml b/camlp4/ocaml_src/meta/q_MLast.ml
index 3b31682a5..643d07cfd 100644
--- a/camlp4/ocaml_src/meta/q_MLast.ml
+++ b/camlp4/ocaml_src/meta/q_MLast.ml
@@ -225,8 +225,6 @@ Grammar.extend
    and direction_flag : 'direction_flag Grammar.Entry.e =
      grammar_entry_create "direction_flag"
    and rec_flag : 'rec_flag Grammar.Entry.e = grammar_entry_create "rec_flag"
-   and as_opt : 'as_opt Grammar.Entry.e = grammar_entry_create "as_opt"
-   and when_opt : 'when_opt Grammar.Entry.e = grammar_entry_create "when_opt"
    and mutable_flag : 'mutable_flag Grammar.Entry.e =
      grammar_entry_create "mutable_flag"
    and dir_param : 'dir_param Grammar.Entry.e =
@@ -262,8 +260,6 @@ Grammar.extend
    and anti_str : 'anti_str Grammar.Entry.e = grammar_entry_create "anti_str"
    and anti_to : 'anti_to Grammar.Entry.e = grammar_entry_create "anti_to"
    and anti_uid : 'anti_uid Grammar.Entry.e = grammar_entry_create "anti_uid"
-   and anti_when : 'anti_when Grammar.Entry.e =
-     grammar_entry_create "anti_when"
    and class_declaration : 'class_declaration Grammar.Entry.e =
      grammar_entry_create "class_declaration"
    and class_fun_binding : 'class_fun_binding Grammar.Entry.e =
@@ -484,7 +480,7 @@ Grammar.extend
                 Tuple [xx1; xx2; xx3] -> xx1, xx2, xx3
               | _ ->
                   match () with
-                  _ -> raise (Match_failure ("q_MLast.ml", 5635, 5651))
+                  _ -> raise (Match_failure ("q_MLast.ml", 5624, 5640))
             in
             Node ("StExc", [Loc; c; tl; b]) :
             'str_item));
@@ -719,7 +715,7 @@ Grammar.extend
                 Tuple [xx1; xx2; xx3] -> xx1, xx2, xx3
               | _ ->
                   match () with
-                  _ -> raise (Match_failure ("q_MLast.ml", 7698, 7714))
+                  _ -> raise (Match_failure ("q_MLast.ml", 7687, 7703))
             in
             Node ("SgExc", [Loc; c; tl]) :
             'sig_item));
@@ -1533,13 +1529,38 @@ Grammar.extend
     Grammar.Entry.obj (match_case : 'match_case Grammar.Entry.e), None,
     [None, None,
      [[Gramext.Snterm (Grammar.Entry.obj (patt : 'patt Grammar.Entry.e));
-       Gramext.Snterm (Grammar.Entry.obj (as_opt : 'as_opt Grammar.Entry.e));
-       Gramext.Snterm
-         (Grammar.Entry.obj (when_opt : 'when_opt Grammar.Entry.e));
+       Gramext.srules
+         [[Gramext.Sopt
+             (Gramext.srules
+                [[Gramext.Stoken ("", "as");
+                  Gramext.Snterm
+                    (Grammar.Entry.obj (patt : 'patt Grammar.Entry.e))],
+                 Gramext.action
+                   (fun (p : 'patt) _ (loc : int * int) -> (p : 'e__7))])],
+          Gramext.action
+            (fun (o : 'e__7 option) (loc : int * int) -> (Option o : 'anti));
+          [Gramext.Stoken ("ANTIQUOT", "as")],
+          Gramext.action
+            (fun (a : string) (loc : int * int) ->
+               (antiquot "as" loc a : 'anti))];
+       Gramext.srules
+         [[Gramext.Sopt
+             (Gramext.srules
+                [[Gramext.Stoken ("", "when");
+                  Gramext.Snterm
+                    (Grammar.Entry.obj (expr : 'expr Grammar.Entry.e))],
+                 Gramext.action
+                   (fun (e : 'expr) _ (loc : int * int) -> (e : 'e__8))])],
+          Gramext.action
+            (fun (o : 'e__8 option) (loc : int * int) -> (Option o : 'anti));
+          [Gramext.Stoken ("ANTIQUOT", "when")],
+          Gramext.action
+            (fun (a : string) (loc : int * int) ->
+               (antiquot "when" loc a : 'anti))];
        Gramext.Stoken ("", "->");
        Gramext.Snterm (Grammar.Entry.obj (expr : 'expr Grammar.Entry.e))],
       Gramext.action
-        (fun (e : 'expr) _ (w : 'when_opt) (aso : 'as_opt) (p : 'patt)
+        (fun (e : 'expr) _ (w : ast) (aso : ast) (p : 'patt)
            (loc : int * int) ->
            (let p =
               match aso with
@@ -1554,10 +1575,10 @@ Grammar.extend
      [[Gramext.Snterm
          (Grammar.Entry.obj
             (patt_label_ident : 'patt_label_ident Grammar.Entry.e));
-       Gramext.Stoken ("", "=");
-       Gramext.Snterm (Grammar.Entry.obj (expr : 'expr Grammar.Entry.e))],
+       Gramext.Snterm
+         (Grammar.Entry.obj (fun_binding : 'fun_binding Grammar.Entry.e))],
       Gramext.action
-        (fun (e : 'expr) _ (i : 'patt_label_ident) (loc : int * int) ->
+        (fun (e : 'fun_binding) (i : 'patt_label_ident) (loc : int * int) ->
            (Tuple [i; e] : 'label_expr))]];
     Grammar.Entry.obj (expr_ident : 'expr_ident Grammar.Entry.e), None,
     [None, Some Gramext.RightA,
@@ -1660,10 +1681,10 @@ Grammar.extend
               Gramext.Snterm
                 (Grammar.Entry.obj (expr : 'expr Grammar.Entry.e))],
              Gramext.action
-               (fun (e : 'expr) _ (loc : int * int) -> (e : 'e__8))]);
+               (fun (e : 'expr) _ (loc : int * int) -> (e : 'e__10))]);
        Gramext.Stoken ("", ")")],
       Gramext.action
-        (fun _ (e : 'e__8 option) (t : 'ctyp) _ (p : 'patt) _ _ (i : 'lident)
+        (fun _ (e : 'e__10 option) (t : 'ctyp) _ (p : 'patt) _ _ (i : 'lident)
            _ (loc : int * int) ->
            (let p = Node ("PaTyc", [Loc; p; t]) in
             Node ("PaOlb", [Loc; i; p; Option e]) :
@@ -1677,10 +1698,10 @@ Grammar.extend
               Gramext.Snterm
                 (Grammar.Entry.obj (expr : 'expr Grammar.Entry.e))],
              Gramext.action
-               (fun (e : 'expr) _ (loc : int * int) -> (e : 'e__7))]);
+               (fun (e : 'expr) _ (loc : int * int) -> (e : 'e__9))]);
        Gramext.Stoken ("", ")")],
       Gramext.action
-        (fun _ (e : 'e__7 option) (p : 'patt) _ _ (i : 'lident) _
+        (fun _ (e : 'e__9 option) (p : 'patt) _ _ (i : 'lident) _
            (loc : int * int) ->
            (Node ("PaOlb", [Loc; i; p; Option e]) : 'patt));
       [Gramext.Stoken ("", "~");
@@ -1782,10 +1803,10 @@ Grammar.extend
               Gramext.Snterm
                 (Grammar.Entry.obj (patt : 'patt Grammar.Entry.e))],
              Gramext.action
-               (fun (p : 'patt) _ (loc : int * int) -> (p : 'e__9))]);
+               (fun (p : 'patt) _ (loc : int * int) -> (p : 'e__11))]);
        Gramext.Stoken ("", "]")],
       Gramext.action
-        (fun _ (last : 'e__9 option) (pl : 'patt list) _ (loc : int * int) ->
+        (fun _ (last : 'e__11 option) (pl : 'patt list) _ (loc : int * int) ->
            (mklistpat last pl : 'patt));
       [Gramext.Stoken ("", "["); Gramext.Stoken ("", "]")],
       Gramext.action
@@ -2391,29 +2412,6 @@ Grammar.extend
          (Grammar.Entry.obj (anti_rec : 'anti_rec Grammar.Entry.e))],
       Gramext.action
         (fun (a : 'anti_rec) (loc : int * int) -> (a : 'rec_flag))]];
-    Grammar.Entry.obj (as_opt : 'as_opt Grammar.Entry.e), None,
-    [None, None,
-     [[], Gramext.action (fun (loc : int * int) -> (Option None : 'as_opt));
-      [Gramext.Snterm
-         (Grammar.Entry.obj (anti_as : 'anti_as Grammar.Entry.e))],
-      Gramext.action (fun (a : 'anti_as) (loc : int * int) -> (a : 'as_opt));
-      [Gramext.Stoken ("", "as");
-       Gramext.Snterm (Grammar.Entry.obj (patt : 'patt Grammar.Entry.e))],
-      Gramext.action
-        (fun (p : 'patt) _ (loc : int * int) ->
-           (Option (Some p) : 'as_opt))]];
-    Grammar.Entry.obj (when_opt : 'when_opt Grammar.Entry.e), None,
-    [None, None,
-     [[], Gramext.action (fun (loc : int * int) -> (Option None : 'when_opt));
-      [Gramext.Snterm
-         (Grammar.Entry.obj (anti_when : 'anti_when Grammar.Entry.e))],
-      Gramext.action
-        (fun (a : 'anti_when) (loc : int * int) -> (a : 'when_opt));
-      [Gramext.Stoken ("", "when");
-       Gramext.Snterm (Grammar.Entry.obj (expr : 'expr Grammar.Entry.e))],
-      Gramext.action
-        (fun (e : 'expr) _ (loc : int * int) ->
-           (Option (Some e) : 'when_opt))]];
     Grammar.Entry.obj (mutable_flag : 'mutable_flag Grammar.Entry.e), None,
     [None, None,
      [[],
@@ -2661,12 +2659,6 @@ Grammar.extend
       Gramext.action
         (fun (a : string) (loc : int * int) ->
            (antiquot "uid" loc a : 'anti_uid))]];
-    Grammar.Entry.obj (anti_when : 'anti_when Grammar.Entry.e), None,
-    [None, None,
-     [[Gramext.Stoken ("ANTIQUOT", "when")],
-      Gramext.action
-        (fun (a : string) (loc : int * int) ->
-           (antiquot "when" loc a : 'anti_when))]];
     Grammar.Entry.obj (expr : 'expr Grammar.Entry.e),
     Some (Gramext.Level "top"),
     [None, None,
@@ -2678,9 +2670,9 @@ Grammar.extend
                     (Grammar.Entry.obj (expr : 'expr Grammar.Entry.e));
                   Gramext.Stoken ("", ";")],
                  Gramext.action
-                   (fun _ (e : 'expr) (loc : int * int) -> (e : 'e__12))])],
+                   (fun _ (e : 'expr) (loc : int * int) -> (e : 'e__14))])],
           Gramext.action
-            (fun (l : 'e__12 list) (loc : int * int) -> (List l : 'anti));
+            (fun (l : 'e__14 list) (loc : int * int) -> (List l : 'anti));
           [Gramext.Snterm
              (Grammar.Entry.obj (anti_list : 'anti_list Grammar.Entry.e))],
           Gramext.action
@@ -2704,9 +2696,9 @@ Grammar.extend
                     (Grammar.Entry.obj (expr : 'expr Grammar.Entry.e));
                   Gramext.Stoken ("", ";")],
                  Gramext.action
-                   (fun _ (e : 'expr) (loc : int * int) -> (e : 'e__11))])],
+                   (fun _ (e : 'expr) (loc : int * int) -> (e : 'e__13))])],
           Gramext.action
-            (fun (l : 'e__11 list) (loc : int * int) -> (List l : 'anti));
+            (fun (l : 'e__13 list) (loc : int * int) -> (List l : 'anti));
           [Gramext.Snterm
              (Grammar.Entry.obj (anti_list : 'anti_list Grammar.Entry.e))],
           Gramext.action
@@ -2726,9 +2718,9 @@ Grammar.extend
                     (Grammar.Entry.obj (expr : 'expr Grammar.Entry.e));
                   Gramext.Stoken ("", ";")],
                  Gramext.action
-                   (fun _ (e : 'expr) (loc : int * int) -> (e : 'e__10))])],
+                   (fun _ (e : 'expr) (loc : int * int) -> (e : 'e__12))])],
           Gramext.action
-            (fun (l : 'e__10 list) (loc : int * int) -> (List l : 'anti));
+            (fun (l : 'e__12 list) (loc : int * int) -> (List l : 'anti));
           [Gramext.Snterm
              (Grammar.Entry.obj (anti_list : 'anti_list Grammar.Entry.e))],
           Gramext.action
@@ -3050,9 +3042,9 @@ Grammar.extend
                   Gramext.Stoken ("", ";")],
                  Gramext.action
                    (fun _ (cf : 'class_str_item) (loc : int * int) ->
-                      (cf : 'e__13))])],
+                      (cf : 'e__15))])],
           Gramext.action
-            (fun (l : 'e__13 list) (loc : int * int) -> (List l : 'anti));
+            (fun (l : 'e__15 list) (loc : int * int) -> (List l : 'anti));
           [Gramext.Snterm
              (Grammar.Entry.obj (anti_list : 'anti_list Grammar.Entry.e))],
           Gramext.action
@@ -3148,9 +3140,9 @@ Grammar.extend
                   Gramext.Stoken ("", ";")],
                  Gramext.action
                    (fun _ (s : 'class_str_item) (loc : int * int) ->
-                      (s : 'e__14))])],
+                      (s : 'e__16))])],
           Gramext.action
-            (fun (l : 'e__14 list) (loc : int * int) -> (List l : 'anti));
+            (fun (l : 'e__16 list) (loc : int * int) -> (List l : 'anti));
           [Gramext.Snterm
              (Grammar.Entry.obj (anti_list : 'anti_list Grammar.Entry.e))],
           Gramext.action
@@ -3224,9 +3216,9 @@ Grammar.extend
                   Gramext.Stoken ("", ";")],
                  Gramext.action
                    (fun _ (csf : 'class_sig_item) (loc : int * int) ->
-                      (csf : 'e__15))])],
+                      (csf : 'e__17))])],
           Gramext.action
-            (fun (l : 'e__15 list) (loc : int * int) -> (List l : 'anti));
+            (fun (l : 'e__17 list) (loc : int * int) -> (List l : 'anti));
           [Gramext.Snterm
              (Grammar.Entry.obj (anti_list : 'anti_list Grammar.Entry.e))],
           Gramext.action
@@ -3347,9 +3339,9 @@ Grammar.extend
                   Gramext.Stoken ("", ";")],
                  Gramext.action
                    (fun _ (s : 'class_sig_item) (loc : int * int) ->
-                      (s : 'e__16))])],
+                      (s : 'e__18))])],
           Gramext.action
-            (fun (l : 'e__16 list) (loc : int * int) -> (List l : 'anti));
+            (fun (l : 'e__18 list) (loc : int * int) -> (List l : 'anti));
           [Gramext.Snterm
              (Grammar.Entry.obj (anti_list : 'anti_list Grammar.Entry.e))],
           Gramext.action