Failing tests, ocp-indent version 1.5.1+2 (2015-09-03)

(* this could be fixed, but we actually want to handle the first case

(* this could be fixed, but we actually want to handle the first case

   differently for when there is only one case (see next examples) *)

   differently for when there is only one case (see next examples) *)

let f x = function A -> x;

let f x = function A -> x;

  2

  2

                 | B -> y;

                 | B -> y;

                   3

                   3

(* if we were to fix to the case above, the second >>= would be below the _

(* if we were to fix to the case above, the second >>= would be below the _

   (test taken from js-fun) *)

   (test taken from js-fun) *)

let _ =

let _ =

  x

  x

  >>= fun x ->

  >>= fun x ->

  try x with _ -> ()

  try x with _ -> ()

    >>= fun x ->

    >>= fun x ->

    x

    x

(* (and also: the some_handling here would be below Not_found) *)

(* (and also: the some_handling here would be below Not_found) *)

let _ =

let _ =

  try

  try

    _

    _

  with Not_found ->

  with Not_found ->

    some_handling

    some_handling

let f = fun x ->

let f = fun x ->

  x

  x

let f = (fun x ->

let f = (fun x ->

    x

    x

  )

  )

let f g = g @@ fun x ->

let f g = g @@ fun x ->

  x

  x

let f g = g @@ (fun x ->

let f g = g @@ (fun x ->

    x

    x

  )

  )

(* the above should probably be consistent with: *)

(* the above should probably be consistent with: *)

let f x y = y + match x with A ->

let f x y = y + match x with A ->

    0

    0

let f x y = y + (match x with A ->

let f x y = y + (match x with A ->

    0

    0

  )

  )

(* wich means we may over-indent even when the block is non-closable *)

(* wich means we may over-indent even when the block is non-closable *)

let f x y = y + match x with

let f x y = y + match x with

  | A -> 0

  | A -> 0

let f x y = y + (match x with

let f x y = y + (match x with

    | A -> 0

    | A -> 0

  )

  )

let f x y = y + match x with

let f x y = y + match x with

  | A -> 0

  | A -> 0

let _ =

let _ =

  somefun

  somefun

    (fun x ->

    (fun x ->

       x);

       x);

  somefun

  somefun

    (if

    (if

      bla

      bla

     then

     then

       bli);

       bli);

  somefun

  somefun

    (if bla then

    (if bla then

       bli

       bli

     else

     else

       blu)

       blu)

let _ =

let _ =

  a

  a

  ;

  ;

  b

  b

(* Surprisingly, this is the indentation correpsonding to OCaml's interpretation

(* Surprisingly, this is the indentation correpsonding to OCaml's interpretation

   of this code.  Indenting this accordingly may help users notice that they're

   of this code.  Indenting this accordingly may help users notice that they're

   doing something dubious. *)

   doing something dubious. *)

let b = `b

let b = `b

let d = `d

let d = `d

;;

;;

let a = b

let a = b

;;

;;

let () =

let () =

  foo.bar <-

  foo.bar <-

    f x

    f x

      y z

      y z

let should_check_can_sell_and_marking regulatory_regime =

let should_check_can_sell_and_marking regulatory_regime =

  match z with

  match z with

  | `foo

  | `foo

    -> some_function

    -> some_function

         argument

         argument

(* The above typically occurs in a multi-pattern match clause, so the clause

(* The above typically occurs in a multi-pattern match clause, so the clause

   expression is on a line by itself.  This is the more typical way a long

   expression is on a line by itself.  This is the more typical way a long

   single-pattern match clause would be written: *)

   single-pattern match clause would be written: *)

let should_check_can_sell_and_marking regulatory_regime =

let should_check_can_sell_and_marking regulatory_regime =

  match z with

  match z with

  | `foo ->

  | `foo ->

    some_function

    some_function

      argument

      argument

let f = fun x ->

let f = fun x ->

  ghi

  ghi

    x

    x

(* common *)

(* common *)

let x =

let x =

  try x with

  try x with

  | a -> b

  | a -> b

  | c -> d

  | c -> d

let x = try x with

let x = try x with

  | a -> b

  | a -> b

  | c -> d

  | c -> d

let x =

