Merge pull request #1570 from stan-dev/ocamlformat-version

Update `ocamlformat` to 0.28

Author: WardBrian

.git-blame-ignore-revs

@@ -1,6 +1,7 @@
 # usage: git config blame.ignoreRevsFile .git-blame-ignore-revs
 # generated with: git log --grep "[fF]ormat.*ocamlformat" --format="format:%H # %s"
 
+e34fdeb4050139946d0409b09489cf91f5502ad7 # Format with ocamlformat 0.28.1
 2030298f84a95a78953866bf46bc6564f9faee1b # Migrate to Core and format with ocamlformat 0.26.1
 845f34e165e16c95596fd48da67bb987bbbe2446 # Format with ocamlformat 0.19.0
 9c75bd01015157bae5a133417acf1f7e8af71887 # reformatting using ocamlformat 0.9

.ocamlformat

@@ -1,4 +1,5 @@
-version=0.26.1
+version=0.28.1
+ocaml-version=4.14
 # loosely re-creates the now-removed "compact" profile
 break-separators=before
 break-before-in=auto
@@ -11,3 +12,5 @@ space-around-lists=false
 space-around-records=false
 space-around-variants=false
 sequence-blank-line=compact
+parse-docstrings=true
+wrap-comments=true

docs/dependencies.mld

@@ -35,7 +35,7 @@ build requirements) with [scripts/setup_dev_env.sh]. Versioning of these depende
 strict, though some (like ocamlformat) are used to ensure a standard format across developers
 and must use the same version.
 
-- ocamlformat 0.26.1
+- ocamlformat 0.28.1
 - merlin
 - ocaml-lsp-server
 - utop

dune-project

@@ -29,7 +29,7 @@
   (ocamlformat
    (and
     :with-test
-    (= 0.26.1)))
+    (= 0.28.1)))
   (bisect_ppx :with-test)
   (merlin :with-test)
   (utop :with-test)

scripts/install_dev_deps.sh

@@ -1,5 +1,5 @@
 #!/bin/bash
 
 # Merlin, utop, ocp-indent, ocamlformat, and patdiff are all for developer assistance
-opam pin -y ocamlformat 0.26.1 --no-action
-opam install -y ocamlformat.0.26.1 bisect_ppx landmarks-ppx merlin ocaml-lsp-server utop ocp-indent patdiff odoc
+opam pin -y ocamlformat 0.28.1 --no-action
+opam install -y ocamlformat.0.28.1 bisect_ppx landmarks-ppx merlin ocaml-lsp-server utop ocp-indent patdiff odoc

src/analysis_and_optimization/Dataflow_types.ml

@@ -4,27 +4,20 @@ open Core
 (* Basic datatypes                 *)
 (***********************************)
 
-(**
-   A label is a unique identifier for a node in the dataflow/dependency graph, and
-   often corresponds to one node in the Mir.
-*)
+(** A label is a unique identifier for a node in the dataflow/dependency graph,
+    and often corresponds to one node in the Mir. *)
 type label = int [@@deriving sexp]
 
-(**
-   Representation of an expression that can be assigned to. This should also be able to
-   represent indexed variables, but we don't support that yet.
-*)
+(** Representation of an expression that can be assigned to. This should also be
+    able to represent indexed variables, but we don't support that yet. *)
 type vexpr = VVar of string [@@deriving sexp]
 
-(**
-   A 'reaching definition' (or reaching_defn or RD) statement (v, l) says that the variable
-   v could have been affected at the label l.
-*)
+(** A 'reaching definition' (or reaching_defn or RD) statement (v, l) says that
+    the variable v could have been affected at the label l. *)
 type reaching_defn = vexpr * label [@@deriving sexp]
 
 (** The most recently nested control flow (block start, if/then, or loop)
 
-    This isn't included in the traversal_state because it only flows downward through the
-    tree, not across and up like everything else
-*)
+    This isn't included in the traversal_state because it only flows downward
+    through the tree, not across and up like everything else *)
 type cf_state = label

src/analysis_and_optimization/Dataflow_utils.ml

@@ -13,9 +13,8 @@ let union_maps_left (m1 : ('a, 'b) Map.Poly.t) (m2 : ('a, 'b) Map.Poly.t) :
     | `Both (v1, _) -> Some v1 in
   Map.Poly.merge m1 m2 ~f
 
-(**
-   Merge two maps whose values are sets, and union the sets when there's a collision.
-*)
+(** Merge two maps whose values are sets, and union the sets when there's a
+    collision. *)
 let merge_set_maps m1 m2 =
   let merge_map_elems ~key:_ es =
     match es with
@@ -24,10 +23,8 @@ let merge_set_maps m1 m2 =
     | `Both (e1, e2) -> Some (Set.union e1 e2) in
   Map.Poly.merge ~f:merge_map_elems m1 m2
 
