Fallback to Object.hasOwn

DZakh · DZakh · commit 04fd8e05c0dc · 2025-03-24T16:26:34.000+03:00
diff --git a/compiler/core/js_exp_make.ml b/compiler/core/js_exp_make.ml
@@ -1131,6 +1131,28 @@ let or_ ?comment (e1 : t) (e2 : t) =
 let in_ (prop : t) (obj : t) : t =
   {expression_desc = In (prop, obj); comment = None}
 
+let has (obj : t) (prop : t) : t =
+  let non_prototype_prop =
+    match prop.expression_desc with
+    | Str
+        {
+          txt =
+            ( "__proto__" | "toString" | "toLocaleString" | "valueOf"
+            | "hasOwnProperty" | "isPrototypeOf" | "propertyIsEnumerable" );
+        } ->
+      false
+    (* Optimize to use the in operator when property is a known string which is not a prototype property *)
+    | Str _ -> true
+    (* We can be sure in this case that the prop is not a prototype property like __proto__ or toString *)
+    | _ -> false
+  in
+  if non_prototype_prop then in_ prop obj
+  else
+    call
+      ~info:{arity = Full; call_info = Call_na}
+      (js_global "Object.hasOwn")
+      [obj; prop]
+
 let not (e : t) : t =
   match e.expression_desc with
   | Number (Int {i; _}) -> bool (i = 0l)
diff --git a/compiler/core/js_exp_make.mli b/compiler/core/js_exp_make.mli
@@ -358,6 +358,8 @@ val or_ : ?comment:string -> t -> t -> t
 
 val in_ : t -> t -> t
 
+val has : t -> t -> t
+
 (** we don't expose a general interface, since a general interface is generally not safe *)
 
 val dummy_obj : ?comment:string -> Lam_tag_info.t -> t
diff --git a/compiler/core/lam_analysis.ml b/compiler/core/lam_analysis.ml
@@ -78,7 +78,7 @@ let rec no_side_effects (lam : Lam.t) : bool =
     (* list primitives *)
     | Pmakelist
     (* dict primitives *)
-    | Pmakedict | Phasin
+    | Pmakedict | Phas
     (* Test if the argument is a block or an immediate integer *)
     | Pisint | Pis_poly_var_block
     (* Test if the (integer) argument is outside an interval *)
diff --git a/compiler/core/lam_compile_primitive.ml b/compiler/core/lam_compile_primitive.ml
@@ -574,12 +574,12 @@ let translate output_prefix loc (cxt : Lam_compile_context.t)
                  Some (Js_op.Lit txt, expr)
                | _ -> None))
     | _ -> assert false)