let x =

  try x

  try x

  with

  with

  | a -> b

  | a -> b

  | c -> d

  | c -> d

let z =

let z =

  some_function

  some_function

    argument

    argument

let () =

let () =

  f a b ~c:c

  f a b ~c:c

    d

    d

let () =

let () =

  f a b ~c:1.

  f a b ~c:1.

    d

    d

let () =

let () =

  My_module.f a b ~c:c

  My_module.f a b ~c:c

    d

    d

(* This last case is where Tuareg is inconsistent with the others. *)

(* This last case is where Tuareg is inconsistent with the others. *)

let () =

let () =

  My_module.f a b ~c:1.

  My_module.f a b ~c:1.

    d

    d

let () =

let () =

  messages :=

  messages :=

    Message_store.create (Session_id.of_string "")

    Message_store.create (Session_id.of_string "")

      (* Tuareg indents these lines too far to the left. *)

      (* Tuareg indents these lines too far to the left. *)

      "herd-retransmitter"

      "herd-retransmitter"

      Message_store.Message_size.Byte

      Message_store.Message_size.Byte

let () =

let () =

  raise (Bug ("foo"

  raise (Bug ("foo"

              (* In this and similar cases, we want the subsequent lines to

              (* In this and similar cases, we want the subsequent lines to

                 align with the first expression. *)

                 align with the first expression. *)

              ^ "bar"));

              ^ "bar"));

  raise (Bug ("foo" ^ "quux"

  raise (Bug ("foo" ^ "quux"

              ^ "bar"));

              ^ "bar"));

  raise (Bug (foo + quux

  raise (Bug (foo + quux

              ^ "bar"));

              ^ "bar"));

  raise (Bug ((foo + quux)

  raise (Bug ((foo + quux)

              ^ "bar"))

              ^ "bar"))

(* Except in specific cases, we want the argument indented relative to the

(* Except in specific cases, we want the argument indented relative to the

   function being called.  (Exceptions include "fun" arguments where the line

   function being called.  (Exceptions include "fun" arguments where the line

   ends with "->" and subsequent lines beginning with operators, like above.) *)

   ends with "->" and subsequent lines beginning with operators, like above.) *)

let () =

let () =

  Some (Message_store.create s

  Some (Message_store.create s

          "herd-retransmitter" ~unlink:true Message_store.Message_size.Byte)

          "herd-retransmitter" ~unlink:true Message_store.Message_size.Byte)

(* We like the indentation of most arguments, but want to get back towards the

(* We like the indentation of most arguments, but want to get back towards the

   left margin in a few special cases: *)

   left margin in a few special cases: *)

let _ =

let _ =

  foo (bar (fun x ->                    (* special: "fun _ ->" at EOL *)

  foo (bar (fun x ->                    (* special: "fun _ ->" at EOL *)

    baz))                               (* assume no more arguments to "bar" *)

    baz))                               (* assume no more arguments to "bar" *)

let _ =

let _ =

  foo

  foo

    ~a_long_field_name:(check (fun bar ->

    ~a_long_field_name:(check (fun bar ->

      baz))

      baz))

let _ =

let _ =

  foo ~a_long_field_name:(check (fun bar ->

  foo ~a_long_field_name:(check (fun bar ->

    baz))

    baz))

let _ =

let _ =

  foo (bar (quux (fnord (fun x ->       (* any depth *)

  foo (bar (quux (fnord (fun x ->       (* any depth *)

    baz))))

    baz))))

(* We also wanted to tweak the operator indentation, making operators like <=

(* We also wanted to tweak the operator indentation, making operators like <=

   not special cases in contexts like this:  *)

   not special cases in contexts like this:  *)

let _ =

let _ =

  assert (foo (bar + baz

  assert (foo (bar + baz

               <= quux))                (* lined up under left argument to op,

               <= quux))                (* lined up under left argument to op,

                                           sim. to ^ above *)

                                           sim. to ^ above *)

(* Sim. indentation of if conditions: *)

(* Sim. indentation of if conditions: *)

let _ =

let _ =

  if (a

  if (a

      <= b)

      <= b)

  then ()

  then ()

let _ =

