remove unused code and fix rescript-lang#2559

Author: bobzhang

jscomp/core/js_dump.ml

@@ -471,7 +471,8 @@ and
             else 
               begin 
                 P.string f  L.app_array;                
-                P.paren_group f 1 (fun _ -> arguments cxt f [ e ; E.arr Mutable el])
+                P.paren_group f 1 
+                  (fun _ -> arguments cxt f [ e ; E.array Mutable el])
               end)
     in
     if l > 15 then P.paren_group f 1 action   
@@ -880,7 +881,8 @@ and
         P.string f L.caml_block; 
         P.string f L.dot ;
         P.string f L.caml_block_create;
-        P.paren_group f 1 (fun _ -> arguments cxt f [tag; E.arr mutable_flag el])
+        P.paren_group f 1 
+          (fun _ -> arguments cxt f [tag; E.array mutable_flag el])
     end
   | Caml_block_tag e ->
     P.group f 1 (fun _ ->  

jscomp/core/js_exp_make.ml

@@ -29,37 +29,42 @@
 
 let no_side_effect = Js_analyzer.no_side_effect_expression
 
+type t = J.expression 
+
 type binary_op =
   ?comment:string ->
-  J.expression ->
-  J.expression ->
-  J.expression 
+  t ->
+  t ->
+  t
 type unary_op =
   ?comment:string ->
-  J.expression ->
-  J.expression
+  t ->
+  t
+
 
 (*
-  Remove pure part of the expression
+  [remove_pure_sub_exp x]
+  Remove pure part of the expression (minor optimization)
   and keep the non-pure part while preserve the semantics 
   (modulo return value)
+  It will return None if  [x] is pure
  *)
-let rec extract_non_pure (x : J.expression)  = 
+let rec remove_pure_sub_exp (x : t)  : t option = 
   match x.expression_desc with 
   | Var _
   | Str _
   | Number _ -> None (* Can be refined later *)
   | Access (a,b) -> 
-    begin match extract_non_pure a , extract_non_pure b with 
+    begin match remove_pure_sub_exp a , remove_pure_sub_exp b with 
       | None, None -> None
       | _, _ -> Some x 
     end
   | Array (xs,_mutable_flag)  ->
-    if List.for_all (fun x -> extract_non_pure x = None)  xs then
+    if List.for_all (fun x -> remove_pure_sub_exp x = None)  xs then
       None 
     else Some x 
   | Seq (a,b) -> 
-    begin match extract_non_pure a , extract_non_pure b with 
+    begin match remove_pure_sub_exp a , remove_pure_sub_exp b with 
       | None, None  ->  None
       | Some u, Some v ->  
         Some { x with expression_desc =  Seq(u,v)}
@@ -69,20 +74,28 @@ let rec extract_non_pure (x : J.expression)  =
     end
   | _ -> Some x 
 
-type t = J.expression 
 
-let mk ?comment exp : t = 
-  {expression_desc = exp ; comment  }
+(* let mk ?comment exp : t = 
+  {expression_desc = exp ; comment  } *)
 
 let var ?comment  id  : t = 
   {expression_desc = Var (Id id); comment }
 
+let call ?comment ~info e0 args : t = 
+  {expression_desc = Call(e0,args,info); comment }
+
+let flat_call ?comment e0 es : t = 
+  (* TODO: optimization when es is known at compile time
+      to be an array
+  *)
+  {expression_desc = FlatCall (e0,es); comment }
+
 let runtime_var_dot ?comment (x : string)  (e1 : string) : J.expression = 
   {expression_desc = 
      Var (Qualified(Ext_ident.create_js x,Runtime, Some e1)); comment }
 
-let runtime_var_vid  x  e1 : J.vident = 
-  Qualified(Ext_ident.create_js x,Runtime, Some e1)
+(* let runtime_var_vid  x  e1 : J.vident = 
+  Qualified(Ext_ident.create_js x,Runtime, Some e1) *)
 
 let ml_var_dot ?comment ( id  : Ident.t) e : J.expression =     
   {expression_desc = Var (Qualified(id, Ml, Some e)); comment }
@@ -97,8 +110,17 @@ let external_var_dot ?comment  ~external_name:name ?dot (id : Ident.t) : t =
   {expression_desc = Var (Qualified(id, External name,  dot)); comment }
 
 
-let ml_var ?comment (id : Ident.t) : t  = 
-  {expression_desc = Var (Qualified (id, Ml, None)); comment}
+(* let ml_var ?comment (id : Ident.t) : t  = 
+  {expression_desc = Var (Qualified (id, Ml, None)); comment} *)
+
+(* Dot .....................**)        
+let runtime_call ?comment module_name fn_name args = 
+  call ?comment 
+    ~info:Js_call_info.builtin_runtime_call
+    (runtime_var_dot  module_name fn_name) args
+
+let runtime_ref module_name fn_name = 
+  runtime_var_dot  module_name fn_name
 
 let str ?(pure=true)  ?comment s : t =  
   {expression_desc = Str (pure,s); comment}
@@ -109,12 +131,13 @@ let unicode ?comment s : t =
 let raw_js_code ?comment info s : t =
   {expression_desc = Raw_js_code (s,info) ; comment }
 
+(* TODO: could optimize literal *)
 let anything_to_string ?comment (e : t) : t =  
   match e.expression_desc with 
   | Str _ -> e 
   | _ -> {expression_desc = Anything_to_string e ; comment}
 
-let arr ?comment mt es : t  = 
+let array ?comment mt es : t  = 
   {expression_desc = Array (es,mt) ; comment}
 
 let sep = " : "
@@ -150,10 +173,10 @@ let make_block ?comment tag tag_info es mutable_flag : t =
 (* let uninitialized_object ?comment tag size : t = 
   { expression_desc = Caml_uninitialized_obj(tag,size); comment } *)
 
-let uninitialized_array ?comment (e : t) : t  = 
+(* let uninitialized_array ?comment (e : t) : t  = 
   match e.expression_desc with 
-  | Number (Int {i = 0l; _}) -> arr ?comment NA []
-  | _ -> {comment; expression_desc = Array_of_size e}
+  | Number (Int {i = 0l; _}) -> array ?comment NA []
+  | _ -> {comment; expression_desc = Array_of_size e} *)
 
 
 module L = Literals
@@ -340,23 +363,8 @@ let index_addr ?comment ~yes ~no (e0 : t)  e1 : t =
   | _ ->
     yes ({ expression_desc = Access (e0, int ?comment e1); comment = None} : t) 
 
-let call ?comment ~info e0 args : t = 
-  {expression_desc = Call(e0,args,info); comment }
-
-let flat_call ?comment e0 es : t = 
-  (* TODO: optimization when es is known at compile time
-      to be an array
-  *)
-  {expression_desc = FlatCall (e0,es); comment }
 
-(* Dot .....................**)        
-let runtime_call ?comment module_name fn_name args = 
-  call ?comment 
-    ~info:Js_call_info.builtin_runtime_call
-    (runtime_var_dot  module_name fn_name) args
 
-let runtime_ref module_name fn_name = 
-  runtime_var_dot  module_name fn_name
 
 
 (* only used in property access, 
@@ -907,7 +915,7 @@ let public_method_call meth_name obj label cache args =
       [label; 
        int cache;
        obj ;  
-       arr NA (obj::args)
+       array NA (obj::args)
       ]
 
 (* TODO: handle arbitrary length of args .. 

jscomp/core/js_exp_make.mli

@@ -50,7 +50,8 @@
     ]}
 *)
 type t = J.expression 
