Support for old versions of the compiler.

[hhugo]

Extracted from #630:

@hhugo:

This makes me think that we might need a flag to specify the targeted version of the OCaml compiler.
For instance, it would be incorrect to use the following syntax in 4.07.
module M(_:S) = struct end

@jberdine:

My position has always been to try to support the latest released version and the one preceding for "a while" to make it possible to upgrade non-atomically. That's not very generous, I know. But I'm not sure of the cost:value ratio for supporting old versions for dev tools, especially when they are so closely tied to compiler internals. Also, I don't know if it makes sense to commit/try to ensure that everyone can use the same compiler version to build ocamlformat as to build the code they are formatting. I'm definitely open to alternative, but just to say that I haven't already been convinced that something like dune's approach to legacy support is the right choice here.

For examples like the particular case of module M(_:S) = struct end, would it make more sense wrt community-wide effort to make a ppx that could be used with eg 407 that would convert the 408 ast to the expanded form that 407 can handle?

[hhugo]

While formatting some part of js_of_ocaml, I had to manually tune few places to stay compatible with ocaml 4.02.3. The churn was not very big, work around were trivial. Unsure if it could become painful overtime.

[emillon]

This came up again a couple times:

• (type a b) as a shorthand for (type a) (type b) (only available on 4.03+)
• functor keyword vs module argument Feature request: consistent formatting of functor keyword #1285

Initially I was thinking that an option for target version would work, but maintaining concrete syntax seems a better choice in general.

[jberdine]

Can I just note that there are noteworthy downsides to just punting on such questions and trying to preserve the concrete syntax.

• Preserving the concrete syntax undermines all the objectives of using an auto-formatter, and should really be left as a last-ditch escape hatch mechanism for when things are necessarily very ad hoc.
• The use of autoformatters to automatically update code to the current/modern language is blocked by this sort of thing. It would be better if the formatter could automatically rewrite old workaround to new solutions based on a target version.
• The implementation mechanisms for preserving the concrete syntax will never be as efficient.

Do we know how much of a maintenance burden it would be to add a target version for the generated concrete syntax? Most importantly, do we know if it would interact with other configuration options in a multiplicative or additive way?

[gpetiot]

4.14+

• Allow explicit binders for type variables: Allow explicit binders for type variables ocaml/ocaml#10437

4.13+

• Let-punning. Allow 'let* x in ...' and 'let%ext x in ...' as shorthand for 'let* x = x in ...' and 'let%ext x = x in ...' respectively. Syntax proposal: let punning ocaml/ocaml#10013

4.11+

• Quoted extensions: {%foo|...|} is lighter syntax for [%foo {||}], and {%foo bar|...|bar} for [%foo {bar|...|bar}]. Quoted extensions ocaml/ocaml#8820 Quoted extensions in comments, ocamllex and ocamlyacc ocaml/ocaml#9166

4.10+

• Multi-indices for extended indexing operators: a.%{0;1;2} desugars to ( .%{ ;.. } ) a [|0;1;2|] MPR#7557: Multi-indices for extended indexing operators ocaml/ocaml#1726

4.08+

• Allow [module M(_:S) = struct end] syntax Syntax: allow [module M(_:S) = struct end] syntax ocaml/ocaml#1958

4.06+

• Extended indexing operators, add a new class of
  user-defined indexing operators, obtained by adding at least
  one operator character after the dot symbol to the standard indexing
  operators: e,g ".%()", ".?[]", ".@{}<-": let ( .%() ) = List.nth in [0; 1; 2].%(1) Extended indexing operators ocaml/ocaml#1064

4.04+

• Local opening of modules in a pattern. Syntax: "M.(p)", "M.[p]","M.[| p |]", "M.{p}" Local open in patterns ocaml/ocaml#187
• Allow shortcut for extension on semicolons: ;%foo Allow shortcut for extension on semicolons ocaml/ocaml#508

4.03+

• Syntax shortcut for putting a type annotation on a record field: { f1 : typ = e } is sugar for { f1 = (e : typ) } { f1 : typ } is sugar for { f1 = (f1 : typ) } Syntax shortcut for putting a type annotation on a record field ocaml/ocaml#6806
• Support for "(type a b)" as syntactic sugar for "(type a) (type b)" support for "(type a b ..)" as syntactic sugar for "(type a) (type b) ..." ocaml/ocaml#26
• Short functor type syntax: "S -> T" for "functor (_ : S) -> T" Short functor type syntax ocaml/ocaml#42
• Allow field punning in object copying expressions: {< x; y; >} is sugar for {< x = x; y = y; >} Add punning for object copying expressions. ocaml/ocaml#88
• Allow shortcuts for extension and attributes on all keywords: module%foo, class[@foo], etc. The attribute in "let[@foo] .. in .." is now attached to the value binding, not to the expression. (this last part won't be considered) Shortcut for extension and attributes ocaml/ocaml#342

4.02+

• Shorten syntax for functor signatures: "functor (M1:S1) (M2:S2) .. -> .." ocaml/ocaml@9e410c0

[emillon]

A related issue is how automatic we want punning to happen vs preserving concrete syntax. For example, ocamlformat is always formatting{x = x} as {x} (that's a 3.12+ shortcut) or ~x:x as ~x, but for let-punning we always preserve the syntax.

I don't think there's any advantage to preserving concrete syntax for ~x:x, but I wonder if ocamlformat should be auto-punning lets when the target version supports it.

[gpetiot]

I would be in favor of always using the last available syntax according to the target version (since there is a new option --ocaml-version users can select an older syntax) instead of preserving the syntax of the input.

[hhugo]

I've suggested in the past to preserve as much as possible in fmt_ast and have other pass/tool to rewrite sugars.

[gpetiot]

--ocaml-version should now take care of this (if there are some bugs let's open another issue).