Failing tests, ocp-indent version 1.4.2+55 (2015-01-07)

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

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

(* pszilagyi: 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

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

   long single-pattern match clause would be written: *)

   long 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 _ =

  if a

  if a

     <= b

     <= b

  then ()

  then ()

let _ =

let _ =

  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

  )

  )

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

    let x

    let x

  end) (struct

  end) (struct

    let y

    let y

  end)

  end)

module M =

module M =

  Foo (struct

  Foo (struct

    let x

    let x

  end) (struct

  end) (struct

    let y

    let y

  end)

  end)

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

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

  }

  }

;;

;;

(* 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