-(**
-   Like a forward traversal, but branches accumulate two different states that are
-   recombined with join.
-*)
+(** Like a forward traversal, but branches accumulate two different states that
+    are recombined with join. *)
 let branching_traverse_statement stmt ~join ~init ~f =
   Stmt.Pattern.(
     match stmt with
@@ -40,15 +37,12 @@ let branching_traverse_statement stmt ~join ~init ~f =
             (join s' s'', IfElse (pred, c, Some c')))
     | _ as s -> fwd_traverse_statement s ~init ~f)
 
-(** Like a branching traversal, but doesn't return an updated statement.
-*)
+(** Like a branching traversal, but doesn't return an updated statement. *)
 let branching_fold_statement stmt ~join ~init ~f =
   fst
     (branching_traverse_statement stmt ~join ~init ~f:(fun s a -> (f s a, ())))
 
-(**
-   See interface file
-*)
+(** See interface file *)
 let build_statement_map extract metadata stmt =
   let rec build_statement_map_rec next_label map stmt =
     let this_label = next_label in
@@ -66,38 +60,37 @@ let build_statement_map extract metadata stmt =
 (* TODO: this currently does not seem to be labelling inside function bodies.
    Could we also do that? *)
 
-(**
-   See interface file
-*)
+(** See interface file *)
 let rec build_recursive_statement rebuild statement_map label =
   let stmt_ints, meta = Map.Poly.find_exn statement_map label in
   let build_stmt = build_recursive_statement rebuild statement_map in
   let stmt = Stmt.Pattern.map Fn.id build_stmt stmt_ints in
   rebuild stmt meta
 
-(** Represents the state required to build control flow information during an MIR
-    traversal, where
-     * breaks is the set of Breaks seen since the beginning of their loop
-     * continues is the set of Continues seen since the beginning of their loop
-     * returns is the set of Returns seen since the beginning of their function definition
-     * exits is the set of nodes that could have been the last one to execute before this
-       node
-*)
+(** Represents the state required to build control flow information during an
+    MIR traversal, where
+    - breaks is the set of Breaks seen since the beginning of their loop
+    - continues is the set of Continues seen since the beginning of their loop
+    - returns is the set of Returns seen since the beginning of their function
+      definition
+    - exits is the set of nodes that could have been the last one to execute
+      before this node *)
 type cf_state =
   { breaks: label Set.Poly.t
   ; continues: label Set.Poly.t
   ; returns: label Set.Poly.t
   ; exits: label Set.Poly.t }
 
-(** Represents the control flow information at each node in the control graph, where
-     * predecessors points to the nodes which could have executed before this node
-     * parents points to the adjacent nodes which directly influence the execution of this
-       node
-*)
+(** Represents the control flow information at each node in the control graph,
+    where
+    - predecessors points to the nodes which could have executed before this
+      node
+    - parents points to the adjacent nodes which directly influence the
+      execution of this node *)
 type cf_edges = {predecessors: label Set.Poly.t; parents: label Set.Poly.t}
 
-(** Join the state of a controlflow traversal across different branches of execution such
-    as over if/else branch. *)
+(** Join the state of a controlflow traversal across different branches of
+    execution such as over if/else branch. *)
 let join_cf_states (state1 : cf_state) (state2 : cf_state) : cf_state =
   { breaks= Set.union state1.breaks state2.breaks
   ; continues= Set.union state1.continues state2.continues
@@ -112,11 +105,10 @@ let is_ctrl_flow pattern =
   | For _ -> true
   | _ -> false
 
-(**
-   Simultaneously builds the controlflow parent graph, the predecessor graph and the exit
-   set of a statement. It's advantageous to build them together because they both rely on
-   some of the same Break, Continue and Return bookkeeping.
-*)
+(** Simultaneously builds the controlflow parent graph, the predecessor graph
+    and the exit set of a statement. It's advantageous to build them together
+    because they both rely on some of the same Break, Continue and Return
+    bookkeeping. *)
 let build_cf_graphs ?(flatten_loops = false) ?(blocks_after_body = true)
     statement_map =
   let rec build_cf_graph_rec (cf_parent : label option)
@@ -138,28 +130,31 @@ let build_cf_graphs ?(flatten_loops = false) ?(blocks_after_body = true)
       branching_fold_statement stmt ~join
         ~init:({in_state with exits= substmt_preds}, in_map)
         ~f:(build_cf_graph_rec child_cf) in
-    (* If the statement is a loop, we need to include the loop body exits as predecessors
-         of the loop *)
+    (* If the statement is a loop, we need to include the loop body exits as
+       predecessors of the loop *)
     let substmt_state, predecessors =
       match stmt with
       | For _ | While _ ->
           (* Loop statements are preceded by:
+
              1. The statements that come before the loop
+
              2. The natural exit points of the loop body
-             3. Continue statements in the loop body
-             This comment mangling brought to you by the autoformatter
-          *)
+
+             3. Continue statements in the loop body This comment mangling
+             brought to you by the autoformatter *)
           let loop_predecessors =
             Set.Poly.union_list
               [ (*1*) in_state.exits; (*2*) substmt_state_unlooped.exits; (*3*)
                 Set.diff substmt_state_unlooped.continues in_state.continues ]
           in
           (* Loop exits are:
-             1. The loop node itself, since the last action of a typical loop execution is
-                to check if there are any iterations remaining
-             2. Break statements in the loop body, since broken loops don't execute the
-                loop statement
-          *)
+
+             1. The loop node itself, since the last action of a typical loop
+             execution is to check if there are any iterations remaining
+
+             2. Break statements in the loop body, since broken loops don't
+             execute the loop statement *)
           let loop_exits =
             if flatten_loops then substmt_state_unlooped.exits
             else
