Merge pull request #2572 from BuckleScript/remove_is_nil_undefined_special_handling

bobzhang · web-flow · commit a57c01a00bca · 2018-03-06T00:08:22.000-06:00
remove #is_nil, #is_undef
diff --git a/jscomp/core/js_exp_make.ml b/jscomp/core/js_exp_make.ml
@@ -827,6 +827,9 @@ let rec float_equal ?comment (e0 : t) (e1 : t) : t =
 
 
 let int_equal = float_equal 
+
+
+
 let rec string_equal ?comment (e0 : t) (e1 : t) : t = 
   match e0.expression_desc, e1.expression_desc with     
   | Str (_, a0), Str(_, b0) 
@@ -1280,12 +1283,11 @@ let of_block ?comment ?e block : t =
             , Js_fun_env.empty 0)
     } []
 
-let is_nil ?comment x = triple_equal ?comment x nil 
+let is_null ?comment x = triple_equal ?comment x nil 
 
-let js_bool ?comment x : t = 
-  { comment; 
-    expression_desc = Bool x
-  }
+let js_true : t = {comment = None; expression_desc = Bool true} 
+let js_false : t = {comment = None; expression_desc = Bool false} 
+let js_bool  x : t = if x then js_true else js_false
 
 let is_undef ?comment x = triple_equal ?comment x undefined
 
@@ -1307,6 +1309,55 @@ let is_null_undefined ?comment (x: t) : t =
       { comment ; 
         expression_desc = Is_null_undefined_to_boolean x 
       }
+
+let eq_null_undefined_boolean ?comment (a : t) (b : t) = 
+  match a.expression_desc, b.expression_desc with 
+  | Var (Id ({name = "null" | "undefined"} as id) ),   
+    (Char_of_int _ | Char_to_int _ 
+    | Bool _ | Number _ | Typeof _ | Int_of_boolean _ 
+    | Fun _ | Array _ | Caml_block _ )
+    when Ext_ident.is_js id -> 
+    caml_false
+  | (Char_of_int _ | Char_to_int _ 
+    | Bool _ | Number _ | Typeof _ | Int_of_boolean _ 
+    | Fun _ | Array _ | Caml_block _ ), 
+      Var (Id ({name = "null" | "undefined"} as id) )
+    when Ext_ident.is_js id -> 
+    caml_false
+  | Var (Id ({name = "null" | "undefined" as n1 } as id1) ), 
+    Var (Id ({name = "null" | "undefined" as n2 } as id2) )
+    when Ext_ident.is_js id1 && Ext_ident.is_js id2 
+   ->   
+    if  n1 = n2 then caml_true else caml_false
+  | _ ->       
+     bool_of_boolean {expression_desc = Bin(EqEqEq, a, b); comment}
+    
+
+
+let neq_null_undefined_boolean ?comment (a : t) (b : t) = 
+  match a.expression_desc, b.expression_desc with 
+  | Var (Id ({name = "null" | "undefined"} as id) ),   
+    (Char_of_int _ | Char_to_int _ 
+    | Bool _ | Number _ | Typeof _ | Int_of_boolean _ 
+    | Fun _ | Array _ | Caml_block _ )
+    when Ext_ident.is_js id -> 
+    caml_true
+  | (Char_of_int _ | Char_to_int _ 
+    | Bool _ | Number _ | Typeof _ | Int_of_boolean _ 
+    | Fun _ | Array _ | Caml_block _ ), 
+      Var (Id ({name = "null" | "undefined"} as id) )
+    when Ext_ident.is_js id -> 
+    caml_true
+  | Var (Id ({name = "null" | "undefined" as n1 } as id1) ), 
+    Var (Id ({name = "null" | "undefined" as n2 } as id2) )
+    when Ext_ident.is_js id1 && Ext_ident.is_js id2 
+    ->   
+    if  n1 <> n2 then caml_true else caml_false
+  | _ ->       
+     bool_of_boolean {expression_desc = Bin(NotEqEq, a, b); comment}
+
+
+
 let not_implemented ?comment (s : string) : t =  
   runtime_call
     Js_runtime_modules.missing_polyfill
diff --git a/jscomp/core/js_exp_make.mli b/jscomp/core/js_exp_make.mli
@@ -208,6 +208,8 @@ val triple_equal : binary_op
 val float_equal : binary_op
 val int_equal : binary_op
 val string_equal : binary_op    
+val eq_null_undefined_boolean: binary_op
+val neq_null_undefined_boolean: binary_op
 val is_type_number : unary_op
 val typeof : unary_op
 
@@ -253,7 +255,7 @@ val flat_call : binary_op
 
 val dump : ?comment:string -> Js_op.level -> t list -> t
 
