make fmt

Author: Ekdohibs

middle_end/flambda2/compare/compare.ml

@@ -631,16 +631,26 @@ let unary_prim_ops env (prim_op1 : Flambda_primitive.unary_primitive)
            Flambda_primitive.Project_function_slot
              { move_from = move_from1'; move_to = move_to1' })
   | ( Project_value_slot
-        { project_from = function_slot1; value_slot = value_slot1; kind = kind1 },
+        { project_from = function_slot1;
+          value_slot = value_slot1;
+          kind = kind1
+        },
       Project_value_slot
-        { project_from = function_slot2; value_slot = value_slot2; kind = kind2 } ) ->
-    triples ~f1:function_slots ~f2:value_slots ~f3:(Comparator.of_predicate Flambda_kind.With_subkind.equal)
+        { project_from = function_slot2;
+          value_slot = value_slot2;
+          kind = kind2
+        } ) ->
+    triples ~f1:function_slots ~f2:value_slots
+      ~f3:(Comparator.of_predicate Flambda_kind.With_subkind.equal)
       env
       (function_slot1, value_slot1, kind1)
       (function_slot2, value_slot2, kind2)
     |> Comparison.map ~f:(fun (function_slot1', value_slot1', kind1') ->
            Flambda_primitive.Project_value_slot
-             { project_from = function_slot1'; value_slot = value_slot1'; kind = kind1' })
+             { project_from = function_slot1';
+               value_slot = value_slot1';
+               kind = kind1'
+             })
   | _, _ ->
     if Flambda_primitive.equal_unary_primitive prim_op1 prim_op2
     then Equivalent

middle_end/flambda2/from_lambda/closure_conversion.ml

@@ -59,7 +59,10 @@ let declare_symbol_for_function_slot env ident function_slot : Env.t * Symbol.t
       (Compilation_unit.get_current_exn ())
       (Linkage_name.of_string (Function_slot.to_string function_slot))
   in
-  let env = Env.add_simple_to_substitute env ident (Simple.symbol symbol) K.With_subkind.any_value in
+  let env =
+    Env.add_simple_to_substitute env ident (Simple.symbol symbol)
+      K.With_subkind.any_value
+  in
   env, symbol
 
 let register_const0 acc constant name =
@@ -726,7 +729,8 @@ let close_named acc env ~let_bound_var (named : IR.named)
       (fun acc named -> k acc (Some named))
   | Prim { prim; args; loc; exn_continuation; region } ->
     close_primitive acc env ~let_bound_var named prim ~args loc exn_continuation
-      ~current_region:(fst (Env.find_var env region)) k
+      ~current_region:(fst (Env.find_var env region))
+      k
 
 let close_let acc env id user_visible kind defining_expr
     ~(body : Acc.t -> Env.t -> Expr_with_acc.t) : Expr_with_acc.t =
@@ -798,7 +802,8 @@ let close_let acc env id user_visible kind defining_expr
               (* In spirit, this is the same as the simple case but more
                  cumbersome to detect, we have to remove the now useless
                  let-binding later. *)
-              Some (Env.add_simple_to_substitute env id (Simple.symbol sym) kind)
+              Some
+                (Env.add_simple_to_substitute env id (Simple.symbol sym) kind)
             | _ ->
               Some (Env.add_value_approximation body_env (Name.var var) approx))
           )
@@ -830,17 +835,16 @@ let close_let_cont acc env ~name ~is_exn_handler ~params
       Misc.fatal_errorf
         "[Let_cont]s marked as exception handlers must be [Nonrecursive]: %a"
         Continuation.print name);
-  let params_with_kinds = List.map (fun (param, user_visible, kind) ->
-      (param, user_visible, K.With_subkind.from_lambda kind)
-    ) params
-  in
-  let handler_env, params =
-    Env.add_vars_like env params_with_kinds
+  let params_with_kinds =
+    List.map
+      (fun (param, user_visible, kind) ->
+        param, user_visible, K.With_subkind.from_lambda kind)
+      params
   in
+  let handler_env, params = Env.add_vars_like env params_with_kinds in
   let handler_params =
     List.map2
-      (fun param (_, _, kind) ->
-        BP.create param kind)
+      (fun param (_, _, kind) -> BP.create param kind)
       params params_with_kinds
     |> Bound_parameters.create
   in
@@ -1191,7 +1195,10 @@ let close_one_function acc ~code_id ~external_env ~by_function_slot decl
           in
           let simple = Simple.with_coercion (Simple.var var) coerce_to_deeper in
           let approx = Function_slot.Map.find function_slot approx_map in
