Add parens on labeled function argument types when they are tuples

[ccasin]

Per discussion, we want to try adding parens to disambiguate labeled arguments from labeled tuples.

After this PR the jane street profile prefers

x:(int * bool) -> string

Rather than:

x:int * bool -> string

Suggest testing on tree before merging, and further discussion to make sure we don't want fewer parens.

[goldfirere]

There is some logic in Params.parens_if that you're not duplicating. Is this change intentional?

[ccasin]

Yeah - I only recently added this call to parens_if, and in retrospect believe I should have done what is here instead (though I'm not super high confidence either way).

[tdelvecchio-jsc]

Evidence for why this change is good: the parens in the type language now directly match their corresponding expression.

-| type a = x:int * y:bool -> string
+| type a = x:(int * y:bool) -> string
 | let a = f ~x:(20, ~y:false)

 | type b = (x:int * y:bool) -> string
 | let b = f (~x:20, ~y:false)

[tdelvecchio-jsc]

If a file is styled with ocamlformat at the base of this PR to look like:

val f
  :  argument1
  -> argument2
  -> argument3
  -> label:argument4a * argument4b
  (* Some multi-line
     comment *)
  -> result

Then formatting it with tip moves the comment association:

val f
  :  argument1
  -> argument2
  -> argument3
  -> label:(argument4a * argument4b)
  -> (* Some multi-line
     comment *)
     result

Similarly:

val f
  :  label:argument1a * argument1b
  (* Some multi-line
     comment *)
  -> argument2
  -> argument3
  -> argument4
  -> result

gets restyled to

val f
  :  label:(argument1a * argument1b)
  -> (* Some multi-line
     comment *)
     argument2
  -> argument3
  -> argument4
  -> result

[ccasin]

If a file is styled with ocamlformat at the base of this PR to look like:

...

@tdelvecchio-jsc I spent some time looking at this, and I think it's quite hard to fix! The issue is that in the examples without the parens, the comment is considered adjacent to the argument type, and with the parens it is not. At the cost of some sanity, I figured out how to get them considered adjacent (you can play with it here, if you really want), but it breaks the formatting of other things.

Instead, I'm going to weakly claim this change is fine. One thing to observe is that today if you write

val f : foo -> lbl:(bar -> baz) (* comment *) -> boz

This gets rewritten to

val f : foo -> lbl:(bar -> baz) -> (* comment *) boz

So, it's already the case that you can't write a comment after a labeled argument with parens - it's just that we're creating some new ones of those.

As another note about current ocamlformat insanity, val g : a -> b*c (* hi *) -> d is formatted unchanged, but val g : a -> (b*c) (* hi *) -> d is rewritten to val g : a -> b*c -> (* hi *) d. So we remove the parens but move the comment anyway. Weak evidence the situation here is already pretty sad and we're not making it dramatically worse.

[tdelvecchio-jsc]

Tree-smash looks good, only manual work will be moving the comments affected by the issue discussed above.