camlspotter avatar camlspotter committed d216a5a

now compiled in 4.01.0 but with logs of test failures

Comments (0)

Files changed (5)

 # Various commands and dir
 ##########################
 CAMLRUN= ocamlrun
-OCAMLC   = ocamlc -annot -bin-annot -w A-4-9 -warn-error A-4-9-32-33-34-44
-OCAMLOPT = ocamlopt -annot -bin-annot -w A-4-9 -warn-error A-4-9-32-33-34-44
+OCAMLC   = ocamlc -annot -bin-annot -w A-4-9-40-42-44 -warn-error A-4-9-32-33-34-40-42-44
+OCAMLOPT = ocamlopt -annot -bin-annot -w A-4-9-40-42-44 -warn-error A-4-9-32-33-34-40-42-44
 OCAMLDEP = ocamldep
 OCAMLLEX = ocamllex
 OCAMLYACC= ocamlyacc
     | (_, ".cmx") -> true 
     | _ -> false) (Array.to_list cmt.cmt_args)
 
+(*
 (* CR jfuruse: This module should be removed once OCaml compilier-libs has the env restoration function *)
 module Envaux = struct (* copied from debugger/envaux.ml *)
   open Misc
         Hashtbl.add env_cache (sum, subst) env;
         env
 end 
+*)
 
 let reset_env_cache () = Envaux.reset_cache ()
 
 	List.map (fun (cls, _names, _) -> AStr_class cls.ci_id_class) classdescs
     | Tstr_class_type iddecls ->
 	List.map (fun (id, _, _) -> AStr_class_type id) iddecls
