remove Misc.maybe_map deps

Author: bobzhang

jscomp/Makefile

@@ -204,6 +204,7 @@ CORE_SRCS= type_int_to_string type_util  ocaml_stdlib_slots bs_conditional_initi
 	js_of_lam_option js_output lam_compile_global lam_dispatch_primitive lam_beta_reduce\
 	lam_compile_external_call lam_compile_primitive lam_compile lam_pass_exits\
 	lam_pass_count\
+	lam_pass_eliminate_ref\
 	lam_pass_lets_dce \
 	lam_pass_remove_alias lam_compile_group\
 	js_implementation ocaml_batch_compile

jscomp/all.depend

@@ -292,6 +292,7 @@ core/lam_compile.cmi : core/lam_compile_defs.cmi core/lam.cmi \
     core/js_output.cmi core/j.cmx
 core/lam_pass_exits.cmi : core/lam.cmi ext/int_hashtbl.cmi
 core/lam_pass_count.cmi : core/lam.cmi ext/ident_hashtbl.cmi
+core/lam_pass_eliminate_ref.cmi : core/lam.cmi
 core/lam_pass_lets_dce.cmi : core/lam.cmi
 core/lam_pass_remove_alias.cmi : core/lam_stats.cmi core/lam.cmi
 core/lam_compile_group.cmi : core/j.cmx
@@ -493,10 +494,12 @@ core/lam_pass_exits.cmx : core/lam_util.cmx core/lam_beta_reduce.cmx \
 core/lam_pass_count.cmx : core/lam_beta_reduce.cmx core/lam.cmx \
     ext/ident_map.cmx ext/ident_hashtbl.cmx ext/ext_list.cmx \
     core/lam_pass_count.cmi
-core/lam_pass_lets_dce.cmx : core/lam_util.cmx core/lam_pass_count.cmx \
+core/lam_pass_eliminate_ref.cmx : core/lam.cmx ext/ident_set.cmx \
+    core/lam_pass_eliminate_ref.cmi
+core/lam_pass_lets_dce.cmx : core/lam_util.cmx \
+    core/lam_pass_eliminate_ref.cmx core/lam_pass_count.cmx \
     core/lam_beta_reduce.cmx core/lam_analysis.cmx core/lam.cmx \
-    ext/ident_set.cmx ext/ident_hashtbl.cmx ext/ext_list.cmx \
-    core/lam_pass_lets_dce.cmi
+    ext/ident_hashtbl.cmx ext/ext_list.cmx core/lam_pass_lets_dce.cmi
 core/lam_pass_remove_alias.cmx : core/lam_util.cmx core/lam_stats.cmx \
     core/lam_module_ident.cmx core/lam_inline_util.cmx \
     core/lam_compile_env.cmx core/lam_closure.cmx core/lam_beta_reduce.cmx \

jscomp/bin/whole_compiler.d

@@ -340,6 +340,8 @@ bin/whole_compiler.ml : core/lam_pass_exits.ml
 bin/whole_compiler.ml : core/lam_pass_exits.mli
 bin/whole_compiler.ml : core/lam_pass_count.ml
 bin/whole_compiler.ml : core/lam_pass_count.mli
+bin/whole_compiler.ml : core/lam_pass_eliminate_ref.ml
+bin/whole_compiler.ml : core/lam_pass_eliminate_ref.mli
 bin/whole_compiler.ml : core/lam_pass_lets_dce.ml
 bin/whole_compiler.ml : core/lam_pass_lets_dce.mli
 bin/whole_compiler.ml : core/lam_inline_util.ml

jscomp/bin/whole_compiler.ml

@@ -94741,7 +94741,10 @@ let subst_helper (subst : subst_tbl) query lam =
       let new_l = simplif l
       and new_consts =  List.map (fun (n, e) -> (n, simplif e)) sw.sw_consts
       and new_blocks =  List.map (fun (n, e) -> (n, simplif e)) sw.sw_blocks