@@ -168,16 +163,16 @@ let build_cf_graphs ?(flatten_loops = false) ?(blocks_after_body = true)
                   Set.diff substmt_state_unlooped.breaks in_state.breaks ] in
           ({substmt_state_unlooped with exits= loop_exits}, loop_predecessors)
       | (Block _ | Profile _) when blocks_after_body ->
-          (* Block statements are preceded by the natural exit points of the block
-             body *)
+          (* Block statements are preceded by the natural exit points of the
+             block body *)
           let block_predecessors = substmt_state_unlooped.exits in
           (* Block exits are just the block node *)
           let block_exits = Set.Poly.singleton label in
           ({substmt_state_unlooped with exits= block_exits}, block_predecessors)
       | _ -> (substmt_state_unlooped, in_state.exits) in
-    (* Some statements interact with the break/return/continue states
-       E.g., loops nullify breaks and continues in their body, but are still affected by
-       breaks and input continues*)
+    (* Some statements interact with the break/return/continue states E.g.,
+       loops nullify breaks and continues in their body, but are still affected
+       by breaks and input continues *)
     let breaks_out, returns_out, continues_out, extra_cf_deps =
       match stmt with
       | Break ->

src/analysis_and_optimization/Dataflow_utils.mli

@@ -13,50 +13,45 @@ val build_cf_graphs :
   -> label Set.Poly.t
      * (label, label Set.Poly.t) Map.Poly.t
      * (label, label Set.Poly.t) Map.Poly.t
