Use record type for Fun payload in j.ml.

cristianoc · cristianoc · commit b30d6dd29e3c · 2022-07-18T11:02:59.000+02:00
diff --git a/jscomp/core/j.ml b/jscomp/core/j.ml
@@ -32,27 +32,17 @@
 *)
 
 type mutable_flag = Js_op.mutable_flag
-
 type binop = Js_op.binop
-
 type int_op = Js_op.int_op
-
 type kind = Js_op.kind
-
 type property = Js_op.property
-
 type number = Js_op.number
-
 type ident_info = Js_op.ident_info
-
 type exports = Js_op.exports
-
 type tag_info = Js_op.tag_info
-
 type property_name = Js_op.property_name
 
 type label = string
-
 and ident = Ident.t
 (* we override `method ident` *)
 
@@ -64,7 +54,6 @@ and ident = Ident.t
 and module_id = { id : ident; kind : Js_op.kind }
 
 and required_modules = module_id list
-
 and vident = Id of ident | Qualified of module_id * string option
 (* Since camldot is only available for toplevel module accessors,
    we don't need print  `A.length$2`
@@ -83,13 +72,9 @@ and vident = Id of ident | Qualified of module_id * string option
 *)
 
 and exception_ident = ident
-
 and for_ident = ident
-
 and for_direction = Js_op.direction_flag
-
 and property_map = (property_name * expression) list
-
 and length_object = Js_op.length_object
 
 and expression_desc =
@@ -142,13 +127,15 @@ and expression_desc =
   *)
   | New of expression * expression list option (* TODO: option remove *)
   | Var of vident
-  | Fun of bool * ident list * block * Js_fun_env.t * bool * bool
-  (* The first parameter by default is false,
-     it will be true when it's a method
-     The second-last pararemter [true] return unit
-     The last pararemter [true] means async
-  *)
-  | Str of {delim: string option; txt: string}
+  | Fun of {
+      is_method : bool;
+      params : ident list;
+      body : block;
+      env : Js_fun_env.t;
+      return_unit : bool;
+      async : bool;
+    }
+  | Str of { delim : string option; txt : string }
   (* A string is UTF-8 encoded, and may contain
      escape sequences.
   *)
@@ -267,7 +254,6 @@ and case_clause = {
 }
 
 and string_clause = string * case_clause
-
 and int_clause = int * case_clause
 
 and statement_desc =
@@ -276,7 +262,8 @@ and statement_desc =
   (* Function declaration and Variable declaration  *)
   | Exp of expression
   | If of expression * block * block
-  | While of label option * expression * block * Js_closure.t (* check if it contains loop mutable values, happens in nested loop *)
+  | While of label option * expression * block * Js_closure.t
+    (* check if it contains loop mutable values, happens in nested loop *)
   | ForRange of
       for_ident_expression option
       * finish_ident_expression
@@ -286,8 +273,9 @@ and statement_desc =
       * Js_closure.t
   | Continue of label
   | Break (* only used when inline a fucntion *)
