clean up

Author: bobzhang

jscomp/core/js_exp_make.ml

@@ -399,12 +399,10 @@ let string_length ?comment (e : t) : t =
   (* No optimization for {j||j}*)
   | _ -> { expression_desc = Length (e, String) ; comment }
 
+(* TODO: use [Buffer] instead? *)  
 let bytes_length ?comment (e : t) : t = 
   match e.expression_desc with 
-  (* TODO: use array instead? *)
   | Array (l, _) -> int ?comment (Int32.of_int (List.length l))
-  | Str(_,v) -> int ?comment (Int32.of_int @@ String.length v)
-  (* No optimization for unicode *)
   | _ -> { expression_desc = Length (e, Bytes) ; comment }
 
 let function_length ?comment (e : t) : t = 
@@ -416,7 +414,6 @@ let function_length ?comment (e : t) : t =
       (Int32.of_int 
          (if b then params_length - 1 
           else params_length))
-  (* TODO: optimize if [e] is know at compile time *)
   | _ -> { expression_desc = Length (e, Function) ; comment }
 
 (** no dependency introduced *)
@@ -467,11 +464,11 @@ let obj ?comment properties : t =
 
 
 (* var (Jident.create_js "true") *)
-let caml_true : t = {comment = None; expression_desc = Bool true }
+let true_ : t = {comment = None; expression_desc = Bool true }
 
-let caml_false : t = {comment = None; expression_desc = Bool false }
+let false_ : t = {comment = None; expression_desc = Bool false }
 
-let bool v = if  v then caml_true else caml_false
+let bool v = if  v then true_ else false_
 
 (** Arith operators *)
 (* Dot .....................**)        
@@ -499,13 +496,13 @@ let rec triple_equal ?comment (e0 : t) (e1 : t ) : t =
     | Bool _ | Number _ | Typeof _
     | Fun _ | Array _ | Caml_block _ )
     when  no_side_effect e1 -> 
-    caml_false (* TODO: rename it as [caml_false] *)
+    false_ (* TODO: rename it as [caml_false] *)
   | 
     (Char_of_int _ | Char_to_int _ 
     | Bool _ | Number _ | Typeof _
     | Fun _ | Array _ | Caml_block _ ),  (Null|Undefined)
     when no_side_effect e0 -> 
-    caml_false
+    false_
   | Str (_,x), Str (_,y) ->  (* CF*)
     bool (Ext_string.equal x y)
   | Char_to_int a , Char_to_int b -> 
@@ -523,9 +520,9 @@ let rec triple_equal ?comment (e0 : t) (e1 : t ) : t =
   | Undefined, Optional_block _  
   | Optional_block _, Undefined   
   | Null, Undefined   
-  | Undefined, Null -> caml_false
+  | Undefined, Null -> false_
   | Null, Null
-  | Undefined, Undefined -> caml_true
+  | Undefined, Undefined -> true_
   | _ -> 
      {expression_desc = Bin(EqEqEq, e0,e1); comment}
 
@@ -540,12 +537,8 @@ let bin ?comment (op : J.binop) e0 e1 : t =
    optimizations
    We wrap all boolean functions here, since OCaml boolean is a 
    bit different from Javascript, so that we can change it in the future
-*)
 
-let rec and_ ?comment (e1 : t) (e2 : t) : t = 
-  match e1.expression_desc, e2.expression_desc with 
-  (*
-     {[ a && (b && c) === (a && b ) && c ]}
+   {[ a && (b && c) === (a && b ) && c ]}
      is not used: benefit is not clear 
      | Int_of_boolean e10, Bin(And, {expression_desc = Int_of_boolean e20 }, e3) 
       -> 
@@ -555,15 +548,15 @@ let rec and_ ?comment (e1 : t) (e2 : t) : t =
                     J.Int_of_boolean { expression_desc = Bin (And, e10,e20); comment = None}
         }
         e3