-val extract_non_pure : t -> t option
+
+val remove_pure_sub_exp : t -> t option
 
 type binary_op =   ?comment:string -> t -> t -> t 
 
@@ -63,31 +64,48 @@ type unary_op =  ?comment:string -> t -> t
 val ocaml_boolean_under_condition : t -> t 
 
 
-(* val bin : ?comment:string -> J.binop -> t -> t -> t *)
-val mk :
-  ?comment:string -> J.expression_desc -> t
+
+(* val mk :
+  ?comment:string -> J.expression_desc -> t *)
 
 val access : binary_op
 
 val string_access : binary_op
 
 val var : ?comment:string  -> J.ident -> t 
 
-val runtime_var_dot : ?comment:string -> string -> string -> t
+(* val runtime_var_dot : ?comment:string -> string -> string -> t *)
 
-val runtime_var_vid : string -> string -> J.vident
+(* val runtime_var_vid : string -> string -> J.vident *)
 
+(** [ml_var_dot ocaml_module name]
+*)
 val ml_var_dot : ?comment:string -> Ident.t -> string -> t
 
-val external_var_dot : ?comment:string ->  external_name:string -> ?dot:string -> Ident.t -> t
-
+(** [external_var_dot ~external_name ~dot id]
+  Used in FFI
+*)
+val external_var_dot : 
+  ?comment:string ->  
+  external_name:string -> 
+  ?dot:string -> 
+  Ident.t ->
+  t
 
+val runtime_call : 
+  ?comment:string -> 
+  string -> (* module_name *)
+  string -> (* fn_name *)
+  t list -> (* args *)
+  t
 
-val ml_var : ?comment:string -> Ident.t -> t
+val runtime_ref : 
+  string -> 
+  string -> 
+  t  
 
-val runtime_call : ?comment:string -> string -> string -> t list -> t
 val public_method_call : string -> t -> t -> Int32.t -> t list -> t
-val runtime_ref : string -> string -> t
+
 
 val str : 
   ?pure:bool -> 
@@ -224,16 +242,24 @@ val to_json_string : unary_op
 
 val new_ : ?comment:string -> J.expression -> J.expression list -> t
 
-val arr : ?comment:string -> J.mutable_flag -> J.expression list -> t
+val array : 
+  ?comment:string -> 
+  J.mutable_flag -> 
+  J.expression list ->
+  t
 
 val make_block : 
   ?comment:string ->