-(* val anything_to_string : unary_op *)
+
 
 (** see {!https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Arithmetic_Operators#Unary_plus}*)
 (* val to_number : unary_op *)
@@ -309,9 +311,6 @@ val undefined : t
 val is_caml_block : ?comment:string -> t -> t
 
 
-
-
-
 val tag : ?comment:string -> J.expression -> t
 val set_tag : ?comment:string -> J.expression -> J.expression -> t
 
@@ -328,7 +327,6 @@ val and_ : binary_op
 val or_ : binary_op
 
 (** we don't expose a general interface, since a general interface is generally not safe *)
-(* val is_instance_array  : unary_op *)
 
 (** used combined with [caml_update_dummy]*)
 val dummy_obj : ?comment:string ->  unit -> t 
@@ -339,9 +337,9 @@ val of_block : ?comment:string -> ?e:J.expression -> J.statement list -> t
 val raw_js_code : ?comment:string -> J.code_info ->  string -> t
 
 val nil : t 
-val is_nil : unary_op
+val is_null : unary_op
 
-val js_bool :  ?comment:string -> bool -> t 
+val js_bool :  bool -> t 
 val is_undef : unary_op
 val for_sure_js_null_undefined_boolean : J.expression -> bool
 val is_null_undefined : unary_op
diff --git a/jscomp/core/lam.ml b/jscomp/core/lam.ml
@@ -1862,12 +1862,10 @@ let convert exports lam : _ * _  =
         | "#undefined_to_opt" -> Pundefined_to_opt
         | "#null_undefined_to_opt" -> Pnull_undefined_to_opt
         | "#null_to_opt" -> Pnull_to_opt
-        | "#is_nil"  -> Pis_null
-        | "#is_undef" -> Pis_undefined
         | "#is_nil_undef" -> Pis_null_undefined
         | "#string_append" -> Pstringadd
 
-        (* | "#is_instance_array" -> Pjs_is_instance_array *)
+
         | "#string_of_small_int_array" -> Pjs_string_of_small_array
         (* {[String.fromCharCode.apply(null,x)]} 
            Note if we have better suport [@bs.splice],
diff --git a/jscomp/core/lam_compile_primitive.ml b/jscomp/core/lam_compile_primitive.ml
@@ -76,7 +76,7 @@ let translate  loc
       | [e] -> 
         begin match e.expression_desc with 
           | Var _ -> 
-            E.econd (E.is_nil e) Js_of_lam_option.none (Js_of_lam_option.some e)
+            E.econd (E.is_null e) Js_of_lam_option.none (Js_of_lam_option.some e)
           | _ ->
             E.runtime_call Js_runtime_modules.js_primitive
               "null_to_opt" args 
@@ -151,7 +151,7 @@ let translate  loc
 
   | Pis_null -> 
     begin match args with 
-      | [e] -> E.is_nil e 
+      | [e] -> E.is_null e 
       | _ -> assert false 
     end   
   | Pis_undefined -> 
diff --git a/jscomp/core/lam_dispatch_primitive.ml b/jscomp/core/lam_dispatch_primitive.ml
@@ -672,21 +672,33 @@ let translate loc (prim_name : string)
       -> 
       call Js_runtime_modules.obj_runtime
 
+    | "caml_notequal" ->
+      begin match args with 
+      | [a1;b1]  when 
+        E.for_sure_js_null_undefined_boolean a1 
+        || E.for_sure_js_null_undefined_boolean b1 
+        -> 
+        E.neq_null_undefined_boolean a1 b1 
+      (* FIXME address_equal *)
+      | _ -> 
+        Location.prerr_warning loc Warnings.Bs_polymorphic_comparison ; 
+        call Js_runtime_modules.obj_runtime
+      end
     | "caml_equal"  ->     
       begin match args with 
       | [a1;b1]  when 
         E.for_sure_js_null_undefined_boolean a1 || E.for_sure_js_null_undefined_boolean b1 
         -> 
-        E.int_comp Ceq a1 b1 
+        E.eq_null_undefined_boolean a1 b1 
         (* FIXME address_equal *)
       | _ -> 
         Location.prerr_warning loc Warnings.Bs_polymorphic_comparison ; 
         call Js_runtime_modules.obj_runtime
       end
+  
     | "caml_min"
     | "caml_max"
     | "caml_compare"    
-    | "caml_notequal"
     | "caml_greaterequal"
     | "caml_greaterthan"
     | "caml_lessequal"
diff --git a/jscomp/others/belt_MutableQueue.ml b/jscomp/others/belt_MutableQueue.ml
@@ -79,7 +79,7 @@ let pop q =
   | None -> None
   | Some x  ->
     let next = next x in 
-    if Js.Null.test next then 
+    if next = Js.null then 
       begin (* only one element*)
         clear q;
         Some (content x)
@@ -95,7 +95,7 @@ let popExn q =
   | None -> [%assert "Empty"]
   | Some x  ->
     let next = next x in 
-    if Js.Null.test next then 
+    if next = Js.null then 
       begin (* only one element*)
         clear q;
         content x
@@ -111,7 +111,7 @@ let popUndefined q =
   | None -> Js.undefined
   | Some x  ->
     let next = next x in 
-    if Js.Null.test next then 
+    if next = Js.null then 
       begin (* only one element*)
         clear q;
         Js.Undefined.return (content x)
diff --git a/jscomp/others/belt_MutableStack.ml b/jscomp/others/belt_MutableStack.ml
@@ -50,7 +50,7 @@ let top s =
   | None -> None 
   | Some x -> Some (head x)
 
-let isEmpty s = Js.Null.test (root s)    
+let isEmpty s = root s = Js.null
 
 let popUndefined s =   
   match Js.nullToOption (root s) with 
diff --git a/jscomp/runtime/.depend b/jscomp/runtime/.depend
@@ -4,7 +4,7 @@ caml_bytes.cmj : caml_bytes.cmi
 caml_obj.cmj : js_null.cmj js.cmj caml_array.cmj bs_obj.cmj caml_obj.cmi
 caml_int64.cmj : js_typed_array.cmj js_float.cmj js.cmj caml_utils.cmj \
     caml_int32.cmj bs_string.cmj caml_int64.cmi
-caml_exceptions.cmj : caml_builtin_exceptions.cmj caml_exceptions.cmi
+caml_exceptions.cmj : js.cmj caml_builtin_exceptions.cmj caml_exceptions.cmi
 caml_utils.cmj : caml_utils.cmi
 caml_sys.cmj : js.cmj caml_sys.cmi
 caml_io.cmj : js_undefined.cmj js.cmj bs_string.cmj
diff --git a/jscomp/runtime/caml_exceptions.ml b/jscomp/runtime/caml_exceptions.ml
@@ -67,7 +67,6 @@ let create (str : string) : Caml_builtin_exceptions.exception_block =
 (*   Obj.set_tag (Obj.repr v) object_tag; *)
 (*   v  *)
 
-external isUndefined : 'a -> bool = "#is_undef"
 
 
 (**
@@ -102,12 +101,12 @@ external isUndefined : 'a -> bool = "#is_undef"
    This is not a problem in `try .. with` since the logic above is not expressible, see more design in [destruct_exn.md]
 *)
 let isCamlExceptionOrOpenVariant e = 
-  if isUndefined e then false 
+  if  Obj.magic e = Js.undefined then false 
   else 
     Obj.tag (Obj.repr e) = object_tag  (* nullary exception *)
     ||
     let slot = Obj.field (Obj.repr e) 0 in 
-    not (isUndefined slot) &&
+    not (Obj.magic slot = Js.undefined) &&
     (Obj.tag slot = object_tag)
 
 
diff --git a/jscomp/runtime/caml_weak.ml b/jscomp/runtime/caml_weak.ml
@@ -47,6 +47,6 @@ let caml_weak_get_copy  xs i =
   | Some x -> Some (Obj.magic (Obj.dup (Obj.repr x) ))
 
 let caml_weak_check xs i = 
-  not @@ Js_undefined.test xs.(i)
+  xs.(i) <> Js.undefined
 
 let caml_weak_blit = Caml_array.caml_array_blit
diff --git a/jscomp/runtime/js_null.ml b/jscomp/runtime/js_null.ml
@@ -30,7 +30,7 @@ type + 'a t = 'a Js.null
 external to_opt : 'a t -> 'a option = "#null_to_opt"
 external toOption : 'a t -> 'a option = "#null_to_opt"
 external return : 'a -> 'a t  = "%identity"
-external test : 'a t -> bool = "#is_nil"
+let test : 'a t -> bool = fun x -> x = Js.null
 external empty : 'a t = "#null" 
 external getUnsafe : 'a t -> 'a = "%identity"
 
diff --git a/jscomp/runtime/js_null.mli b/jscomp/runtime/js_null.mli
@@ -25,14 +25,17 @@
 (** Provides functionality for dealing with the ['a Js.null] type *)
 
 
-(** Local alias for ['a Js.null] *)
+
 type + 'a t = 'a Js.null
+(** Local alias for ['a Js.null] *)
 
-(** Constructs a value of ['a Js.null] containing a value of ['a] *)
 external return : 'a -> 'a t  = "%identity"
+(** Constructs a value of ['a Js.null] containing a value of ['a] *)
+
 
+val test : 'a t -> bool 
+[@@ocaml.deprecated "Use = Js.null directly "]
 (** Returns [true] if the given value is [empty] ([null]), [false] otherwise *)
-external test : 'a t -> bool = "#is_nil"
 
 (** The empty value, [null] *)
 external empty : 'a t = "#null" 
diff --git a/jscomp/runtime/js_undefined.ml b/jscomp/runtime/js_undefined.ml
@@ -28,11 +28,12 @@ type + 'a t = 'a Js.undefined
 external to_opt : 'a t -> 'a option = "#undefined_to_opt"
 external toOption : 'a t -> 'a option = "#undefined_to_opt"
 external return : 'a -> 'a t = "%identity"
-external test : 'a t -> bool =  "#is_undef"
-external testAny : 'a -> bool = "#is_undef"
+
+
   
 external empty : 'a t = "#undefined"
-
+let test : 'a t -> bool =  fun x -> x = empty
+let testAny : 'a -> bool = fun x -> Obj.magic x = empty 
 external getUnsafe : 'a t -> 'a = "%identity"
 
 let getExn f =
diff --git a/jscomp/runtime/js_undefined.mli b/jscomp/runtime/js_undefined.mli
@@ -30,15 +30,16 @@ type + 'a t = 'a Js.undefined
 (** Constructs a value of ['a Js.undefined] containing a value of ['a] *)
 external return : 'a -> 'a t = "%identity"
 
-(** Returns [true] if the given value is [empty] ([undefined]), [false] otherwise *)
-external test : 'a t -> bool =  "#is_undef"
 
+val test : 'a t -> bool 
+[@@ocaml.deprecated "Use = Js.undefined directly"]
+(** Returns [true] if the given value is [empty] ([undefined]), [false] otherwise *)
 
 (**
    @since 1.6.1
    Returns [true] if the given value is [empty] ([undefined])
 *)
-external testAny : 'a -> bool = "#is_undef"
+val testAny : 'a -> bool 
 
 
 (** The empty value, [undefined] *)
diff --git a/jscomp/test/js_null_test.js b/jscomp/test/js_null_test.js
@@ -61,7 +61,7 @@ var suites_001 = /* :: */[
             (function () {
                 return /* Eq */Block.__(0, [
                           /* true */1,
-                          +(null === null)
+                          /* true */1
                         ]);
               })
           ],
diff --git a/jscomp/test/js_null_test.ml b/jscomp/test/js_null_test.ml
@@ -7,7 +7,7 @@ let suites = Mt.[
   "toOption - 'a", (fun _ -> Eq(Some (), return () |> toOption));
   "return", (fun _ -> Eq(Some "something", return "something" |> toOption));
   "test - empty", (fun _ -> Eq(true, empty |> test));
-  "test - 'a", (fun _ -> Eq(false, return () |> test));
+  "test - 'a", (fun _ -> Eq(false, return () = empty));
   "bind - empty", (fun _ -> StrictEq(empty, bind empty ((fun v -> v) [@bs])));
   "bind - 'a", (fun _ -> StrictEq(return 4, bind (return 2) ((fun n -> n * 2) [@bs])));
   "iter - empty", (fun _ ->
diff --git a/jscomp/test/js_null_undefined_test.js b/jscomp/test/js_null_undefined_test.js
@@ -2,7 +2,6 @@
 
 var Mt = require("./mt.js");
 var Block = require("../../lib/js/block.js");
-var Caml_obj = require("../../lib/js/caml_obj.js");
 var Js_primitive = require("../../lib/js/js_primitive.js");
 var Js_null_undefined = require("../../lib/js/js_null_undefined.js");
 
@@ -228,21 +227,21 @@ var suites_001 = /* :: */[
                                       /* tuple */[
                                         "null <> undefined",
                                         (function () {
-                                            return /* Ok */Block.__(4, [Caml_obj.caml_notequal(null, undefined)]);
+                                            return /* Ok */Block.__(4, [/* true */1]);
                                           })
                                       ],
                                       /* :: */[
                                         /* tuple */[
                                           "null <> empty",
                                           (function () {
-                                              return /* Ok */Block.__(4, [Caml_obj.caml_notequal(null, undefined)]);
+                                              return /* Ok */Block.__(4, [/* true */1]);
                                             })
                                         ],
                                         /* :: */[
                                           /* tuple */[
                                             "undefined = empty",
                                             (function () {
-                                                return /* Ok */Block.__(4, [+(undefined === undefined)]);
+                                                return /* Ok */Block.__(4, [/* true */1]);
                                               })
                                           ],
                                           /* :: */[
diff --git a/jscomp/test/js_undefined_test.js b/jscomp/test/js_undefined_test.js
diff --git a/jscomp/test/js_undefined_test.ml b/jscomp/test/js_undefined_test.ml
diff --git a/lib/js/js_null.js b/lib/js/js_null.js
diff --git a/lib/js/js_undefined.js b/lib/js/js_undefined.js
diff --git a/lib/whole_compiler.ml b/lib/whole_compiler.ml