+(*
     | Tstr_include (mexp, idents) ->
+*)
+    | Tstr_include (mexp, sg) ->
+        (* CR jfuruse: 4.01.0 now returns sig instead of just idents! *)
+        let idents = List.map snd (List.map T.kident_of_sigitem sg) in
         let id_kid_list = try aliases_of_include mexp idents with e -> prerr_endline "structure_item include failed!!!"; raise e in
         let m = module_expr mexp in
         List.map (fun (id, (k, id')) -> AStr_included (id, m, k, id')) id_kid_list
 module Annot = struct
   type t =
     | Use               of Kind.t * Path.t
+    | UseConstruct      of Kind.t * Path.t * string
     | Type              of Types.type_expr * Env.t * [`Expr of Path.t option | `Pattern of Ident.t option ]
     | Mod_type          of Types.module_type
     | Str_item          of Abstraction.structure_item
     | Functor_parameter of Ident.t
     | Non_expansive     of bool
 
-  let equal t1 t2 = match t1, t2 with
+  let _equal t1 t2 = match t1, t2 with
     | Type (t1, _, _), Type (t2, _, _) -> t1 == t2
     | Mod_type mty1, Mod_type mty2 -> mty1 == mty2
     | Str_item sitem1, Str_item sitem2 -> Abstraction.Structure_item.equal sitem1 sitem2
     | Module mexp1, Module mexp2 -> mexp1 == mexp2
     | Use (k1,p1), Use (k2,p2) -> k1 = k2 && p1 = p2
+    | UseConstruct (k1,p1,n1), UseConstruct (k2,p2,n2) -> k1 = k2 && p1 = p2 && n1 = n2
     | Non_expansive b1, Non_expansive b2 -> b1 = b2
     | Functor_parameter id1, Functor_parameter id2 -> id1 = id2
-    | (Type _ | Str_item _ | Module _ | Functor_parameter _ | Use _ | Non_expansive _
+    | (Type _ | Str_item _ | Module _ | Functor_parameter _ | Use _ | UseConstruct _ | Non_expansive _
           | Mod_type _),
-      (Type _ | Str_item _ | Module _ | Functor_parameter _ | Use _ | Non_expansive _
+      (Type _ | Str_item _ | Module _ | Functor_parameter _ | Use _ | UseConstruct _ | Non_expansive _
           | Mod_type _) -> false
 
   module Record = struct
     class fold tbl =
       let record = record tbl in
       let record_def loc sitem = record loc (Str_item sitem)
-      and record_use loc kind path = record loc (Use (kind, path)) in
+      and record_use loc kind path = record loc (Use (kind, path))
+      and record_use_construct loc kind path name = record loc (UseConstruct (kind, path, name)) in
     object
-      inherit Ttfold.fold as super
+      inherit Ttfold.ovisit as super
 
       method table = tbl
       method size = Hashtbl.length tbl
         in
         record p.pat_loc (Type (p.pat_type, p.pat_env, `Pattern ident_opt));
         begin match p.pat_desc with
-        | Tpat_construct (path, _, cdesc, _, _) ->
+        | Tpat_construct (_, cdesc, _, _) ->
             let kind = match cdesc.Types.cstr_tag with
               | Types.Cstr_exception _ -> K.Exception
               | _ -> K.Type
             in
-            record p.pat_loc (Use (kind, path))
+            let path = 
+              let ty = cdesc.Types.cstr_res in
+              match (Ctype.repr ty).Types.desc with
+              | Tconstr (p, _, _) -> p
+              | _ -> assert false
+            in
+            record p.pat_loc (UseConstruct (kind, path, cdesc.Types.cstr_name))
         | Tpat_record _ -> record_record tbl p.pat_loc p.pat_type
         | _ -> ()
         end;
         | Tpat_alias (_, id, {loc}) -> record_def loc (AStr_value id)
         | Tpat_construct _ -> () (* done in #pattern *)
         | Tpat_record (lst , _) ->
-            List.iter (fun (path, {loc}, _, _) ->
-              record_use loc K.Type path) lst
+            List.iter (fun ({loc}, ldesc, _) ->
+              let path = match (Ctype.repr ldesc.Types.lbl_res).desc with
+                | Tconstr (p, _, _) -> p
+                | _ -> assert false
+              in
+              record_use_construct loc K.Type path ldesc.lbl_name) lst
         | Tpat_any | Tpat_constant _ | Tpat_tuple _
         | Tpat_variant _ | Tpat_array _ | Tpat_or _ | Tpat_lazy _ -> ()
         end;
         end;
 
         begin match e.exp_desc with
-        | Texp_construct (path, _, cdesc, _, _) ->
+        | Texp_construct (_, cdesc, _, _) ->
             let kind = match cdesc.Types.cstr_tag with
               | Types.Cstr_exception _ -> K.Exception
               | _ -> K.Type
             in
-            record_use e.exp_loc kind path
+            (* CR jfuruse: dupe at class fold *)
+            let path = 
+              let ty = cdesc.Types.cstr_res in
+              match (Ctype.repr ty).Types.desc with
+              | Tconstr (p, _, _) -> p
+              | _ -> assert false
+            in
+            record_use_construct e.exp_loc kind path cdesc.Types.cstr_name
         | Texp_record _ -> record_record tbl e.exp_loc e.exp_type
         | _ -> ()
         end;
       method! exp_extra ee =
         begin match ee with
         | Texp_constraint _ -> ()
-        | Texp_open (path, {loc}, _) -> record_use loc K.Module path
+        | Texp_open (_, path, {loc}, _) -> record_use loc K.Module path
         | Texp_poly _ -> ()
         | Texp_newtype _ -> ()
         end;
             ()
         | Texp_construct _ -> () (* done in #expression *)
         | Texp_record (lst, _) ->
-            List.iter (fun (path, {loc}, _, _) ->
-              record_use loc K.Type path) lst
-        | Texp_field (_, path, {loc}, _)
-        | Texp_setfield (_, path, {loc}, _, _) ->
-            record_use loc K.Type path
+            (* CR jfuruse: duped *)
+            List.iter (fun ({loc}, ldesc, _) ->
+              (* CR jfuruse: we do not need to run this for all the fields *)
+              let path = match (Ctype.repr ldesc.Types.lbl_res).desc with
+                | Tconstr (p, _, _) -> p
+                | _ -> assert false
+              in
+              record_use_construct loc K.Type path ldesc.lbl_name) lst
+        | Texp_field (_, {loc}, ldesc)
+        | Texp_setfield (_, {loc}, ldesc, _) ->
+            (* CR jfuruse: duped *)
+            let path = match (Ctype.repr ldesc.Types.lbl_res).desc with
+              | Tconstr (p, _, _) -> p
+              | _ -> assert false
+            in
+            record_use_construct loc K.Type path ldesc.lbl_name
         | Texp_for (id, {loc}, _, _, _, _) ->
             (* CR jfuruse: add type int to id *)
             record_def loc (AStr_value id)
 
       method! structure_item sitem =
         begin match sitem.str_desc with (* CR jfuruse; todo add env *)
-        | Tstr_include (mexp, idents) ->
+        | Tstr_include (mexp, sg) ->
+            (* CR jfuruse: 4.01.0 now returns sig instead of just idents! *)
+            let idents = List.map snd (List.map T.kident_of_sigitem sg) in
             let loc = sitem.str_loc in
             let id_kid_list = try aliases_of_include mexp idents with e -> prerr_endline "structure_item include failed!!!"; raise e in
             let m = module_expr mexp in
               record_def loc (AStr_module (id, module_expr mexp))) lst
         | Tstr_modtype (id, {loc}, mty) ->
             record_def loc (AStr_modtype (id, module_type mty))
-        | Tstr_open (path, {loc}) ->
+        | Tstr_open (_, path, {loc}) ->
             record_use loc K.Module path
         | Tstr_class_type lst ->
             List.iter (fun (id, {loc}, _) ->
               record_def loc (AStr_module (id, module_type mty))) lst
         | Tsig_modtype (id, {loc}, mtd) ->
             record_def loc (AStr_modtype (id, modtype_declaration mtd))
-        | Tsig_open (path, {loc}) -> record_use loc K.Module path
+        | Tsig_open (_, path, {loc}) -> record_use loc K.Module path
         | Tsig_include _ -> () (* done in #signature_item *)
         | Tsig_class _ -> ()
         | Tsig_class_type _ -> ()
     | Use (use, path) ->
 	fprintf ppf "Use: %s, %s"
 	  (String.capitalize (Kind.name use)) (Path.name path)
+    | UseConstruct (use, path, name) ->
+	fprintf ppf "Use: %s, %s.%s"
+	  (String.capitalize (Kind.name use)) (Path.name path) name
     | Module mexp ->
 	fprintf ppf "Module: %a"
           Abstraction.format_module_expr mexp
     | Use (use, path) ->
 	fprintf ppf "Use: %s, %s"
 	  (String.capitalize (Kind.name use)) (Path.name path)
+    | UseConstruct (use, path, name) ->
+	fprintf ppf "Use: %s, %s.%s"
+	  (String.capitalize (Kind.name use)) (Path.name path) name
     | Module _mexp ->
 	fprintf ppf "Module: ..."
     | Functor_parameter id ->
 module Annot : sig
   type t =
     | Use of Kind.t * Path.t
+    | UseConstruct of Kind.t * Path.t * string
     | Type of Types.type_expr * Env.t * [`Expr of Path.t option | `Pattern of Ident.t option ]
     | Mod_type of Types.module_type
     | Str_item of Abstraction.structure_item 
 
   module Record : sig
     class fold : (Location.t, t list) Hashtbl.t -> object 
-      inherit Ttfold.fold
+      inherit Ttfold.ovisit
       method table : (Location.t, t list) Hashtbl.t 
       method size : int
       method report : unit
 (*                                                                     *)
 (***********************************************************************)
 
-open Asttypes
 open Types
 open Typedtree
   
-class fold =
-  object ((self : 'self))
-    method ref : 'a1. ('self -> 'a1 -> 'self) -> 'a1 ref -> 'self = 
-      fun fa r -> fa self !r
-    method option : 'a1. ('self -> 'a1 -> 'self) -> 'a1 option -> 'self =
-      fun fa -> function
-        | None -> self
-        | Some v -> fa self v 
-    method list : 'a1. ('self -> 'a1 -> 'self) -> 'a1 list -> 'self =
-      fun fa l -> List.fold_left fa self l
-    method pattern : pattern -> 'self =
+class virtual ovisit_pattern =
+  object (self)
+    method virtual ref : 'a1. ('a1 -> unit) -> 'a1 ref -> unit
+    method virtual option : 'a1. ('a1 -> unit) -> 'a1 option -> unit
+    method virtual list : 'a1. ('a1 -> unit) -> 'a1 list -> unit
+    method pattern : pattern -> unit =
       fun __value ->
-        let self = self#pattern_desc __value.pat_desc in
-        let self =
-          self#list
-            (fun self (__x1, __x2) -> let self = self#pat_extra __x1 in self)
-            __value.pat_extra
-        in self
-    method pat_extra : pat_extra -> 'self =
+        (self#pattern_desc __value.pat_desc;
+         self#list (fun (__x1, __x2) -> (self#pat_extra __x1; ()))
+           __value.pat_extra;
+         ())
+    method pat_extra : pat_extra -> unit =
       fun __value ->
         match __value with
-        | Tpat_constraint __x1 -> let self = self#core_type __x1 in self
-        | Tpat_type (__x1, __x2) -> self
-        | Tpat_unpack -> self
-    method pattern_desc : pattern_desc -> 'self =
+        | Tpat_constraint __x1 -> (self#core_type __x1; ())
+        | Tpat_type (__x1, __x2) -> ()
+        | Tpat_unpack -> ()
+    method pattern_desc : pattern_desc -> unit =
       fun __value ->
         match __value with
-        | Tpat_any -> self
-        | Tpat_var (__x1, __x2) -> self
-        | Tpat_alias (__x1, __x2, __x3) ->
-            let self = self#pattern __x1 in self
-        | Tpat_constant __x1 -> self
-        | Tpat_tuple __x1 ->
-            let self = self#list (fun self -> self#pattern) __x1 in self
-        | Tpat_construct (__x1, __x2, __x3, __x4, __x5) ->
-            let self = self#list (fun self -> self#pattern) __x4 in self
+        | Tpat_any -> ()
+        | Tpat_var (__x1, __x2) -> ()
+        | Tpat_alias (__x1, __x2, __x3) -> (self#pattern __x1; ())
+        | Tpat_constant __x1 -> ()
+        | Tpat_tuple __x1 -> (self#list self#pattern __x1; ())
+        | Tpat_construct (__x1, __x2, __x3, __x4) ->
+            (self#list self#pattern __x3; ())
         | Tpat_variant (__x1, __x2, __x3) ->
-            let self = self#option (fun self -> self#pattern) __x2 in
-            let self = self#ref (fun self _ -> self) __x3 in self
+            (self#option self#pattern __x2; self#ref (fun _ -> ()) __x3; ())
         | Tpat_record (__x1, __x2) ->
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3, __x4) ->
-                   let self = self#pattern __x4 in self)
-                __x1
-            in self
-        | Tpat_array __x1 ->
-            let self = self#list (fun self -> self#pattern) __x1 in self
+            (self#list (fun (__x1, __x2, __x3) -> (self#pattern __x3; ()))
+               __x1;
+             ())
+        | Tpat_array __x1 -> (self#list self#pattern __x1; ())
         | Tpat_or (__x1, __x2, __x3) ->
-            let self = self#pattern __x1 in
-            let self = self#pattern __x2 in
-            let self = self#option (fun self _ -> self) __x3 in self
-        | Tpat_lazy __x1 -> let self = self#pattern __x1 in self
-    method expression : expression -> 'self =
+            (self#pattern __x1;
+             self#pattern __x2;
+             self#option (fun _ -> ()) __x3;
+             ())
+        | Tpat_lazy __x1 -> (self#pattern __x1; ())
+    method expression : expression -> unit =
       fun __value ->
-        let self = self#expression_desc __value.exp_desc in
-        let self =
-          self#list
-            (fun self (__x1, __x2) -> let self = self#exp_extra __x1 in self)
-            __value.exp_extra
-        in self
-    method exp_extra : exp_extra -> 'self =
+        (self#expression_desc __value.exp_desc;
+         self#list (fun (__x1, __x2) -> (self#exp_extra __x1; ()))
+           __value.exp_extra;
+         ())
+    method exp_extra : exp_extra -> unit =
       fun __value ->
         match __value with
         | Texp_constraint (__x1, __x2) ->
-            let self = self#option (fun self -> self#core_type) __x1 in
-            let self = self#option (fun self -> self#core_type) __x2 in self
-        | Texp_open (__x1, __x2, __x3) -> self
-        | Texp_poly __x1 ->
-            let self = self#option (fun self -> self#core_type) __x1 in self
-        | Texp_newtype __x1 -> self
-    method expression_desc : expression_desc -> 'self =
+            (self#option self#core_type __x1;
+             self#option self#core_type __x2;
+             ())
+        | Texp_open (__x1, __x2, __x3, __x4) -> ()
+        | Texp_poly __x1 -> (self#option self#core_type __x1; ())
+        | Texp_newtype __x1 -> ()
+    method expression_desc : expression_desc -> unit =
       fun __value ->
         match __value with
-        | Texp_ident (__x1, __x2, __x3) -> self
-        | Texp_constant __x1 -> self
+        | Texp_ident (__x1, __x2, __x3) -> ()
+        | Texp_constant __x1 -> ()
         | Texp_let (__x1, __x2, __x3) ->
-            let self =
-              self#list
-                (fun self (__x1, __x2) ->
-                   let self = self#pattern __x1 in
-                   let self = self#expression __x2 in self)
-                __x2 in
-            let self = self#expression __x3 in self
+            (self#list
+               (fun (__x1, __x2) ->
+                  (self#pattern __x1; self#expression __x2; ()))
+               __x2;
+             self#expression __x3;
+             ())
         | Texp_function (__x1, __x2, __x3) ->
-            let self =
-              self#list
-                (fun self (__x1, __x2) ->
-                   let self = self#pattern __x1 in
-                   let self = self#expression __x2 in self)
-                __x2
-            in self
+            (self#list
+               (fun (__x1, __x2) ->
+                  (self#pattern __x1; self#expression __x2; ()))
+               __x2;
+             ())
         | Texp_apply (__x1, __x2) ->
-            let self = self#expression __x1 in
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3) ->
-                   let self = self#option (fun self -> self#expression) __x2
-                   in self)
-                __x2
-            in self
+            (self#expression __x1;
+             self#list
+               (fun (__x1, __x2, __x3) ->
+                  (self#option self#expression __x2; ()))
+               __x2;
+             ())
         | Texp_match (__x1, __x2, __x3) ->
-            let self = self#expression __x1 in
-            let self =
-              self#list
-                (fun self (__x1, __x2) ->
-                   let self = self#pattern __x1 in
-                   let self = self#expression __x2 in self)
-                __x2
-            in self
+            (self#expression __x1;
+             self#list
+               (fun (__x1, __x2) ->
+                  (self#pattern __x1; self#expression __x2; ()))
+               __x2;
+             ())
         | Texp_try (__x1, __x2) ->
-            let self = self#expression __x1 in
-            let self =
-              self#list
-                (fun self (__x1, __x2) ->
-                   let self = self#pattern __x1 in
-                   let self = self#expression __x2 in self)
-                __x2
-            in self
-        | Texp_tuple __x1 ->
-            let self = self#list (fun self -> self#expression) __x1 in self
-        | Texp_construct (__x1, __x2, __x3, __x4, __x5) ->
-            let self = self#list (fun self -> self#expression) __x4 in self
-        | Texp_variant (__x1, __x2) ->
-            let self = self#option (fun self -> self#expression) __x2 in self
+            (self#expression __x1;
+             self#list
+               (fun (__x1, __x2) ->
+                  (self#pattern __x1; self#expression __x2; ()))
+               __x2;
+             ())
+        | Texp_tuple __x1 -> (self#list self#expression __x1; ())
+        | Texp_construct (__x1, __x2, __x3, __x4) ->
+            (self#list self#expression __x3; ())
+        | Texp_variant (__x1, __x2) -> (self#option self#expression __x2; ())
         | Texp_record (__x1, __x2) ->
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3, __x4) ->
-                   let self = self#expression __x4 in self)
-                __x1 in
-            let self = self#option (fun self -> self#expression) __x2 in self
-        | Texp_field (__x1, __x2, __x3, __x4) ->
-            let self = self#expression __x1 in self
-        | Texp_setfield (__x1, __x2, __x3, __x4, __x5) ->
-            let self = self#expression __x1 in
-            let self = self#expression __x5 in self
-        | Texp_array __x1 ->
-            let self = self#list (fun self -> self#expression) __x1 in self
+            (self#list (fun (__x1, __x2, __x3) -> (self#expression __x3; ()))
+               __x1;
+             self#option self#expression __x2;
+             ())
+        | Texp_field (__x1, __x2, __x3) -> (self#expression __x1; ())
+        | Texp_setfield (__x1, __x2, __x3, __x4) ->
+            (self#expression __x1; self#expression __x4; ())
+        | Texp_array __x1 -> (self#list self#expression __x1; ())
         | Texp_ifthenelse (__x1, __x2, __x3) ->
-            let self = self#expression __x1 in
-            let self = self#expression __x2 in
-            let self = self#option (fun self -> self#expression) __x3 in self
+            (self#expression __x1;
+             self#expression __x2;
+             self#option self#expression __x3;
+             ())
         | Texp_sequence (__x1, __x2) ->
-            let self = self#expression __x1 in
-            let self = self#expression __x2 in self
+            (self#expression __x1; self#expression __x2; ())
         | Texp_while (__x1, __x2) ->
-            let self = self#expression __x1 in
-            let self = self#expression __x2 in self
+            (self#expression __x1; self#expression __x2; ())
         | Texp_for (__x1, __x2, __x3, __x4, __x5, __x6) ->
-            let self = self#expression __x3 in
-            let self = self#expression __x4 in
-            let self = self#expression __x6 in self
+            (self#expression __x3;
+             self#expression __x4;
+             self#expression __x6;
+             ())
         | Texp_when (__x1, __x2) ->
-            let self = self#expression __x1 in
-            let self = self#expression __x2 in self
+            (self#expression __x1; self#expression __x2; ())
         | Texp_send (__x1, __x2, __x3) ->
-            let self = self#expression __x1 in
-            let self = self#meth __x2 in
-            let self = self#option (fun self -> self#expression) __x3 in self
-        | Texp_new (__x1, __x2, __x3) -> self
-        | Texp_instvar (__x1, __x2, __x3) -> self
+            (self#expression __x1;
+             self#meth __x2;
+             self#option self#expression __x3;
+             ())
+        | Texp_new (__x1, __x2, __x3) -> ()
+        | Texp_instvar (__x1, __x2, __x3) -> ()
         | Texp_setinstvar (__x1, __x2, __x3, __x4) ->
-            let self = self#expression __x4 in self
+            (self#expression __x4; ())
         | Texp_override (__x1, __x2) ->
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3) ->
-                   let self = self#expression __x3 in self)
-                __x2
-            in self
+            (self#list (fun (__x1, __x2, __x3) -> (self#expression __x3; ()))
+               __x2;
+             ())
         | Texp_letmodule (__x1, __x2, __x3, __x4) ->
-            let self = self#module_expr __x3 in
-            let self = self#expression __x4 in self
-        | Texp_assert __x1 -> let self = self#expression __x1 in self
-        | Texp_assertfalse -> self
-        | Texp_lazy __x1 -> let self = self#expression __x1 in self
+            (self#module_expr __x3; self#expression __x4; ())
+        | Texp_assert __x1 -> (self#expression __x1; ())
+        | Texp_assertfalse -> ()
+        | Texp_lazy __x1 -> (self#expression __x1; ())
         | Texp_object (__x1, __x2) ->
-            let self = self#class_structure __x1 in
-            let self = self#list (fun self _ -> self) __x2 in self
-        | Texp_pack __x1 -> let self = self#module_expr __x1 in self
-    method meth : meth -> 'self = fun __value -> self
-    method class_expr : class_expr -> 'self =
-      fun __value -> let self = self#class_expr_desc __value.cl_desc in self
-    method class_expr_desc : class_expr_desc -> 'self =
+            (self#class_structure __x1; self#list (fun _ -> ()) __x2; ())
+        | Texp_pack __x1 -> (self#module_expr __x1; ())
+    method meth : meth -> unit = fun __value -> ()
+    method class_expr : class_expr -> unit =
+      fun __value -> (self#class_expr_desc __value.cl_desc; ())
+    method class_expr_desc : class_expr_desc -> unit =
       fun __value ->
         match __value with
-        | Tcl_ident (__x1, __x2, __x3) ->
-            let self = self#list (fun self -> self#core_type) __x3 in self
-        | Tcl_structure __x1 -> let self = self#class_structure __x1 in self
+        | Tcl_ident (__x1, __x2, __x3) -> (self#list self#core_type __x3; ())
+        | Tcl_structure __x1 -> (self#class_structure __x1; ())
         | Tcl_fun (__x1, __x2, __x3, __x4, __x5) ->
-            let self = self#pattern __x2 in
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3) ->
-                   let self = self#expression __x3 in self)
-                __x3 in
-            let self = self#class_expr __x4 in self
+            (self#pattern __x2;
+             self#list (fun (__x1, __x2, __x3) -> (self#expression __x3; ()))
+               __x3;
+             self#class_expr __x4;
+             ())
         | Tcl_apply (__x1, __x2) ->
-            let self = self#class_expr __x1 in
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3) ->
-                   let self = self#option (fun self -> self#expression) __x2
-                   in self)
-                __x2
-            in self
+            (self#class_expr __x1;
+             self#list
+               (fun (__x1, __x2, __x3) ->
+                  (self#option self#expression __x2; ()))
+               __x2;
+             ())
         | Tcl_let (__x1, __x2, __x3, __x4) ->
-            let self =
-              self#list
-                (fun self (__x1, __x2) ->
-                   let self = self#pattern __x1 in
-                   let self = self#expression __x2 in self)
-                __x2 in
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3) ->
-                   let self = self#expression __x3 in self)
-                __x3 in
-            let self = self#class_expr __x4 in self
+            (self#list
+               (fun (__x1, __x2) ->
+                  (self#pattern __x1; self#expression __x2; ()))
+               __x2;
+             self#list (fun (__x1, __x2, __x3) -> (self#expression __x3; ()))
+               __x3;
+             self#class_expr __x4;
+             ())
         | Tcl_constraint (__x1, __x2, __x3, __x4, __x5) ->
-            let self = self#class_expr __x1 in
-            let self = self#option (fun self -> self#class_type) __x2 in
-            let self = self#list (fun self _ -> self) __x3 in
-            let self = self#list (fun self _ -> self) __x4 in self
-    method class_structure : class_structure -> 'self =
+            (self#class_expr __x1;
+             self#option self#class_type __x2;
+             self#list (fun _ -> ()) __x3;
+             self#list (fun _ -> ()) __x4;
+             ())
+    method class_structure : class_structure -> unit =
       fun __value ->
-        let self = self#pattern __value.cstr_pat in
-        let self =
-          self#list (fun self -> self#class_field) __value.cstr_fields
-        in self
-    method class_field : class_field -> 'self =
-      fun __value -> let self = self#class_field_desc __value.cf_desc in self
-    method class_field_kind : class_field_kind -> 'self =
+        (self#pattern __value.cstr_pat;
+         self#list self#class_field __value.cstr_fields;
+         ())
+    method class_field : class_field -> unit =
+      fun __value -> (self#class_field_desc __value.cf_desc; ())
+    method class_field_kind : class_field_kind -> unit =
       fun __value ->
         match __value with
-        | Tcfk_virtual __x1 -> let self = self#core_type __x1 in self
-        | Tcfk_concrete __x1 -> let self = self#expression __x1 in self
-    method class_field_desc : class_field_desc -> 'self =
+        | Tcfk_virtual __x1 -> (self#core_type __x1; ())
+        | Tcfk_concrete __x1 -> (self#expression __x1; ())
+    method class_field_desc : class_field_desc -> unit =
       fun __value ->
         match __value with
         | Tcf_inher (__x1, __x2, __x3, __x4, __x5) ->
-            let self = self#class_expr __x2 in
-            let self = self#option (fun self _ -> self) __x3 in
-            let self = self#list (fun self (__x1, __x2) -> self) __x4 in
-            let self = self#list (fun self (__x1, __x2) -> self) __x5 in self
+            (self#class_expr __x2;
+             self#option (fun _ -> ()) __x3;
+             self#list (fun (__x1, __x2) -> ()) __x4;
+             self#list (fun (__x1, __x2) -> ()) __x5;
+             ())
         | Tcf_val (__x1, __x2, __x3, __x4, __x5, __x6) ->
-            let self = self#class_field_kind __x5 in self
+            (self#class_field_kind __x5; ())
         | Tcf_meth (__x1, __x2, __x3, __x4, __x5) ->
-            let self = self#class_field_kind __x4 in self
+            (self#class_field_kind __x4; ())
         | Tcf_constr (__x1, __x2) ->
-            let self = self#core_type __x1 in
-            let self = self#core_type __x2 in self
-        | Tcf_init __x1 -> let self = self#expression __x1 in self
-    method module_expr : module_expr -> 'self =
-      fun __value ->
-        let self = self#module_expr_desc __value.mod_desc in self
-    method module_type_constraint : module_type_constraint -> 'self =
+            (self#core_type __x1; self#core_type __x2; ())
+        | Tcf_init __x1 -> (self#expression __x1; ())
+    method module_expr : module_expr -> unit =
+      fun __value -> (self#module_expr_desc __value.mod_desc; ())
+    method module_type_constraint : module_type_constraint -> unit =
       fun __value ->
         match __value with
-        | Tmodtype_implicit -> self
-        | Tmodtype_explicit __x1 -> let self = self#module_type __x1 in self
-    method module_expr_desc : module_expr_desc -> 'self =
+        | Tmodtype_implicit -> ()
+        | Tmodtype_explicit __x1 -> (self#module_type __x1; ())
+    method module_expr_desc : module_expr_desc -> unit =
       fun __value ->
         match __value with
-        | Tmod_ident (__x1, __x2) -> self
-        | Tmod_structure __x1 -> let self = self#structure __x1 in self
+        | Tmod_ident (__x1, __x2) -> ()
+        | Tmod_structure __x1 -> (self#structure __x1; ())
         | Tmod_functor (__x1, __x2, __x3, __x4) ->
-            let self = self#module_type __x3 in
-            let self = self#module_expr __x4 in self
+            (self#module_type __x3; self#module_expr __x4; ())
         | Tmod_apply (__x1, __x2, __x3) ->
-            let self = self#module_expr __x1 in
-            let self = self#module_expr __x2 in
-            let self = self#module_coercion __x3 in self
+            (self#module_expr __x1;
+             self#module_expr __x2;
+             self#module_coercion __x3;
+             ())
         | Tmod_constraint (__x1, __x2, __x3, __x4) ->
-            let self = self#module_expr __x1 in
-            let self = self#module_type_constraint __x3 in
-            let self = self#module_coercion __x4 in self
-        | Tmod_unpack (__x1, __x2) -> let self = self#expression __x1 in self
-    method structure : structure -> 'self =
-      fun __value ->
-        let self =
-          self#list (fun self -> self#structure_item) __value.str_items
-        in self
-    method structure_item : structure_item -> 'self =
-      fun __value ->
-        let self = self#structure_item_desc __value.str_desc in self
-    method structure_item_desc : structure_item_desc -> 'self =
+            (self#module_expr __x1;
+             self#module_type_constraint __x3;
+             self#module_coercion __x4;
+             ())
+        | Tmod_unpack (__x1, __x2) -> (self#expression __x1; ())
+    method structure : structure -> unit =
+      fun __value -> (self#list self#structure_item __value.str_items; ())
+    method structure_item : structure_item -> unit =
+      fun __value -> (self#structure_item_desc __value.str_desc; ())
+    method structure_item_desc : structure_item_desc -> unit =
       fun __value ->
         match __value with
-        | Tstr_eval __x1 -> let self = self#expression __x1 in self
+        | Tstr_eval __x1 -> (self#expression __x1; ())
         | Tstr_value (__x1, __x2) ->
-            let self =
-              self#list
-                (fun self (__x1, __x2) ->
-                   let self = self#pattern __x1 in
-                   let self = self#expression __x2 in self)
-                __x2
-            in self
+            (self#list
+               (fun (__x1, __x2) ->
+                  (self#pattern __x1; self#expression __x2; ()))
+               __x2;
+             ())
         | Tstr_primitive (__x1, __x2, __x3) ->
-            let self = self#value_description __x3 in self
+            (self#value_description __x3; ())
         | Tstr_type __x1 ->
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3) ->
-                   let self = self#type_declaration __x3 in self)
-                __x1
-            in self
+            (self#list
+               (fun (__x1, __x2, __x3) -> (self#type_declaration __x3; ()))
+               __x1;
+             ())
         | Tstr_exception (__x1, __x2, __x3) ->
-            let self = self#exception_declaration __x3 in self
-        | Tstr_exn_rebind (__x1, __x2, __x3, __x4) -> self
-        | Tstr_module (__x1, __x2, __x3) ->
-            let self = self#module_expr __x3 in self
+            (self#exception_declaration __x3; ())
+        | Tstr_exn_rebind (__x1, __x2, __x3, __x4) -> ()
+        | Tstr_module (__x1, __x2, __x3) -> (self#module_expr __x3; ())
         | Tstr_recmodule __x1 ->
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3, __x4) ->
-                   let self = self#module_type __x3 in
-                   let self = self#module_expr __x4 in self)
-                __x1
-            in self
-        | Tstr_modtype (__x1, __x2, __x3) ->
-            let self = self#module_type __x3 in self
-        | Tstr_open (__x1, __x2) -> self
+            (self#list
+               (fun (__x1, __x2, __x3, __x4) ->
+                  (self#module_type __x3; self#module_expr __x4; ()))
+               __x1;
+             ())
+        | Tstr_modtype (__x1, __x2, __x3) -> (self#module_type __x3; ())
+        | Tstr_open (__x1, __x2, __x3) -> ()
         | Tstr_class __x1 ->
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3) ->
-                   let self = self#class_declaration __x1 in
-                   let self = self#list (fun self _ -> self) __x2 in self)
-                __x1
-            in self
+            (self#list
+               (fun (__x1, __x2, __x3) ->
+                  (self#class_declaration __x1;
+                   self#list (fun _ -> ()) __x2;
+                   ()))
+               __x1;
+             ())
         | Tstr_class_type __x1 ->
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3) ->
-                   let self = self#class_type_declaration __x3 in self)
-                __x1
-            in self
-        | Tstr_include (__x1, __x2) ->
-            let self = self#module_expr __x1 in
-            let self = self#list (fun self _ -> self) __x2 in self
-    method module_coercion : module_coercion -> 'self =
+            (self#list
+               (fun (__x1, __x2, __x3) ->
+                  (self#class_type_declaration __x3; ()))
+               __x1;
+             ())
+        | Tstr_include (__x1, __x2) -> (self#module_expr __x1; ())
+    method module_coercion : module_coercion -> unit =
       fun __value ->
         match __value with
-        | Tcoerce_none -> self
+        | Tcoerce_none -> ()
         | Tcoerce_structure __x1 ->
-            let self =
-              self#list
-                (fun self (__x1, __x2) ->
-                   let self = self#module_coercion __x2 in self)
-                __x1
-            in self
+            (self#list (fun (__x1, __x2) -> (self#module_coercion __x2; ()))
+               __x1;
+             ())
         | Tcoerce_functor (__x1, __x2) ->
-            let self = self#module_coercion __x1 in
-            let self = self#module_coercion __x2 in self
-        | Tcoerce_primitive __x1 -> self
-    method module_type : module_type -> 'self =
-      fun __value ->
-        let self = self#module_type_desc __value.mty_desc in self
-    method module_type_desc : module_type_desc -> 'self =
+            (self#module_coercion __x1; self#module_coercion __x2; ())
+        | Tcoerce_primitive __x1 -> ()
+    method module_type : module_type -> unit =
+      fun __value -> (self#module_type_desc __value.mty_desc; ())
+    method module_type_desc : module_type_desc -> unit =
       fun __value ->
         match __value with
-        | Tmty_ident (__x1, __x2) -> self
-        | Tmty_signature __x1 -> let self = self#signature __x1 in self
+        | Tmty_ident (__x1, __x2) -> ()
+        | Tmty_signature __x1 -> (self#signature __x1; ())
         | Tmty_functor (__x1, __x2, __x3, __x4) ->
-            let self = self#module_type __x3 in
-            let self = self#module_type __x4 in self
+            (self#module_type __x3; self#module_type __x4; ())
         | Tmty_with (__x1, __x2) ->
-            let self = self#module_type __x1 in
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3) ->
-                   let self = self#with_constraint __x3 in self)
-                __x2
-            in self
-        | Tmty_typeof __x1 -> let self = self#module_expr __x1 in self
-    method signature : signature -> 'self =
-      fun __value ->
-        let self =
-          self#list (fun self -> self#signature_item) __value.sig_items
-        in self
-    method signature_item : signature_item -> 'self =
-      fun __value ->
-        let self = self#signature_item_desc __value.sig_desc in self
-    method signature_item_desc : signature_item_desc -> 'self =
+            (self#module_type __x1;
+             self#list
+               (fun (__x1, __x2, __x3) -> (self#with_constraint __x3; ()))
+               __x2;
+             ())
+        | Tmty_typeof __x1 -> (self#module_expr __x1; ())
+    method signature : signature -> unit =
+      fun __value -> (self#list self#signature_item __value.sig_items; ())
+    method signature_item : signature_item -> unit =
+      fun __value -> (self#signature_item_desc __value.sig_desc; ())
+    method signature_item_desc : signature_item_desc -> unit =
       fun __value ->
         match __value with
-        | Tsig_value (__x1, __x2, __x3) ->
-            let self = self#value_description __x3 in self
+        | Tsig_value (__x1, __x2, __x3) -> (self#value_description __x3; ())
         | Tsig_type __x1 ->
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3) ->
-                   let self = self#type_declaration __x3 in self)
-                __x1
-            in self
+            (self#list
+               (fun (__x1, __x2, __x3) -> (self#type_declaration __x3; ()))
+               __x1;
+             ())
         | Tsig_exception (__x1, __x2, __x3) ->
-            let self = self#exception_declaration __x3 in self
-        | Tsig_module (__x1, __x2, __x3) ->
-            let self = self#module_type __x3 in self
+            (self#exception_declaration __x3; ())
+        | Tsig_module (__x1, __x2, __x3) -> (self#module_type __x3; ())
         | Tsig_recmodule __x1 ->
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3) ->
-                   let self = self#module_type __x3 in self)
-                __x1
-            in self
+            (self#list
+               (fun (__x1, __x2, __x3) -> (self#module_type __x3; ())) __x1;
+             ())
         | Tsig_modtype (__x1, __x2, __x3) ->
-            let self = self#modtype_declaration __x3 in self
-        | Tsig_open (__x1, __x2) -> self
-        | Tsig_include (__x1, __x2) ->
-            let self = self#module_type __x1 in self
-        | Tsig_class __x1 ->
-            let self = self#list (fun self -> self#class_description) __x1
-            in self
+            (self#modtype_declaration __x3; ())
+        | Tsig_open (__x1, __x2, __x3) -> ()
+        | Tsig_include (__x1, __x2) -> (self#module_type __x1; ())
+        | Tsig_class __x1 -> (self#list self#class_description __x1; ())
         | Tsig_class_type __x1 ->
-            let self =
-              self#list (fun self -> self#class_type_declaration) __x1
-            in self
-    method modtype_declaration : modtype_declaration -> 'self =
+            (self#list self#class_type_declaration __x1; ())
+    method modtype_declaration : modtype_declaration -> unit =
       fun __value ->
         match __value with
-        | Tmodtype_abstract -> self
-        | Tmodtype_manifest __x1 -> let self = self#module_type __x1 in self
-    method with_constraint : with_constraint -> 'self =
+        | Tmodtype_abstract -> ()
+        | Tmodtype_manifest __x1 -> (self#module_type __x1; ())
+    method with_constraint : with_constraint -> unit =
       fun __value ->
         match __value with
-        | Twith_type __x1 -> let self = self#type_declaration __x1 in self
-        | Twith_module (__x1, __x2) -> self
-        | Twith_typesubst __x1 ->
-            let self = self#type_declaration __x1 in self
-        | Twith_modsubst (__x1, __x2) -> self
-    method core_type : core_type -> 'self =
-      fun __value -> let self = self#core_type_desc __value.ctyp_desc in self
-    method core_type_desc : core_type_desc -> 'self =
+        | Twith_type __x1 -> (self#type_declaration __x1; ())
+        | Twith_module (__x1, __x2) -> ()
+        | Twith_typesubst __x1 -> (self#type_declaration __x1; ())
+        | Twith_modsubst (__x1, __x2) -> ()
+    method core_type : core_type -> unit =
+      fun __value -> (self#core_type_desc __value.ctyp_desc; ())
+    method core_type_desc : core_type_desc -> unit =
       fun __value ->
         match __value with
-        | Ttyp_any -> self
-        | Ttyp_var __x1 -> self
+        | Ttyp_any -> ()
+        | Ttyp_var __x1 -> ()
         | Ttyp_arrow (__x1, __x2, __x3) ->
-            let self = self#core_type __x2 in
-            let self = self#core_type __x3 in self
-        | Ttyp_tuple __x1 ->
-            let self = self#list (fun self -> self#core_type) __x1 in self
+            (self#core_type __x2; self#core_type __x3; ())
+        | Ttyp_tuple __x1 -> (self#list self#core_type __x1; ())
         | Ttyp_constr (__x1, __x2, __x3) ->
-            let self = self#list (fun self -> self#core_type) __x3 in self
-        | Ttyp_object __x1 ->
-            let self = self#list (fun self -> self#core_field_type) __x1
-            in self
+            (self#list self#core_type __x3; ())
+        | Ttyp_object __x1 -> (self#list self#core_field_type __x1; ())
         | Ttyp_class (__x1, __x2, __x3, __x4) ->
-            let self = self#list (fun self -> self#core_type) __x3 in
-            let self = self#list (fun self _ -> self) __x4 in self
-        | Ttyp_alias (__x1, __x2) -> let self = self#core_type __x1 in self
+            (self#list self#core_type __x3; self#list (fun _ -> ()) __x4; ())
+        | Ttyp_alias (__x1, __x2) -> (self#core_type __x1; ())
         | Ttyp_variant (__x1, __x2, __x3) ->
-            let self = self#list (fun self -> self#row_field) __x1 in
-            let self = self#option (fun self -> self#list (fun self _ -> self)) __x3
-            in self
+            (self#list self#row_field __x1;
+             self#option (self#list (fun _ -> ())) __x3;
+             ())
         | Ttyp_poly (__x1, __x2) ->
-            let self = self#list (fun self _ -> self) __x1 in
-            let self = self#core_type __x2 in self
-        | Ttyp_package __x1 -> let self = self#package_type __x1 in self
-    method package_type : package_type -> 'self =
+            (self#list (fun _ -> ()) __x1; self#core_type __x2; ())
+        | Ttyp_package __x1 -> (self#package_type __x1; ())
+    method package_type : package_type -> unit =
       fun __value ->
-        let self =
-          self#list
-            (fun self (__x1, __x2) -> let self = self#core_type __x2 in self)
-            __value.pack_fields
-        in self
-    method core_field_type : core_field_type -> 'self =
-      fun __value ->
-        let self = self#core_field_desc __value.field_desc in self
-    method core_field_desc : core_field_desc -> 'self =
+        (self#list (fun (__x1, __x2) -> (self#core_type __x2; ()))
+           __value.pack_fields;
+         ())
+    method core_field_type : core_field_type -> unit =
+      fun __value -> (self#core_field_desc __value.field_desc; ())
+    method core_field_desc : core_field_desc -> unit =
       fun __value ->
         match __value with
-        | Tcfield (__x1, __x2) -> let self = self#core_type __x2 in self
-        | Tcfield_var -> self
-    method row_field : row_field -> 'self =
+        | Tcfield (__x1, __x2) -> (self#core_type __x2; ())
+        | Tcfield_var -> ()
+    method row_field : row_field -> unit =
       fun __value ->
         match __value with
-        | Ttag (__x1, __x2, __x3) ->
-            let self = self#list (fun self -> self#core_type) __x3 in self
-        | Tinherit __x1 -> let self = self#core_type __x1 in self
-    method value_description : value_description -> 'self =
+        | Ttag (__x1, __x2, __x3) -> (self#list self#core_type __x3; ())
+        | Tinherit __x1 -> (self#core_type __x1; ())
+    method value_description : value_description -> unit =
       fun __value ->
-        let self = self#core_type __value.val_desc in
-        let self = self#list (fun self _ -> self) __value.val_prim in self
-    method type_declaration : type_declaration -> 'self =
+        (self#core_type __value.val_desc;
+         self#list (fun _ -> ()) __value.val_prim;
+         ())
+    method type_declaration : type_declaration -> unit =
       fun __value ->
-        let self =
-          self#list (fun self -> self#option (fun self _ -> self)) __value.typ_params in
-        let self =
-          self#list
-            (fun self (__x1, __x2, __x3) ->
-               let self = self#core_type __x1 in
-               let self = self#core_type __x2 in self)
-            __value.typ_cstrs in
-        let self = self#type_kind __value.typ_kind in
-        let self =
-          self#option (fun self -> self#core_type) __value.typ_manifest in
-        let self =
-          self#list (fun self (__x1, __x2) -> self) __value.typ_variance
-        in self
-    method type_kind : type_kind -> 'self =
+        (self#list (self#option (fun _ -> ())) __value.typ_params;
+         self#list
+           (fun (__x1, __x2, __x3) ->
+              (self#core_type __x1; self#core_type __x2; ()))
+           __value.typ_cstrs;
+         self#type_kind __value.typ_kind;
+         self#option self#core_type __value.typ_manifest;
+         self#list (fun (__x1, __x2) -> ()) __value.typ_variance;
+         ())
+    method type_kind : type_kind -> unit =
       fun __value ->
         match __value with
-        | Ttype_abstract -> self
+        | Ttype_abstract -> ()
         | Ttype_variant __x1 ->
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3, __x4) ->
-                   let self = self#list (fun self -> self#core_type) __x3
-                   in self)
-                __x1
-            in self
+            (self#list
+               (fun (__x1, __x2, __x3, __x4) ->
+                  (self#list self#core_type __x3; ()))
+               __x1;
+             ())
         | Ttype_record __x1 ->
-            let self =
-              self#list
-                (fun self (__x1, __x2, __x3, __x4, __x5) ->
-                   let self = self#core_type __x4 in self)
-                __x1
-            in self
-    method exception_declaration : exception_declaration -> 'self =
-      fun __value ->
-        let self = self#list (fun self -> self#core_type) __value.exn_params
-        in self
-    method class_type : class_type -> 'self =
-      fun __value ->
-        let self = self#class_type_desc __value.cltyp_desc in self
-    method class_type_desc : class_type_desc -> 'self =
+            (self#list
+               (fun (__x1, __x2, __x3, __x4, __x5) ->
+                  (self#core_type __x4; ()))
+               __x1;
+             ())
+    method exception_declaration : exception_declaration -> unit =
+      fun __value -> (self#list self#core_type __value.exn_params; ())
+    method class_type : class_type -> unit =
+      fun __value -> (self#class_type_desc __value.cltyp_desc; ())
+    method class_type_desc : class_type_desc -> unit =
       fun __value ->
         match __value with
         | Tcty_constr (__x1, __x2, __x3) ->
-            let self = self#list (fun self -> self#core_type) __x3 in self
-        | Tcty_signature __x1 -> let self = self#class_signature __x1 in self
+            (self#list self#core_type __x3; ())
+        | Tcty_signature __x1 -> (self#class_signature __x1; ())
         | Tcty_fun (__x1, __x2, __x3) ->
-            let self = self#core_type __x2 in
-            let self = self#class_type __x3 in self
-    method class_signature : class_signature -> 'self =
+            (self#core_type __x2; self#class_type __x3; ())
+    method class_signature : class_signature -> unit =
       fun __value ->
-        let self = self#core_type __value.csig_self in
-        let self =
-          self#list (fun self -> self#class_type_field) __value.csig_fields
-        in self
-    method class_type_field : class_type_field -> 'self =
-      fun __value ->
-        let self = self#class_type_field_desc __value.ctf_desc in self
-    method class_type_field_desc : class_type_field_desc -> 'self =
+        (self#core_type __value.csig_self;
+         self#list self#class_type_field __value.csig_fields;
+         ())
+    method class_type_field : class_type_field -> unit =
+      fun __value -> (self#class_type_field_desc __value.ctf_desc; ())
+    method class_type_field_desc : class_type_field_desc -> unit =
       fun __value ->
         match __value with
-        | Tctf_inher __x1 -> let self = self#class_type __x1 in self
+        | Tctf_inher __x1 -> (self#class_type __x1; ())
         | Tctf_val __x1 ->
-            let self =
-              (fun (__x1, __x2, __x3, __x4) ->
-                 let self = self#core_type __x4 in self)
-                __x1
-            in self
+            ((fun (__x1, __x2, __x3, __x4) -> (self#core_type __x4; ())) __x1;
+             ())
         | Tctf_virt __x1 ->
-            let self =
-              (fun (__x1, __x2, __x3) ->
-                 let self = self#core_type __x3 in self)
-                __x1
-            in self
+            ((fun (__x1, __x2, __x3) -> (self#core_type __x3; ())) __x1; ())
         | Tctf_meth __x1 ->
-            let self =
-              (fun (__x1, __x2, __x3) ->
-                 let self = self#core_type __x3 in self)
-                __x1
-            in self
+            ((fun (__x1, __x2, __x3) -> (self#core_type __x3; ())) __x1; ())
         | Tctf_cstr __x1 ->
-            let self =
-              (fun (__x1, __x2) ->
-                 let self = self#core_type __x1 in
-                 let self = self#core_type __x2 in self)
-                __x1
-            in self
-    method class_declaration : class_declaration -> 'self =
-      fun __value -> self#class_infos (fun self -> self#class_expr) __value
-    method class_description : class_description -> 'self =
-      fun __value -> self#class_infos (fun self -> self#class_type) __value
-    method class_type_declaration : class_type_declaration -> 'self =
-      fun __value -> self#class_infos (fun self -> self#class_type) __value
-    method class_infos :
-      'a. ('self -> 'a -> 'self) -> 'a class_infos -> 'self =
-      fun __f_a __value ->
-        let self =
-          (fun (__x1, __x2) -> let self = self#list (fun self _ -> self) __x1 in self)
-            __value.ci_params in
-        let self = __f_a self __value.ci_expr in
-        let self =
-          self#list (fun self (__x1, __x2) -> self) __value.ci_variance
-        in self
+            ((fun (__x1, __x2) ->
+                (self#core_type __x1; self#core_type __x2; ()))
+               __x1;
+             ())
+    method class_declaration : class_declaration -> unit =
+      fun __value -> self#class_infos self#class_expr __value
+    method class_description : class_description -> unit =
+      fun __value -> self#class_infos self#class_type __value
+    method class_type_declaration : class_type_declaration -> unit =
+      fun __value -> self#class_infos self#class_type __value
+    method class_infos : 'a. ('a -> unit) -> 'a class_infos -> unit =
+      fun __tv_a __value ->
+        ((fun (__x1, __x2) -> (self#list (fun _ -> ()) __x1; ()))
+           __value.ci_params;
+         __tv_a __value.ci_expr;
+         self#list (fun (__x1, __x2) -> ()) __value.ci_variance;
+         ())
   end
+
+class ovisit = object
+  inherit ovisit_pattern
+  method ref f x = f !x
+  method option f = function
+    | None -> ()
+    | Some v -> f v
+  method list f xs = List.iter f xs
+end
+
Tip: Filter by directory path e.g. /media app.js to search for public/media/app.js.
Tip: Use camelCasing e.g. ProjME to search for ProjectModifiedEvent.java.
Tip: Filter by extension type e.g. /repo .js to search for all .js files in the /repo directory.
Tip: Separate your search with spaces e.g. /ssh pom.xml to search for src/ssh/pom.xml.
Tip: Use ↑ and ↓ arrow keys to navigate and return to view the file.
Tip: You can also navigate files with Ctrl+j (next) and Ctrl+k (previous) and view the file with Ctrl+o.
Tip: You can also navigate files with Alt+j (next) and Alt+k (previous) and view the file with Alt+o.