meaningful names

Author: bobzhang

jscomp/core/lam.ml

@@ -33,16 +33,16 @@ type apply_status =
 module Types = struct
 
   type lambda_switch =
-    { sw_numconsts: bool; (* TODO: refine its representation *)
+    { sw_consts_full : bool; (* TODO: refine its representation *)
       sw_consts: (int * t) list;
-      sw_numblocks: bool;
+      sw_blocks_full : bool;
       sw_blocks: (int * t) list;
       sw_failaction : t option;
       sw_names : Lambda.switch_names option }
   (* 
     Invariant: 
-    length (sw_consts) <= sw_numconsts 
-    when length (sw_consts) >= sw_numconsts -> true 
+    length (sw_consts) <= sw_consts_full 
+    when length (sw_consts) >= sw_consts_full -> true 
     Note that failaction would appear in both
      {[
        match x with
@@ -55,16 +55,16 @@ module Types = struct
 
      In most cases: {[
        let sw =
-         {sw_numconsts = cstr.cstr_consts; sw_consts = consts;
-          sw_numblocks = cstr.cstr_nonconsts; sw_blocks = nonconsts;
+         {sw_consts_full = cstr.cstr_consts; sw_consts = consts;
+          sw_blocks_full = cstr.cstr_nonconsts; sw_blocks = nonconsts;
           sw_failaction = None} in
      ]}
 
      but there are some edge cases (see https://caml.inria.fr/mantis/view.php?id=6033)
      one predicate used is
      {[
-       (sw.sw_numconsts - List.length sw.sw_consts) +
-       (sw.sw_numblocks - List.length sw.sw_blocks) > 1
+       (sw.sw_consts_full - List.length sw.sw_consts) +
+       (sw.sw_blocks_full - List.length sw.sw_blocks) > 1
      ]}
      if [= 1] with [some fail] -- called once
      if [= 0] could not have [some fail]
@@ -111,9 +111,9 @@ module X = struct
   type lambda_switch
     = Types.lambda_switch
     =
-      { sw_numconsts: bool;
+      { sw_consts_full: bool;
         sw_consts: (int * t) list;
-        sw_numblocks: bool;
+        sw_blocks_full: bool;
         sw_blocks: (int * t) list;
         sw_failaction: t option;
         sw_names: Lambda.switch_names option }
@@ -190,12 +190,12 @@ let inner_map
     let args = Ext_list.map args f in
     Lprim { args; primitive; loc}
 
-  | Lswitch(arg, {sw_consts; sw_numconsts; sw_blocks; sw_numblocks; sw_failaction; sw_names}) ->
+  | Lswitch(arg, {sw_consts; sw_consts_full; sw_blocks; sw_blocks_full; sw_failaction; sw_names}) ->
     let arg = f arg in
     let sw_consts = Ext_list.map_snd  sw_consts f in
     let sw_blocks = Ext_list.map_snd  sw_blocks f in
     let sw_failaction = Ext_option.map sw_failaction f in
-    Lswitch(arg, { sw_consts; sw_blocks; sw_failaction; sw_numblocks; sw_numconsts; sw_names})
+    Lswitch(arg, { sw_consts; sw_blocks; sw_failaction; sw_blocks_full; sw_consts_full; sw_names})
   | Lstringswitch (arg,cases,default) ->
     let arg = f arg  in
     let cases = Ext_list.map_snd  cases f in
@@ -757,14 +757,14 @@ let if_ (a : t) (b : t) (c : t) : t =
          -> 
          begin match c with 
            | Lswitch ( Lvar yy as switch_arg, 
-                       ({sw_blocks = []; sw_numblocks = true; sw_consts ;
-                         sw_numconsts = _; sw_failaction = None} as body)
+                       ({sw_blocks = []; sw_blocks_full = true; sw_consts ;
+                         sw_consts_full = _; sw_failaction = None} as body)
                      )
              when Ident.same xx yy 
                && complete_range sw_consts ~start:0 ~finish:range
              ->  
              Lswitch(switch_arg, 
-                     { body with sw_failaction = Some b; sw_numconsts = false; })
+                     { body with sw_failaction = Some b; sw_consts_full = false; })
            |  _ -> Lifthenelse(a,b,c)      
          end
        | _ ->  Lifthenelse (a,b,c))

jscomp/core/lam.mli

@@ -29,9 +29,9 @@
 type ident = Ident.t
 
 type lambda_switch  =
-  { sw_numconsts: bool;
+  { sw_consts_full: bool;
     sw_consts: (int * t) list;
-    sw_numblocks: bool;
+    sw_blocks_full: bool;
     sw_blocks: (int * t) list;
     sw_failaction: t option;
     sw_names: Lambda.switch_names option }

jscomp/core/lam_arity_analysis.ml

@@ -111,8 +111,8 @@ let rec get_arity (meta : Lam_stats.t) (lam : Lam.t) :  Lam_arity.t =
   | Lswitch(_, {sw_failaction; 
                 sw_consts; 
                 sw_blocks;
-                sw_numblocks = _;
-                sw_numconsts = _;
+                sw_blocks_full = _;
+                sw_consts_full = _;
                }) -> 
     all_lambdas meta (
       let rest = 

jscomp/core/lam_bounded_vars.ml

@@ -118,17 +118,17 @@ let rewrite (map :   _ Hash_ident.t)
     | Lswitch(l, {sw_failaction; 
                   sw_consts; 
                   sw_blocks;
-                  sw_numblocks;
-                  sw_numconsts;
+                  sw_blocks_full;
+                  sw_consts_full;
                   sw_names;
                  }) ->
       let l = aux l in
       Lam.switch l
               {sw_consts = 
                  Ext_list.map_snd  sw_consts aux;
                sw_blocks = Ext_list.map_snd  sw_blocks aux;
-               sw_numconsts = sw_numconsts;
-               sw_numblocks = sw_numblocks;
+               sw_consts_full = sw_consts_full;
+               sw_blocks_full = sw_blocks_full;
                sw_failaction = option_map sw_failaction;
                sw_names;
               }

jscomp/core/lam_check.ml

@@ -132,7 +132,7 @@ let check file lam =
         iter_list_snd sw.sw_consts;
         iter_list_snd sw.sw_blocks;
         Ext_option.iter sw.sw_failaction iter;         
-        assert (not (sw.sw_failaction <> None && sw.sw_numconsts && sw.sw_numblocks))
+        assert (not (sw.sw_failaction <> None && sw.sw_consts_full && sw.sw_blocks_full))
       | Lstringswitch (arg,cases,default) ->
         iter arg ;
         iter_list_snd cases ;

jscomp/core/lam_closure.ml

@@ -102,8 +102,8 @@ let free_variables
               ({sw_consts; 
                 sw_blocks; 
                 sw_failaction;
-                sw_numconsts;
-                sw_numblocks
+                sw_consts_full;
+                sw_blocks_full
                })) ->
       iter top arg; 
       let top = Lam_var_stats.new_position_after_lam arg top  in       
@@ -112,7 +112,7 @@ let free_variables
       (match sw_failaction with 
        | None -> ()
        | Some x ->
-         if  sw_numconsts || sw_numblocks
+         if  sw_consts_full || sw_blocks_full
          then iter top x 
          else iter sink_pos x)      
     | Lstringswitch (arg,cases,default) ->

jscomp/core/lam_compile.ml

@@ -589,16 +589,16 @@ and compile_switch
             also if last statement is throw -- should we drop remaining
             statement?
   *)
-  let ({sw_numconsts;
+  let ({sw_consts_full;
         sw_consts;
-        sw_numblocks;
+        sw_blocks_full;
         sw_blocks;
         sw_failaction;
         sw_names } : Lam.lambda_switch) = sw in 
   let  sw_num_default  = 
-    default_action ~saturated:sw_numconsts sw_failaction in     
+    default_action ~saturated:sw_consts_full sw_failaction in     
   let sw_blocks_default = 
-    default_action ~saturated:sw_numblocks sw_failaction in 
+    default_action ~saturated:sw_blocks_full sw_failaction in 
 
   let get_name is_const i =
     match sw_names with
@@ -613,9 +613,9 @@ and compile_switch
     | {value =  None; _}  -> assert false
     | { block; value = Some e } ->
       block @
-      (if sw_numconsts && sw_consts = [] then
+      (if sw_consts_full && sw_consts = [] then
          compile_cases cxt (E.tag e)  sw_blocks sw_blocks_default (get_name false)
-       else if sw_numblocks && sw_blocks = [] then
+       else if sw_blocks_full && sw_blocks = [] then
          compile_cases cxt e  sw_consts sw_num_default (get_name true)
        else
          (* [e] will be used twice  *)

jscomp/core/lam_convert.ml

@@ -755,9 +755,9 @@ let convert (exports : Set_ident.t) (lam : Lambda.lambda) : Lam.t * Lam_module_i
       | Alias, Lprim {primitive = Poffsetint offset; args =  [Lvar _ as matcher ]},
         Lswitch (Lvar switcher3 ,
                  ({
-                   sw_numconsts = false ; 
+                   sw_consts_full = false ; 
                    sw_consts ;
-                   sw_blocks = []; sw_numblocks = true;
+                   sw_blocks = []; sw_blocks_full = true;
                    sw_failaction = Some ifso
                  } as px)
                 ) 
@@ -795,9 +795,9 @@ let convert (exports : Set_ident.t) (lam : Lambda.lambda) : Lam.t * Lam_module_i
         | {
           sw_failaction = None ;
           sw_blocks = [];
-          sw_numblocks = 0;
+          sw_blocks_full = 0;
           sw_consts ;
-          sw_numconsts ;
+          sw_consts_full ;
         } ->
           begin match happens_to_be_diff sw_consts with
             | Some 0 -> e
@@ -810,19 +810,19 @@ let convert (exports : Set_ident.t) (lam : Lambda.lambda) : Lam.t * Lam_module_i
               Lam.switch e
                 {sw_failaction = None;
                  sw_blocks = [];
-                 sw_numblocks = true;
+                 sw_blocks_full = true;
                  sw_consts =
                    Ext_list.map_snd  sw_consts convert_aux;
-                 sw_numconsts = 
-                   Ext_list.length_ge sw_consts sw_numconsts;
+                 sw_consts_full = 
+                   Ext_list.length_ge sw_consts sw_consts_full;
                  sw_names = s.sw_names;
                 }
           end
         | _ -> 
           Lam.switch  e   
-            { sw_numconsts =  Ext_list.length_ge s.sw_consts s.sw_numconsts ;
+            { sw_consts_full =  Ext_list.length_ge s.sw_consts s.sw_consts_full ;
               sw_consts = Ext_list.map_snd  s.sw_consts convert_aux;
-              sw_numblocks = Ext_list.length_ge s.sw_blocks s.sw_numblocks;
+              sw_blocks_full = Ext_list.length_ge s.sw_blocks s.sw_blocks_full;
               sw_blocks = Ext_list.map_snd s.sw_blocks convert_aux;
               sw_failaction =Ext_option.map s.sw_failaction convert_aux;
               sw_names = s.sw_names } in

jscomp/core/lam_exit_count.ml

@@ -50,7 +50,7 @@ let incr_exit (exits : collection) i =
   For Lstringswitch ^
   
   For Lswitch, if it is not exhuastive pattern match, default will be counted twice.
-  Since for pattern match,  we will  test whether it is  an integer or block, both have default cases predicate: [sw_numconsts] vs nconsts
+  Since for pattern match,  we will  test whether it is  an integer or block, both have default cases predicate: [sw_consts_full] vs nconsts
 *)
 let count_helper  (lam : Lam.t) : collection = 
   let exits : collection = Hash_int.create 17 in
@@ -90,7 +90,7 @@ let count_helper  (lam : Lam.t) : collection =
     match sw.sw_failaction with
     | None -> ()
     | Some al ->
-      if not sw.sw_numconsts && not sw.sw_numblocks
+      if not sw.sw_consts_full && not sw.sw_blocks_full
       then 
           (count al ; count al)    
       else 

jscomp/core/lam_iter.ml

@@ -41,7 +41,7 @@ let inner_iter (l : t) (f : t -> unit ) : unit =
   | Lletrec(decl, body) ->
     f body;
     Ext_list.iter_snd  decl f 
-  | Lswitch(arg, {sw_consts; sw_numconsts = _ ; sw_blocks; sw_numblocks = _; sw_failaction}) ->
+  | Lswitch(arg, {sw_consts; sw_consts_full = _ ; sw_blocks; sw_blocks_full = _; sw_failaction}) ->
     f arg;
     Ext_list.iter_snd sw_consts f;
     Ext_list.iter_snd sw_blocks f;
@@ -93,7 +93,7 @@ let inner_exists (l : t) (f : t -> bool) : bool =
   | Lletrec(decl, body) ->
     f body ||
     Ext_list.exists_snd  decl f 
-  | Lswitch(arg, {sw_consts; sw_numconsts = _; sw_blocks; sw_numblocks = _; sw_failaction}) ->
+  | Lswitch(arg, {sw_consts; sw_consts_full = _; sw_blocks; sw_blocks_full = _; sw_failaction}) ->
     f arg ||
     Ext_list.exists_snd sw_consts f ||
     Ext_list.exists_snd sw_blocks f ||