Failing tests, ocp-indent version 1.4.1+19 (2014-07-04)

let () =

let () =

  foo.bar <-

  foo.bar <-

    f x

    f x

      y z

      y z

(* yminsky *)

(* yminsky *)

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

(* dwu *)

(* dwu *)

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

  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

  )

  )

BENCH_FUN "Array.get (tuple)" =

BENCH_FUN "Array.get (tuple)" =

BENCH_FUN "Array.set (tuple)" =

BENCH_FUN "Array.set (tuple)" =

  let len = 300 in

  let len = 300 in

  let arr = create ~len (1,2) in

  let arr = create ~len (1,2) in

  (fun () -> arr.(len-1) <- (3,4))

  (fun () -> arr.(len-1) <- (3,4))

(* Some benchmarks of the blit operations *)

(* Some benchmarks of the blit operations *)

BENCH_MODULE "Blit tests" = struct

BENCH_MODULE "Blit tests" = struct

  let lengths = [0; 10; 100; 1000; 10_000]

  let lengths = [0; 10; 100; 1000; 10_000]

  BENCH_MODULE "Int" = struct

  BENCH_MODULE "Int" = struct

    BENCH_INDEXED "blit" len lengths  =

    BENCH_INDEXED "blit" len lengths  =

      let src = create ~len 0 in

      let src = create ~len 0 in

      let dst = create ~len 0 in

      let dst = create ~len 0 in

      (fun () -> Int.blit ~src ~src_pos:0 ~dst ~dst_pos:0 ~len)

      (fun () -> Int.blit ~src ~src_pos:0 ~dst ~dst_pos:0 ~len)

    BENCH_INDEXED "blito" len lengths  =

    BENCH_INDEXED "blito" len lengths  =

      let src = create ~len 0 in

      let src = create ~len 0 in

      let dst = create ~len 0 in

      let dst = create ~len 0 in

      (fun () -> Int.blito ~src ~src_pos:0 ~dst ~dst_pos:0 ~src_len:len ())

      (fun () -> Int.blito ~src ~src_pos:0 ~dst ~dst_pos:0 ~src_len:len ())

  end

  end

  BENCH_MODULE "Float" = struct

  BENCH_MODULE "Float" = struct

    BENCH_INDEXED "blit" len lengths  =

    BENCH_INDEXED "blit" len lengths  =

      let src = create ~len 0.0 in

      let src = create ~len 0.0 in

      let dst = create ~len 0.0 in

      let dst = create ~len 0.0 in

      (fun () -> Float.blit ~src ~src_pos:0 ~dst ~dst_pos:0 ~len)

      (fun () -> Float.blit ~src ~src_pos:0 ~dst ~dst_pos:0 ~len)

    BENCH_INDEXED "blito" len lengths  =

    BENCH_INDEXED "blito" len lengths  =

      let src = create ~len 0.0 in

      let src = create ~len 0.0 in

      let dst = create ~len 0.0 in

      let dst = create ~len 0.0 in

      (fun () -> Float.blito ~src ~src_pos:0 ~dst ~dst_pos:0 ~src_len:len ())

      (fun () -> Float.blito ~src ~src_pos:0 ~dst ~dst_pos:0 ~src_len:len ())

  end

  end

end

end

(* maizatulin *)

(* maizatulin *)

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 sexp, compare

  } with sexp, compare

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)

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

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

   arguments by 2".  To illustrate, with a case where the functor name is

   longer: *)

   longer: *)

module M =

module M =

  Functor (G)

  Functor (G)

    (H)

    (H)

    (I)

    (I)

(* sweeks *)

(* sweeks *)

