Merge pull request #4397 from BuckleScript/internal_cleanup

internal clean up, separate between objects and array

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
@@ -737,6 +737,10 @@ let if_ (a : t) (b : t) (c : t) : t =
 
   | _ -> 
     match  b, c with 
+    | _, Lconst (Const_pointer (_, Pt_assertfalse))
+      -> seq a b (* TODO: we could customize more cases *)
+    | Lconst (Const_pointer (_, Pt_assertfalse)), _ 
+      -> seq a c
     | Lconst(Const_js_true), Lconst(Const_js_false)
       -> 
       if has_boolean_type a != None then a 
@@ -757,14 +761,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

@@ -147,6 +147,23 @@ type default_case =
   | Complete
   | NonComplete
 
+let default_action ~saturated failaction =
+    match failaction with
+    | None -> Complete 
+    | Some x -> 
+      if saturated then Complete
+      else Default x 
+
+let get_const_name i (sw_names : Lambda.switch_names option) =
+  match sw_names with 
+  | None -> None 
+  | Some {consts} -> Some consts.(i) 
+
+let get_block_name i (sw_names : Lambda.switch_names option) =   
+  match sw_names with 
+  | None -> None 
+  | Some {blocks} -> Some blocks.(i) 
+
 let no_effects_const  = lazy true
 (* let has_effects_const = lazy false *)
 
@@ -558,7 +575,9 @@ and compile_general_cases
           [switch ?default ?declaration switch_exp body]
         )
 
-and compile_cases cxt switch_exp table default get_name =
+and compile_cases cxt 
+  (switch_exp : E.t) 
+  table default get_name =
   compile_general_cases
     get_name
     (fun i -> {(E.small_int i) with comment = get_name i})
@@ -569,39 +588,29 @@ and compile_cases cxt switch_exp table default get_name =
     switch_exp
     table
     default
-and compile_switch switch_arg sw (lambda_cxt : Lam_compile_context.t) = 
+and compile_switch 
+  (switch_arg : Lam.t) 
+  (sw : Lam.lambda_switch) 
+  (lambda_cxt : Lam_compile_context.t) = 
   (* TODO: if default is None, we can do some optimizations
       Use switch vs if/then/else
 
       TODO: switch based optimiztion - hash, group, or using array,
             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  =
-    match sw_failaction with
-    | None -> Complete
-    | Some x ->
-      if sw_numconsts
-      then Complete
-      else Default x in
-  let sw_blocks_default =
-    match sw_failaction  with
-    | None -> Complete
-    | Some x ->
-      if sw_numblocks
-      then Complete
-      else Default x in
-  let get_name is_const i =
-    match sw_names with
-    | None -> None
-    | Some {blocks; consts} ->
-      Some (if is_const then consts.(i) else blocks.(i)) in
+  let  sw_num_default  = 
+    default_action ~saturated:sw_consts_full sw_failaction in     
+  let sw_blocks_default = 
+    default_action ~saturated:sw_blocks_full sw_failaction in 
+  let get_const_name i = get_const_name i sw_names in 
+  let get_block_name i = get_block_name i sw_names in   
   let compile_whole  (cxt  : Lam_compile_context.t ) =
     match compile_lambda 
             {cxt with  continuation = NeedValue Not_tail}
@@ -610,21 +619,21 @@ and compile_switch switch_arg sw (lambda_cxt : Lam_compile_context.t) =
     | {value =  None; _}  -> assert false
     | { block; value = Some e } ->
       block @
-      (if sw_numconsts && sw_consts = [] then
-         compile_cases cxt (E.tag e)  sw_blocks sw_blocks_default (get_name false)
-       else if sw_numblocks && sw_blocks = [] then
-         compile_cases cxt e  sw_consts sw_num_default (get_name true)
+      (if sw_consts_full && sw_consts = [] then
+         compile_cases cxt (E.tag e)  sw_blocks sw_blocks_default get_block_name
+       else if sw_blocks_full && sw_blocks = [] then
+         compile_cases cxt e  sw_consts sw_num_default get_const_name
        else
          (* [e] will be used twice  *)
          let dispatch e =
            S.if_
              (E.is_type_number e )
-             (compile_cases cxt e sw_consts sw_num_default (get_name true)
+             (compile_cases cxt e sw_consts sw_num_default get_const_name
              )
              (* default still needed, could simplified*)
              ~else_:
                (compile_cases cxt (E.tag e ) sw_blocks
-                  sw_blocks_default (get_name false)) in
+                  sw_blocks_default get_block_name) in
            match e.expression_desc with
            | J.Var _  -> [ dispatch e]
            | _ ->

jscomp/core/lam_compile_util.ml

@@ -67,5 +67,8 @@ let comment_of_pointer_info (x :  Lam_pointer_info.t)=
   match x with 
   | Pt_constructor {name;_}
   | Pt_variant {name} -> Some name
-  (* | Pt_module_alias -> module_alias *)
+  | Pt_assertfalse -> Some "assert_false"
   | Pt_na -> None
+  | Pt_module_alias 
+  | Pt_builtin_boolean
+  | Pt_shape_none -> assert false

jscomp/core/lam_constant_convert.ml

@@ -38,17 +38,18 @@ let rec convert_constant ( const : Lambda.structured_constant) : Lam_constant.t
   | Const_base (Const_int32 i) -> (Const_int32 i)
   | Const_base (Const_int64 i) -> (Const_int64 i)
   | Const_base (Const_nativeint i) -> (Const_nativeint i)
-  | Const_pointer(0, Pt_constructor{name = "()"; cstrs = 1,0})
+  | Const_pointer(0, Pt_constructor{name = "()"; const = 1; non_const = 0})
     -> Const_js_undefined
   | Const_pointer(i,p) ->
     begin match p with 
-    | Pt_constructor {name;cstrs} -> Const_pointer(i, Pt_constructor {name; cstrs})
-    | Pt_variant {name} -> Const_pointer(i,Pt_variant {name})
-    | Pt_module_alias -> Const_module_alias
-    | Pt_builtin_boolean -> if i = 0 then Const_js_false else Const_js_true
-    | Pt_shape_none ->
-       Lam_constant.lam_none
-    | Pt_na ->  Const_pointer(i, Pt_na)      
+      | Pt_module_alias -> Const_module_alias
+      | Pt_builtin_boolean -> if i = 0 then Const_js_false else Const_js_true
+      | Pt_shape_none ->
+        Lam_constant.lam_none
+    | Pt_assertfalse    
+    | Pt_constructor _
+    | Pt_variant _    
+    | Pt_na ->  Const_pointer(i, p)      
      end 
   | Const_float_array (s) -> Const_float_array(s)
   | Const_immstring s -> Const_immstring s

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)
                 ) 
@@ -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 = 
+                 sw_consts_full = 
                    Ext_list.length_ge sw_consts sw_numconsts;
                  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_numconsts ;
               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_numblocks;
               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