1. use dict to make module pass consistent

2. inline camlinternalOO into camlinternalMod to avoid unnecessary deps

Author: bobzhang

jscomp/bsb/bsb_templates.ml

@@ -9,7 +9,7 @@ type ('elt, 'id)enumeration =
     | More of 'elt * ('elt, 'id) t0 * ('elt, 'id) enumeration
 
 type ('elt, 'id) t = {
-  cmp : ('elt,'id) Bs_Cmp.t ; 
+  dict : ('elt,'id) Bs_Cmp.t ; 
   data : ('elt,'id) t0
 }
 
@@ -190,74 +190,74 @@ let ofArray0 ~cmp (xs : _ array) : _ t0 =
   done ;
   !result 
 
-let empty cmp = {
-  cmp ;
+let empty dict = {
+  dict ;
   data = empty0
 }  
-let ofArray (type elt) (type id) (cmp : (elt,id) Bs_Cmp.t) data = 
-  let module M = (val cmp ) in 
+let ofArray (type elt) (type id) (dict : (elt,id) Bs_Cmp.t) data = 
+  let module M = (val dict ) in 
   {
-  cmp ; 
+  dict ; 
   data = ofArray0 ~cmp:M.cmp data
 }
 
 let isEmpty m = isEmpty0 m.data
 
 
 let mem (type elt) (type id) e (m : (elt,id) t) = 
-  let module M = (val m.cmp) in 
+  let module M = (val m.dict) in 
   mem0 ~cmp:(M.cmp) e m.data
 
 let add (type elt) (type id) e (m : (elt,id) t) =   
-  let m_cmp = m.cmp in
+  let m_cmp = m.dict in
   let module M = (val m_cmp) in 
-  {data = add0 ~cmp:(M.cmp) e m.data ; cmp = m_cmp}
+  {data = add0 ~cmp:(M.cmp) e m.data ; dict = m_cmp}
 
-let singleton cmp e =     
-  { cmp; 
+let singleton dict e =     
+  { dict; 
     data = singleton0 e
   }
 
 let remove (type elt) (type id) e (m : (elt,id) t) =      
-  let m_cmp = m.cmp in 
+  let m_cmp = m.dict in 
   let module M = (val m_cmp) in 
   { data = remove0 ~cmp:M.cmp e m.data ; 
-    cmp = m_cmp
+    dict = m_cmp
   }
 
 let union (type elt) (type id) (m : (elt,id) t) (n : (elt,id) t) =   
-  let m_cmp = m.cmp in 
+  let m_cmp = m.dict in 
   let module M = (val m_cmp) in 
   { data = union0 ~cmp:M.cmp m.data n.data ;
-    cmp = m_cmp
+    dict = m_cmp
   }
 
 let inter (type elt) (type id) (m : (elt,id) t) (n : (elt,id) t) =   
-  let m_cmp = m.cmp in 
+  let m_cmp = m.dict in 
   let module M = (val m_cmp) in 
   { data = inter0 ~cmp:M.cmp m.data n.data ;
-    cmp = m_cmp
+    dict = m_cmp
   }  
 
 let diff (type elt) (type id) (m : (elt,id) t) (n : (elt,id) t) =   
-  let m_cmp = m.cmp in 
+  let m_cmp = m.dict in 
   let module M = (val m_cmp) in 
   { data = diff0 ~cmp:M.cmp m.data n.data ;
-    cmp = m_cmp
+    dict = m_cmp
   }    
 
 let cmp (type elt) (type id) (m : (elt,id) t) (n : (elt,id) t) =     
-  let m_cmp = m.cmp in 
+  let m_cmp = m.dict in 
   let module M = (val m_cmp) in 
   cmp0 ~cmp:M.cmp m.data n.data
 
 let eq (type elt) (type id) (m : (elt,id) t) (n : (elt,id) t) =     
-  let m_cmp = m.cmp in 
+  let m_cmp = m.dict in 
   let module M = (val m_cmp) in 
   eq0 ~cmp:M.cmp m.data n.data  
 
 let subset (type elt) (type id) (m : (elt,id) t) (n : (elt,id) t) =     
-  let m_cmp = m.cmp in 
+  let m_cmp = m.dict in 
   let module M = (val m_cmp) in 
   subset0 ~cmp:M.cmp m.data n.data  
 
@@ -273,8 +273,8 @@ let filter f m = {m with data = filter0 f m.data}
 
 let partition f m = 
   let l,r = partition0 f m.data in 
-  let cmp = m.cmp in 
-  {data = l; cmp}, {data = r; cmp}
+  let dict = m.dict in 
+  {data = l; dict }, {data = r; dict }
 
 let cardinal m = cardinal0 m.data  
 
@@ -285,20 +285,20 @@ let min m = min0 m.data
 let max m = max0 m.data
 
 let split (type elt) (type id) e (m : (elt,id) t) = 
-  let m_cmp = m.cmp in 
-  let module M = (val m_cmp) in 
+  let dict = m.dict in 
+  let module M = (val dict) in 
   let l, b, r = split0 ~cmp:M.cmp e m.data in 
-  {cmp = m_cmp; data = l},
+  {dict; data = l},
   b,
-  {cmp = m_cmp ; data = r}
+  {dict; data = r}
 
 let findOpt (type elt) (type id) e (m : (elt,id) t) =   
-  let m_cmp = m.cmp in 
+  let m_cmp = m.dict in 
   let module M = (val m_cmp) in 
   findOpt0 ~cmp:M.cmp e m.data
 
 let findAssert (type elt) (type id) e (m : (elt,id) t) =   
-  let m_cmp = m.cmp in 
+  let m_cmp = m.dict in 
   let module M = (val m_cmp) in 
   findAssert0 ~cmp:M.cmp e m.data
 

jscomp/others/bs_Set.ml

@@ -4,7 +4,7 @@
 type ('elt, 'id) t0
 
 type ('elt, 'id) t = {
-  cmp : ('elt,'id) Bs_Cmp.t ; 
+  dict : ('elt,'id) Bs_Cmp.t ; 
   data : ('elt,'id) t0
 }
 (** The type of sets. *)

jscomp/others/bs_Set.mli

@@ -68,8 +68,11 @@ type shape =
 (*         update_mod comps.(i) (Obj.field o i) (Obj.field n i) *)
 (*       done *)
 (*   | Value v -> () (\* the value is already there *\) *)
-
-
+#if BS then 
+let dummy_class loc =
+  let undef = fun _ -> raise (Undefined_recursive_module loc) in
+  (Obj.magic undef, undef, undef, Obj.repr 0)
+#end  
 (** Note that we have to provide a drop in replacement, since compiler internally will
     spit out ("CamlinternalMod".[init_mod|update_mod] unless we intercept it 
     in the lambda layer
@@ -80,7 +83,12 @@ let init_mod (loc : string * int * int) (shape : shape) =
     match shape with 
     | Function -> struct_.(idx)<-(Obj.magic undef_module)
     | Lazy -> struct_.(idx)<- (Obj.magic (lazy undef_module))
-    | Class ->  struct_.(idx)<- (Obj.magic (CamlinternalOO.dummy_class loc))
+    | Class ->  struct_.(idx)<-
+#if BS then
+        (Obj.magic (dummy_class loc))
+#else    
+        (Obj.magic (CamlinternalOO.dummy_class loc))
+#end                
     | Module comps 
       -> 
       let v =  (Obj.magic [||]) in

jscomp/stdlib/camlinternalMod.ml

@@ -382,10 +382,11 @@ let make_class_store pub_meths class_init init_table =
   init_table.class_init <- class_init;
   init_table.env_init <- env_init
 
+#if undefined BS then
 let dummy_class loc =
   let undef = fun _ -> raise (Undefined_recursive_module loc) in
   (Obj.magic undef, undef, undef, Obj.repr 0)
-
+#end
 (**** Objects ****)
 
 let create_object table =

jscomp/stdlib/camlinternalOO.ml

@@ -51,10 +51,11 @@ val make_class :
 type init_table
 val make_class_store :
     string array -> (table -> t) -> init_table -> unit
+#if undefined BS then
 val dummy_class :
     string * int * int ->
     (t * (table -> Obj.t -> t) * (Obj.t -> t) * Obj.t)
-
+#end
 (** {6 Objects} *)
 
 val copy : (< .. > as 'a) -> 'a

jscomp/stdlib/camlinternalOO.mli

@@ -13100,7 +13100,7 @@ let root = OCamlRes.Res.([
       \    }\n\
        }") ;
     Dir ("src", [
-      File ("demo.re",
+      File ("Demo.re",
         "Js.log(\"Hello, BuckleScript and Reason!\");\n\
          ")]) ;
     File ("README.md",
@@ -13396,15 +13396,15 @@ let root = OCamlRes.Res.([
       "const path = require('path');\n\
        \n\
        module.exports = {\n\
-      \  entry: './src/index.bs.js',\n\
+      \  entry: './src/Index.bs.js',\n\
       \  output: {\n\
       \    path: path.join(__dirname, \"build\"),\n\
-      \    filename: 'index.js',\n\
+      \    filename: 'Index.js',\n\
       \  },\n\
        };\n\
        ") ;
     Dir ("src", [
-      File ("page.re",
+      File ("Page.re",
         "/* This is the basic component. */\n\
          let component = ReasonReact.statelessComponent(\"Page\");\n\
          \n\
@@ -13427,7 +13427,7 @@ let root = OCamlRes.Res.([
         \    <div onClick=(self.handle(handleClick))> (ReasonReact.stringToElement(message)) </div>\n\
          };\n\
          ") ;
-      File ("index.re",
+      File ("Index.re",
         "ReactDOMRe.renderToElementWithId(<Page message=\"Hello!\" />, \"index\");\n\
          ") ;
       File ("index.html",
@@ -13439,7 +13439,7 @@ let root = OCamlRes.Res.([
          </head>\n\
          <body>\n\
         \  <div id=\"index\"></div>\n\
-        \  <script src=\"../build/index.js\"></script>\n\
+        \  <script src=\"../build/Index.js\"></script>\n\
          </body>\n\
          </html>\n\
          ")]) ;
@@ -13506,7 +13506,10 @@ let root = OCamlRes.Res.([
       \  \"bs-dependencies\": [\n\
       \    \"reason-react\"\n\
       \  ],\n\
-      \  \"refmt\": 3\n\
+      \  \"refmt\": 3,\n\
+      \  \"warnings\": {\n\
+      \    \"error\": \"+5\"\n\
+      \  }\n\
        }\n\
        ") ;
     File (".gitignore",

lib/bsb.ml

@@ -195,17 +195,17 @@ function ofArray0(cmp, xs) {
   return result;
 }
 
-function empty(cmp) {
+function empty(dict) {
   return /* record */[
-          /* cmp */cmp,
+          /* dict */dict,
           /* data */Bs_internalAVLset.empty0
         ];
 }
 
-function ofArray(cmp, data) {
+function ofArray(dict, data) {
   return /* record */[
-          /* cmp */cmp,
-          /* data */ofArray0(cmp[/* cmp */0], data)
+          /* dict */dict,
+          /* data */ofArray0(dict[/* cmp */0], data)
         ];
 }
 
@@ -214,48 +214,48 @@ function isEmpty(m) {
 }
 
 function mem(e, m) {
-  var M = m[/* cmp */0];
+  var M = m[/* dict */0];
   return mem0(M[/* cmp */0], e, m[/* data */1]);
 }
 
 function add(e, m) {
-  var m_cmp = m[/* cmp */0];
+  var m_cmp = m[/* dict */0];
   return /* record */[
-          /* cmp */m_cmp,
+          /* dict */m_cmp,
           /* data */add0(m_cmp[/* cmp */0], e, m[/* data */1])
         ];
 }
 
-function singleton(cmp, e) {
+function singleton(dict, e) {
   return /* record */[
-          /* cmp */cmp,
+          /* dict */dict,
           /* data */Bs_internalAVLset.singleton0(e)
         ];
 }
 
 function remove(e, m) {
-  var m_cmp = m[/* cmp */0];
+  var m_cmp = m[/* dict */0];
   return /* record */[
-          /* cmp */m_cmp,
+          /* dict */m_cmp,
           /* data */remove0(m_cmp[/* cmp */0], e, m[/* data */1])
         ];
 }
 
 function union(m, n) {
-  var m_cmp = m[/* cmp */0];
+  var m_cmp = m[/* dict */0];
   return /* record */[
-          /* cmp */m_cmp,
+          /* dict */m_cmp,
           /* data */union0(m_cmp[/* cmp */0], m[/* data */1], n[/* data */1])
         ];
 }
 
 function cmp(m, n) {
-  var m_cmp = m[/* cmp */0];
+  var m_cmp = m[/* dict */0];
   return cmp0(m_cmp[/* cmp */0], m[/* data */1], n[/* data */1]);
 }
 
 function eq(m, n) {
-  var m_cmp = m[/* cmp */0];
+  var m_cmp = m[/* dict */0];
   return eq0(m_cmp[/* cmp */0], m[/* data */1], n[/* data */1]);
 }
 
@@ -277,21 +277,21 @@ function exists(f, m) {
 
 function filter(f, m) {
   return /* record */[
-          /* cmp */m[/* cmp */0],
+          /* dict */m[/* dict */0],
           /* data */Bs_internalAVLset.filter0(f, m[/* data */1])
         ];
 }
 
 function partition(f, m) {
   var match = Bs_internalAVLset.partition0(f, m[/* data */1]);
-  var cmp = m[/* cmp */0];
+  var dict = m[/* dict */0];
   return /* tuple */[
           /* record */[
-            /* cmp */cmp,
+            /* dict */dict,
             /* data */match[0]
           ],
           /* record */[
-            /* cmp */cmp,
+            /* dict */dict,
             /* data */match[1]
           ]
         ];
@@ -314,16 +314,16 @@ function max(m) {
 }
 
 function split(e, m) {
-  var m_cmp = m[/* cmp */0];
-  var match = split0(m_cmp[/* cmp */0], e, m[/* data */1]);
+  var dict = m[/* dict */0];
+  var match = split0(dict[/* cmp */0], e, m[/* data */1]);
   return /* tuple */[
           /* record */[
-            /* cmp */m_cmp,
+            /* dict */dict,
             /* data */match[0]
           ],
           match[1],
           /* record */[
-            /* cmp */m_cmp,
+            /* dict */dict,
             /* data */match[2]
           ]
         ];