-          let env = Env.add_simple_to_substitute env let_rec_ident simple K.With_subkind.any_value in
+          let env =
+            Env.add_simple_to_substitute env let_rec_ident simple
+              K.With_subkind.any_value
+          in
           let env = Env.add_value_approximation env (Name.var var) approx in
           to_bind, env)
         (Variable.Map.empty, closure_env)
@@ -1201,23 +1208,26 @@ let close_one_function acc ~code_id ~external_env ~by_function_slot decl
     Ident.Map.fold
       (fun id var env ->
         let simple, kind = find_simple_from_id_with_kind external_env id in
-        Simple.pattern_match
-          simple
+        Simple.pattern_match simple
           ~const:(fun _ -> assert false)
           ~name:(fun name ~coercion:_ ->
-            Env.add_approximation_alias (Env.add_var env id var kind) name
-              (Name.var var)))
+            Env.add_approximation_alias
+              (Env.add_var env id var kind)
+              name (Name.var var)))
       value_slots_for_idents closure_env
   in
   let closure_env =
     List.fold_right
       (fun (id, kind) env ->
-        let env, _var = Env.add_var_like env id User_visible (K.With_subkind.from_lambda kind) in
+        let env, _var =
+          Env.add_var_like env id User_visible (K.With_subkind.from_lambda kind)
+        in
         env)
       params closure_env
   in
   let closure_env, my_region =
-    Env.add_var_like closure_env my_region Not_user_visible K.With_subkind.region
+    Env.add_var_like closure_env my_region Not_user_visible
+      K.With_subkind.region
   in
   let closure_env = Env.with_depth closure_env my_depth in
   let closure_env, absolute_history, relative_history =
@@ -1588,13 +1598,13 @@ let close_functions acc external_env ~current_region function_declarations =
   let value_slots =
     Ident.Map.fold
       (fun id value_slot map ->
-        let external_simple, kind = find_simple_from_id_with_kind external_env id in
+        let external_simple, kind =
+          find_simple_from_id_with_kind external_env id
+        in
         (* We're sure [external_simple] is a variable since
            [value_slot_from_idents] has already filtered constants and symbols
            out. *)
-        Value_slot.Map.add value_slot
-          (external_simple, kind)
-          map)
+        Value_slot.Map.add value_slot (external_simple, kind) map)
       value_slots_from_idents Value_slot.Map.empty
   in
   let set_of_closures =
@@ -1636,15 +1646,19 @@ let close_let_rec acc env ~function_declarations
     List.fold_right
       (fun decl env ->
         let id = Function_decl.let_rec_ident decl in
-        let env, _var = Env.add_var_like env id User_visible K.With_subkind.any_value in
+        let env, _var =
+          Env.add_var_like env id User_visible K.With_subkind.any_value
+        in
         env)
       function_declarations env
   in
   let fun_vars_map, ident_map =
     List.fold_left
       (fun (fun_vars_map, ident_map) decl ->
         let ident = Function_decl.let_rec_ident decl in
-        let fun_var = VB.create (fst (Env.find_var env ident)) Name_mode.normal in
+        let fun_var =
+          VB.create (fst (Env.find_var env ident)) Name_mode.normal
+        in
         let function_slot = Function_decl.function_slot decl in
         ( Function_slot.Map.add function_slot fun_var fun_vars_map,
           Function_slot.Map.add function_slot ident ident_map ))
@@ -1687,7 +1701,8 @@ let close_let_rec acc env ~function_declarations
         (fun function_slot (symbol, approx) env ->
           let ident = Function_slot.Map.find function_slot ident_map in
           let env =
-            Env.add_simple_to_substitute env ident (Simple.symbol symbol) K.With_subkind.any_value
+            Env.add_simple_to_substitute env ident (Simple.symbol symbol)
+              K.With_subkind.any_value
           in
           Env.add_value_approximation env (Name.symbol symbol) approx)
         symbols env
@@ -2114,7 +2129,8 @@ let close_program (type mode) ~(mode : mode Flambda_features.mode)
   let module_block_var = Variable.create "module_block" in
   let return_cont = Continuation.create ~sort:Toplevel_return () in
   let env, toplevel_my_region =
-    Env.add_var_like env toplevel_my_region Not_user_visible Flambda_kind.With_subkind.region
+    Env.add_var_like env toplevel_my_region Not_user_visible
+      Flambda_kind.With_subkind.region
   in
   let slot_offsets = Slot_offsets.empty in
   let acc = Acc.create ~symbol_for_global ~slot_offsets in

middle_end/flambda2/from_lambda/closure_conversion_aux.ml

