Done! no object used

Author: bobzhang

jscomp/core/js_analyzer.ml

@@ -44,47 +44,51 @@ let add_defined_idents (x : idents_stats) ident =
    Note such shaking is done in the toplevel, so that it requires us to 
    flatten the statement first 
 *)
-let free_variables (stats : idents_stats) : Js_iter.iter = 
-  object (self)
-    inherit Js_iter.iter as super
-    method! variable_declaration st = 
-      add_defined_idents stats st.ident; 
-      match st.value with 
-      |  None
-        ->  ()
-      | Some v
-        -> 
-        self # expression v
-    method! ident id = 
-      (if not (Set_ident.mem stats.defined_idents id )then 
-         stats.used_idents <- Set_ident.add stats.used_idents id)
-
-    method! expression exp = 
-      match exp.expression_desc with
-      | Fun(_, _,_, env)
-        (** a optimization to avoid walking into funciton again
-            if it's already comuted
-        *)
-        ->
-        stats.used_idents <-
-          Set_ident.union (Js_fun_env.get_unbounded env) stats.used_idents
+let super = Js_record_iter.iter
+let free_variables (stats : idents_stats) = {
+  super with 
+  variable_declaration = begin fun self st ->   
+    add_defined_idents stats st.ident; 
+    match st.value with 
+    |  None
+      ->  ()
+    | Some v
+      -> 
+      self.expression self v
 
+  end;
+  ident = begin fun _ id -> 
+    if not (Set_ident.mem stats.defined_idents id )then 
+      stats.used_idents <- Set_ident.add stats.used_idents id
+  end;
+  expression = begin fun self exp -> 
+    match exp.expression_desc with
+    | Fun(_, _,_, env)
+      (** a optimization to avoid walking into funciton again
+          if it's already comuted
+      *)
+      ->
+      stats.used_idents <-
+        Set_ident.union (Js_fun_env.get_unbounded env) stats.used_idents
+    | _
+      ->
+      super.expression self exp
+  end
+}
 
-      | _
-        ->
-        super#expression exp
-  end 
 
 let free_variables_of_statement  st = 
   let init = {used_idents = Set_ident.empty;  
-              defined_idents = Set_ident.empty} in 
-  let _ = (free_variables init)#statement st in 
+              defined_idents = Set_ident.empty} in
+  let obj = free_variables init in               
+  obj.statement obj st ;
   Set_ident.diff init.used_idents init.defined_idents
 
 let free_variables_of_expression  st = 
   let init = {used_idents = Set_ident.empty;  
               defined_idents = Set_ident.empty} in 
-  let _ = (free_variables init)#expression st in 
+  let obj = free_variables init in 
+  obj.expression obj st ;
   Set_ident.diff init.used_idents init.defined_idents
 
 let rec no_side_effect_expression_desc (x : J.expression_desc)  = 
@@ -139,26 +143,26 @@ and no_side_effect (x : J.expression)  =
 
 let no_side_effect_expression (x : J.expression) = no_side_effect x 
 
-let no_side_effect_obj  : Js_iter.iter = 
-  object (self)
-    inherit Js_iter.iter as super
-    method! statement s = 
+let super = Js_record_iter.iter 
+let no_side_effect_obj  = 
+  {super with 
+    statement = (fun self s -> 
         match s.statement_desc with 
         | Throw _ 
         | Debugger 
         | Break 
         | Variable _ 
         | Continue _ ->  
           raise_notrace Not_found
-        | Exp e -> self#expression e 
+        | Exp e -> self.expression self e 
         | Int_switch _ | String_switch _ | ForRange _ 
-        | If _ | While _   | Block _ | Return _ | Try _  -> super#statement s 
-    method! expression s = 
+        | If _ | While _   | Block _ | Return _ | Try _  -> super.statement self s );
+    expression = begin fun _ s ->  
       if not (no_side_effect_expression s) then raise_notrace Not_found
-  end
+  end}
 let no_side_effect_statement st = 
   try 
-    no_side_effect_obj#statement st; true
+    no_side_effect_obj.statement no_side_effect_obj st; true
   with _ -> false
 
 

jscomp/core/js_fold_basic.ml

@@ -27,25 +27,30 @@
 
 let add_lam_module_ident = Lam_module_ident.Hash_set.add
 let create = Lam_module_ident.Hash_set.create
-let count_hard_dependencies hard_dependencies = 
-  object
-    inherit  Js_iter.iter as super
-    method! module_id vid = 
-        add_lam_module_ident  hard_dependencies vid
-    method! expression x   = 
-      (* check {!Js_pass_scope} when making changes *)
+
+let super = Js_record_iter.iter 
+let  count_hard_dependencies hard_dependencies = {
+  super with 
+  module_id = begin 
+    fun _ vid -> 
+      add_lam_module_ident hard_dependencies vid
+  end;
+  expression = begin 
+    fun self x ->   
       (match  Js_block_runtime.check_additional_id x with
        | Some id -> 
          add_lam_module_ident hard_dependencies
            (Lam_module_ident.of_runtime 
               id)
        | _ -> ());
-      super#expression x
-  end
+      super.expression self x
+  end    
+}
 
 let calculate_hard_dependencies block = 
   let hard_dependencies = create 17 in   