-      and new_fail = Misc.may_map simplif sw.sw_failaction in
+      and new_fail = 
+      begin match sw.sw_failaction with 
+      | None   -> None
+      | Some x -> Some (simplif x) end in
       Lam.switch
         new_l
          { 
@@ -94752,7 +94755,7 @@ let subst_helper (subst : subst_tbl) query lam =
     | Lstringswitch(l,sw,d) ->
       Lam.stringswitch
         (simplif l) (List.map (fun (s,l) -> s,simplif l) sw)
-         (Misc.may_map simplif d)
+         (begin match d with None -> None | Some d -> Some (simplif d) end)
     | Ltrywith (l1, v, l2) -> 
       Lam.try_ (simplif l1) v (simplif l2)
     | Lifthenelse (l1, l2, l3) -> 
@@ -95007,46 +95010,49 @@ let collect_occurs  lam : occ_tbl =
 
 
 end
-module Lam_pass_lets_dce : sig 
-#1 "lam_pass_lets_dce.mli"
-(***********************************************************************)
-(*                                                                     *)
-(*                                OCaml                                *)
-(*                                                                     *)
-(*            Xavier Leroy, projet Cristal, INRIA Rocquencourt         *)
-(*                                                                     *)
-(*  Copyright 1996 Institut National de Recherche en Informatique et   *)
-(*  en Automatique.  All rights reserved.  This file is distributed    *)
-(*  under the terms of the Q Public License version 1.0.               *)
-(*                                                                     *)
-(***********************************************************************)
-(* Adapted for Javascript backend: Hongbo Zhang                        *)
+module Lam_pass_eliminate_ref : sig 
+#1 "lam_pass_eliminate_ref.mli"
+(* Copyright (C) 2015-2016 Bloomberg Finance L.P.
+ * 
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Lesser General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * In addition to the permissions granted to you by the LGPL, you may combine
+ * or link a "work that uses the Library" with a publicly distributed version
+ * of this file to produce a combined library or application, then distribute
+ * that combined work under the terms of your choosing, with no requirement
+ * to comply with the obligations normally placed on you by section 4 of the
+ * LGPL version 3 (or the corresponding section of a later version of the LGPL
+ * should you choose to use a later version).
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Lesser General Public License for more details.
+ * 
+ * You should have received a copy of the GNU Lesser General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. *)
+
+
+exception Real_reference 
+
+val eliminate_ref : 
+    Ident.t -> 
+    Lam.t -> 
+    Lam.t
+
 
-(**
-   This pass would do beta reduction, and dead code elimination (adapted from compiler's built-in [Simplif] module )
 
-   1. beta reduction -> Llet (Strict )
-  
-   2. The global table [occ] associates to each let-bound identifier
-   the number of its uses (as a reference):
-     - 0 if never used
-     - 1 if used exactly once in and *not under a lambda or within a loop
-     - > 1 if used several times or under a lambda or within a loop.
 
-   The local table [bv] associates to each locally-let-bound variable
-   its reference count, as above.  [bv] is enriched at let bindings
-   but emptied when crossing lambdas and loops. 
 
-   For this pass, when it' used under a lambda or within a loop, we don't do anything,
-   in theory, we can still do something if it's pure but we are conservative here.
 
-   [bv] is used to help caculate [occ] it is not useful outside
 
- *)
-val simplify_lets :  Lam.t -> Lam.t
 
 end = struct
-#1 "lam_pass_lets_dce.ml"
+#1 "lam_pass_eliminate_ref.ml"
 (***********************************************************************)
 (*                                                                     *)
 (*                                OCaml                                *)
@@ -95061,7 +95067,7 @@ end = struct
 (* Adapted for Javascript backend : Hongbo Zhang,  *)
 
 
-open Asttypes
+
 
 exception Real_reference
 
@@ -95127,12 +95133,17 @@ let rec eliminate_ref id (lam : Lam.t) =
        sw_blocks =
          List.map (fun (n, e) -> (n, eliminate_ref id e)) sw.sw_blocks;
        sw_failaction =
-         Misc.may_map (eliminate_ref id) sw.sw_failaction; }
+         match sw.sw_failaction with 
+         | None -> None 
+         | Some x -> Some (eliminate_ref id x)
+          }
   | Lstringswitch(e, sw, default) ->
     Lam.stringswitch
       (eliminate_ref id e)
       (List.map (fun (s, e) -> (s, eliminate_ref id e)) sw)
-      (Misc.may_map (eliminate_ref id) default)
+      (match default with 
+      | None -> None 
+      | Some x ->  Some (eliminate_ref id x))
   | Lstaticraise (i,args) ->
     Lam.staticraise i (List.map (eliminate_ref id) args)
   | Lstaticcatch(e1, i, e2) ->
@@ -95162,6 +95173,61 @@ let rec eliminate_ref id (lam : Lam.t) =
 
 
 