let _ =

  (* Comparisons are different than conditionals; we don't regard them as

  (* Comparisons are different than conditionals; we don't regard them as

     conceptually part of the [if] expression. *)

     conceptually part of the [if] expression. *)

  if a

  if a

     <= b

     <= b

  then ()

  then ()

let _ =

let _ =

  (* We regard the outermost condition terms as conceptually part of the [if]

  (* We regard the outermost condition terms as conceptually part of the [if]

     expression and indent accordingly.  Whether [&&] or [||], conditionals

     expression and indent accordingly.  Whether [&&] or [||], conditionals

     effectively state lists of conditions for [then]. *)

     effectively state lists of conditions for [then]. *)

  if Edge_adjustment.is_zero arb.cfg.extra_edge

  if Edge_adjustment.is_zero arb.cfg.extra_edge

  && 0. = sys.plugs.edge_backoff

  && 0. = sys.plugs.edge_backoff

  && 0. = zero_acvol_edge_backoff

  && 0. = zero_acvol_edge_backoff

  then 0.

  then 0.

  else 1.

  else 1.

let _ =

let _ =

  if

  if

    Edge_adjustment.is_zero arb.cfg.extra_edge

    Edge_adjustment.is_zero arb.cfg.extra_edge

    && 0. = sys.plugs.edge_backoff

    && 0. = sys.plugs.edge_backoff

    && 0. = zero_acvol_edge_backoff

    && 0. = zero_acvol_edge_backoff

  then 0.

  then 0.

  else 1.

  else 1.

let _ =

let _ =

  let entries = List.filter (Lazy.force transferstati) ~f:(fun ts ->

  let entries = List.filter (Lazy.force transferstati) ~f:(fun ts ->

    Pcre.pmatch ~pat ts.RQ.description

    Pcre.pmatch ~pat ts.RQ.description

  ) in

  ) in

  x

  x

(* combination of operator at BOL and -> at EOL: *)

(* combination of operator at BOL and -> at EOL: *)

let _ =