-  (count_hard_dependencies hard_dependencies)#block block ;
+  let obj = (count_hard_dependencies hard_dependencies) in 
+  obj.block obj block ;
   hard_dependencies
 
 (*

jscomp/core/js_pass_flatten.ml

@@ -36,20 +36,19 @@
 *)
 module E = Js_exp_make
 module S = Js_stmt_make 
-
-let flatten_map = 
-  object(self)
-    inherit Js_map.map as super
-    method! statement x = 
+let super = Js_record_map.super 
+let flatten_map = { super with 
+  
+    statement = (fun self x ->
       match x.statement_desc with 
       |  Exp ({expression_desc = Seq _; _} as v) ->
-          S.block ( List.rev_map self#statement (Js_analyzer.rev_flatten_seq v ))
+          S.block ( List.rev_map (fun x -> self.statement self x) (Js_analyzer.rev_flatten_seq v ))
       | Exp {expression_desc = Caml_block (args, _mutable_flag, _tag, _tag_info )}
         ->         
-        S.block (Ext_list.map args (fun arg -> self#statement (S.exp arg)))         
+        S.block (Ext_list.map args (fun arg -> self.statement self (S.exp arg)))         
       |  Exp ({expression_desc = Cond(a,b,c); comment} ) -> 
-          { statement_desc = If (a, [ self#statement (S.exp b)],  
-                                  [ self#statement (S.exp c)]); comment}
+          { statement_desc = If (a, [ self.statement self (S.exp b)],  
+                                  [ self.statement self (S.exp c)]); comment}
 
       |  Exp ({expression_desc = Bin(Eq, a, ({expression_desc = Seq _; _ } as v)); _} )
         ->
@@ -58,8 +57,8 @@ let flatten_map =
           | {statement_desc = Exp last_one ; _} :: rest_rev
             ->  
               S.block (Ext_list.rev_map_append  rest_rev 
-                [self#statement @@ S.exp (E.assign a  last_one)]
-                self#statement
+                [self.statement self (S.exp (E.assign a  last_one))]
+                (fun x -> self.statement self x)
               )
                 (* TODO: here we introduce a block, should avoid it *)
               (* super#statement *)
@@ -69,36 +68,36 @@ let flatten_map =
           end
       | Return {expression_desc = Cond (a,b,c);  comment}
         -> 
-          { statement_desc = If (a, [self#statement (S.return_stmt b)],  
-                                  [ self#statement (S.return_stmt c)]); comment}
+          { statement_desc = If (a, [self.statement self (S.return_stmt b)],  
+                                  [ self.statement self (S.return_stmt c)]); comment}
 
       | Return ({expression_desc = Seq _; _} as v) ->
           let block = Js_analyzer.rev_flatten_seq v  in
           begin match block with
           | {statement_desc = Exp last_one ; _} :: rest_rev
             ->  
-              super#statement 
-                (S.block (Ext_list.rev_map_append rest_rev [S.return_stmt last_one] (self#statement)))
+              super.statement self
+                (S.block (Ext_list.rev_map_append rest_rev [S.return_stmt last_one] (fun x -> self.statement self x)))
           | _ -> assert false
           end
       | Block [x]
           -> 
-            self#statement x 
-      | _ -> super#statement x 
-
-    method! block b =
+            self.statement self x 
+      | _ -> super.statement self x 
+    );      
+    block = fun self b ->
       match b with
       | {statement_desc = Block bs } :: rest ->
-          self#block ( bs @  rest)
+          self.block self ( bs @  rest)
       | x::rest  
         -> 
-          let st = self#statement x in 
-          let block = self#block rest in 
+          let st = self.statement self x in 
+          let block = self.block self rest in 
           begin match st.statement_desc with 
           | Block bs ->  bs @ block
           | _ -> st :: block
           end  
       | [] -> []
-  end
+}
 
-let program ( x : J.program) = flatten_map # program x 
+let program ( x : J.program) = flatten_map.program flatten_map x 

jscomp/core/js_pass_flatten_and_mark_dead.ml

@@ -39,35 +39,35 @@ type meta_info =
   | Recursive
 
 
+let super = Js_record_iter.iter
 
 let mark_dead_code (js : J.program) : J.program = 
   let ident_use_stats : meta_info Hash_ident.t
     = Hash_ident.create 17 in 
-  let mark_dead  : Js_iter.iter = object (self)
-    inherit Js_iter.iter
-    method! ident ident = 
+  let mark_dead  = { super with 
+    ident = (fun _ ident -> 
       (match Hash_ident.find_opt ident_use_stats ident with
        | None -> (* First time *)
          Hash_ident.add ident_use_stats ident Recursive 
        (* recursive identifiers *)
        | Some Recursive
          -> ()
-       | Some (Info x) ->  Js_op_util.update_used_stats x Used )
-    method! variable_declaration vd = 
+       | Some (Info x) ->  Js_op_util.update_used_stats x Used ));
+     variable_declaration = fun self vd -> 
       match vd.ident_info.used_stats with 
       |  Dead_pure 
         -> ()
       |  Dead_non_pure  -> 
         begin match vd.value with
           | None -> ()
-          | Some x -> self#expression x 
+          | Some x -> self.expression self x 
         end
       |  _ -> 
         let ({ident; ident_info ; value ; _} : J.variable_declaration) = vd in 
         let pure = 
           match value with 
           | None  -> true
-          | Some x ->  (self#expression x); Js_analyzer.no_side_effect_expression x in
+          | Some x ->  self.expression self x; Js_analyzer.no_side_effect_expression x in
         (
          let () = 
            if Set_ident.mem js.export_set ident then 
@@ -87,8 +87,8 @@ let mark_dead_code (js : J.program) : J.program =
            Hash_ident.add ident_use_stats ident (Info ident_info);
            Js_op_util.update_used_stats ident_info 
              (if pure then Scanning_pure else Scanning_non_pure))
-  end  in 
-  let () =  (mark_dead#program js) in 
+    }  in 
+  mark_dead.program mark_dead js;
   Hash_ident.iter ident_use_stats (fun _id (info : meta_info) ->
       match info  with 
       | Info ({used_stats = Scanning_pure} as info) -> 
@@ -152,17 +152,12 @@ let mark_dead_code (js : J.program) : J.program =
     ]}
 
 *) 
-let subst_map (substitution : J.expression Hash_ident.t) = object (self)
-  inherit Js_map.map as super
 
-
-
-
-
-  method add_substitue (ident : Ident.t) (e:J.expression) = 
+let super = Js_record_map.super
+let add_substitue substitution (ident : Ident.t) (e:J.expression) = 
     Hash_ident.replace  substitution ident e
-
-  method! statement v = 
+let subst_map (substitution : J.expression Hash_ident.t) = { super
+  with statement  =  (fun self v ->
     match v.statement_desc with 
     | Variable ({ident = _; ident_info = {used_stats = Dead_pure } ; _}) -> 
       {v with statement_desc = Block []}
@@ -193,7 +188,7 @@ let subst_map (substitution : J.expression Hash_ident.t) = object (self)
                    bottomline, when the block size is one, no need to do 
                    this
                *)
-               let v' = self#expression x in 
+               let v' = self.expression self x in 
                let match_id =
                  Ext_ident.create
                    (ident.name ^ "_" ^
@@ -212,7 +207,7 @@ let subst_map (substitution : J.expression Hash_ident.t) = object (self)
          expression_desc = 
            Caml_block(List.rev e, Immutable, tag, tag_info)
         } in
-      let () = self#add_substitue ident e in
+      let () = add_substitue substitution ident e in
       (* let bindings =  !bindings in *)
       let original_statement = 
         { v with 
@@ -228,9 +223,9 @@ let subst_map (substitution : J.expression Hash_ident.t) = object (self)
             (fun (id,v) -> 
                S.define_variable ~kind:Strict id v)  )
       end
-    | _ -> super#statement v 
-
-  method! expression x =
+    | _ -> super.statement self v 
+  );
+  expression = fun self x -> 
     match x.expression_desc with 
     | Array_index ({expression_desc = Var (Id (id))}, 
               {expression_desc = Number (Int {i; _})})
@@ -246,11 +241,11 @@ let subst_map (substitution : J.expression Hash_ident.t) = object (self)
           | Some ({expression_desc = J.Var _ | Number _ | Str _ | Undefined} as x)
             -> x 
           | None | Some _ -> 
-            super#expression x )          
-       | Some _ | None -> super#expression x )
+            super.expression self x )          
+       | Some _ | None -> super.expression self x )
 
-    | _ -> super#expression x
-end 
+    | _ -> super.expression self x
+}
 
 (* Top down or bottom up ?*)
 (* A pass to support nullary argument in JS 
@@ -259,9 +254,9 @@ end
  *)
 
 let program  (js : J.program) = 
-  js 
-  |> (subst_map (Hash_ident.create 32) )#program
-  |> mark_dead_code
+  let obj = (subst_map (Hash_ident.create 32) )  in 
+  let js = obj.program obj js in 
+  mark_dead_code js
   (* |> mark_dead_code *)
   (* mark dead code twice does have effect in some cases, however, we disabled it 
     since the benefit is not obvious