snapshot

Author: bobzhang

lib/4.06.1/unstable/js_compiler.ml

@@ -83962,27 +83962,26 @@ and statement_desc =
         * Js_closure.t  
   | Continue of label 
   | Break (* only used when inline a fucntion *)
-  | Return of return_expression   (* Here we need track back a bit ?, move Return to Function ...
+  | Return of expression   (* Here we need track back a bit ?, move Return to Function ...
                               Then we can only have one Return, which is not good *)
-  | Int_switch of expression * int case_clause list * block option 
-  | String_switch of expression * string case_clause list * block option 
-  | Throw of expression
-  | Try of block * (exception_ident * block) option * block option
-  | Debugger
-and return_expression = {
- (* since in ocaml, it's expression oriented langauge, [return] in
+    (* since in ocaml, it's expression oriented langauge, [return] in
     general has no jumps, it only happens when we do 
     tailcall conversion, in that case there is a jump.
     However, currently  a single [break] is good to cover
     our compilation strategy 
-
     Attention: we should not insert [break] arbitrarily, otherwise 
     it would break the semantics
     A more robust signature would be 
     {[ goto : label option ; ]}
   *)
-  return_value : expression
-}   
+
+  | Int_switch of expression * int case_clause list * block option 
+  | String_switch of expression * string case_clause list * block option 
+  | Throw of expression
+  | Try of block * (exception_ident * block) option * block option
+  | Debugger
+
+
 
 and expression = {
   expression_desc : expression_desc; 
@@ -84668,7 +84667,7 @@ class virtual fold =
           let o = o#block _x_i4 in let o = o#unknown _x_i5 in o
       | Continue _x -> let o = o#label _x in o
       | Break -> o
-      | Return _x -> let o = o#return_expression _x in o
+      | Return _x -> let o = o#expression _x in o
       | Int_switch (_x, _x_i1, _x_i2) ->
           let o = o#expression _x in
           let o =
@@ -84865,6 +84864,16 @@ class virtual fold =
                  (* only used when inline a fucntion *)
                  (* Here we need track back a bit ?, move Return to Function ...
                               Then we can only have one Return, which is not good *)
+                 (* since in ocaml, it's expression oriented langauge, [return] in
+    general has no jumps, it only happens when we do 
+    tailcall conversion, in that case there is a jump.
+    However, currently  a single [break] is good to cover
+    our compilation strategy 
+    Attention: we should not insert [break] arbitrarily, otherwise 
+    it would break the semantics
+    A more robust signature would be 
+    {[ goto : label option ; ]}
+  *)
                  o#case_clause (fun o -> o#int))
               _x_i1 in
           let o = o#option (fun o -> o#block) _x_i2 in o
@@ -84887,8 +84896,6 @@ class virtual fold =
       fun { statement_desc = _x; comment = _x_i1 } ->
         let o = o#statement_desc _x in
         let o = o#option (fun o -> o#string) _x_i1 in o
-    method return_expression : return_expression -> 'self_type =
-      fun { return_value = _x } -> let o = o#expression _x in o
     method required_modules : required_modules -> 'self_type = o#unknown
     method property_name : property_name -> 'self_type = o#unknown
     method property_map : property_map -> 'self_type =
@@ -84987,18 +84994,7 @@ class virtual fold =
         let o = o#required_modules _x_i1 in
         let o = o#option (fun o -> o#string) _x_i2 in o
     method case_clause :
-      (* since in ocaml, it's expression oriented langauge, [return] in
-    general has no jumps, it only happens when we do 
-    tailcall conversion, in that case there is a jump.
-    However, currently  a single [break] is good to cover
-    our compilation strategy 
-
-    Attention: we should not insert [break] arbitrarily, otherwise 
-    it would break the semantics
-    A more robust signature would be 
-    {[ goto : label option ; ]}
-  *)
-        'a. ('self_type -> 'a -> 'self_type) -> 'a case_clause -> 'self_type =
+      'a. ('self_type -> 'a -> 'self_type) -> 'a case_clause -> 'self_type =
       fun _f_a
         {
           switch_case = _x;
@@ -85413,9 +85409,9 @@ and eq_statement
       | Exp b -> eq_expression a b 
       | _ -> false
     end
-  | Return { return_value = a ; _} -> 
+  | Return a  -> 
     begin match y0 with 
-      | Return { return_value = b; _} ->
+      | Return b ->
         eq_expression a b
       | _ -> false 
     end
@@ -87568,7 +87564,7 @@ let of_block ?comment ?e block : t =
                | None -> block 
                | Some e -> 
                  Ext_list.append block  
-                   [{J.statement_desc = Return {return_value = e } ;
+                   [{J.statement_desc = Return e  ;
                      comment}]
              end
             , Js_fun_env.make 0)
@@ -88246,14 +88242,14 @@ and  pp_function ~is_method
     (l : Ident.t list) (b : J.block) (env : Js_fun_env.t ) : cxt =
   match b  with
   | [ {statement_desc =
-         Return {return_value =
+         Return 
                    {expression_desc =
                       Call(({expression_desc = Var v ; _} as function_id),
                            ls ,
                            {arity = ( Full | NA as arity(* see #234*));
                             (* TODO: need a case to justify it*)
                             call_info =
-                              (Call_builtin_runtime | Call_ml )})}}}]
+                              (Call_builtin_runtime | Call_ml )})}}]
     when
       (* match such case:
          {[ function(x,y){ return u(x,y) } ]}
@@ -89116,7 +89112,7 @@ and statement_desc top cxt f (s : J.statement_desc) : cxt =
   | Debugger ->  debugger_nl f ; cxt
   | Break -> break_nl f; cxt
 
-  | Return {return_value = e} ->
+  | Return e ->
     begin match e.expression_desc with
       | Fun (is_method,  l, b, env) ->
         let cxt =
@@ -89213,10 +89209,10 @@ and function_body (cxt : cxt) f (b : J.block) : unit =
           then_,
            [{
               statement_desc =
-                Return {return_value = {expression_desc = Undefined}} }])
+                Return {expression_desc = Undefined}} ])
         ->
         ignore (statement false cxt f {s with statement_desc = If(bool,then_, [])} : cxt)