-  | Phasin -> (
+  | Phas -> (
     match args with
-    | [obj; prop] -> E.in_ prop obj
+    | [obj; prop] -> E.has obj prop
     | _ ->
       Location.raise_errorf ~loc
-        "Invalid external \"%%has_in\" type signature. Expected to have two \
+        "Invalid external \"%%has\" type signature. Expected to have two \
          arguments.")
   | Parraysetu -> (
     match args with
diff --git a/compiler/core/lam_convert.ml b/compiler/core/lam_convert.ml
@@ -314,7 +314,7 @@ let lam_prim ~primitive:(p : Lambda.primitive) ~args loc : Lam.t =
   | Parraysets -> prim ~primitive:Parraysets ~args loc
   | Pmakelist _mutable_flag (*FIXME*) -> prim ~primitive:Pmakelist ~args loc
   | Pmakedict -> prim ~primitive:Pmakedict ~args loc
-  | Phasin -> prim ~primitive:Phasin ~args loc
+  | Phas -> prim ~primitive:Phas ~args loc
   | Pawait -> prim ~primitive:Pawait ~args loc
   | Pimport -> prim ~primitive:Pimport ~args loc
   | Pinit_mod -> (
diff --git a/compiler/core/lam_primitive.ml b/compiler/core/lam_primitive.ml
@@ -137,7 +137,7 @@ type t =
   | Pmakelist
   (* dict primitives *)
   | Pmakedict
-  | Phasin
+  | Phas
   (* promise *)
   | Pawait
   (* etc or deprecated *)
@@ -216,7 +216,7 @@ let eq_primitive_approx (lhs : t) (rhs : t) =
   (* List primitives *)
   | Pmakelist
   (* dict primitives *)
-  | Pmakedict | Phasin
+  | Pmakedict | Phas
   (* promise *)
   | Pawait
   (* etc *)
diff --git a/compiler/core/lam_primitive.mli b/compiler/core/lam_primitive.mli
@@ -132,7 +132,7 @@ type t =
   | Pmakelist
   (* dict primitives *)
   | Pmakedict
-  | Phasin
+  | Phas
   (* promise *)
   | Pawait
   (* etc or deprecated *)
diff --git a/compiler/core/lam_print.ml b/compiler/core/lam_print.ml
@@ -194,7 +194,7 @@ let primitive ppf (prim : Lam_primitive.t) =
   | Pmakearray -> fprintf ppf "makearray"
   | Pmakelist -> fprintf ppf "makelist"
   | Pmakedict -> fprintf ppf "makedict"
-  | Phasin -> fprintf ppf "has_in"
+  | Phas -> fprintf ppf "has_in"
   | Parrayrefu -> fprintf ppf "array.unsafe_get"
   | Parraysetu -> fprintf ppf "array.unsafe_set"
   | Parrayrefs -> fprintf ppf "array.get"
diff --git a/compiler/ml/lambda.ml b/compiler/ml/lambda.ml
@@ -271,7 +271,7 @@ type primitive =
   | Pmakelist of Asttypes.mutable_flag
   (* dict primitives *)
   | Pmakedict
-  | Phasin
+  | Phas
   (* promise *)
   | Pawait
   (* module *)
diff --git a/compiler/ml/lambda.mli b/compiler/ml/lambda.mli
@@ -238,7 +238,7 @@ type primitive =
   | Pmakelist of Asttypes.mutable_flag
   (* dict primitives *)
   | Pmakedict
-  | Phasin
+  | Phas
   (* promise *)
   | Pawait
   (* modules *)
diff --git a/compiler/ml/printlambda.ml b/compiler/ml/printlambda.ml
@@ -229,7 +229,7 @@ let primitive ppf = function
   | Pmakelist Mutable -> fprintf ppf "makelist"
   | Pmakelist Immutable -> fprintf ppf "makelist_imm"
   | Pmakedict -> fprintf ppf "makedict"
-  | Phasin -> fprintf ppf "has_in"
+  | Phas -> fprintf ppf "has_in"
   | Pisint -> fprintf ppf "isint"
   | Pisout -> fprintf ppf "isout"
   | Pisnullable -> fprintf ppf "isnullable"
diff --git a/compiler/ml/translcore.ml b/compiler/ml/translcore.ml
@@ -346,7 +346,7 @@ let primitives_table =
       ("%array_unsafe_set", Parraysetu);
       (* dict primitives *)
       ("%makedict", Pmakedict);
-      ("%has_in", Phasin);
+      ("%has", Phas);
       (* promise *)
       ("%await", Pawait);
       (* module *)
diff --git a/runtime/Stdlib_Dict.res b/runtime/Stdlib_Dict.res
@@ -41,6 +41,6 @@ let mapValues = (dict, f) => {
   target
 }
 
-external has: (dict<'a>, string) => bool = "%has_in"
+external has: (dict<'a>, string) => bool = "%has"
 
 external ignore: dict<'a> => unit = "%ignore"
diff --git a/runtime/Stdlib_Dict.resi b/runtime/Stdlib_Dict.resi
@@ -246,18 +246,20 @@ let mapValues: (dict<'a>, 'a => 'b) => dict<'b>
 /**
 `has(dictionary, "key")` returns true if the "key" is present in the dictionary.
 
+It uses the `in` operator under the hood and falls back to the `Object.hasOwn` method when safety cannot be guaranteed at compile time.
+
 ## Examples
 
 ```rescript
 let dict = dict{"key1": Some(1), "key2": None}
 
-dict->Dict.has("key1") // true
-dict->Dict.has("key2") // true
-dict->Dict.has("key3") // false
-dict->Dict.has("__proto__") // true, since it uses in operator under the hood
+dict->Dict.has("key1")->assertEqual(true)
+dict->Dict.has("key2")->assertEqual(true)
+dict->Dict.has("key3")->assertEqual(false)
+dict->Dict.has("toString")->assertEqual(false)
 ```
 */
-external has: (dict<'a>, string) => bool = "%has_in"
+external has: (dict<'a>, string) => bool = "%has"
 
 /**
   `ignore(dict)` ignores the provided dict and returns unit.
diff --git a/tests/tests/src/DictTests.mjs b/tests/tests/src/DictTests.mjs
@@ -51,7 +51,7 @@ if (!("key1" in dict)) {
     RE_EXN_ID: "Assert_failure",
     _1: [
       "DictTests.res",
-      43,
+      44,
       2
     ],
     Error: new Error()
@@ -63,7 +63,7 @@ if (!("key2" in dict)) {
     RE_EXN_ID: "Assert_failure",
     _1: [
       "DictTests.res",
-      44,
+      46,
       2
     ],
     Error: new Error()
@@ -75,19 +75,31 @@ if ("key3" in dict !== false) {
     RE_EXN_ID: "Assert_failure",
     _1: [
       "DictTests.res",
-      45,
+      48,
       2
     ],
     Error: new Error()
   };
 }
 
-if (!("__proto__" in dict)) {
+if (Object.hasOwn(dict, "toString") !== false) {
   throw {
     RE_EXN_ID: "Assert_failure",
     _1: [
       "DictTests.res",
-      46,
+      50,
+      2
+    ],
+    Error: new Error()
+  };
+}
+
+if (!Object.hasOwn(dict, "key1")) {
+  throw {
+    RE_EXN_ID: "Assert_failure",
+    _1: [
+      "DictTests.res",
+      52,
       2
     ],
     Error: new Error()
@@ -99,7 +111,7 @@ if (typeof ("key1" in dict) !== "boolean") {
     RE_EXN_ID: "Assert_failure",
     _1: [
       "DictTests.res",
-      47,
+      54,
       2
     ],
     Error: new Error()
diff --git a/tests/tests/src/DictTests.res b/tests/tests/src/DictTests.res
@@ -40,9 +40,16 @@ module DictHas = {
     "key2": None,
   }
 
+  // Test success path
   assert(dict->Dict.has("key1"))
+  // Test undefined field
   assert(dict->Dict.has("key2"))
+  // Test missing field
   assert(dict->Dict.has("key3") === false)
-  assert(dict->Dict.has("__proto__"))
+  // Test prototype field
+  assert(dict->Dict.has("toString") === false)
+  // Test without compile time knowledge
+  assert(dict->Dict.has(%raw(`"key1"`)))
+  // Test parantesis in generated code
   assert(typeof(dict->Dict.has("key1")) === #boolean)
 }