@@ -130,7 +130,8 @@ module Env = struct
   type t =
     { variables : (Variable.t * Flambda_kind.With_subkind.t) Ident.Map.t;
       globals : Symbol.t Numeric_types.Int.Map.t;
-      simples_to_substitute : (Simple.t * Flambda_kind.With_subkind.t) Ident.Map.t;
+      simples_to_substitute :
+        (Simple.t * Flambda_kind.With_subkind.t) Ident.Map.t;
       current_unit_id : Ident.t;
       current_depth : Variable.t option;
       symbol_for_global : Ident.t -> Symbol.t;
@@ -249,7 +250,8 @@ module Env = struct
 
   let with_depth t depth_var = { t with current_depth = Some depth_var }
 
-  let add_var t id var kind = { t with variables = Ident.Map.add id (var, kind) t.variables }
+  let add_var t id var kind =
+    { t with variables = Ident.Map.add id (var, kind) t.variables }
 
   let add_vars t ids vars =
     List.fold_left2 (fun t id (var, kind) -> add_var t id var kind) t ids vars
@@ -275,7 +277,7 @@ module Env = struct
             | Not_user_visible -> None
             | User_visible -> Some ()
           in
-          (Variable.create_with_same_name_as_ident ?user_visible id, kind))
+          Variable.create_with_same_name_as_ident ?user_visible id, kind)
         ids
     in
     add_vars t (List.map (fun (id, _, _) -> id) ids) vars, List.map fst vars
@@ -310,7 +312,8 @@ module Env = struct
       Misc.fatal_errorf "Cannot redefine [Simple] associated with %a"
         Ident.print id;
     { t with
-      simples_to_substitute = Ident.Map.add id (simple, kind) t.simples_to_substitute
+      simples_to_substitute =
+        Ident.Map.add id (simple, kind) t.simples_to_substitute
     }
 
   let add_simple_to_substitute_map t map =

middle_end/flambda2/from_lambda/closure_conversion_aux.mli

@@ -110,14 +110,23 @@ module Env : sig
 
   val add_var : t -> Ident.t -> Variable.t -> Flambda_kind.With_subkind.t -> t
 
-  val add_vars : t -> Ident.t list -> (Variable.t * Flambda_kind.With_subkind.t) list -> t
+  val add_vars :
+    t -> Ident.t list -> (Variable.t * Flambda_kind.With_subkind.t) list -> t
 
-  val add_var_map : t -> (Variable.t * Flambda_kind.With_subkind.t) Ident.Map.t -> t
+  val add_var_map :
+    t -> (Variable.t * Flambda_kind.With_subkind.t) Ident.Map.t -> t
 
-  val add_var_like : t -> Ident.t -> IR.user_visible -> Flambda_kind.With_subkind.t -> t * Variable.t
+  val add_var_like :
+    t ->
+    Ident.t ->
+    IR.user_visible ->
+    Flambda_kind.With_subkind.t ->
+    t * Variable.t
 
   val add_vars_like :
-    t -> (Ident.t * IR.user_visible * Flambda_kind.With_subkind.t) list -> t * Variable.t list
+    t ->
+    (Ident.t * IR.user_visible * Flambda_kind.With_subkind.t) list ->
+    t * Variable.t list
 
   val find_name : t -> Ident.t -> Name.t
 
@@ -127,17 +136,21 @@ module Env : sig
 
   val find_var_exn : t -> Ident.t -> Variable.t * Flambda_kind.With_subkind.t
 
-  val find_vars : t -> Ident.t list -> (Variable.t * Flambda_kind.With_subkind.t) list
+  val find_vars :
+    t -> Ident.t list -> (Variable.t * Flambda_kind.With_subkind.t) list
 
   val add_global : t -> int -> Symbol.t -> t
 
   val find_global : t -> int -> Symbol.t
 
-  val add_simple_to_substitute : t -> Ident.t -> Simple.t -> Flambda_kind.With_subkind.t -> t
+  val add_simple_to_substitute :
+    t -> Ident.t -> Simple.t -> Flambda_kind.With_subkind.t -> t
 
-  val add_simple_to_substitute_map : t -> (Simple.t * Flambda_kind.With_subkind.t) Ident.Map.t -> t
+  val add_simple_to_substitute_map :
+    t -> (Simple.t * Flambda_kind.With_subkind.t) Ident.Map.t -> t
 
-  val find_simple_to_substitute_exn : t -> Ident.t -> Simple.t * Flambda_kind.With_subkind.t
+  val find_simple_to_substitute_exn :
+    t -> Ident.t -> Simple.t * Flambda_kind.With_subkind.t
 
   val add_value_approximation : t -> Name.t -> value_approximation -> t