From 82769053dbfb3a6207c706a53cd9b615bc256ce5 Mon Sep 17 00:00:00 2001
From: Hongbo Zhang <bobzhang1988@gmail.com>
Date: Mon, 18 Jan 2016 13:29:58 +0000
Subject: [PATCH] add empty obj unit test (+2 squashed commits) Squashed
 commits: [72476aa] fix {!Sys.max_string_length} [e628e34] micro-optimize band
 (when its inner is `|`) (+1 squashed commit) Squashed commits: [f9bf7d1]
 micro-optimize int32_lsr (+1 squashed commit) Squashed commits: [918fe00] now
 it works, there is a bug in precedence printer, tweak and micro-optimize it
 later (+3 squashed commits) Squashed commits: [6ed0c1b] using js integer
 semantics for js ir 1. this is consistent with what we did 2. easy for
 optimizations, we don't want to add another JS IR after all, if we do too
 much compilation in [js_dump], that will make some simple cases hard to
 optimize like [ (x >>> (i * 8) | 0 )  & 255] [935b94f] migrate div to
 int32_div [1120b77] prepare int 32 operation support

---
 jscomp/j.ml                      |   3 +
 jscomp/j_helper.ml               | 111 +++++++++++++++++++++++++++++--
 jscomp/j_helper.mli              |  43 +++++++-----
 jscomp/js_fold.ml                |   2 +
 jscomp/js_map.ml                 |   2 +
 jscomp/js_op.ml                  |  42 ++++++++++++
 jscomp/js_op_util.ml             |  24 +++++--
 jscomp/js_op_util.mli            |   4 ++
 jscomp/lam_compile_group.ml      |   8 ++-
 jscomp/lam_compile_primitive.ml  |  91 ++++++++++++++++---------
 jscomp/lam_dispatch_primitive.ml |  18 ++---
 jscomp/stdlib/pervasives.js      |   2 +-
 jscomp/stdlib/sys.js             |   2 +-
 jscomp/test/.depend              |   4 ++
 jscomp/test/buffer_test.js       |   2 +-
 jscomp/test/buffer_test.ml       |   2 +-
 jscomp/test/empty_obj.d.ts       |   2 +
 jscomp/test/empty_obj.js         |  16 +++++
 jscomp/test/empty_obj.ml         |   2 +
 jscomp/test/test_per.js          |   2 +-
 20 files changed, 312 insertions(+), 70 deletions(-)
 create mode 100644 jscomp/test/empty_obj.d.ts
 create mode 100644 jscomp/test/empty_obj.js
 create mode 100644 jscomp/test/empty_obj.ml

diff --git a/jscomp/j.ml b/jscomp/j.ml
index dac9da471f..1e3dae1405 100644
--- a/jscomp/j.ml
+++ b/jscomp/j.ml
@@ -113,6 +113,9 @@ and expression_desc =
   | Seq of expression * expression
   | Cond of expression * expression * expression
   | Bin of binop * expression * expression