include Foo (struct

include Foo (struct

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)

let foo

let foo

      some very long arguments that we break onto the next line

      some very long arguments that we break onto the next line

  =

  =

  bar ();

  bar ();

  baz

  baz

(* The [some] above is indented less when [let foo] is the first line.  The

(* The [some] above is indented less when [let foo] is the first line.  The

   problem goes away if there's anything on the line before [let foo]. *)

   problem goes away if there's anything on the line before [let foo]. *)

(* The picture shows where we want the `=' to be.  However, Tuareg currently moves it over

(* The picture shows where we want the `=' to be.  However, Tuareg currently moves it over

   to line up with the arguments.

   to line up with the arguments.

   Perhaps this is merely a personal preference, but that seems ugly to me.

   Perhaps this is merely a personal preference, but that seems ugly to me.

   pszilagyi: It's consistent with other infix operators (although this is syntax) for it

   pszilagyi: It's consistent with other infix operators (although this is syntax) for it

   to be where you prefer. *)

   to be where you prefer. *)

let foo arguments

let foo arguments

  = bar

  = bar

let foo

let foo

      arguments

      arguments

  = bar

  = bar

(* sweeks *)

(* sweeks *)

(* This program parses, but the [let] is indented incorrectly. *)

(* This program parses, but the [let] is indented incorrectly. *)

module M = struct

module M = struct

  module M : module type of M = struct

  module M : module type of M = struct

    let x = ()

    let x = ()

  end

  end

end

end

(* Removing the [: module type of M] removes the bug. *)

(* Removing the [: module type of M] removes the bug. *)

let parenthesized_let_tweak =

let parenthesized_let_tweak =

  (let sub value n l f =

  (let sub value n l f =

   in

   in

   x)

   x)

let parenthesized_let_tweak =

let parenthesized_let_tweak =

  f ~x:(let n =

  f ~x:(let n =

        in

        in

        y)

        y)

(* mixed list styles *)

(* mixed list styles *)

(* nlinger *)

(* nlinger *)

let cases =

let cases =

  [ Group ("publishing", [

  [ Group ("publishing", [

    Group ("recovery", [

    Group ("recovery", [

      basic_pre2

      basic_pre2

        ~name

        ~name

    ]);

    ]);

  ]

  ]

(* Relatively low priority Jane Street indentation bugs. *)

(* Relatively low priority Jane Street indentation bugs. *)

(* js-args *)

(* js-args *)

(* uncommon *)

(* uncommon *)

let x =

let x =

  try x with a -> b

  try x with a -> b

           | c -> d

           | c -> d

let x =

let x =

  try x

  try x

  with a -> b

  with a -> b

     | c -> d

     | c -> d

(* js-comment *)

(* js-comment *)

(* maizatulin *)

(* maizatulin *)

let mk_cont_parser cont_parse = (); fun _state str ~max_pos ~pos ->

let mk_cont_parser cont_parse = (); fun _state str ~max_pos ~pos ->

  let len = max_pos - pos + 1 in

  let len = max_pos - pos + 1 in

  cont_parse ~pos ~len str

  cont_parse ~pos ~len str

(* CR-someday maizatulin: sexp parser is sensitive to

(* CR-someday maizatulin: sexp parser is sensitive to

   absent newlines at the end of files. *)

   absent newlines at the end of files. *)

(* It would be nice if a partially completed ocamldoc code fragment inside a

(* It would be nice if a partially completed ocamldoc code fragment inside a

   comment had the closing delimiter "]}" indented nicely before the comment is

   comment had the closing delimiter "]}" indented nicely before the comment is

   closed.  (This has to be the last comment in the file, to be partial.) *)

   closed.  (This has to be the last comment in the file, to be partial.) *)

(* CR sweeks: Maybe add:

(* CR sweeks: Maybe add:

   {[

   {[

     val state : t -> [ `Unstarted | `Running | `Stopped ]

     val state : t -> [ `Unstarted | `Running | `Stopped ]

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

  }

  }

;;

;;

(* sweeks bug report *)

(* sweeks bug report *)

let _ =

let _ =

  { foo with

  { foo with

    Bar.

    Bar.

    field1 = value1

    field1 = value1

  ; field2 = value2

  ; field2 = value2

  }

  }

;;

;;

(* sweeks preference *)

(* sweeks preference *)

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

  }

  }

;;

;;

TEST =

TEST =

(* Above, a multi-line TEST (likewise BENCH) is indented wrong only when it

(* Above, a multi-line TEST (likewise BENCH) is indented wrong only when it

   starts on the first line.  (That's not really a big problem.) *)

   starts on the first line.  (That's not really a big problem.) *)

(* oUnit *)

(* oUnit *)

module E = Example

module E = Example

TEST_MODULE = struct

TEST_MODULE = struct

  TEST = false

  TEST = false

  TEST =

  TEST =

    let b = true in

    let b = true in

    b

    b

  TEST "Name_test" =

  TEST "Name_test" =

    let b = true in                     (* tricky for Tuareg *)

    let b = true in                     (* tricky for Tuareg *)

    b

    b

end

end

TEST_MODULE "Name" = struct

TEST_MODULE "Name" = struct

  TEST_UNIT = ()

  TEST_UNIT = ()

  TEST_UNIT =

  TEST_UNIT =

    let () = () in

    let () = () in

    ()

    ()

  TEST_UNIT "Name_unit" =

  TEST_UNIT "Name_unit" =

    let () = () in                      (* tricky for Tuareg *)

    let () = () in                      (* tricky for Tuareg *)

    ()

    ()

  TEST_UNIT =

  TEST_UNIT =

    let msgcount = 10_000 in            (* tricky for Tuareg *)

    let msgcount = 10_000 in            (* tricky for Tuareg *)

    ()

    ()

end

end

let _ = printf "Hello, world!\n"

let _ = printf "Hello, world!\n"

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

(* sweeks *)

(* sweeks *)

val instances

val instances

  :  unit

  :  unit

  -> (    Config.Network.t

  -> (    Config.Network.t

     , 'm

     , 'm

     ) Command.Spec.t

     ) Command.Spec.t

(* jmcarthur *)

(* jmcarthur *)

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

(* nested "try" *)

(* nested "try" *)

try

try

  try x

  try x

  with e -> e

  with e -> e

type t =

type t =

type t =

type t =

  s    (* correct, because this doesn't look like a constructor to ocp-indent *)

  s    (* correct, because this doesn't look like a constructor to ocp-indent *)

type t =

type t =

    S                         (* correctly indented a little more, because... *)

    S                         (* correctly indented a little more, because... *)

type t =

type t =

  | S                                   (* we leave room for the vertical bar *)

  | S                                   (* we leave room for the vertical bar *)

(* analogous value expressions, analogous to lists, some different from now *)

(* analogous value expressions, analogous to lists, some different from now *)

let _ =

let _ =

  [ x

  [ x

  ; y

  ; y

  ]

  ]

let _ =

let _ =

  [ x;

  [ x;

    y

    y

  ]

  ]

let _ =

let _ =

  ( x

  ( x

  , y

  , y

  )

  )

let _ =

let _ =

  ( x,

  ( x,

    y

    y

  )

  )

let _ =

let _ =

  (

  (

    x

    x

  , y

  , y

  )

  )

let _ =

let _ =

  [

  [

    x

    x

  ; y

  ; y

  ]

  ]

let _ = (

let _ = (

  x,

  x,

  y

  y

)

)

let _ = [

let _ = [

  x;

  x;

  y

  y

]

]

let _ = (

let _ = (

  x

  x

, y

, y

)

)

let _ = [

let _ = [

  x

  x

; y

; y

]

]

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

let f () =

let f () =

  lwt x = g () in

  lwt x = g () in

  Lwt.return x

  Lwt.return x

let f x = match_lwt x with

let f x = match_lwt x with

  | A -> A

  | A -> A

  | B -> B

  | B -> B

let g x = try_lwt

let g x = try_lwt

    f x

    f x

  finally

  finally

    g x

    g x

let a f x =

let a f x =

  try_lwt f x

  try_lwt f x

  with Failure _ -> ()

  with Failure _ -> ()

  finally ()

  finally ()

(* should'nt break normal try/with imbrication *)

(* should'nt break normal try/with imbrication *)

let z f x =

let z f x =

  try

  try

    try f x

    try f x

    with Exit -> ()

    with Exit -> ()