let _ =

  Shell.ssh_lines x

  Shell.ssh_lines x

  |! List.map ~f:(f (g (fun x ->

  |! List.map ~f:(f (g (fun x ->

(* open paren ending line like begin *)

(* open paren ending line like begin *)

let _ =

let _ =

  if a (p ^/ "s") [ e ] = Ok () then `S (

  if a (p ^/ "s") [ e ] = Ok () then `S (

    let label count =

    let label count =

      sprintf "%d s" c ^ if c = 1 then ":" else "s"

      sprintf "%d s" c ^ if c = 1 then ":" else "s"

    in

    in

    x

    x

  )

  )

let f = function

let f = function

  | zoo -> begin

  | zoo -> begin

      foo;

      foo;

      bar;

      bar;

    end

    end

;;

;;

let g = function

let g = function

  | zoo -> (

  | zoo -> (

      foo;

      foo;

      bar;

      bar;

    )

    )

;;

;;

let () =

let () =

  begin match foo with

  begin match foo with

  end

  end

;;

;;

type t =

type t =

  { last_trading : Week_date.Spec.t;

  { last_trading : Week_date.Spec.t;

    first_notice : Week_date.Spec.t option;

    first_notice : Week_date.Spec.t option;

    first_notice_exceptions : Date.t Year_month.Map.t

    first_notice_exceptions : Date.t Year_month.Map.t

      with default(Year_month.Map.empty);

      with default(Year_month.Map.empty);

    offset       : Week_date.Offset.t;

    offset       : Week_date.Offset.t;

    (* n > 0 *)

    (* n > 0 *)

    new_contract_expires_in_n_months : int

    new_contract_expires_in_n_months : int

  }

  }

(* preferred list style *)

(* preferred list style *)

let z =

let z =

  f

  f

    [ y

    [ y

    ; foo ~f:(fun () ->

    ; foo ~f:(fun () ->

        arg)

        arg)

    ]

    ]

;;

;;

let z =

let z =

  f

  f

    [ y

    [ y

    ; foo ~f:(fun () ->

    ; foo ~f:(fun () ->

        arg

        arg

      )

      )

    ]

    ]

;;

;;

(* legacy list style *)

(* legacy list style *)

let _ =

let _ =

  [ f (fun x ->

  [ f (fun x ->

      x);

      x);

    f (fun x ->

    f (fun x ->

      x);

      x);

    f (fun x ->

    f (fun x ->

      x);

      x);

  ]

  ]

let _ =

let _ =

  [ f (fun x ->

  [ f (fun x ->

      x

      x

    );

    );

    f (fun x ->

    f (fun x ->

      x

      x

    );

    );

    f (fun x ->

    f (fun x ->

      x

      x

    );

    );

  ]

  ]

;;

;;

let _ =

let _ =

  [f (fun x ->

  [f (fun x ->

     x

     x

   );

   );

   f (fun x ->

   f (fun x ->

     x

     x

   );

   );

   f (fun x ->

   f (fun x ->

     x

     x

   );

   );

  ]

  ]

;;

;;

let _ =

let _ =

  x

  x

  >>= fun x ->

  >>= fun x ->

  (try x with _ -> ())

  (try x with _ -> ())

  >>= fun x ->

  >>= fun x ->

  try x with _ -> ()

  try x with _ -> ()

    >>= fun x ->

    >>= fun x ->

    x

    x

;;

;;

let () =

let () =

  expr

  expr

  >>| function

  >>| function

  | x -> 3

  | x -> 3

  | y -> 4

  | y -> 4

;;

;;

let () =

let () =

  expr

  expr

  >>| fun z -> match z with

  >>| fun z -> match z with

;;

;;

let () =

let () =

  expr

  expr

  >>| fun z -> function

  >>| fun z -> function

  | x -> 3

  | x -> 3

  | y -> 4

  | y -> 4

;;

;;

let () =

let () =

  my_func () >>= function

  my_func () >>= function

  | A -> 0

  | A -> 0

  | B -> 0

  | B -> 0

;;

;;

let () =

let () =

  my_func () >>= (function

  my_func () >>= (function

    | A -> 0

    | A -> 0

    | B -> 0)

    | B -> 0)

;;

;;

let () =

let () =

  expr

  expr

  >>| function

  >>| function

  | x -> 3

  | x -> 3

  | y -> 4

  | y -> 4

;;

;;

let () =

let () =

  expr

  expr

  >>| (function

  >>| (function

    | x -> 3

    | x -> 3

    | y -> 4)

    | y -> 4)

;;

;;

let f =

let f =

  f >>= m (fun f ->

  f >>= m (fun f ->

    fun x ->

    fun x ->

      y);

      y);

  z

  z

;;

;;

let f =

let f =

  f

  f

  |> m (fun f ->

  |> m (fun f ->

    fun x ->

    fun x ->

      y

      y

  );

  );

  z

  z

;;

;;

let f =

let f =

  f

  f

  |> m (fun f ->

  |> m (fun f ->

    fun x ->

    fun x ->

      y);

      y);

  z

  z

;;

;;

module M =

module M =

  Foo (G)

  Foo (G)

    (H)

    (H)

module M =

module M =

  Foo

  Foo

    (G)

    (G)

    (struct

    (struct

      let x

      let x

    end)

    end)

    (H)

    (H)

(* To me, this looks fine as it is.  The rule seems fine as "indent arguments by

(* To me, this looks fine as it is.  The rule seems fine as "indent arguments by

   2".  To illustrate, with a case where the functor name is longer: *)

   2".  To illustrate, with a case where the functor name is longer: *)

module M =

module M =

  Functor (G)

  Functor (G)

    (H)

    (H)

    (I)

    (I)

include Foo (struct

include Foo (struct

    let x

    let x

  end) (struct

  end) (struct

    let y

    let y

  end)

  end)

include

include

  Foo (struct

  Foo (struct

include

include

  Foo

  Foo

    (struct

    (struct

      let x

      let x

    end) (struct

    end) (struct

include Persistent.Make

include Persistent.Make

include Persistent.Make

include Persistent.Make

include

include

  Persistent.Make

  Persistent.Make

    (struct let version = 1 end)

    (struct let version = 1 end)

    (Stable.Cr_soons_or_pending.V1)

    (Stable.Cr_soons_or_pending.V1)

include

include

  Persistent.Make

  Persistent.Make

    (struct

    (struct

      let version = 1

      let version = 1

    end)

    end)

    (Stable.Cr_soons_or_pending.V1)

    (Stable.Cr_soons_or_pending.V1)

module M =

module M =

  Foo (struct

  Foo (struct

module M : S =

module M : S =

  Make (M)

  Make (M)

module M : S with type t := int =

module M : S with type t := int =

  Make (M)

  Make (M)

module Simple_command(Arg:sig

module Simple_command(Arg:sig

  end) = struct end

  end) = struct end

module Simple_command(Arg : sig

module Simple_command(Arg : sig

  end) = struct end

  end) = struct end

module Simple_command (Arg:sig

module Simple_command (Arg:sig

  end) = struct end

  end) = struct end

module Simple_command (Arg : sig

module Simple_command (Arg : sig

  end) = struct end

  end) = struct end

module Simple_command

module Simple_command

let f = function

let f = function

  | _ -> 0

  | _ -> 0

;;

;;

let f x = match x with

let f x = match x with

;;

;;

let f =

let f =

  function

  function

  | _ -> 0

  | _ -> 0

;;

;;

let f x =

let f x =

  match x with

  match x with

  | _ -> 0

  | _ -> 0

;;

;;

let f x =

let f x =

  begin match x with

  begin match x with

  end

  end

;;

;;

let check_price t = function

let check_price t = function

  | { Exec.

  | { Exec.

      trade_at_settlement = (None | Some false);

      trade_at_settlement = (None | Some false);

    } -> ()

    } -> ()

let check_price t = function

let check_price t = function

  | simpler -> ()

  | simpler -> ()

  | other -> ()

  | other -> ()

(* Sometimes we like to write big alternations like this, in which case the

(* Sometimes we like to write big alternations like this, in which case the

   comment should typically align with the following clause. *)

   comment should typically align with the following clause. *)

let 0 =

let 0 =

  match x with

  match x with

  | A

  | A

    (* a *)

    (* a *)

    -> a

    -> a

let 0 =

let 0 =

  match x with

  match x with

    A

    A

    (* a *)

    (* a *)

    -> a

    -> a

let _ =

let _ =

  a

  a

  || match a with

  || match a with

type x =

type x =

  { foo : int

  { foo : int

  ; bar : int

  ; bar : int

  }

  }

let x =

let x =

  { x with

  { x with

    foo = 3

    foo = 3

  ; bar = 5

  ; bar = 5

  }

  }

let x =

let x =

  { (* blah blah blah *)

  { (* blah blah blah *)

    foo = 3

    foo = 3

  ; bar = 5

  ; bar = 5

  }

  }

;;

;;

let x =

let x =

  [{ x with

  [{ x with

     foo = 3

     foo = 3

   ; bar = 5

   ; bar = 5

   }]

   }]

let x =

let x =

  [{ (* blah blah blah *)

  [{ (* blah blah blah *)

;;

;;

let x =

let x =

  { M.x with

  { M.x with

    M.

    M.

    foo = 3

    foo = 3

  }

  }

;;

;;

let x =

let x =

  { x with

  { x with

    M.

    M.

    foo = 3

    foo = 3

  }

  }

;;

;;

let x =

let x =

  { M.

  { M.

    foo = 3

    foo = 3

  }

  }

;;

;;

let _ =

let _ =

  { foo with

  { foo with

    Bar.

    Bar.

    field1 = value1

    field1 = value1

  ; field2 = value2

  ; field2 = value2

  }

  }

;;

;;

let _ =

let _ =

  { foo

  { foo

    with Bar.

    with Bar.

  }

  }

;;

;;

(* multicomponent record module pathname *)

(* multicomponent record module pathname *)

let _ =

let _ =

  { A.B.

  { A.B.

    a = b

    a = b

  ; c = d

  ; c = d

  }

  }

;;

;;

(* s *)

(* s *)

let _ =

let _ =

  [%raise_structural_sexp

  [%raise_structural_sexp

    "feature's tip is already an ancestor of new base"

    "feature's tip is already an ancestor of new base"

let _ =

let _ =

  [%raise_structural_sexp "feature's tip is already an ancestor of new base"

  [%raise_structural_sexp "feature's tip is already an ancestor of new base"

  ]

  ]

(* Indentation that Jane Street needs to think about and make precise.

(* Indentation that Jane Street needs to think about and make precise.

   These are long term ideas, possibly even conflicting with other tests. *)

   These are long term ideas, possibly even conflicting with other tests. *)

(* js-args *)

(* js-args *)

let _ =

let _ =

  let min_closing_backoff =

  let min_closing_backoff =

    -. (   Hidden_float.expose (arb.cfg.base_edge @! Buy)

    -. (   Hidden_float.expose (arb.cfg.base_edge @! Buy)

  in

  in

  0

  0

(* js-type *)

(* js-type *)

(* The following tests incorporate several subtle and different indentation

(* The following tests incorporate several subtle and different indentation

   ideas.  Please consider this only a proposal for discussion, for now.

   ideas.  Please consider this only a proposal for discussion, for now.

   First, notice the display treatment of "(,)" tuples, analogous to "[;]"

   First, notice the display treatment of "(,)" tuples, analogous to "[;]"

   lists.  While "(,)" is an intensional combination of "()" and ",", unlike

   lists.  While "(,)" is an intensional combination of "()" and ",", unlike

   "[;]" lists, we believe "(,)" isn't too big a departure.  Value expression

   "[;]" lists, we believe "(,)" isn't too big a departure.  Value expression

   analogies are included in js-type.ml, (meant to be) consistent with the

   analogies are included in js-type.ml, (meant to be) consistent with the

   proposed type indentation.

   proposed type indentation.

   Second, and more divergently, the proposed indentation of function types is

   Second, and more divergently, the proposed indentation of function types is

   based on the idea of aligning the arguments, even the first argument, even

   based on the idea of aligning the arguments, even the first argument, even

   where that means automatically inserting spaces within lines.  This applies

   where that means automatically inserting spaces within lines.  This applies

   to the extra spaces in ":__unit" and "(____Config.Network.t" below.

   to the extra spaces in ":__unit" and "(____Config.Network.t" below.

   We believe this fits into a more general incorporation of alignment into

   We believe this fits into a more general incorporation of alignment into

   ocp-indent, to replace our internal alignment tool with a syntax-aware one.

   ocp-indent, to replace our internal alignment tool with a syntax-aware one.

   We like to align things for readability, like big records, record types,

   We like to align things for readability, like big records, record types,

   lists used to build tables, etc.

   lists used to build tables, etc.

   The proposal also includes indenting "->" in the circumstances below relative

   The proposal also includes indenting "->" in the circumstances below relative

   to the enclosing "()", by two spaces.  In a sense, this happens first, and

   to the enclosing "()", by two spaces.  In a sense, this happens first, and

   then the first argument is aligned accordingly.  So, there's no manual

   then the first argument is aligned accordingly.  So, there's no manual

   indentation or spacing below. *)

   indentation or spacing below. *)

val instances

val instances

  :  unit

  :  unit

  -> (    Config.Network.t

  -> (    Config.Network.t

     , 'm

     , 'm

     ) Command.Spec.t

     ) Command.Spec.t

val instances

val instances

  :  unit

  :  unit

  -> (    Config.Network.t

  -> (    Config.Network.t

     , 'm

     , 'm

     ) Command.Spec.t

     ) Command.Spec.t

(* presumed analog with stars *)

(* presumed analog with stars *)

val instances :

val instances :

  unit

  unit

  * (   Config.Network.t

  * (   Config.Network.t

    , 'm

    , 'm

    ) Command.Spec.t

    ) Command.Spec.t

let f x =

let f x =

  stop

  stop

  (* We don't do this as a matter of style, but the indentation reveals a common

  (* We don't do this as a matter of style, but the indentation reveals a common

     mistake. *)

     mistake. *)

  >>> fun () -> don't_wait_for (close fd);

  >>> fun () -> don't_wait_for (close fd);

let f x =

let f x =

  stop

  stop

  (* This is what was intended, which is indented correctly, although it's bad

  (* This is what was intended, which is indented correctly, although it's bad

     style on my part. *)

     style on my part. *)

  >>> (fun () -> don't_wait_for (close fd));

  >>> (fun () -> don't_wait_for (close fd));

  bind

  bind