Remove deprecated Js modules (#8531)

Author: cknitt

CHANGELOG.md

@@ -14,6 +14,8 @@
 
 #### :boom: Breaking Change
 
+- Remove the deprecated `Js` namespace and its runtime modules. https://github.com/rescript-lang/rescript/pull/8531
+
 #### :eyeglasses: Spec Compliance
 
 #### :rocket: New Feature

analysis/reanalyze/src/exn_lib.ml

@@ -195,7 +195,6 @@ let raises_lib_table : (Name.t, Exceptions.t) Hashtbl.t =
     ("Error", stdlib_error);
     ("Exn", stdlib_exn);
     ("JsError", stdlib_js_error);
-    ("Js.Json", [("parseExn", [js_exn])]);
     ("JSON", stdlib_json);
     ("Json_decode", bs_json);
     ("Json.Decode", bs_json);

analysis/src/completion_front_end.ml

@@ -328,13 +328,13 @@ let complete_pipe_chain ~(in_jsx_context : bool) (exp : Parsetree.expression) =
   (* Complete the end of pipe chains by reconstructing the pipe chain as a single pipe,
      so it can be completed.
      Example:
-      someArray->Js.Array2.filter(v => v > 10)->Js.Array2.map(v => v + 2)->
+      someArray->Array.filter(v => v > 10)->Array.map(v => v + 2)->
         will complete as:
-      Js.Array2.map(someArray->Js.Array2.filter(v => v > 10), v => v + 2)->
+      Array.map(someArray->Array.filter(v => v > 10), v => v + 2)->
   *)
   match exp.pexp_desc with
   (* When the left side of the pipe we're completing is a function application.
-     Example: someArray->Js.Array2.map(v => v + 2)-> *)
+     Example: someArray->Array.map(v => v + 2)-> *)
   | Pexp_apply
       {
         funct = {pexp_desc = Pexp_ident {txt = Lident "->"}};

compiler/core/design.md

@@ -5,7 +5,7 @@
 - printing
 
 ```ocaml
-Js.log true
+Console.log true
 ```
 
 - pattern match

compiler/core/destruct_exn.md

@@ -11,7 +11,7 @@ However it does not prevent things like
 
 ```ocaml
 destruct v begin fun exn -> 
-   Js.log exn ; 
+   Console.log exn ; 
    match exn with 
    | .. 
    | .. 
@@ -44,7 +44,7 @@ Another proposal is
 match%exn computation with 
 | A ..
 | B .. 
-| Js.NonCamlOpenVariant .. 
+| JsExn ..
 | v ->  ..
 ```
 
@@ -53,7 +53,7 @@ Here we pack the data `v`
 ==>
 ```
 
-match (Js_enx.internalTOOCamlException compuation) with
+match (Primitive_exceptions.internalToException computation) with
 | A .. 
 | B 
 | exception .. )
@@ -62,7 +62,7 @@ match (Js_enx.internalTOOCamlException compuation) with
 The same problem is
 
 ```
-match (Js_enx.internalTOOCamlException compuation) with
+match (Primitive_exceptions.internalToException computation) with
 | _ -> ..
 ```
 
@@ -76,6 +76,6 @@ Another very similar proposal would be
 ```ocaml
 fun[@bs:exn] e -> 
   match e with 
-  | Js.Exn.Error ..
+  | JsExn ..
   | .. 
-```
+```

compiler/core/lam_convert.ml

@@ -37,13 +37,13 @@ let lam_extension_id loc (head : Lam.t) =
     ]}
     we approximate that if [id] is destructed or not.
     If it is destructed, we need pack it in case it is JS exception.
-    The packing is called Js.Exn.internalTOOCamlException, which is a nop for OCaml exception, 
+    The packing is called Primitive_exceptions.internalToException, which is a nop for OCaml exception,
     but will wrap as (Error e) when it is an JS exception. 
 
     {[
       try .. with 
       | A (x,y) -> 
-      | Js.Error ..
+      | Exn.Error ..
     ]}
 
     Without such wrapping, the code above would raise

compiler/core/outcome_printer_ns.ml

