finish the removal of all object usage

Author: bobzhang

jscomp/core/j.ml

@@ -355,7 +355,7 @@ and deps_program =
     int_clause; 
     string_clause ;
     for_direction;
-    exception_ident;
+    (* exception_ident; *)
     for_direction;
     expression_desc;
     statement_desc;
@@ -364,7 +364,12 @@ and deps_program =
     finish_ident_expression;
     property_map;
     length_object;
-    for_ident;
+    (* for_ident; *)
     required_modules;
     case_clause
-    |] }]
+    |] }]
+(*
+FIXME: customize for each code generator 
+for each code generator, we can provide a white-list
+so that we can achieve the optimal
+*)    

jscomp/core/js_pass_scope.ml

@@ -99,118 +99,100 @@
     done 
     ]}
 *)
-
-let scope_pass  = 
-  object(self)
-    inherit Js_fold.fold as super
-
-    val  defined_idents = Set_ident.empty 
-        
-    (** [used_idents] 
-        does not contain locally defined idents *)
-    val  used_idents = Set_ident.empty 
-    (** we need collect mutable values and loop defined varaibles *)    
-    val loop_mutable_values = Set_ident.empty 
-
-    val mutable_values = Set_ident.empty      
-
-    val closured_idents = Set_ident.empty 
-
-    (** check if in loop or not *)    
-    val in_loop = false 
-
-    (* method get_in_loop = in_loop *)
-
-    method get_defined_idents = defined_idents
-
-    method get_used_idents = used_idents
-
-    method get_loop_mutable_values = loop_mutable_values 
-
-    (* method get_mutable_values = mutable_values  *)
-
-    method get_closured_idents = closured_idents 
-
-    method with_in_loop b = 
-      if b = in_loop then self
-      else {< in_loop = b >}
-     (* Since it's loop mutable variable, for sure
-         it is mutable variable
-         *)       
-    method with_loop_mutable_values b = 
-      {< loop_mutable_values =  b >}
-
-    method add_loop_mutable_variable id = 
-      {< loop_mutable_values = Set_ident.add loop_mutable_values id;
-         mutable_values = Set_ident.add mutable_values id 
-         >}
-
-    method add_mutable_variable id = 
-      {< mutable_values = Set_ident.add mutable_values id >}
-
-    method add_defined_ident ident = 
-      {< defined_idents = Set_ident.add defined_idents ident >} 
-    method add_used_ident ident = 
-      {< used_idents = Set_ident.add used_idents ident >}
-    method! expression x = 
-      match x.expression_desc with 
-      | Fun (_method_, params, block , env) -> 
-        (* Function is the only place to introduce a new scope in 
-            ES5
-            TODO: check 
-            {[ try .. catch(exn) {.. }]}
-            what's the scope of exn
-        *)
-        (* Note that [used_idents] is not complete
-            it ignores some locally defined idents *)
-        let param_set = Set_ident.of_list params in
-        let obj =  {<defined_idents = Set_ident.empty;
-                     (** pass [empty]
-                         so that we can check which parameter was actually used *)
-                     used_idents = Set_ident.empty ;
-                     in_loop = false;
-                     loop_mutable_values = Set_ident.empty;
-                     mutable_values = Set_ident.of_list (Js_fun_env.get_mutable_params params env) ; 
-                     closured_idents = Set_ident.empty; (* think about nested function*)
-                   >} # block block in
-        let defined_idents', used_idents' = 
-          obj#get_defined_idents, obj#get_used_idents  in
-        (* mark which param is used *)
-        params |> List.iteri 
-          (fun i v -> 
-             if not (Set_ident.mem used_idents' v) then 
-               Js_fun_env.mark_unused env i) ;
-        let closured_idents' =  (* pass param_set down *)
-          Set_ident.(diff used_idents' (union defined_idents' param_set )) in
-
-        (* Noe that we don't know which variables are exactly mutable yet ..
-           due to the recursive thing
-         *)
-        Js_fun_env.set_unbounded env closured_idents'   ; 
-        let lexical_scopes = Set_ident.(inter closured_idents' self#get_loop_mutable_values) in
-        Js_fun_env.set_lexical_scope env lexical_scopes;
-        (* tailcall , note that these varibles are used in another pass *)
-        {< used_idents = 
-             Set_ident.union used_idents closured_idents' ;
-           (* There is a bug in ocaml -dsource*)           
-           closured_idents = Set_ident.union closured_idents closured_idents'
-        >}
-      | _ -> 
-        let obj = super#expression x in 
-        match Js_block_runtime.check_additional_id x with
-        | None -> obj
-        | Some id -> 
-          obj#add_used_ident id                
-        (* TODO: most variables are immutable *)
-
-    method! variable_declaration x = 
+type state = {
+  defined_idents : Set_ident.t;
+  used_idents : Set_ident.t;
+  loop_mutable_values : Set_ident.t;
+  mutable_values : Set_ident.t;
+  closured_idents : Set_ident.t;
+  in_loop : bool;
+}
+
+let init_state = {
+  defined_idents = Set_ident.empty;
+  used_idents = Set_ident.empty;
+  loop_mutable_values = Set_ident.empty;
+  mutable_values = Set_ident.empty;
+  closured_idents = Set_ident.empty;
+  in_loop = false;
+}
+let with_in_loop (st:state) b = 
+    if b = st.in_loop then st 
+    else {st with in_loop = b} 
+let add_loop_mutable_variable (st : state) id = 
+  { st with 
+    loop_mutable_values = Set_ident.add st.loop_mutable_values id;
+    mutable_values = Set_ident.add st.mutable_values id 
+  }
+let add_mutable_variable (st: state) id = 
+  { 
+    st with 
+    mutable_values = Set_ident.add st.mutable_values id
+  }
+let add_defined_ident (st : state) id = {
+  st with 
+  defined_idents = Set_ident.add st.defined_idents id
+}
+let add_used_ident (st : state) id = {
+  st with used_idents = Set_ident.add st.used_idents id
+}
+
+
+let super = Js_record_fold.super  
+let record_scope_pass = {
+  super with 
+  expression = begin fun self state x -> 
+  match x.expression_desc with 
+  | Fun (_method_, params, block , env) -> 
+    (* Function is the only place to introduce a new scope in 
+        ES5
+        TODO: check 
+        {[ try .. catch(exn) {.. }]}
+        what's the scope of exn
+    *)
+    (* Note that [used_idents] is not complete
+        it ignores some locally defined idents *)
+    let param_set = Set_ident.of_list params in
+    let {defined_idents = defined_idents' ; used_idents = used_idents' } =  self.block self {
+          init_state with   
+                 mutable_values = Set_ident.of_list (Js_fun_env.get_mutable_params params env) ;                  
+               } block in
+    (* let defined_idents', used_idents' = 
+      obj#get_defined_idents, obj#get_used_idents  in *)
+    (* mark which param is used *)
+    params |> List.iteri 
+      (fun i v -> 
+         if not (Set_ident.mem used_idents' v) then 
+           Js_fun_env.mark_unused env i) ;
+    let closured_idents' =  (* pass param_set down *)
+      Set_ident.(diff used_idents' (union defined_idents' param_set )) in
+
+    (* Noe that we don't know which variables are exactly mutable yet ..
+       due to the recursive thing
+     *)
+    Js_fun_env.set_unbounded env closured_idents'   ; 
+    let lexical_scopes = Set_ident.(inter closured_idents' state.loop_mutable_values) in
+    Js_fun_env.set_lexical_scope env lexical_scopes;
+    (* tailcall , note that these varibles are used in another pass *)
+    {state with  used_idents = 
+         Set_ident.union state.used_idents closured_idents' ;
+       (* There is a bug in ocaml -dsource*)           
+       closured_idents = Set_ident.union state.closured_idents closured_idents'
+    }
+  | _ -> 
+    let obj = super.expression self state x in 
+    match Js_block_runtime.check_additional_id x with
+    | None -> obj
+    | Some id -> add_used_ident obj id       
+  end;
+  variable_declaration = begin fun self state x ->  
       match x with
       | { ident ; value; property  }  -> 
         let obj = 
-          (match in_loop, property with 
+          add_defined_ident  (match state.in_loop, property with 
            | true, Variable 
              -> 
-             self#add_loop_mutable_variable ident 
+             add_loop_mutable_variable state ident 
            | true, (Strict | StrictOpt | Alias)
            (* Not real true immutable in javascript 
                since it's in the loop 
@@ -219,7 +201,7 @@ let scope_pass  =
            *)
              -> 
              begin match value with 
-               | None -> self#add_loop_mutable_variable ident
+               | None -> add_loop_mutable_variable state ident
                (* TODO: Check why assertion failure *)
                (* self#add_loop_mutable_variable ident *) (* assert false *)
                | Some x
@@ -234,7 +216,7 @@ let scope_pass  =
                  *)
                  match x.expression_desc with
                  | Fun _  | Number _ | Str _ 
-                   -> self 
+                   -> state
                  | _ -> 
                    (* if Set_ident.(is_empty @@ *)
                    (*   inter self#get_mutable_values  *)
@@ -245,80 +227,87 @@ let scope_pass  =
                    (*   (\* FIXME: still need to check expression is pure or not*\) *)
                    (*   self *)
                    (* else  *)
-                   self#add_loop_mutable_variable ident
+                   add_loop_mutable_variable state ident
              end
            | false, Variable
              -> 
-             self#add_mutable_variable ident      
+             add_mutable_variable state ident      
            | false, (Strict | StrictOpt | Alias)
-             -> self
-          )#add_defined_ident ident
+             -> state
+          ) ident
         in
         begin match value with 
           | None -> obj 
-          | Some x -> obj # expression x  
+          | Some x -> self.expression self obj  x  
         end 
-
-        
-    method! statement x = 
+      end;
+      statement = begin fun self state x -> 
       match x.statement_desc with 
-      | ForRange  (_,_, loop_id, _,_,a_env) as y -> (* TODO: simplify definition of For *)
-          let obj = 
-            {< in_loop = true ;
-               loop_mutable_values = Set_ident.singleton loop_id ;
-               used_idents = Set_ident.empty; (* TODO: if unused, can we generate better code? *)
-               defined_idents = Set_ident.singleton loop_id ;
-               closured_idents = Set_ident.empty (* Think about nested for blocks *)
-                 (* Invariant: Finish id is never used *)
-                 >}
-              # statement_desc y in
+      | ForRange  (_,_, loop_id, _,_,a_env)  -> (* TODO: simplify definition of For *)
+          let {defined_idents = defined_idents'; used_idents = used_idents'; closured_idents = closured_idents'} = 
 
-          let defined_idents', used_idents', closured_idents' = 
-            obj#get_defined_idents, obj#get_used_idents, obj#get_closured_idents in
+              super.statement self             { in_loop = true ;
+              loop_mutable_values = Set_ident.singleton loop_id ;
+              used_idents = Set_ident.empty; (* TODO: if unused, can we generate better code? *)
+              defined_idents = Set_ident.singleton loop_id ;
+              closured_idents = Set_ident.empty ;(* Think about nested for blocks *)
+                (* Invariant: Finish id is never used *)
+                mutable_values = state.mutable_values
+                } x in (* CHECK*)
 
+          (* let defined_idents', used_idents', closured_idents' = 
+            obj#get_defined_idents, obj#get_used_idents, obj#get_closured_idents in *)
 
-          let lexical_scope =  Set_ident.(inter (diff closured_idents' defined_idents') self#get_loop_mutable_values) in
+
+          let lexical_scope =  Set_ident.(inter (diff closured_idents' defined_idents') state.loop_mutable_values) in
           let () = Js_closure.set_lexical_scope a_env lexical_scope in
           (* set scope *)
-          {< used_idents = Set_ident.union used_idents used_idents';
+          { state with 
+          used_idents = Set_ident.union state.used_idents used_idents';
              (* walk around ocaml -dsource bug 
                 {[ 
                   Set_ident.(union used_idents used_idents)                  
                 ]}                
              *)             
-             defined_idents = Set_ident.union defined_idents defined_idents';
+             defined_idents = Set_ident.union state.defined_idents defined_idents';
              (* TODO: if we our generated code also follow lexical scope,
                 this is not necessary ;
                 [varaibles] are mutable or not is known at definition
               *)
-             closured_idents = Set_ident.union closured_idents lexical_scope
-             >}
+             closured_idents = Set_ident.union state.closured_idents lexical_scope
+             }
 
       | While (_label,pred,body, _env) ->  
-          (((self#expression pred)#with_in_loop true) # block  body )
-            #with_in_loop (in_loop)
+      with_in_loop (self.block self (with_in_loop (self.expression self state pred) true) body )
+             (state.in_loop)
       | _ -> 
-          super#statement x 
-
-    method! exception_ident x = 
-      (* we can not simply skip it, since it can be used 
-          TODO: check loop exception
-          (loop {
-          excption(i){
-          () => {i}
-          } 
-          })
-       *)
-      {< used_idents = Set_ident.add used_idents x ;
-         defined_idents = Set_ident.add defined_idents x
-         >}
-    method! for_ident x = {< loop_mutable_values = Set_ident.add loop_mutable_values x >}
+          super.statement self state x 
+          end;
+
+     
+      exception_ident = begin fun _ state x ->
+    (* we can not simply skip it, since it can be used 
+        TODO: check loop exception
+        (loop {
+        excption(i){
+        () => {i}
+        } 
+        })
+     *)
+    {state with  used_idents = Set_ident.add state.used_idents x ;
+       defined_idents = Set_ident.add state.defined_idents x
+       }
+      end;
+      for_ident = begin fun _ state x -> {state with  loop_mutable_values = Set_ident.add state.loop_mutable_values x } end;
+
+     ident = begin fun _ state x ->
+    if Set_ident.mem state.defined_idents x then 
+      state
+    else {state with used_idents = Set_ident.add state.used_idents x }     
+      end
+}
 
-    method! ident x = 
-      if Set_ident.mem defined_idents x then 
-        self
-      else {< used_idents = Set_ident.add used_idents x >}
-  end
 
 let program js = 
-  (scope_pass # program js ) # get_loop_mutable_values
+  (record_scope_pass.program record_scope_pass init_state js).loop_mutable_values  
+  (* (scope_pass # program js ) # get_loop_mutable_values *)