-  J.expression -> J.tag_info -> J.expression list -> J.mutable_flag -> t
+  J.expression -> (* tag *)
+  J.tag_info ->  (* tag_info *)
+  J.expression list -> 
+  J.mutable_flag ->
+  t
 
 (* val uninitialized_object : 
   ?comment:string -> J.expression -> J.expression -> t *)
 
-val uninitialized_array : unary_op
+(* val uninitialized_array : unary_op *)
 
 val seq : binary_op
 val fuse_to_seq : t -> t list -> t 

jscomp/core/js_of_lam_array.ml

@@ -58,9 +58,12 @@ module E  = Js_exp_make
 let make_array mt (kind : Lambda.array_kind) args = 
   match kind with 
   | Pgenarray
-  | Paddrarray -> E.arr ~comment:"array" mt args 
-  | Pintarray  -> E.arr ~comment:"int array" mt args 
-  | Pfloatarray -> E.arr ~comment:"float array" mt args
+  | Paddrarray -> 
+    E.array ~comment:"array" mt args 
+  | Pintarray  -> 
+    E.array ~comment:"int array" mt args 
+  | Pfloatarray -> 
+    E.array ~comment:"float array" mt args
 
 let set_array  e e0 e1 = 
   E.assign (E.access e e0)  e1

jscomp/core/lam_compile.ml

@@ -304,7 +304,7 @@ and compile_recursive_let ~all_bindings
        and need to be declared first 
     *)
     Js_output.of_block (
-      S.define ~kind:Variable id (E.arr Mutable []) :: 
+      S.define ~kind:Variable id (E.array Mutable []) :: 
       (List.mapi (fun i (x : Lam.t) -> 
            match x with  
            | Lvar lid
@@ -978,8 +978,8 @@ and
               |  ReturnFalse , {block = []; value =  Some out1}, 
                  {block = []; value =  Some out2} ->
                 begin
-                  match Js_exp_make.extract_non_pure out1 ,
-                        Js_exp_make.extract_non_pure out2 with
+                  match Js_exp_make.remove_pure_sub_exp out1 ,
+                        Js_exp_make.remove_pure_sub_exp out2 with
                   | None, None -> Js_output.make (Ext_list.append b  [ S.exp e]) 
                   (* FIX #1762 *)
                   | Some out1, Some out2 -> 

jscomp/core/lam_dispatch_primitive.ml

@@ -428,15 +428,15 @@ let translate loc (prim_name : string)
         | _ -> assert false 
       end
     | "caml_create_string" -> 
+      (* Bytes.create *)
       (* Note that for invalid range, JS raise an Exception RangeError, 
          here in OCaml it's [Invalid_argument], we have to preserve this semantics.
           Also, it's creating a [bytes] which is a js array actually.
       *)
       begin match args with
-        | [{expression_desc = Number (Int {i; _}); _} as v] 
-          when i >= 0l -> 
-          E.uninitialized_array v 
-        (* TODO: inline and spits out a warning when i is negative *)
+        | [{expression_desc = Number (Int {i = 0l; _}); _}] 
+          ->
+          E.array NA []
         | _ -> 
           call Js_runtime_modules.string 
       end

jscomp/runtime/caml_string.ml

@@ -54,7 +54,13 @@ let caml_string_get s i=
 let caml_create_string len : bytes = 
   (* Node raise [RangeError] exception *)
   if len < 0 then raise (Invalid_argument "String.create")
-  else new_uninitialized len 
+  else 
+    let result = new_uninitialized len in 
+    for i = 0 to  len - 1 do 
+      unsafe_set result i '\000'
+    done ;
+    result 
+
 
 
 

jscomp/test/bytes_split_gpr_743_test.js

@@ -28,7 +28,7 @@ function eq(loc, param) {
   return /* () */0;
 }
 
-var b = new Array(3);
+var b = Caml_string.caml_create_string(3);
 
 b[0] = /* "a" */97;
 
@@ -47,7 +47,7 @@ eq("File \"bytes_split_gpr_743_test.ml\", line 17, characters 5-12", /* tuple */
       res
     ]);
 
-var b$1 = new Array(3);
+var b$1 = Caml_string.caml_create_string(3);
 
 b$1[0] = /* "a" */97;
 

jscomp/test/ocaml_parsetree_test.js

@@ -10393,7 +10393,7 @@ var keyword_table = create_hashtable(149, /* :: */[
       ]
     ]);
 
-var initial_string_buffer = new Array(256);
+var initial_string_buffer = Caml_string.caml_create_string(256);
 
 var string_buff = [initial_string_buffer];
 

jscomp/test/ocaml_re_test.js

@@ -1941,8 +1941,8 @@ function colorize(c, regexp) {
 }
 
 function flatten_cmap(cm) {
-  var c = new Array(256);
-  var col_repr = new Array(256);
+  var c = Caml_string.caml_create_string(256);
+  var col_repr = Caml_string.caml_create_string(256);
   var v = 0;
   c[0] = /* "\000" */0;
   col_repr[0] = /* "\000" */0;