@@ -27,26 +27,6 @@ let ps = Format.pp_print_string
 let out_ident ppf s =
   ps ppf
     (match s with
-    | "Js_null" -> "Js.Null"
-    | "Js_undefined" -> "Js.Undefined"
-    | "Js_null_undefined" -> "Js.Nullable"
-    | "Js_exn" -> "Js.Exn"
-    | "Js_array" -> "Js.Array"
-    | "Js_string" -> "Js.String"
-    | "Js_re" -> "Js.Re"
-    | "Js_promise" -> "Js.Promise"
-    | "Js_date" -> "Js.Date"
-    | "Js_dict" -> "Js.Dict"
-    | "Js_global" -> "Js.Global"
-    | "Js_json" -> "Js.Json"
-    | "Js_math" -> "Js.Math"
-    | "Js_obj" -> "Js.Obj"
-    | "Js_typed_array" -> "Js.Typed_array"
-    | "Js_types" -> "Js.Types"
-    | "Js_float" -> "Js.Float"
-    | "Js_int" -> "Js.Int"
-    | "Js_option" -> "Js.Option"
-    | "Js_result" -> "Js.Result"
     (* Belt_libs  *)
     | "Belt_Id" -> "Belt.Id"
     | "Belt_Array" -> "Belt.Array"

compiler/ext/primitive_modules.ml

@@ -52,4 +52,6 @@ let curry = "Primitive_curry"
 
 let util = "Primitive_util"
 
+let js_extern = "Primitive_js_extern"
+
 let pervasives = "Pervasives"

compiler/frontend/ast_core_type.mli

@@ -34,7 +34,7 @@ val from_labels : loc:Location.t -> int -> string Asttypes.loc list -> t
 (** return a function type
     [from_labels ~loc tyvars labels]
     example output:
-    {[x:'a0 -> y:'a1 -> < x :'a0 ;y :'a1  > Js.t]}
+    {[x:'a0 -> y:'a1 -> < x :'a0 ;y :'a1 >]}
 *)
 
 val make_obj : loc:Location.t -> Parsetree.object_field list -> t

compiler/frontend/ast_exp_handle_external.ml

@@ -22,50 +22,6 @@
  * along with this program; if not, write to the Free Software
  * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
 
-(**
-   {[
-     Js.undefinedToOption 
-       (if Js.typeof x = "undefined" then undefined 
-        else x  )
-
-   ]}
-
-   @deprecated
-*)
-let handle_external loc (x : string) : Parsetree.expression =
-  let raw_exp : Ast_exp.t =
-    let str_exp =
-      Ast_compatible.const_exp_string ~loc x ~delimiter:Ext_string.empty
-    in
-    {
-      str_exp with
-      pexp_desc =
-        Ast_external_mk.local_external_apply loc ~pval_prim:["#raw_expr"]
-          ~pval_type:
-            (Ast_helper.Typ.arrows
-               [{attrs = []; lbl = Nolabel; typ = Ast_helper.Typ.any ()}]
-               (Ast_helper.Typ.any ()))
-          [str_exp];
-    }
-  in
-  let empty =
-    (* FIXME: the empty delimiter does not make sense*)
-    Ast_helper.Exp.ident ~loc
-      {txt = Ldot (Ldot (Lident "Js", "Undefined"), "empty"); loc}
-  in
-  let undefined_typeof =
-    Ast_helper.Exp.ident {loc; txt = Ldot (Lident "Js", "undefinedToOption")}
-  in
-  let typeof = Ast_helper.Exp.ident {loc; txt = Ldot (Lident "Js", "typeof")} in
-
-  Ast_compatible.app1 ~loc undefined_typeof
-    (Ast_helper.Exp.ifthenelse ~loc
-       (Ast_compatible.app2 ~loc
-          (Ast_helper.Exp.ident ~loc {loc; txt = Lident "=="})
-          (Ast_compatible.app1 ~loc typeof raw_exp)
-          (Ast_compatible.const_exp_string ~loc "undefined"))
-       empty (Some raw_exp))
-
 let handle_debugger loc (payload : Ast_payload.t) =
   match payload with
   | PStr [] ->