+end
+module Lam_pass_lets_dce : sig 
+#1 "lam_pass_lets_dce.mli"
+(***********************************************************************)
+(*                                                                     *)
+(*                                OCaml                                *)
+(*                                                                     *)
+(*            Xavier Leroy, projet Cristal, INRIA Rocquencourt         *)
+(*                                                                     *)
+(*  Copyright 1996 Institut National de Recherche en Informatique et   *)
+(*  en Automatique.  All rights reserved.  This file is distributed    *)
+(*  under the terms of the Q Public License version 1.0.               *)
+(*                                                                     *)
+(***********************************************************************)
+(* Adapted for Javascript backend: Hongbo Zhang                        *)
+
+(**
+   This pass would do beta reduction, and dead code elimination (adapted from compiler's built-in [Simplif] module )
+
+   1. beta reduction -> Llet (Strict )
+  
+   2. The global table [occ] associates to each let-bound identifier
+   the number of its uses (as a reference):
+     - 0 if never used
+     - 1 if used exactly once in and *not under a lambda or within a loop
+     - > 1 if used several times or under a lambda or within a loop.
+
+   The local table [bv] associates to each locally-let-bound variable
+   its reference count, as above.  [bv] is enriched at let bindings
+   but emptied when crossing lambdas and loops. 
+
+   For this pass, when it' used under a lambda or within a loop, we don't do anything,
+   in theory, we can still do something if it's pure but we are conservative here.
+
+   [bv] is used to help caculate [occ] it is not useful outside
+
+ *)
+val simplify_lets :  Lam.t -> Lam.t
+
+end = struct
+#1 "lam_pass_lets_dce.ml"
+(***********************************************************************)
+(*                                                                     *)
+(*                                OCaml                                *)
+(*                                                                     *)
+(*            Xavier Leroy, projet Cristal, INRIA Rocquencourt         *)
+(*                                                                     *)
+(*  Copyright 1996 Institut National de Recherche en Informatique et   *)
+(*  en Automatique.  All rights reserved.  This file is distributed    *)
+(*  under the terms of the Q Public License version 1.0.               *)
+(*                                                                     *)
+(***********************************************************************)
+(* Adapted for Javascript backend : Hongbo Zhang,  *)
+
+
 let lets_helper (count_var : Ident.t -> Lam_pass_count.used_info) lam = 
   let subst : Lam.t Ident_hashtbl.t = Ident_hashtbl.create 32 in
   let string_table : string Ident_hashtbl.t = Ident_hashtbl.create 32 in  
@@ -95183,8 +95249,9 @@ let lets_helper (count_var : Ident.t -> Lam_pass_count.used_info) lam =
       begin 
         try (** TODO: record all references variables *)
           Lam_util.refine_let
-            ~kind:Variable v slinit (eliminate_ref v slbody)
-        with Real_reference ->
+            ~kind:Variable v slinit
+             (Lam_pass_eliminate_ref.eliminate_ref v slbody)
+        with Lam_pass_eliminate_ref.Real_reference ->
           Lam_util.refine_let 
             ~kind v (Lam.prim ~primitive ~args:[slinit] loc)
             slbody
@@ -95344,15 +95411,19 @@ let lets_helper (count_var : Ident.t -> Lam_pass_count.used_info) lam =
       let new_l = simplif l
       and new_consts =  List.map (fun (n, e) -> (n, simplif e)) sw.sw_consts
       and new_blocks =  List.map (fun (n, e) -> (n, simplif e)) sw.sw_blocks
-      and new_fail = Misc.may_map simplif sw.sw_failaction in
+      and new_fail = 
+        match sw.sw_failaction with 
+        | None -> None 
+        | Some x -> Some (simplif x)
+      in
       Lam.switch
         new_l
         {sw with sw_consts = new_consts ; sw_blocks = new_blocks;
                  sw_failaction = new_fail}
     | Lstringswitch (l,sw,d) ->
       Lam.stringswitch
         (simplif l) (List.map (fun (s,l) -> s,simplif l) sw)
-        (Misc.may_map simplif d)
+        (match d with None -> None | Some d -> Some (simplif d))
     | Lstaticraise (i,ls) ->
       Lam.staticraise i (List.map simplif ls)
     | Lstaticcatch(l1, (i,args), l2) ->

jscomp/core/lam_pass_eliminate_ref.ml

@@ -0,0 +1,119 @@
+(***********************************************************************)
+(*                                                                     *)
+(*                                OCaml                                *)
+(*                                                                     *)
+(*            Xavier Leroy, projet Cristal, INRIA Rocquencourt         *)
+(*                                                                     *)
+(*  Copyright 1996 Institut National de Recherche en Informatique et   *)
+(*  en Automatique.  All rights reserved.  This file is distributed    *)
+(*  under the terms of the Q Public License version 1.0.               *)
+(*                                                                     *)
+(***********************************************************************)
+(* Adapted for Javascript backend : Hongbo Zhang,  *)
+
+
+
+
+exception Real_reference
+
+let rec eliminate_ref id (lam : Lam.t) = 
+  match lam with  (** we can do better escape analysis in Javascript backend *)
+  | Lvar v ->
+    if Ident.same v id then raise_notrace Real_reference else lam
+  | Lprim {primitive = Pfield (0,_); args =  [Lvar v]} when Ident.same v id ->
+    Lam.var id
+  | Lfunction{ kind; params; body} as lam ->
+    if Ident_set.mem id (Lam.free_variables  lam)
+    then raise_notrace Real_reference
+    else lam
+  (* In Javascript backend, its okay, we can reify it later
+     a failed case 
+     {[
+       for i = .. 
+           let v = ref 0 
+               for j = .. 
+                   incr v 
+                     a[j] = ()=>{!v}
+
+     ]}
+     here v is captured by a block, and it's a loop mutable value,
+     we have to generate 
+     {[
+       for i = .. 
+           let v = ref 0 
+               (function (v){for j = .. 
+                                   a[j] = ()=>{!v}}(v)
+
+     ]}
+     now, v is a real reference 
+     TODO: we can refine analysis in later
+  *)
+  (* Lfunction(kind, params, eliminate_ref id body) *)
+  | Lprim {primitive = Psetfield(0, _,_); 
+           args =  [Lvar v; e]} when Ident.same v id ->
+    Lam.assign id (eliminate_ref id e)
+  | Lprim {primitive = Poffsetref delta ; 
+           args =  [Lvar v]; loc } when Ident.same v id ->
+    Lam.assign id (Lam.prim ~primitive:(Poffsetint delta) ~args:[Lam.var id] loc)
+  | Lconst _  -> lam
+  | Lapply{fn = e1; args =  el;  loc; status} ->
+    Lam.apply 
+      (eliminate_ref id e1)
+      (List.map (eliminate_ref id) el)
+      loc status
+  | Llet(str, v, e1, e2) ->
+    Lam.let_ str v (eliminate_ref id e1) (eliminate_ref id e2)
+  | Lletrec(idel, e2) ->
+    Lam.letrec
+      (List.map (fun (v, e) -> (v, eliminate_ref id e)) idel)
+      (eliminate_ref id e2)
+  | Lprim {primitive ; args ; loc} ->
+    Lam.prim  ~primitive ~args:(List.map (eliminate_ref id) args) loc
+  | Lswitch(e, sw) ->
+    Lam.switch(eliminate_ref id e)
+      {sw_numconsts = sw.sw_numconsts;
+       sw_consts =
+         List.map (fun (n, e) -> (n, eliminate_ref id e)) sw.sw_consts;
+       sw_numblocks = sw.sw_numblocks;
+       sw_blocks =
+         List.map (fun (n, e) -> (n, eliminate_ref id e)) sw.sw_blocks;
+       sw_failaction =
+         match sw.sw_failaction with 
+         | None -> None 
+         | Some x -> Some (eliminate_ref id x)
+          }
+  | Lstringswitch(e, sw, default) ->
+    Lam.stringswitch
+      (eliminate_ref id e)
+      (List.map (fun (s, e) -> (s, eliminate_ref id e)) sw)
+      (match default with 
+      | None -> None 
+      | Some x ->  Some (eliminate_ref id x))
+  | Lstaticraise (i,args) ->
+    Lam.staticraise i (List.map (eliminate_ref id) args)
+  | Lstaticcatch(e1, i, e2) ->
+    Lam.staticcatch (eliminate_ref id e1) i (eliminate_ref id e2)
+  | Ltrywith(e1, v, e2) ->
+    Lam.try_ (eliminate_ref id e1) v (eliminate_ref id e2)
+  | Lifthenelse(e1, e2, e3) ->
+    Lam.if_ (eliminate_ref id e1) (eliminate_ref id e2) (eliminate_ref id e3)
+  | Lsequence(e1, e2) ->
+    Lam.seq (eliminate_ref id e1) (eliminate_ref id e2)
+  | Lwhile(e1, e2) ->
+    Lam.while_ (eliminate_ref id e1) (eliminate_ref id e2)
+  | Lfor(v, e1, e2, dir, e3) ->
+    Lam.for_ v
+      (eliminate_ref id e1) 
+      (eliminate_ref id e2)
+      dir
+      (eliminate_ref id e3)
+  | Lassign(v, e) ->
+    Lam.assign v (eliminate_ref id e)
+  | Lsend(k, m, o, el, loc) ->
+    Lam.send k 
+      (eliminate_ref id m) (eliminate_ref id o)
+      (List.map (eliminate_ref id) el) loc
+  | Lifused(v, e) ->
+    Lam.ifused v (eliminate_ref id e)
+
+