+
+  (* [int_op] will guarantee return [int32] bits 
+     https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators  *)
   (* | Int32_bin of int_op * expression * expression *)
   | FlatCall of expression * expression 
     (* f.apply(null,args) -- Fully applied guaranteed 
diff --git a/jscomp/j_helper.ml b/jscomp/j_helper.ml
index 811f5c0143..2d777104e2 100644
--- a/jscomp/j_helper.ml
+++ b/jscomp/j_helper.ml
@@ -44,6 +44,8 @@ let oo = "Caml_oo"
 
 let no_side_effect = Js_analyzer.no_side_effect_expression
 
+type binary_op =   ?comment:string -> J.expression -> J.expression -> J.expression 
+type unary_op =  ?comment:string -> J.expression -> J.expression
 (*
   remove pure part of the expression
   and keep the non-pure part while preserve the semantics 
@@ -552,7 +554,23 @@ module Exp = struct
 
      check: Re-association: avoid integer overflow
   *) 
-  let rec add ?comment (e1 : t) (e2 : t) = 
+  let rec to_int32  ?comment (e : J.expression)  : J.expression = 
+    let expression_desc =  e.expression_desc in
+    match expression_desc  with 
+    | Bin(Bor, a, {expression_desc = Number (Int {i = 0});  _})
+        -> 
+          to_int32 ?comment a
+    | _ ->
+        { comment ;
+          expression_desc = Bin (Bor, {comment = None; expression_desc }, int 0)
+        }
+
+  let rec to_uint32 ?comment (e : J.expression)  : J.expression = 
+    { comment ; 
+      expression_desc = Bin (Lsr, e , int 0)
+    }
+
+  let rec float_add ?comment (e1 : t) (e2 : t) = 
     match e1.expression_desc, e2.expression_desc with 
     | Number (Int {i;_}), Number (Int {i = j;_}) -> 
       int ?comment (i + j)
@@ -577,15 +595,100 @@ module Exp = struct
     (*     bin ?comment Plus  e2 e1 *)
     | _ -> 
       bin ?comment Plus e1 e2
+  let int32_add ?comment e1 e2 = 
+    (* to_int32 @@  *)float_add ?comment e1 e2
 
-  and minus ?comment e1 e2 = 
+  let float_minus ?comment e1 e2 = 
     bin ?comment Minus e1 e2 
 
-  and mul ?comment e1 e2 = 
+  let int32_minus ?comment e1 e2 : J.expression = 
+     (* to_int32 @@ *)  float_minus ?comment e1 e2
+
+  let float_mul ?comment e1 e2 = 
     bin ?comment Mul e1 e2 
 
-  and div ?comment e1 e2 = 
+  let float_div ?comment e1 e2 = 
     bin ?comment Div e1 e2 
+  let float_notequal ?comment e1 e2 = 
+    bin ?comment NotEqEq e1 e2
+
+  let int32_div ?comment e1 e2 : J.expression = 
+    to_int32 (float_div ?comment e1 e2)
+    
+
+  (* TODO: call primitive *)    
+  let int32_mul ?comment e1 e2 : J.expression = 
+    { comment ; 
+      expression_desc = Bin (Mul, e1,e2)
+    }
+  
+
+  (* TODO: check division by zero *)                
+  let int32_mod ?comment e1 e2 : J.expression = 
+    { comment ; 
+      expression_desc = Bin (Mod, e1,e2)
+    }
+
+  let int32_lsl ?comment e1 e2 : J.expression = 
+    { comment ; 
+      expression_desc = Bin (Lsl, e1,e2)
+    }
+
+  (* TODO: optimization *)    
+  let int32_lsr ?comment
+      (e1 : J.expression) 
+      (e2 : J.expression) : J.expression = 
+    match e1.expression_desc, e2.expression_desc with
+    | Number (Int { i = i1}), Number( Int {i = i2})
+      ->
+        int @@ Int32.to_int 
+                 (Int32.shift_right_logical
+                    (Int32.of_int i1) i2)
+    | _ ,  Number( Int {i = i2})
+      ->
+        if i2 = 0 then 
+          e1
+        else 
+          { comment ; 
+            expression_desc = Bin (Lsr, e1,e2) (* uint32 *)
+          }
+    | _, _ ->
+        to_int32  { comment ; 
+                    expression_desc = Bin (Lsr, e1,e2) (* uint32 *)
+                  }
+
+  let int32_asr ?comment e1 e2 : J.expression = 
+    { comment ; 
+      expression_desc = Bin (Asr, e1,e2)
+    }
+
+  let int32_bxor ?comment e1 e2 : J.expression = 
+    { comment ; 
+      expression_desc = Bin (Bxor, e1,e2)
+    }
+
+  let rec int32_band ?comment (e1 : J.expression) (e2 : J.expression) : J.expression = 
+    match e1.expression_desc with 
+    | Bin (Bor ,a, {expression_desc = Number (Int {i = 0})})
+        -> 
+          (* Note that in JS
+             {[ -1 >>> 0 & 0xffffffff = -1]} is the same as 
+             {[ (-1 >>> 0 | 0 ) & 0xffffff ]}
+           *)
+          int32_band a e2
+    | _  ->
+        { comment ; 
+          expression_desc = Bin (Band, e1,e2)
+        }
+
+  let int32_bor ?comment e1 e2 : J.expression = 
+    { comment ; 
+      expression_desc = Bin (Bor, e1,e2)
+    }
+
+  (* let int32_bin ?comment op e1 e2 : J.expression =  *)
+  (*   {expression_desc = Int32_bin(op,e1, e2); comment} *)
+
 
     (* TODO -- alpha conversion 
         remember to add parens..
diff --git a/jscomp/j_helper.mli b/jscomp/j_helper.mli
index d5520d6c80..574290f6cc 100644
--- a/jscomp/j_helper.mli
+++ b/jscomp/j_helper.mli
@@ -63,6 +63,10 @@ val is_constant : J.expression -> bool
 
 val extract_non_pure : J.expression -> J.expression option
 
+type binary_op =   ?comment:string -> J.expression -> J.expression -> J.expression 
+
+type unary_op =  ?comment:string -> J.expression -> J.expression
+
 module Exp : sig 
   type t = J.expression 
 
@@ -139,15 +143,23 @@ module Exp : sig
 
   val is_type_number : ?comment:string -> t -> t
 
-  val bin : ?comment:string -> Js_op.binop -> t -> t -> t 
-
-  val int_plus : ?comment:string -> t -> t -> t
-
-  val int_minus : ?comment:string -> t -> t -> t
-
-  val float_plus : ?comment:string -> t -> t -> t
+  (* val bin : ?comment:string -> Js_op.binary_op -> t -> t -> t  *)
+  val to_int32 : unary_op
+  val to_uint32 : unary_op
+
+  val int_plus : binary_op
+  val int_minus : binary_op
+  val int32_lsl : binary_op
+  val int32_lsr : binary_op
+  val int32_asr : binary_op
+  val int32_mod : binary_op
+  val int32_bxor : binary_op
+  val int32_band : binary_op
+  val int32_bor : binary_op
+  val float_plus : binary_op
+  val float_minus : binary_op
+  val float_notequal : binary_op
 
-  val float_minus : ?comment:string -> t -> t -> t
   (* val un : ?comment:string -> Js_op.unop -> t -> t  *)
   val not : t -> t
 
@@ -219,14 +231,15 @@ module Exp : sig
 
   val stringcomp : ?comment:string -> Js_op.binop -> t -> t -> t
 
-  val add : ?comment:string -> t -> t -> t
-
-  val minus : ?comment:string -> t -> t -> t
-
-  val mul : ?comment:string -> t -> t -> t
-  
-  val div : ?comment:string -> t -> t -> t
 
+  val float_add : ?comment:string -> t -> t -> t
+  val float_minus : ?comment:string -> t -> t -> t
+  val float_mul : ?comment:string -> t -> t -> t
+  val float_div : ?comment:string -> t -> t -> t
+  val int32_div : ?comment:string -> t -> t -> t
+  val int32_add : ?comment:string -> t -> t -> t
+  val int32_minus : ?comment:string -> t -> t -> t
+  val int32_mul : ?comment:string -> t -> t -> t
   val of_block : ?comment:string -> J.statement list -> J.expression -> t
 end
 
diff --git a/jscomp/js_fold.ml b/jscomp/js_fold.ml
index 88805d5d44..8ad08a8108 100644
--- a/jscomp/js_fold.ml
+++ b/jscomp/js_fold.ml
@@ -125,6 +125,8 @@ class virtual fold =
        val log3 : 'a -> 'b -> 'c -> unit 
      *)
                  (* TODO: Add some primitives so that [js inliner] can do a better job *)
+                 (* [int_op] will guarantee return [int32] bits 
+     https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators  *)
                  (* | Int32_bin of int_op * expression * expression *)
                  (* f.apply(null,args) -- Fully applied guaranteed 
        TODO: once we know args's shape --
diff --git a/jscomp/js_map.ml b/jscomp/js_map.ml
index 4be54729a1..0876e1e456 100644
--- a/jscomp/js_map.ml
+++ b/jscomp/js_map.ml
@@ -138,6 +138,8 @@ class virtual map =
        val log3 : 'a -> 'b -> 'c -> unit 
      *)
                  (* TODO: Add some primitives so that [js inliner] can do a better job *)
+                 (* [int_op] will guarantee return [int32] bits 
+     https://developer.mozilla.org/en/docs/Web/JavaScript/Reference/Operators/Bitwise_Operators  *)
                  (* | Int32_bin of int_op * expression * expression *)
                  (* f.apply(null,args) -- Fully applied guaranteed 
        TODO: once we know args's shape --
diff --git a/jscomp/js_op.ml b/jscomp/js_op.ml
index ef6418c315..437e011519 100644
--- a/jscomp/js_op.ml
+++ b/jscomp/js_op.ml
@@ -52,6 +52,41 @@ type binop =
   | Div
   | Mod
 
+(**
+note that we don't need raise [Div_by_zero] in ocamlscript
+
+{[
+let add x y = x + y  (* | 0 *)
+let minus x y = x - y (* | 0 *)
+let mul x y = x * y   (* caml_mul | Math.imul *)
+let div x y = x / y (* caml_div (x/y|0)*)
+let imod x y = x mod y  (* caml_mod (x%y) (zero_divide)*)
+
+let bor x y = x lor y   (* x  | y *)
+let bxor x y = x lxor y (* x ^ y *)
+let band x y = x land y (* x & y *)
+let ilnot  y  = lnot y (* let lnot x = x lxor (-1) *)
+let ilsl x y = x lsl y (* x << y*)
+let ilsr x y = x lsr y  (* x >>> y | 0 *)
+let iasr  x y = x asr y (* x >> y *)
+]}
+
+
+Note that js treat unsigned shift 0 bits in a special way
+   Unsigned shifts convert their left-hand side to Uint32, 
+   signed shifts convert it to Int32.
+   Shifting by 0 digits returns the converted value.
+   {[
+    function ToUint32(x) {
+        return x >>> 0;
+    }
+    function ToInt32(x) {
+        return x >> 0;
+    }
+   ]}
+   So in Js, [-1 >>>0] will be the largest Uint32, while [-1>>0] will remain [-1]
+   and [-1 >>> 0 >> 0 ] will be [-1]
+*)
 type int_op = 
     
   | Bor
@@ -62,10 +97,17 @@ type int_op =
   | Asr
 
   | Plus
+      (* for [+], given two numbers 
+         x + y | 0
+       *)
   | Minus
+      (* x - y | 0 *)
   | Mul
+      (* *)
   | Div
+      (* x / y | 0 *)
   | Mod
+      (* x  % y *)
 
 (* https://developer.mozilla.org/en-US/docs/Web/JavaScript/Guide/Expressions_and_Operators#Bitwise_operators
     {[
diff --git a/jscomp/js_op_util.ml b/jscomp/js_op_util.ml
index 9b11212c29..4efa7cfde6 100644
--- a/jscomp/js_op_util.ml
+++ b/jscomp/js_op_util.ml
@@ -51,18 +51,34 @@ let op_int_prec (op : Js_op.int_op) =
 
 let op_str (op : Js_op.binop) =
   match op with
-  | Eq      -> "="
-  | Or      -> "||"
-  | And     -> "&&"
   | Bor     -> "|"
   | Bxor    -> "^"
   | Band    -> "&"
+  | Lsl     -> "<<"
+  | Lsr     -> ">>>"
+  | Asr     -> ">>"
+  | Plus    -> "+"
+  | Minus   -> "-"
+  | Mul     -> "*"
+  | Div     -> "/"
+  | Mod     -> "%"
+
+  | Eq      -> "="
+  | Or      -> "||"
+  | And     -> "&&"
   | EqEqEq  -> "==="
   | NotEqEq -> "!=="
   | Lt      -> "<"
   | Le      -> "<="
   | Gt      -> ">"
   | Ge      -> ">="
+
+
+let op_int_str (op : Js_op.int_op) = 
+  match op with
+  | Bor     -> "|"
+  | Bxor    -> "^"
+  | Band    -> "&"
   | Lsl     -> "<<"
   | Lsr     -> ">>>"
   | Asr     -> ">>"
@@ -71,7 +87,7 @@ let op_str (op : Js_op.binop) =
   | Mul     -> "*"
   | Div     -> "/"
   | Mod     -> "%"
-
+  
 let str_of_used_stats = function
   | Js_op.Dead_pure ->  "Dead_pure"
   | Dead_non_pure -> "Dead_non_pure"
diff --git a/jscomp/js_op_util.mli b/jscomp/js_op_util.mli
index 6994183597..9ecaff31e9 100644
--- a/jscomp/js_op_util.mli
+++ b/jscomp/js_op_util.mli
@@ -26,6 +26,10 @@ val op_prec : Js_op.binop -> int * int * int
 
 val op_str : Js_op.binop -> string
 
+val op_int_prec : Js_op.int_op -> int * int * int
+
+val op_int_str : Js_op.int_op -> string
+
 val str_of_used_stats : Js_op.used_stats -> string
 
 val update_used_stats : J.ident_info -> Js_op.used_stats -> unit
diff --git a/jscomp/lam_compile_group.ml b/jscomp/lam_compile_group.ml
index 96f3411249..058422ee95 100644
--- a/jscomp/lam_compile_group.ml
+++ b/jscomp/lam_compile_group.ml
@@ -95,9 +95,13 @@ let compile_group ({filename = file_name; env;} as meta : Lam_stats.meta) (x : L
               J_helper.string "bytes_cat")
 
   (** Special handling for values in [Sys] *)
-  | Single(_, ({name="max_array_length";_} as id) ,_ ),  "sys.ml" ->
-    (* See [js_knowledge] Array size section, can not be expressed by OCaml int *)
+  | Single(_, ({name="max_array_length" | "max_string_length";_} as id) ,_ ),  "sys.ml" ->
+    (* See [js_knowledge] Array size section, can not be expressed by OCaml int,
+       note that casual handling of {!Sys.max_string_length} could result into 
+       negative value which could cause wrong behavior of {!Buffer.create}
+     *)
     Js_output.of_stmt @@ S.const_variable id ~exp:(E.float "4_294_967_295.") 
+                           
   | Single(_, ({name="max_int";_} as id) ,_ ),  ("sys.ml" | "nativeint.ml") ->
     (* See [js_knowledge] Max int section, (2. ** 53. -. 1.;;) can not be expressed by OCaml int *)
     Js_output.of_stmt @@ S.const_variable id ~exp:(E.float "9007199254740991.") 
diff --git a/jscomp/lam_compile_primitive.ml b/jscomp/lam_compile_primitive.ml
index 5d8f1c945d..561e28db66 100644
--- a/jscomp/lam_compile_primitive.ml
+++ b/jscomp/lam_compile_primitive.ml
@@ -69,82 +69,107 @@ let translate
         E.assign  v (E.int_plus v (E.int n))
       | _ -> E.unknown_primitive prim
     end
-  | Paddint | Paddbint _ | Paddfloat ->
+  | Paddint | Paddbint _
+    ->
     begin match args with
       | [e1;e2] ->
-        E.add  e1  e2
+        E.int32_add  e1  e2
       | _ -> E.unknown_primitive prim
     end
-  | (Psubint | Psubbint _ | Psubfloat)->
+ | Paddfloat
+     -> 
     begin match args with
       | [e1;e2] ->
-        E.minus   e1  e2
+        E.float_add  e1  e2
+      | _ -> E.unknown_primitive prim
+    end
+  | Psubint | Psubbint _ 
+    -> 
+    begin match args with
+      | [e1;e2] ->
+          E.int32_minus   e1  e2
       | _ -> E.unknown_primitive prim end
-
-  | (Pmulint | Pmulbint _ | Pmulfloat)->
+  | Psubfloat
+    ->
+      begin match args with
+      | [e1;e2] ->
+          E.float_minus   e1  e2
+      | _ -> E.unknown_primitive prim 
+      end
+  | Pmulint | Pmulbint _ 
+    ->
     begin match args with
       | [e1; e2]  ->
-        E.mul  e1  e2
-      | _ -> E.unknown_primitive prim end
+        E.int32_mul  e1  e2
+      | _ -> E.unknown_primitive prim 
+    end
+  | Pmulfloat 
+    -> 
+      begin match args with
+      | [e1; e2]  ->
+          E.float_mul  e1  e2
+      | _ -> E.unknown_primitive prim 
+      end
   | Pdivfloat -> 
     begin match args with  (* TODO: see ocamljs -- assertion*)
-      | [e1;e2] ->
-        (E.div  e1  e2) (** 32 bits  *)
+      | [e1;e2] -> E.float_div  e1  e2
       | _ -> E.unknown_primitive prim end
   | (  Pdivint | Pdivbint _)->
     begin match args with  (* TODO: see ocamljs -- assertion*)
       | [e1;e2] ->
-        E.bin Bor (E.div  e1  e2) (E.int 0) (** 32 bits  *)
+        E.int32_div e1 e2  (** 32 bits  *)
       | _ -> E.unknown_primitive prim end
-  | (Pmodint | Pmodbint _) ->
+  | Pmodint | Pmodbint _ ->
     begin match args with
       | [e1; e2] ->
-        E.bin Mod  e1  e2
-      | _ -> E.unknown_primitive prim end
-
-  | (Plslint | Plslbint _) ->
+        E.int32_mod   e1  e2
+      | _ -> E.unknown_primitive prim 
+    end
+  | Plslint | Plslbint _ ->
     begin match args with
       | [e1;e2] ->
-        E.bin Lsl  e1  e2
-      | _ -> E.unknown_primitive prim end
+        E.int32_lsl e1  e2
+      | _ -> E.unknown_primitive prim 
+    end
   | (Plsrint | Plsrbint _) ->
     begin match args with
       | [e1; e2] ->
-        E.bin Lsr  e1  e2
+        E.int32_lsr   e1  e2
       | _ -> E.unknown_primitive prim
     end
   | (Pasrint | Pasrbint _) ->
     begin match args with
       | [e1;e2] ->
-        E.bin Asr  e1  e2
+        E.int32_asr  e1  e2
       | _ -> E.unknown_primitive prim
     end
 
-  | (Pandint | Pandbint _)->
+  | Pandint | Pandbint _->
     begin match args with
       | [e1;e2] ->
-        E.bin Band  e1  e2
+        E.int32_band  e1  e2
       | _ -> E.unknown_primitive prim
     end
-  | (Porint | Porbint _) ->
+  | Porint | Porbint _ ->
     begin match args with
       | [e1;e2] ->
-        E.bin Bor  e1  e2
+        E.int32_bor  e1  e2
       | _ -> E.unknown_primitive prim
     end
-  | (Pxorint | Pxorbint _) ->
+  | Pxorint | Pxorbint _ ->
     begin match args with
       | [e1;e2] ->
-        E.bin Bxor  e1  e2
+        E.int32_bxor  e1  e2
       | _ -> E.unknown_primitive prim
     end
-  | Psequand ->
+
+  | Psequand -> (* TODO: rhs is possibly a tail call *)
     begin match args with
       | [e1;e2] ->
         E.and_   e1  e2
       | _ -> E.unknown_primitive prim
     end
-  | Psequor -> (* rhs is possibly a tail call *)
+  | Psequor -> (* TODO: rhs is possibly a tail call *)
     begin match args with
       | [e1;e2] ->
         E.or_  e1  e2
@@ -152,10 +177,14 @@ let translate
     end
   | Pisout -> 
     begin match args with 
-      (** learn from js_of_ocaml
-          > range  and < 0 
+      (* predicate: [x > range  and x < 0 ]
+         can be simplified if x is positive , x > range
+         if x is negative, fine, its uint is for sure larger than range,
+         the output is not readable, we might change it back.
       *)
-      | [range; e] -> E.lt range (E.bin  Lsr e  (E.int 0))
+      | [range; e] -> 
+          (* E.and_ (E.lt) *)
+          E.lt range (E.to_uint32 e)
       | _ -> E.unknown_primitive prim
     end
   | Pidentity ->
diff --git a/jscomp/lam_dispatch_primitive.ml b/jscomp/lam_dispatch_primitive.ml
index c60e2728a7..cc721d3129 100644
--- a/jscomp/lam_dispatch_primitive.ml
+++ b/jscomp/lam_dispatch_primitive.ml
@@ -79,7 +79,7 @@ let query (prim : Lam_compile_env.primitive_description)
         end
     |"caml_div_float" -> 
         begin match args with 
-        | [e0;e1] -> E.bin Div e0 e1 
+        | [e0;e1] -> E.float_div e0 e1
         | _ -> assert false 
         end
     |"caml_sub_float" -> 
@@ -181,12 +181,12 @@ let query (prim : Lam_compile_env.primitive_description)
         end
     | "caml_int32_div"| "caml_nativeint_div" -> 
         begin match args with 
-        | [e0;e1] -> E.bin Bor (E.bin Div e0 e1) (E.int 0)
+        | [e0;e1] -> E.int32_div e0 e1
         | _ -> assert false 
         end
     | "caml_int32_mul" | "caml_nativeint_mul"  -> 
         begin match args with 
-        | [e0;e1] -> E.bin Mul e0 e1 
+        | [e0;e1] -> E.int32_mul e0 e1 
         | _ -> assert false 
         end
     | "caml_int32_of_int" | "caml_nativeint_of_int" 
@@ -197,7 +197,7 @@ let query (prim : Lam_compile_env.primitive_description)
          end
     |  "caml_int32_of_float" | "caml_int_of_float"|"caml_nativeint_of_float" -> 
         begin match args with 
-        | [e] -> E.bin Bor e (E.int 0) (* (|) *)
+        | [e] -> E.to_int32 e 
         | _ -> assert false 
         end
     | "caml_int32_to_float" | "caml_int32_to_int" | "caml_nativeint_to_int" 
@@ -213,18 +213,18 @@ let query (prim : Lam_compile_env.primitive_description)
         end
     | "caml_int32_xor" | "caml_nativeint_xor" -> 
         begin match args with 
-        | [e0; e1] -> E.bin Bxor e0 e1 
+        | [e0; e1] -> E.int32_bxor e0 e1 
         | _ -> assert false 
         end
           
     | "caml_int32_and" | "caml_nativeint_and" -> 
         begin match args with 
-        | [e0;e1] -> E.bin Band e0 e1 
+        | [e0;e1] -> E.int32_band e0 e1 
         | _ -> assert false 
         end
     | "caml_int32_or" | "caml_nativeint_or" ->
         begin match args with
-        | [e0;e1] -> E.bin Bor e0 e1 
+        | [e0;e1] -> E.int32_bor e0 e1 
         | _ -> assert false  
         end
     | "caml_le_float" ->
@@ -246,12 +246,12 @@ let query (prim : Lam_compile_env.primitive_description)
         end
     | "caml_neq_float" -> 
         begin match args with 
-        | [e0;e1] -> E.bin NotEqEq e0 e1 
+        | [e0;e1] -> E.float_notequal e0 e1
         | _ -> assert false 
         end
     | "caml_mul_float" -> 
         begin match args with 
-        | [e0; e1] -> E.bin Mul e0 e1 
+        | [e0; e1] -> E.float_mul e0 e1 
         | _ -> assert false  
         end
     | "caml_int64_bits_of_float"
diff --git a/jscomp/stdlib/pervasives.js b/jscomp/stdlib/pervasives.js
index 5a363891a6..756eb5b41f 100644
--- a/jscomp/stdlib/pervasives.js
+++ b/jscomp/stdlib/pervasives.js
@@ -45,7 +45,7 @@ function lnot(x) {
   return x ^ -1;
 }
 
-var max_int = (-1 >>> 1);
+var max_int = 2147483647;
 
 var min_int = max_int + 1;
 
diff --git a/jscomp/stdlib/sys.js b/jscomp/stdlib/sys.js
index 48cc7014c9..8f13b7bdf8 100644
--- a/jscomp/stdlib/sys.js
+++ b/jscomp/stdlib/sys.js
@@ -19,7 +19,7 @@ var cygwin = /* false */0;
 
 var max_array_length = 4294967295;
 
-var max_string_length = (word_size / 8 | 0) * max_array_length - 1;
+var max_string_length = 4294967295;
 
 var interactive = [
   0,
diff --git a/jscomp/test/.depend b/jscomp/test/.depend
index 7b1c721775..4f0ee28158 100644
--- a/jscomp/test/.depend
+++ b/jscomp/test/.depend
@@ -60,6 +60,8 @@ demo.cmo :
 demo.cmx :
 demo_page.cmo :
 demo_page.cmx :
+empty_obj.cmo :
+empty_obj.cmx :
 equal_exception_test.cmo : ../stdlib/string.cmi mt.cmo ../stdlib/bytes.cmi
 equal_exception_test.cmx : ../stdlib/string.cmx mt.cmx ../stdlib/bytes.cmx
 ext_bytes.cmo : ../stdlib/bytes.cmi
@@ -392,6 +394,8 @@ demo.cmo :
 demo.cmo :
 demo_page.cmo :
 demo_page.cmo :
+empty_obj.cmo :
+empty_obj.cmo :
 equal_exception_test.cmo : ../stdlib/string.cmi mt.cmo ../stdlib/bytes.cmi
 equal_exception_test.cmo : ../stdlib/string.cmo mt.cmo ../stdlib/bytes.cmo
 ext_bytes.cmo : ../stdlib/bytes.cmi
diff --git a/jscomp/test/buffer_test.js b/jscomp/test/buffer_test.js
index f8bf9d3105..0a9eae7ef5 100644
--- a/jscomp/test/buffer_test.js
+++ b/jscomp/test/buffer_test.js
@@ -92,7 +92,7 @@ var suites = [
   suites_002
 ];
 
-Mt.from_suites("buffer", suites);
+Mt.from_suites("buffer_test.ml", suites);
 
 exports.v = v;
 exports.bytes_equal = bytes_equal;
diff --git a/jscomp/test/buffer_test.ml b/jscomp/test/buffer_test.ml
index 4116b10865..307c168472 100644
--- a/jscomp/test/buffer_test.ml
+++ b/jscomp/test/buffer_test.ml
@@ -25,4 +25,4 @@ let suites = [
             )
 ]
 open Mt 
-;; from_suites "buffer" suites
+;; from_suites __FILE__ suites
diff --git a/jscomp/test/empty_obj.d.ts b/jscomp/test/empty_obj.d.ts
new file mode 100644
index 0000000000..89ba82deb4
--- /dev/null
+++ b/jscomp/test/empty_obj.d.ts
@@ -0,0 +1,2 @@
+export var v: any ;
+
diff --git a/jscomp/test/empty_obj.js b/jscomp/test/empty_obj.js
new file mode 100644
index 0000000000..55440adc47
--- /dev/null
+++ b/jscomp/test/empty_obj.js
@@ -0,0 +1,16 @@
+// Generated CODE, PLEASE EDIT WITH CARE
+"use strict";
+var CamlinternalOO = require("../stdlib/camlinternalOO");
+
+var $$class = CamlinternalOO.create_table(0);
+
+function obj_init() {
+  return CamlinternalOO.create_object_opt(0, $$class);
+}
+
+CamlinternalOO.init_class($$class);
+
+var v = obj_init(0);
+
+exports.v = v;
+/* class Not a pure module */
diff --git a/jscomp/test/empty_obj.ml b/jscomp/test/empty_obj.ml
new file mode 100644
index 0000000000..5b3ab74c28
--- /dev/null
+++ b/jscomp/test/empty_obj.ml
@@ -0,0 +1,2 @@
+let v = object 
+end
diff --git a/jscomp/test/test_per.js b/jscomp/test/test_per.js
index c54692803a..88e3637661 100644
--- a/jscomp/test/test_per.js
+++ b/jscomp/test/test_per.js
@@ -46,7 +46,7 @@ function lnot(x) {
   return x ^ -1;
 }
 
-var max_int = (-1 >>> 1);
+var max_int = 2147483647;
 
 var min_int = max_int + 1;