-  *)
-  (* Note that 
-     {[ "" && 3 ]}
+   Note that 
+   {[ "" && 3 ]}
      return  "" instead of false, so [e1] is indeed useful
-  *)
-
-  (* optimization if [e1 = e2], then and_ e1 e2 -> e2
+   optimization if [e1 = e2], then and_ e1 e2 -> e2
      be careful for side effect        
-  *)
+*)
+
+let rec and_ ?comment (e1 : t) (e2 : t) : t = 
+  match e1.expression_desc, e2.expression_desc with 
   | Var i, Var j when Js_op_util.same_vident  i j 
     -> 
     e1
@@ -600,50 +593,48 @@ let rec or_ ?comment (e1 : t) (e2 : t) =
 (* TODO: 
      when comparison with Int
      it is right that !(x > 3 ) -> x <= 3 *)
-let rec not ({expression_desc; comment} as e : t) : t =
-  match expression_desc with 
-  | Number (Int {i; _}) -> 
-    bool (i = 0l )
+let rec not ( e : t) : t =
+  match e.expression_desc with 
+  | Number (Int {i; _}) -> bool (i = 0l )
   | Js_not e -> e 
-  (* match expression_desc with  *)
-  (* can still hapen after some optimizations *)
-  | Bin(EqEqEq , e0,e1) 
-    -> {expression_desc = Bin(NotEqEq, e0,e1); comment}
-  | Bin(NotEqEq , e0,e1) -> {expression_desc = Bin(EqEqEq, e0,e1); comment}
+  | Bool b -> if b then false_ else true_
+  | Bin(EqEqEq , e0,e1) -> {e with expression_desc = Bin(NotEqEq, e0,e1)}
+  | Bin(NotEqEq , e0,e1) -> {e with expression_desc = Bin(EqEqEq, e0,e1)}
   | Bin(Lt, a, b) -> {e with expression_desc = Bin (Ge,a,b)}
   | Bin(Ge,a,b) -> {e with expression_desc = Bin (Lt,a,b)}
   | Bin(Le,a,b) -> {e with expression_desc = Bin (Gt,a,b)}
   | Bin(Gt,a,b) -> {e with expression_desc = Bin (Le,a,b)}
-  | Bool b -> if b then caml_false else caml_true
   | x -> {expression_desc = Js_not e ; comment = None}
 
 
 
 
 
-let rec econd ?comment (b : t) (t : t) (f : t) : t = 
-  match b.expression_desc , t.expression_desc, f.expression_desc with
-  | Bool false,  _, _ -> f
+let rec econd ?comment (pred : t) (ifso : t) (ifnot : t) : t = 
+  match pred.expression_desc , ifso.expression_desc, ifnot.expression_desc with
+  | Bool false,  _, _ -> ifnot
   | Number ((Int { i = 0l; _}) ), _, _ 
-    -> f  (* TODO: constant folding: could be refined *)
-  | (Number _ | Array _ | Caml_block _ | Optional_block _), _, _ when no_side_effect b 
-    -> t  (* a block can not be false in OCAML, CF - relies on flow inference*)
-  | Bool true, _, _ -> t   
+    -> ifnot  
+  | (Number _ | Array _ | Caml_block _ | Optional_block _), _, _ 
+    when no_side_effect pred 
+    -> ifso  (* a block can not be false in OCAML, CF - relies on flow inference*)
+  | Bool true, _, _ -> ifso   
   | (Bin (Ge, 
           ({expression_desc = Length _ ;
             _}), {expression_desc = Number (Int { i = 0l ; _})})), _, _ 
-    -> f
+    -> ifnot
   | (Bin (Gt, 
           ({expression_desc = Length _;
             _} as pred ), 
           ({expression_desc = Number (Int {i = 0l; }) }  as zero) )), _, _
     ->
     (** Add comment when simplified *)
-    econd ?comment {b with expression_desc = (Bin (NotEqEq, 
-           pred , zero ))} t f 
-
-  | _, (Cond (p1, branch_code0, branch_code1)), _
-    when Js_analyzer.eq_expression branch_code1 f
+    econd ?comment 
+      {pred with 
+       expression_desc = 
+         Bin (NotEqEq, pred, zero)} ifso ifnot 
+  | _, (Cond (pred1, ifso1, ifnot1)), _
+    when Js_analyzer.eq_expression ifnot1 ifnot
     ->
     (* {[
          if b then (if p1 then branch_code0 else branch_code1)
@@ -654,15 +645,15 @@ let rec econd ?comment (b : t) (t : t) (f : t) : t =
          if b && p1 then branch_code0 else branch_code1           
        ]}         
     *)      
