Currently, in signatures, extensible variant constructors can be declared for types of abstract kind:

module type S = sig
  type t
  type t += Foo
end

This is a useful feature allowing constructors to be created by functors without exposing the underlying extensiblity. See the msg.ml example in the testsuite for a nice example of this. However, it also allows nonsensical signatures to be created:

module type S = sig
  type int += A_new_number
end

This doesn't cause any soundness issues but it does cause difficulties for the compiler. For example:

# module F (X : sig type int += A_new_number end) = struct
    let f = function
      | X.A_new_number | 0 -> true
      | _ -> false
  end;;
Fatal error: exception File "typing/parmatch.ml", line 109, characters 6-12: Assertion failed

It also makes changes like #792 unnecessarily difficult. In general it is quite awkward to support having constructors available for arbitrary types.

This PR adds a notion of "private" extensible variant type:

module type S = sig
  type t = private ..
  type t += Foo
end

which are visibly extensible but cannot actually be extended. This allows us to make it illegal to extend a type which is not known to be extensible:

module type S = sig
  type t
  type t += Foo
end;;
      Characters 31-44:
    type t += Foo
    ^^^^^^^^^^^^^
Error: Type definition t is not extensible

and so avoid the various problems described above whilst still allowing the use cases previously supported with extensions to abstract types.

This change is not backwards compatible, however extending abstract types is a little used and undocumented feature so I doubt that there will be much disruption.