continue eleminate intermediate variables

Author: bobzhang

Diff for: jscomp/core/js_fun_env.ml

@@ -69,7 +69,9 @@ let make ?immutable_mask n = {
 }
 
  let no_tailcall x = 
-  x.immutable_mask = All_immutable_and_no_tail_call 
+  match x.immutable_mask with
+  | All_immutable_and_no_tail_call -> []
+  | Immutable_mask arr -> Array.to_list arr 
 
 let mark_unused  t i = 
   t.used_mask.(i) <- true

Diff for: jscomp/core/js_fun_env.mli

@@ -37,7 +37,7 @@ type t
 
 val make :  ?immutable_mask:bool array  -> int -> t
 
-val no_tailcall : t -> bool
+val no_tailcall : t -> bool list
 
 (* val is_empty : t -> bool  *)
 

Diff for: jscomp/core/js_pass_tailcall_inline.ml

@@ -55,37 +55,40 @@ let substitue_variables (map : Ident.t Map_ident.t) =
     since we have to guarantee that the one use
     case is substituted
     we already have this? in [defined_idents]
+
+    At this time, when tailcall happened, the parameter can be assigned
+      for example {[
+     function (_x,y){
+         _x = u
+       }
+   ]}
+      if it is substitued, the assignment will align the value which is incorrect
 *)
 
 let inline_call
-  no_tailcall 
-  params (args : J.expression list) processed_blocks =  
-  if no_tailcall then   
-    let map, block =   
+    (immutable_list : bool list)
+    params (args : J.expression list) processed_blocks =    
+  let map, block =   
+    if immutable_list = [] then     
       Ext_list.fold_right2 
         params args  (Map_ident.empty,  processed_blocks)
         (fun param arg (map,acc) ->  
            match arg.expression_desc with 
            | Var (Id id) ->  
              Map_ident.add map param id, acc 
            | _ -> 
-             map, S.define_variable ~kind:Variable param arg :: acc) in 
-    if Map_ident.is_empty map then block 
-    else (substitue_variables map) # block block        
-  else    
-  (*
-      At this time, when tailcall happened, the parameter can be assigned
-      for example {[
-        function (_x,y){
-          _x = u
-        }
-      ]}
-      if it is substitued, the assignment will align the value which is incorrect
-  *)
-    Ext_list.fold_right2 
-      params args  processed_blocks
-      (fun param arg acc ->  
-         S.define_variable ~kind:Variable param arg :: acc) 
+             map, S.define_variable ~kind:Variable param arg :: acc) 
+    else      
+      Ext_list.fold_right3 
+        params args  immutable_list (Map_ident.empty,  processed_blocks)
+        (fun param arg mask (map,acc) ->  
+           match mask, arg.expression_desc with 
+           | true, Var (Id id) ->  
+             Map_ident.add map param id, acc 
+           | _ -> 
+             map, S.define_variable ~kind:Variable param arg :: acc) in
+  if Map_ident.is_empty map then block 
+  else (substitue_variables map) # block block  
 
 (** There is a side effect when traversing dead code, since 
     we assume that substitue a node would mark a node as dead node,

Diff for: jscomp/ext/ext_list.ml

@@ -244,6 +244,20 @@ let rec fold_right2 l r acc f =
     f a0 b0 (f a1 b1 (f a2 b2 (f a3 b3 (f a4 b4 (fold_right2 arest brest acc f )))))  
   | _, _ -> invalid_arg "Ext_list.fold_right2"
 
+let rec fold_right3 l r last acc f = 
+  match l,r,last  with  
+  | [],[],[] -> acc 
+  | [a0],[b0],[c0] -> f a0 b0 c0 acc 
+  | [a0;a1],[b0;b1],[c0; c1] -> f a0 b0 c0 (f a1 b1 c1 acc)
+  | [a0;a1;a2],[b0;b1;b2],[c0;c1;c2] -> f a0 b0 c0 (f a1 b1 c1 (f a2 b2 c2 acc))
+  | [a0;a1;a2;a3],[b0;b1;b2;b3],[c0;c1;c2;c3] ->
+    f a0 b0 c0 (f a1 b1 c1 (f a2 b2 c2 (f a3 b3 c3 acc))) 
+  | [a0;a1;a2;a3;a4], [b0;b1;b2;b3;b4], [c0;c1;c2;c3;c4] -> 
+    f a0 b0 c0 (f a1 b1 c1 (f a2 b2 c2 (f a3 b3 c3 (f a4 b4 c4 acc))))
+  | a0::a1::a2::a3::a4::arest, b0::b1::b2::b3::b4::brest, c0::c1::c2::c3::c4::crest -> 
+    f a0 b0 c0 (f a1 b1 c1 (f a2 b2 c2 (f a3 b3 c3 (f a4 b4 c4 (fold_right3 arest brest crest acc f )))))  
+  | _, _, _ -> invalid_arg "Ext_list.fold_right2"
+
 let rec map2  l r f = 
   match l,r  with  
   | [],[] -> []

Diff for: jscomp/ext/ext_list.mli

@@ -95,6 +95,15 @@ val fold_right2 :
   'c -> 
   ('a -> 'b -> 'c -> 'c) ->  'c
 
+val fold_right3 : 
+  'a list -> 
+  'b list -> 
+  'c list -> 
+  'd -> 
+  ('a -> 'b -> 'c -> 'd -> 'd) -> 
+  'd
+  
+  
 val map2 : 
   'a list ->
   'b list ->

Diff for: jscomp/test/ast_js_mapper_test.js

@@ -41,12 +41,10 @@ tFromJs({
 
 function searchForSureExists(xs, k) {
   var _i = 0;
-  var xs$1 = xs;
-  var k$1 = k;
   while(true) {
     var i = _i;
-    var match = xs$1[i];
-    if (match[0] === k$1) {
+    var match = xs[i];
+    if (match[0] === k) {
       return match[1];
     }
     _i = i + 1 | 0;

Diff for: jscomp/test/ext_array_test.js

@@ -214,10 +214,9 @@ function rfind_and_split(arr, cmp, v) {
 function find_with_index(arr, cmp, v) {
   var len = arr.length;
   var _i = 0;
-  var len$1 = len;
   while(true) {
     var i = _i;
-    if (i >= len$1) {
+    if (i >= len) {
       return -1;
     }
     if (Curry._2(cmp, arr[i], v)) {

Diff for: jscomp/test/ext_string_test.js

@@ -352,15 +352,13 @@ function tail_from(s, x) {
 function digits_of_str(s, offset, x) {
   var _i = 0;
   var _acc = 0;
-  var s$1 = s;
-  var x$1 = x;
   while(true) {
     var acc = _acc;
     var i = _i;
-    if (i >= x$1) {
+    if (i >= x) {
       return acc;
     }
-    _acc = (Caml_int32.imul(10, acc) + Caml_string.get(s$1, offset + i | 0) | 0) - 48 | 0;
+    _acc = (Caml_int32.imul(10, acc) + Caml_string.get(s, offset + i | 0) | 0) - 48 | 0;
     _i = i + 1 | 0;
     continue ;
   };