-    | Return {return_value = {expression_desc = Undefined }} -> ()    
+    | Return {expression_desc = Undefined } -> ()    
     | _ ->        
       ignore (statement false  cxt f  s : cxt)
     end
@@ -100866,7 +100862,7 @@ module E = Js_exp_make
 type t = J.statement 
 
 let return_stmt ?comment e : t = 
-  {statement_desc = Return {return_value = e; } ; comment}
+  {statement_desc = Return  e; comment}
 
 
 let empty_stmt  : t = 
@@ -101065,8 +101061,8 @@ let if_ ?comment  ?declaration ?else_ (e : J.expression) (then_ : J.block)   : t
       |  [], [] -> exp e 
       |  [], _ ->
          aux ?comment (E.not e) ifnot [] (*Make sure no infinite loop*)        
-      | [ {statement_desc = Return {return_value = ret_ifso; _}; _}], 
-        [ {statement_desc = Return {return_value = ret_ifnot; _}; _}]
+      | [ {statement_desc = Return ret_ifso; _}], 
+        [ {statement_desc = Return ret_ifnot; _}]
         ->      
         return_stmt (E.econd e ret_ifso ret_ifnot ) 
       | _, [{statement_desc = Return _ }]
@@ -102845,7 +102841,7 @@ class virtual map =
           in ForRange (_x, _x_i1, _x_i2, _x_i3, _x_i4, _x_i5)
       | Continue _x -> let _x = o#label _x in Continue _x
       | Break -> Break