-(**
-   Simultaneously builds the controlflow parent graph, the predecessor graph and the exit
-   set of a statement. It's advantageous to build them together because they both rely on
-   some of the same Break, Continue and Return bookkeeping.
+(** Simultaneously builds the controlflow parent graph, the predecessor graph
+    and the exit set of a statement. It's advantageous to build them together
+    because they both rely on some of the same Break, Continue and Return
+    bookkeeping.
 
-   Takes a statement map and returns the triple:
-     (exit set, predecessor graph, controlflow parent graph)
-   where
-     * (exit set, predecessor graph) is the return value of build_predecessor_graph
-     * (controlflow parent graph) is the return value of build_cf_graph
-*)
+    Takes a statement map and returns the triple: (exit set, predecessor graph,
+    controlflow parent graph) where
+    - (exit set, predecessor graph) is the return value of
+      build_predecessor_graph
+    - (controlflow parent graph) is the return value of build_cf_graph *)
 
 val build_cf_graph :
      (label, (Expr.Typed.t, label) Stmt.Pattern.t * 'm) Map.Poly.t
   -> (label, label Set.Poly.t) Map.Poly.t
-(**
-   Building the controlflow graph requires a traversal with state that includes continues,
-   breaks, returns and the controlflow graph accumulator. The traversal should be a
-   branching traversal with set unions rather than a forward traversal because continue
-   and return statements shouldn't affect other branches of execution.
-*)
+(** Building the controlflow graph requires a traversal with state that includes
+    continues, breaks, returns and the controlflow graph accumulator. The
+    traversal should be a branching traversal with set unions rather than a
+    forward traversal because continue and return statements shouldn't affect
+    other branches of execution. *)
 
 val build_predecessor_graph :
      ?flatten_loops:bool
   -> ?blocks_after_body:bool
   -> (label, (Expr.Typed.t, label) Stmt.Pattern.t * 'm) Map.Poly.t
   -> label Set.Poly.t * (label, label Set.Poly.t) Map.Poly.t
-(**
-   Building the predecessor graph requires a traversal with state that includes the
-   current previous nodes and the predecessor graph accumulator. Special cases are made
-   for loops, because they should include the body exits as predecessors to the body, and
-   they should include loop predecessors in their exit sets. I'm not sure if the single
-   re-traversal of the loop body is sufficient or this requires finding a fixed-point.
-*)
+(** Building the predecessor graph requires a traversal with state that includes
+    the current previous nodes and the predecessor graph accumulator. Special
+    cases are made for loops, because they should include the body exits as
+    predecessors to the body, and they should include loop predecessors in their
+    exit sets. I'm not sure if the single re-traversal of the loop body is
+    sufficient or this requires finding a fixed-point. *)
 
 val build_recursive_statement :
      (('e, 's) Stmt.Pattern.t -> 'm -> 's)
   -> (label, ('e, label) Stmt.Pattern.t * 'm) Map.Poly.t
   -> label
   -> 's
-(**
-   Build a fixed-point data type representation of a statement given a label-map
-   representation.
-*)
+(** Build a fixed-point data type representation of a statement given a
+    label-map representation. *)
 
 val is_ctrl_flow : ('a, 'b) Stmt.Pattern.t -> bool
 (** Check if the statement controls the execution of its substatements. *)
@@ -65,18 +60,16 @@ val merge_set_maps :
      ('a, 'b Set.Poly.t) Map.Poly.t
   -> ('a, 'b Set.Poly.t) Map.Poly.t
   -> ('a, 'b Set.Poly.t) Map.Poly.t
-(**
-   Merge two maps whose values are sets, and union the sets when there's a collision.
-*)
+(** Merge two maps whose values are sets, and union the sets when there's a
+    collision. *)
 
 val build_statement_map :
      ('s -> ('e, 's) Stmt.Pattern.t)
   -> ('s -> 'm)
   -> 's
   -> (label, ('e, label) Stmt.Pattern.t * 'm) Map.Poly.t
-(**
-   The statement map is built by traversing substatements recursively to replace
-   substatements with their labels while building up the substatements' statement maps.
-   Then, the result is the union of the substatement maps with this statement's singleton
-   pair, which is expressed in terms of the new label-containing statement.
-*)
+(** The statement map is built by traversing substatements recursively to
+    replace substatements with their labels while building up the substatements'
+    statement maps. Then, the result is the union of the substatement maps with
+    this statement's singleton pair, which is expressed in terms of the new
+    label-containing statement. *)

src/analysis_and_optimization/Debug_data_generation.ml

@@ -195,10 +195,6 @@ let gen_corr_cholesky_unwrapped n =
 
 let gen_corr_cholesky n = wrap_real_mat (gen_corr_cholesky_unwrapped n)
 
-(* let gen_identity_matrix m n =
-   let id_mat = gen_diag_mat (List.init ~f:(fun _ -> 1.) n) in
-   if m <= n then wrap_real_mat id_mat else pad_mat id_mat m n *)
-
 let gen_cov_matrix n =
   let cov = gen_cov_unwrapped n in
   wrap_real_mat cov
@@ -327,7 +323,7 @@ let json_to_mir (decls : (Expr.Typed.t SizedType.t * 'a * string) list)
     | `Assoc l, UTuple ts ->
         l
         |> List.sort ~compare:(fun (x, _) (y, _) ->
-               Int.compare (int_of_string x) (int_of_string y))
+            Int.compare (int_of_string x) (int_of_string y))
         |> List.map2_exn ~f:(fun typ_ (_, json) -> create_expr typ_ json) ts
         |> Option.all
         |> Option.map ~f:(fun l -> Expr.Helpers.tuple_expr l)
@@ -339,7 +335,7 @@ let json_to_mir (decls : (Expr.Typed.t SizedType.t * 'a * string) list)
   List.filter_map decls ~f:(fun (st, _, name) ->
       Map.find map name
       |> Option.bind ~f:(fun value ->
-             create_expr (SizedType.to_unsized st) value)
+          create_expr (SizedType.to_unsized st) value)
       |> Option.map ~f:(fun value -> (name, value)))
   |> Map.Poly.of_alist_reduce ~f:Fn.const