-  | 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 *)
+  | 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 *)
   (* 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.
@@ -305,7 +293,6 @@ and statement_desc =
   | Debugger
 
 and expression = { expression_desc : expression_desc; comment : string option }
-
 and statement = { statement_desc : statement_desc; comment : string option }
 
 and variable_declaration = {
@@ -319,7 +306,6 @@ and variable_declaration = {
    be concatenated in both ways
 *)
 and block = statement list
-
 and program = { block : block; exports : exports; export_set : Set_ident.t }
 
 and deps_program = {
diff --git a/jscomp/core/js_analyzer.ml b/jscomp/core/js_analyzer.ml
@@ -53,7 +53,7 @@ let free_variables (stats : idents_stats) =
     expression =
       (fun self exp ->
         match exp.expression_desc with
-        | Fun (_, _, _, env, _, _)
+        | Fun {env}
         (* a optimization to avoid walking into funciton again
             if it's already comuted
         *) ->
diff --git a/jscomp/core/js_dump.ml b/jscomp/core/js_dump.ml
@@ -93,13 +93,11 @@ module Curry_gen = struct
 end
 
 let return_indent = String.length L.return / Ext_pp.indent_length
-
 let throw_indent = String.length L.throw / Ext_pp.indent_length
 
 type cxt = Ext_pp_scope.t
 
 let semi f = P.string f L.semi
-
 let comma f = P.string f L.comma
 
 let exn_block_as_obj ~(stack : bool) (el : J.expression list) (ext : J.tag_info)
@@ -531,10 +529,10 @@ and expression_desc cxt ~(level : int) f x : cxt =
           let cxt = expression ~level:0 cxt f e1 in
           comma_sp f;
           expression ~level:0 cxt f e2)
-  | Fun (is_method, l, b, env, return_unit, async) ->
+  | Fun { is_method; params; body; env; return_unit; async } ->
       (* TODO: dump for comments *)
-      pp_function ~is_method cxt f ~fn_state:default_fn_exp_state l b env
-        ~return_unit ~async
+      pp_function ~is_method cxt f ~fn_state:default_fn_exp_state params body
+        env ~return_unit ~async
       (* TODO:
          when [e] is [Js_raw_code] with arity
          print it in a more precise way
@@ -555,12 +553,20 @@ and expression_desc cxt ~(level : int) f x : cxt =
                       | [
                        {
                          expression_desc =
-                           Fun (is_method, l, b, env, return_unit, async);
+                           Fun
+                             {
+                               is_method;
+                               params;
+                               body;
+                               env;
+                               return_unit;
+                               async;
+                             };
                        };
                       ] ->
                           pp_function ~is_method ~return_unit ~async cxt f
                             ~fn_state:(No_name { single_arg = true })
-                            l b env
+                            params body env
                       | _ -> arguments cxt f el)
               | _, _ ->
                   let len = List.length el in
@@ -587,16 +593,14 @@ and expression_desc cxt ~(level : int) f x : cxt =
           P.string f L.codePointAt;
           (* FIXME: use code_point_at *)
           P.paren_group f 1 (fun _ -> expression ~level:0 cxt f b))
-  | Str {delim; txt} ->
+  | Str { delim; txt } ->
       (*TODO --
          when utf8-> it will not escape '\\' which is definitely not we want
       *)
       if delim = Some "j" || delim = Some "*j" then
         P.string f ("\"" ^ txt ^ "\"")
-      else if delim = Some "json" then
-        P.string f txt
-      else
-        Js_dump_string.pp_string f txt;
+      else if delim = Some "json" then P.string f txt
+      else Js_dump_string.pp_string f txt;
       cxt
   | Raw_js_code { code = s; code_info = info } -> (
       match info with
@@ -902,10 +906,10 @@ and variable_declaration top cxt f (variable : J.variable_declaration) : cxt =
           statement_desc top cxt f (J.Exp e)
       | _ -> (
           match e.expression_desc with
-          | Fun (is_method, params, b, env, return_unit, async) ->
+          | Fun { is_method; params; body; env; return_unit; async } ->
               pp_function ~is_method cxt f ~return_unit ~async
                 ~fn_state:(if top then Name_top name else Name_non_top name)
-                params b env
+                params body env
           | _ ->
               let cxt = pp_var_assign cxt f name in
               let cxt = expression ~level:1 cxt f e in
@@ -1129,10 +1133,10 @@ and statement_desc top cxt f (s : J.statement_desc) : cxt =
       cxt
   | Return e -> (
       match e.expression_desc with
-      | Fun (is_method, l, b, env, return_unit, async) ->
+      | Fun { is_method; params; body; env; return_unit; async } ->
           let cxt =
             pp_function ~return_unit ~is_method ~async cxt f ~fn_state:Is_return
-              l b env
+              params body env
           in
           semi f;
           cxt
diff --git a/jscomp/core/js_exp_make.ml b/jscomp/core/js_exp_make.ml
@@ -197,20 +197,35 @@ let unit : t = { expression_desc = Undefined; comment = None }
    [Js_fun_env.empty] is a mutable state ..
 *)
 
-let ocaml_fun ?comment ?immutable_mask ~return_unit ~async params block : t =
+let ocaml_fun ?comment ?immutable_mask ~return_unit ~async params body : t =
   let len = List.length params in
   {
     expression_desc =
       Fun
-        (false, params, block, Js_fun_env.make ?immutable_mask len, return_unit, async);
+        {
+          is_method = false;
+          params;
+          body;
+          env = Js_fun_env.make ?immutable_mask len;
+          return_unit;
+          async;
+        };
     comment;
   }
 
-let method_ ?comment ?immutable_mask ~return_unit params block : t =
+let method_ ?comment ?immutable_mask ~return_unit params body : t =
   let len = List.length params in
   {
     expression_desc =
-      Fun (true, params, block, Js_fun_env.make ?immutable_mask len, return_unit, false);
+      Fun
+        {
+          is_method = true;
+          params;
+          body;
+          env = Js_fun_env.make ?immutable_mask len;
+          return_unit;
+          async = false;
+        };
     comment;
   }
 
@@ -484,10 +499,10 @@ let bytes_length ?comment (e : t) : t =
 
 let function_length ?comment (e : t) : t =
   match e.expression_desc with
-  | Fun (b, params, _, _, _, _) ->
+  | Fun { is_method; params } ->
       let params_length = List.length params in
       int ?comment
-        (Int32.of_int (if b then params_length - 1 else params_length))
+        (Int32.of_int (if is_method then params_length - 1 else params_length))
   | _ -> { expression_desc = Length (e, Function); comment }
 
 (** no dependency introduced *)
@@ -1150,15 +1165,19 @@ let of_block ?comment ?e block : t =
       comment;
       expression_desc =
         Fun
-          ( false,
-            [],
-            (match e with
-            | None -> block
-            | Some e ->
-                Ext_list.append block
-                  [ { J.statement_desc = Return e; comment } ]),
-            Js_fun_env.make 0,
-            return_unit, (* async *) false);
+          {
+            is_method = false;
+            params = [];
+            body =
+              (match e with
+              | None -> block
+              | Some e ->
+                  Ext_list.append block
+                    [ { J.statement_desc = Return e; comment } ]);
+            env = Js_fun_env.make 0;
+            return_unit;
+            async = false;
+          };
     }
     []
 
diff --git a/jscomp/core/js_fold.ml b/jscomp/core/js_fold.ml
@@ -146,9 +146,9 @@ class fold =
       | Var _x0 ->
           let _self = _self#vident _x0 in
           _self
-      | Fun (_x0, _x1, _x2, _x3, _x4, _x5) ->
-          let _self = list (fun _self -> _self#ident) _self _x1 in
-          let _self = _self#block _x2 in
+      | Fun {params=x1; body=x2} ->
+          let _self = list (fun _self -> _self#ident) _self x1 in
+          let _self = _self#block x2 in
           _self
       | Str _ -> _self
       | Raw_js_code _ -> _self
diff --git a/jscomp/core/js_pass_scope.ml b/jscomp/core/js_pass_scope.ml
@@ -137,7 +137,7 @@ let record_scope_pass =
     expression =
       (fun self state x ->
         match x.expression_desc with
-        | Fun (_method_, params, block, env, _return_unit, _async) ->
+        | Fun {params; body; env} ->
             (* Function is the only place to introduce a new scope in
                 ES5
                 TODO: check
@@ -155,7 +155,7 @@ let record_scope_pass =
                   mutable_values =
                     Set_ident.of_list (Js_fun_env.get_mutable_params params env);
                 }
-                block
+                body
             in
             (* let defined_idents', used_idents' =
                obj#get_defined_idents, obj#get_used_idents  in *)
diff --git a/jscomp/core/js_pass_tailcall_inline.ml b/jscomp/core/js_pass_tailcall_inline.ml
@@ -165,7 +165,7 @@ let subst (export_set : Set_ident.t) stats =
                      Some
                        {
                          expression_desc =
-                           Fun (false, params, block, env, _return_unit, _async);
+                           Fun {is_method=false; params; body; env};
                          comment = _;
                        };
                    (*TODO: don't inline method tail call yet,
@@ -179,7 +179,7 @@ let subst (export_set : Set_ident.t) stats =
                 Js_op_util.update_used_stats v.ident_info Dead_pure;
                 let no_tailcall = Js_fun_env.no_tailcall env in
                 let processed_blocks =
-                  self.block self block
+                  self.block self body
                   (* see #278 before changes*)
                 in
                 inline_call no_tailcall params args processed_blocks
@@ -200,7 +200,7 @@ let subst (export_set : Set_ident.t) stats =
                    Call
                      ( {
                          expression_desc =
-                           Fun (false, params, block, env, _return_unit, _async);
+                           Fun {is_method=false; params; body; env};
                        },
                        args,
                        _info );
@@ -210,7 +210,7 @@ let subst (export_set : Set_ident.t) stats =
           when Ext_list.same_length params args ->
             let no_tailcall = Js_fun_env.no_tailcall env in
             let processed_blocks =
-              self.block self block
+              self.block self body
               (* see #278 before changes*)
             in
             inline_call no_tailcall params args processed_blocks
diff --git a/jscomp/core/js_record_fold.ml b/jscomp/core/js_record_fold.ml
@@ -152,9 +152,9 @@ let expression_desc : 'a. ('a, expression_desc) fn =
   | Var _x0 ->
       let st = _self.vident _self st _x0 in
       st
-  | Fun (_x0, _x1, _x2, _x3, _x4, _x5) ->
-      let st = list _self.ident _self st _x1 in
-      let st = _self.block _self st _x2 in
+  | Fun {params; body} ->
+      let st = list _self.ident _self st params in
+      let st = _self.block _self st body in
       st
   | Str _ -> st
   | Raw_js_code _ -> st
diff --git a/jscomp/core/js_record_iter.ml b/jscomp/core/js_record_iter.ml
@@ -118,9 +118,9 @@ let expression_desc : expression_desc fn =
       _self.expression _self _x0;
       option (fun _self arg -> list _self.expression _self arg) _self _x1
   | Var _x0 -> _self.vident _self _x0
-  | Fun (_x0, _x1, _x2, _x3, _x4, _x5) ->
-      list _self.ident _self _x1;
-      _self.block _self _x2
+  | Fun {params; body} ->
+      list _self.ident _self params;
+      _self.block _self body
   | Str _ -> ()
   | Raw_js_code _ -> ()
   | Array (_x0, _x1) -> list _self.expression _self _x0
diff --git a/jscomp/core/js_record_map.ml b/jscomp/core/js_record_map.ml
diff --git a/lib/4.06.1/unstable/js_compiler.ml b/lib/4.06.1/unstable/js_compiler.ml
diff --git a/lib/4.06.1/unstable/js_playground_compiler.ml b/lib/4.06.1/unstable/js_playground_compiler.ml
diff --git a/lib/4.06.1/whole_compiler.ml b/lib/4.06.1/whole_compiler.ml