-      | Return _x -> let _x = o#return_expression _x in Return _x
+      | Return _x -> let _x = o#expression _x in Return _x
       | Int_switch (_x, _x_i1, _x_i2) ->
           let _x = o#expression _x in
           let _x_i1 =
@@ -103042,6 +103038,16 @@ class virtual map =
                  (* only used when inline a fucntion *)
                  (* Here we need track back a bit ?, move Return to Function ...
                               Then we can only have one Return, which is not good *)
+                 (* since in ocaml, it's expression oriented langauge, [return] in
+    general has no jumps, it only happens when we do 
+    tailcall conversion, in that case there is a jump.
+    However, currently  a single [break] is good to cover
+    our compilation strategy 
+    Attention: we should not insert [break] arbitrarily, otherwise 
+    it would break the semantics
+    A more robust signature would be 
+    {[ goto : label option ; ]}
+  *)
                  o#case_clause (fun o -> o#int))
               _x_i1 in
           let _x_i2 = o#option (fun o -> o#block) _x_i2
@@ -103069,9 +103075,6 @@ class virtual map =
         let _x = o#statement_desc _x in
         let _x_i1 = o#option (fun o -> o#string) _x_i1
         in { statement_desc = _x; comment = _x_i1; }
-    method return_expression : return_expression -> return_expression =
-      fun { return_value = _x } ->
-        let _x = o#expression _x in { return_value = _x; }
     method required_modules : required_modules -> required_modules =
       o#unknown
     method property_name : property_name -> property_name = o#unknown
@@ -103192,18 +103195,7 @@ class virtual map =
         let _x_i2 = o#option (fun o -> o#string) _x_i2
         in { program = _x; modules = _x_i1; side_effect = _x_i2; }
     method case_clause :
-      (* since in ocaml, it's expression oriented langauge, [return] in
-    general has no jumps, it only happens when we do 
-    tailcall conversion, in that case there is a jump.
-    However, currently  a single [break] is good to cover
-    our compilation strategy 
-
-    Attention: we should not insert [break] arbitrarily, otherwise 
-    it would break the semantics
-    A more robust signature would be 
-    {[ goto : label option ; ]}
-  *)
-        'a 'a_out.
+      'a 'a_out.
         ('self_type -> 'a -> 'a_out) -> 'a case_clause -> 'a_out case_clause =
       fun _f_a
         {
@@ -103349,12 +103341,12 @@ let flatten_map =
           | _ ->
               assert false
           end
-      | Return ( {return_value = {expression_desc = Cond (a,b,c);  comment}}) 
+      | Return {expression_desc = Cond (a,b,c);  comment}
         -> 
           { statement_desc = If (a, [self#statement (S.return_stmt b)],  
                                   [ self#statement (S.return_stmt c)]); comment}
 
-      | Return ({return_value = {expression_desc = Seq _; _} as v}) ->
+      | Return ({expression_desc = Seq _; _} as v) ->
           let block = Js_analyzer.rev_flatten_seq v  in
           begin match block with
           | {statement_desc = Exp last_one ; _} :: rest_rev
@@ -104416,9 +104408,9 @@ let subst (export_set : Set_ident.t) stats  =
           end
 
       | [{statement_desc = 
-           Return {return_value = 
+           Return 
                      {expression_desc = 
-                        Call({expression_desc = Var (Id id)},args,_info)}} } as st ]
+                        Call({expression_desc = Var (Id id)},args,_info)} } as st ]
         -> 
         begin match Hash_ident.find_opt stats id with 
 
@@ -104450,9 +104442,8 @@ let subst (export_set : Set_ident.t) stats  =
         end
 
       | [{statement_desc = 
-            Return {return_value = 
-                      {expression_desc = 
-                         Call({expression_desc = Fun (false, params, block, env)},args,_info)}} } ]
+            Return {expression_desc = 
+                         Call({expression_desc = Fun (false, params, block, env)},args,_info)}}  ]
 
             when Ext_list.same_length params args 
             ->