-    econd (and_ b p1) branch_code0 f
+    econd (and_ pred pred1) ifso1 ifnot
   | _, (Cond (p1, branch_code0, branch_code1)), _
-    when Js_analyzer.eq_expression branch_code0 f
+    when Js_analyzer.eq_expression branch_code0 ifnot
     ->
     (* the same as above except we revert the [cond] expression *)      
-    econd (and_ b (not p1)) branch_code1 f
+    econd (and_ pred (not p1)) branch_code1 ifnot
 
   | _, _, (Cond (p1', branch_code0, branch_code1))
-    when Js_analyzer.eq_expression t branch_code0 
+    when Js_analyzer.eq_expression ifso branch_code0 
     (*
        {[
          if b then branch_code0 else (if p1' then branch_code0 else branch_code1)           
@@ -673,21 +664,21 @@ let rec econd ?comment (b : t) (t : t) (f : t) : t =
        ]}         
     *)
     ->
-    econd (or_ b p1') t branch_code1
+    econd (or_ pred p1') ifso branch_code1
   | _, _, (Cond (p1', branch_code0, branch_code1))
-    when Js_analyzer.eq_expression t branch_code1
+    when Js_analyzer.eq_expression ifso branch_code1
     ->
     (* the same as above except we revert the [cond] expression *)      
-    econd (or_ b (not p1')) t branch_code0
+    econd (or_ pred (not p1')) ifso branch_code0
 
   | Js_not e, _, _ 
     ->
-    econd ?comment e f t 
+    econd ?comment e ifnot ifso 
   | _ -> 
-    if Js_analyzer.eq_expression t f then
-      if no_side_effect b then t else seq  ?comment b t
+    if Js_analyzer.eq_expression ifso ifnot then
+      if no_side_effect pred then ifso else seq  ?comment pred ifso
     else
-      {expression_desc = Cond(b,t,f); comment}
+      {expression_desc = Cond(pred,ifso,ifnot); comment}
 
 
 let rec float_equal ?comment (e0 : t) (e1 : t) : t = 
@@ -724,7 +715,7 @@ let rec float_equal ?comment (e0 : t) (e1 : t) : t =
     *)
     float_equal ?comment a e1
   | Number (Float {f = f0; _}), Number (Float {f = f1 ; }) when f0 = f1 -> 
-    caml_true
+    true_
 
   | Char_to_int a , Char_to_int b ->
     float_equal ?comment a b
@@ -883,14 +874,14 @@ let rec int_comp (cmp : Lam_compat.comparison) ?comment  (e0 : t) (e1 : t) =
             } , args, call_info)}
   | Ceq, Optional_block _,  Undefined
   | Ceq, Undefined, Optional_block _
-    -> caml_false           
+    -> false_           
   | Ceq, _, _ -> int_equal e0 e1 
 
   | Cneq, Optional_block _, Undefined
   | Cneq, Undefined , Optional_block _
   | Cneq, Caml_block _ ,  Number _ 
   | Cneq, Number _, Caml_block _  
-    -> caml_true
+    -> true_
   | _ ->          
     bin ?comment (Lam_compile_util.jsop_of_comp cmp) e0 e1
 
@@ -908,8 +899,8 @@ let bool_comp (cmp : Lam_compat.comparison) ?comment (e0 : t) (e1 : t) =
   | {expression_desc = Bool true}, rest 
   | rest, {expression_desc = Bool false}  -> 
     begin match cmp with 
-    | Clt -> seq rest caml_false
-    | Cge -> seq rest caml_true
+    | Clt -> seq rest false_
+    | Cge -> seq rest true_
     | Cle 
     | Cgt 
     | Ceq 
@@ -919,8 +910,8 @@ let bool_comp (cmp : Lam_compat.comparison) ?comment (e0 : t) (e1 : t) =
   | {expression_desc = Bool false}, rest 
     ->
     begin match cmp with  
-    | Cle -> seq rest caml_true
-    | Cgt -> seq rest caml_false
+    | Cle -> seq rest true_
+    | Cgt -> seq rest false_
     | Clt
     | Cge 
     | Ceq 
@@ -1229,8 +1220,8 @@ let for_sure_js_null_undefined (x : t) =
 let is_null_undefined ?comment (x: t) : t = 
   match x.expression_desc with 
   | Null | Undefined
-    -> caml_true
-  | Number _ | Array _ | Caml_block _ -> caml_false
+    -> true_
+  | Number _ | Array _ | Caml_block _ -> false_
   | _ ->      
       { comment ; 
         expression_desc = Is_null_or_undefined x 
@@ -1243,18 +1234,18 @@ let eq_null_undefined_boolean ?comment (a : t) (b : t) =
     | Bool _ | Number _ | Typeof _
     | Fun _ | Array _ | Caml_block _ )
      -> 
-    caml_false
+    false_
   | (Char_of_int _ | Char_to_int _ 
     | Bool _ | Number _ | Typeof _
     | Fun _ | Array _ | Caml_block _ ), 
       (Null | Undefined)
      -> 
-    caml_false
+    false_
   | (Null, Undefined)
-  | (Undefined, Null) -> caml_false
+  | (Undefined, Null) -> false_
   | (Null, Null)
   | (Undefined, Undefined)
-    -> caml_true
+    -> true_
   | _ ->       
        {expression_desc = Bin(EqEqEq, a, b); comment}
 
@@ -1267,19 +1258,19 @@ let neq_null_undefined_boolean ?comment (a : t) (b : t) =
     | Bool _ | Number _ | Typeof _
     | Fun _ | Array _ | Caml_block _ )
      -> 
-    caml_true
+    true_
   | (Char_of_int _ | Char_to_int _ 
     | Bool _ | Number _ | Typeof _
     | Fun _ | Array _ | Caml_block _ ), 
       (Null | Undefined)
      -> 
-    caml_true
+    true_
   | (Null , Null )
   | (Undefined, Undefined)
-   -> caml_false
+   -> false_
   | (Null, Undefined)
   | (Undefined, Null)
-   -> caml_true
+   -> true_
   | _ ->       
        {expression_desc = Bin(NotEqEq, a, b); comment}
 

jscomp/core/js_exp_make.mli

@@ -270,9 +270,9 @@ val obj :
   J.property_map -> 
   t 
 
-val caml_true : t 
+val true_ : t 
 
-val caml_false : t
+val false_ : t
 
 val bool : bool -> t
 

jscomp/core/js_of_lam_option.ml

@@ -49,9 +49,9 @@ let is_none_static (arg : J.expression_desc ) = arg = Undefined
 
 let is_not_none  (e : J.expression) : J.expression = 
   let desc = e.expression_desc in 
-  if is_none_static desc then E.caml_false 
+  if is_none_static desc then E.false_
   else match desc with 
-  | Optional_block _ -> E.caml_true
+  | Optional_block _ -> E.true_
   | _ -> 
     E.not (E.triple_equal e none)
 

jscomp/core/js_op.ml

@@ -44,7 +44,7 @@ type binop =
   | And
   | EqEqEq
   | NotEqEq
-  | InstanceOf
+  (* | InstanceOf *)
 
   | Lt
   | Le

jscomp/core/js_op_util.ml

@@ -40,7 +40,7 @@ let op_prec (op : Js_op.binop ) =
   | Or -> 3, 3, 3
   | And -> 4, 4, 4
   | EqEqEq | NotEqEq -> 8, 8, 9
-  | Gt | Ge | Lt | Le | InstanceOf -> 9, 9, 10
+  | Gt | Ge | Lt | Le (* | InstanceOf *) -> 9, 9, 10
   | Bor -> 5, 5, 5
   | Bxor -> 6, 6, 6
   | Band -> 7, 7, 7
@@ -81,7 +81,7 @@ let op_str (op : Js_op.binop) =
   | Le      -> "<="
   | Gt      -> ">"
   | Ge      -> ">="
-  | InstanceOf -> "instanceof"
+  (* | InstanceOf -> "instanceof" *)
 
 let op_int_str (op : Js_op.int_op) = 
   match op with