Representation of types and declarations

Types defines the representation of types and declarations (that is, the content of module signatures).

CMI files are made of marshalled types.

Asttypes exposes basic definitions shared both by Parsetree and Types.

type atomic =

| Nonatomic
| Atomic

Whether or not a mutable field is atomic

type mutability =

| Immutable
| Mutable of {
1. mode : Mode.Value.Comonadic.lr;
  (*
  Mode of new field value in mutation.
  *)
2. atomic : atomic;
}

Describes a mutable field/element.

val is_mutable : mutability -> bool

Returns true is the mutable_flag is mutable or atomic. Should be called if not interested in the payload of Mutable.

val is_atomic : mutability -> bool

Returns true is the mutable_flag is atomic. Should be called if not interested in the payload of Mutable.

val mutable_mode : ('l * 'r) Mode.Value.Comonadic.t -> ('l * 'r) Mode.Value.t

Given the parameter m0 on mutable, return the mode of future writes.

Type expressions for the core language.

The type_desc variant defines all the possible type expressions one can find in OCaml. type_expr wraps this with some annotations.

The level field tracks the level of polymorphism associated to a type, guiding the generalization algorithm. Put shortly, when referring to a type in a given environment, both the type and the environment have a level. If the type has an higher level, then it can be considered fully polymorphic (type variables will be printed as 'a), otherwise it'll be weakly polymorphic, or non generalized (type variables printed as '_a). See http://okmij.org/ftp/ML/generalization.html for more information.

Note about type_declaration: one should not make the confusion between type_expr and type_declaration.

type_declaration refers specifically to the type construct in OCaml language, where you create and name a new type or type alias.

type_expr is used when you refer to existing types, e.g. when annotating the expected type of a value.

Also, as the type system of OCaml is generative, a type_declaration can have the side-effect of introducing a new type constructor, different from all other known types. Whereas type_expr is a pure construct which allows referring to existing types.

Note on mutability: TBD.

module Jkind_mod_bounds : sig ... end

The mod-bounds of a jkind

module With_bounds_type_info : sig ... end

Information tracked about an individual type within the with-bounds for a jkind

type type_expr

type row_desc

type row_field

type field_kind

type commutable

and type_desc =

| Tvar of {
1. name : string option;
2. jkind : jkind_lr;
}
(*
Tvar (Some "a") ==> 'a or '_a Tvar None ==> _
*)
| Tarrow of arrow_desc * type_expr * type_expr * commutable
(*
Tarrow (Nolabel, e1, e2, c) ==> e1 -> e2 Tarrow (Labelled "l", e1, e2, c) ==> l:e1 -> e2 Tarrow (Optional "l", e1, e2, c) ==> ?l:e1 -> e2
See commutable for the last argument. The argument type must be a Tpoly node
*)
| Ttuple of (string option * type_expr) list
(*
Ttuple [None, t1; ...; None, tn] ==> t1 * ... * tn Ttuple [Some "l1", t1; ...; Some "ln", tn] ==> l1:t1 * ... * ln:tn
Any mix of labeled and unlabeled components also works: Ttuple [Some "l1", t1; None, t2; Some "l3", t3] ==> l1:t1 * t2 * l3:t3
*)
| Tunboxed_tuple of (string option * type_expr) list
(*
Tunboxed_tuple [None, t1; ...; None, tn] ==> #(t1 * ... * tn) Tunboxed_tuple [Some "l1", t1; ...; Some "ln", tn] ==> #(l1:t1 * ... * ln:tn)
Any mix of labeled and unlabeled components also works: Tunboxed_tuple [Some "l1", t1; None, t2; Some "l3", t3] ==> #(l1:t1 * t2 * l3:t3)
*)
| Tconstr of Path.t * type_expr list * abbrev_memo ref
(*
Tconstr (`A.B.t', [t1;...;tn], _) ==> (t1,...,tn) A.B.t The last parameter keep tracks of known expansions, see abbrev_memo.
*)
| Tobject of type_expr * (Path.t * type_expr list) option ref
(*
Tobject (`f1:t1;...;fn: tn', `None') ==> < f1: t1; ...; fn: tn > f1, fn are represented as a linked list of types using Tfield and Tnil constructors.
Tobject (_, `Some (`A.ct', [t1;...;tn]') ==> (t1, ..., tn) A.ct. where A.ct is the type of some class.
There are also special cases for so-called "class-types", cf. Typeclass and Ctype.set_object_name:
Tobject (Tfield(_,_,...(Tfield(_,_,rv)...), Some(`A.#ct`, [rv;t1;...;tn]) ==> (t1, ..., tn) #A.ct Tobject (_, Some(`A.#ct`, [Tnil;t1;...;tn]) ==> (t1, ..., tn) A.ct
where rv is the hidden row variable.
*)
| Tfield of string * field_kind * type_expr * type_expr
(*
Tfield ("foo", field_public, t, ts) ==> <...; foo : t; ts>
*)
| Tquote of type_expr
(*
Tquote t ==> <[ t ]>
*)
| Tsplice of type_expr
(*
Tsplice t ==> $t
*)
| Tnil
(*
Tnil ==> <...; >
*)
| Tlink of type_expr
(*
Indirection used by unification engine.
*)
| Tsubst of type_expr * type_expr option
(*
Tsubst is used temporarily to store information in low-level functions manipulating representation of types, such as instantiation or copy. The first argument contains a copy of the original node. The second is available only when the first is the row variable of a polymorphic variant. It then contains a copy of the whole variant. This constructor should not appear outside of these cases.
*)
| Tvariant of row_desc
(*
Representation of polymorphic variants, see row_desc.
*)
| Tunivar of {
1. name : string option;
2. jkind : jkind_lr;
}
(*
Occurrence of a type variable introduced by a forall quantifier / Tpoly.
*)
| Tpoly of type_expr * type_expr list
(*
Tpoly (ty,tyl) ==> 'a1... 'an. ty, where 'a1 ... 'an are names given to types in tyl and occurrences of those types in ty.
*)
| Tpackage of Path.t * (Ocaml_parsing.Longident.t * type_expr) list
(*
Type of a first-class module (a.k.a package).
*)
| Tof_kind of jkind_lr
(*
Tof_kind jkind ==> (type : jkind)
The "canonical" type of a particular kind.
These types are uninhabited, and any appearing in translation will cause an error. They are only used to represent the kinds of existentially-quantified types mentioned in with-bounds. See test typing-jkind-bounds/gadt.ml
*)

and arg_label =

| Nolabel
| Labelled of string
(*
label:T -> ...
*)
| Optional of string
(*
?label:T -> ...
*)
| Position of string
(*
label:[%call_pos] -> ...
*)

This is used in the Typedtree. It is distinct from arg_label because Position argument labels are discovered through typechecking.

and arrow_desc = arg_label * Mode.Alloc.lr * Mode.Alloc.lr

and fixed_explanation =

| Univar of type_expr
(*
The row type was bound to an univar
*)
| Fixed_private
(*
The row type is private
*)
| Reified of Path.t
(*
The row was reified
*)
| Rigid
(*
The row type was made rigid during constraint verification
*)
| Fixed_existential
(*
The row type is existential in a with-bound. See Note With-bounds for GADTs in Jkind.
*)

See also documentation for row_more, which enumerates how these constructors arise.

and abbrev_memo =

| Mnil
(*
No known abbreviation
*)
| Mcons of Ocaml_parsing.Asttypes.private_flag * Path.t * type_expr * type_expr * abbrev_memo
(*
Found one abbreviation. A valid abbreviation should be at least as visible and reachable by the same path. The first expression is the abbreviation and the second the expansion.
*)
| Mlink of abbrev_memo ref
(*
Abbreviations can be found after this indirection
*)

abbrev_memo allows one to keep track of different expansions of a type alias. This is done for performance purposes.

For instance, when defining type 'a pair = 'a * 'a, when one refers to an 'a pair, it is just a shortcut for the 'a * 'a type. This expansion will be stored in the abbrev_memo of the corresponding Tconstr node.

In practice, abbrev_memo behaves like list of expansions with a mutable tail.

Note on marshalling: abbrev_memo must not appear in saved types. Btype, with cleanup_abbrev and memo, takes care of tracking and removing abbreviations.

commutable is a flag appended to every arrow type.

When typing an application, if the type of the functional is known, its type is instantiated with commu_ok arrows, otherwise as commu_var ().

When the type is not known, the application will be used to infer the actual type. This is fragile in presence of labels where there is no principal type.

Two incompatible applications must rely on is_commu_ok arrows, otherwise they will trigger an error.

let f g = g ~a:() ~b:(); g ~b:() ~a:();

Error: This function is applied to arguments in an order different from other calls. This is only allowed when the real type is known.

and jkind_history =

| Interact of {
1. reason : Jkind_intf.History.interact_reason;
2. jkind1 : jkind_desc_packed;
3. history1 : jkind_history;
4. jkind2 : jkind_desc_packed;
5. history2 : jkind_history;
}
| Creation of Jkind_intf.History.creation_reason

A history of conditions placed on a jkind.

INVARIANT: at most one sort variable appears in this history. This is a natural consequence of producing this history by comparing jkinds.

and with_bounds_types

The types within the with-bounds of a jkind

and 'd with_bounds =

| No_with_bounds : ('l * 'r) with_bounds
| With_bounds : with_bounds_types -> ('l * Allowance.disallowed) with_bounds
(*
Invariant : there must always be at least one type in this set *
*)

and ('layout, 'd) layout_and_axes = {

layout : 'layout;
mod_bounds : Jkind_mod_bounds.t;
with_bounds : 'd with_bounds;

} constraint 'd = 'l * 'r

and 'd jkind_desc =
  (Jkind_types.Sort.t Jkind_types.Layout.t, 'd) layout_and_axes constraint 'd = 'l * 'r

and jkind_desc_packed =

| Pack_jkind_desc : ('l * 'r) jkind_desc -> jkind_desc_packed

and 'd jkind_quality =

| Best : ('l * Allowance.disallowed) jkind_quality
| Not_best : ('l * 'r) jkind_quality

The "quality" of a jkind indicates whether we are able to learn more about the jkind later.

We can never learn more about a Best jkind to make it "lower" (according to Jkind.sub / Jkind.sub_jkind_l). A Not_best, jkind, however, might have more information provided about it later that makes it lower.

Note that only left jkinds can be Best (meaning we can never compare less than or equal to a left jkind!)

and 'd jkind = {

jkind : 'd jkind_desc;
annotation : Ocaml_parsing.Parsetree.jkind_annotation option;
history : jkind_history;
has_warned : bool;
ran_out_of_fuel_during_normalize : bool;
quality : 'd jkind_quality;

} constraint 'd = 'l * 'r

and jkind_l = (Allowance.allowed * Allowance.disallowed) jkind

and jkind_r = (Allowance.disallowed * Allowance.allowed) jkind

and jkind_lr = (Allowance.allowed * Allowance.allowed) jkind

and jkind_packed =

| Pack_jkind : ('l * 'r) jkind -> jkind_packed

module With_bounds_types : sig ... end

val is_commu_ok : commutable -> bool

val commu_ok : commutable

val commu_var : unit -> commutable

field_kind indicates the accessibility of a method.

An Fprivate field may become Fpublic or Fabsent during unification, but not the other way round.

The same field_kind is kept shared when copying Tfield nodes so that the copies of the self-type of a class share the same accessibility (see also PR#10539).

type field_kind_view =

| Fprivate
| Fpublic
| Fabsent

val field_kind_repr : field_kind -> field_kind_view

val field_public : field_kind

val field_absent : field_kind

val field_private : unit -> field_kind

val field_kind_internal_repr : field_kind -> field_kind

Getters for type_expr; calls repr before answering a value

val get_desc : type_expr -> type_desc

val get_level : type_expr -> int

val get_scope : type_expr -> int

val get_id : type_expr -> int

type type_mark

Access to marks. They are stored in the scope field.

val with_type_mark : (type_mark -> 'a) -> 'a

val not_marked_node : type_mark -> type_expr -> bool

val try_mark_node : type_mark -> type_expr -> bool

type transient_expr = private {

mutable desc : type_desc;
mutable level : int;
mutable scope : scope_field;
id : int;

}

Transient type_expr. Should only be used immediately after Transient_expr.repr

and scope_field

module Transient_expr : sig ... end

Operations on transient_expr

val create_expr : type_desc -> level:int -> scope:int -> id:int -> type_expr

Functions and definitions moved from Btype

val newty3 : level:int -> scope:int -> type_desc -> type_expr

Create a type with a fresh id

val newty2 : level:int -> type_desc -> type_expr

Create a type with a fresh id and no scope

module TransientTypeOps : sig ... end

Comparisons for functors

module TransientTypeHash : Hashtbl.S with type key = transient_expr

Comparisons for type_expr; cannot be used for functors

val eq_type : type_expr -> type_expr -> bool

val compare_type : type_expr -> type_expr -> int

Constructor and accessors for row_desc

`X | `Y (row_closed = true) < `X | `Y (row_closed = true) > `X | `Y (row_closed = false) < `X | `Y > `X (row_closed = true)

type t = > `X as 'a (row_more = Tvar a) type t = private > `X (row_more = Tconstr ("t#row", , ref Mnil))

And for:

let f = function `X -> `X -> | `Y -> `X

the type of "f" will be a Tarrow whose lhs will (basically) be:

Tvariant row_fields = [("X", _)]; row_more = Tvariant { row_fields = [("Y", _)]; row_more = Tvariant { row_fields = []; row_more = _; _; _

}

; _

}

val create_row : 
  fields:(Ocaml_parsing.Asttypes.label * row_field) list ->
  more:type_expr ->
  closed:bool ->
  fixed:fixed_explanation option ->
  name:(Path.t * type_expr list) option ->
  row_desc

val row_fields : row_desc -> (Ocaml_parsing.Asttypes.label * row_field) list

val row_more : row_desc -> type_expr

row_more returns a type_expr with one of the following type_descs (also described with the return from row_fixed, which varies similarly):

* Tvar: This is a row variable; it would occur in e.g. val f : [> `A | `B] -> int. When/if we learn more about a polymorphic variant, this variable might get unified with one of the other type_descs listed here, or a Tvariant that represents a new set of constructors to add to the row.

During constraint checking (toward the end of checking a type declaration, in Typedecl.check_constraints_rec) we Ctype.rigidify a type to make it so that its unification variables will not unify. When a Tvar row variable is rigidified, its fixed_explanation will be Rigid.

* Tunivar: This is a universally quantified row variable; it would occur in e.g. type t = { f : 'a. ([> `A | `B ] as 'a) -> int }. A Tunivar has a fixed_explanation of Univar.

* Tconstr: There are two possible ways this can happen:

1. This is an abstract #row type created by a private row type, as in type t = private [> `A | `B]. In this case, the fixed_explanation will be Fixed_private.

2. This is a locally abstract type created by Ctype.reify, which happens when a row variable is free in the type of the scrutinee in a GADT pattern match. The fixed_explanation will be Reified. Note that any manifest of a reified row variable is actually ignored by row_repr; this causes some incompletness in type inference.

* Tnil: Used to denote a static polymorphic variant (with no > or <).

* Tof_kind: See Wrinkle BW2 in Note With-bounds for GADTs in Jkind. Briefly, Tof_kind can appear as a row_more when computing the kind of a GADT with an existentially-bound row variable. The fixed_explanation will be Fixed_existential.

----------------------------------------

It is an invariant that row variables are never shared between different types. That is, if row_more row1 == row_more row2, then row1 and row2 come from structurally identical Tvariants (but they might not be physically equal). When copying types, two types with the same row_more field are replaced by the same copy.

val row_closed : row_desc -> bool

val row_fixed : row_desc -> fixed_explanation option

See documentation for row_more.

val row_name : row_desc -> (Path.t * type_expr list) option

val set_row_name : row_desc -> (Path.t * type_expr list) option -> row_desc

val get_row_field : Ocaml_parsing.Asttypes.label -> row_desc -> row_field

type row_desc_repr =

| Row of {
1. fields : (Ocaml_parsing.Asttypes.label * row_field) list;
2. more : type_expr;
3. closed : bool;
4. fixed : fixed_explanation option;
5. name : (Path.t * type_expr list) option;
}

get all fields at once; different from the old row_repr

val row_repr : row_desc -> row_desc_repr

type row_field_view =

| Rpresent of type_expr option
| Reither of bool * type_expr list * bool
| Rabsent

Current contents of a row field

val row_field_repr : row_field -> row_field_view

val rf_present : type_expr option -> row_field

val rf_absent : row_field

val rf_either : 
  ?use_ext_of:row_field ->
  no_arg:bool ->
  type_expr list ->
  matched:bool ->
  row_field

val rf_either_of : type_expr option -> row_field

val eq_row_field_ext : row_field -> row_field -> bool

val changed_row_field_exts : row_field list -> (unit -> unit) -> bool

val match_row_field : 
  present:(type_expr option -> 'a) ->
  absent:(unit -> 'a) ->
  either:(bool -> type_expr list -> bool -> row_field option -> 'a) ->
  row_field ->
  'a

module Uid = Shape.Uid

module MethSet : Set.S with type elt = string

module VarSet : Set.S with type elt = string

module Meths : Map.S with type key = string

module Vars : Map.S with type key = string

type value_kind =

| Val_reg of Jkind_types.Sort.t
| Val_mut of Mode.Value.Comonadic.lr * Jkind_types.Sort.t
| Val_prim of Primitive.description
| Val_ivar of Ocaml_parsing.Asttypes.mutable_flag * string
| Val_self of class_signature * self_meths * Ident.t Vars.t * string
| Val_anc of class_signature * Ident.t Meths.t * string

and self_meths =

| Self_concrete of Ident.t Meths.t
| Self_virtual of Ident.t Meths.t ref

and class_signature = {

csig_self : type_expr;
mutable csig_self_row : type_expr;
mutable csig_vars : (Ocaml_parsing.Asttypes.mutable_flag * Ocaml_parsing.Asttypes.virtual_flag * type_expr) Vars.t;
mutable csig_meths : (method_privacy * Ocaml_parsing.Asttypes.virtual_flag * type_expr) Meths.t;

}

and method_privacy =

| Mpublic
| Mprivate of field_kind

module Variance : sig ... end

module Separability : sig ... end

see Typedecl_separability for an explanation of separability and separability modes.

type type_declaration = {

type_params : type_expr list;
type_arity : int;
type_kind : type_decl_kind;
type_jkind : jkind_l;
type_private : Ocaml_parsing.Asttypes.private_flag;
type_manifest : type_expr option;
type_variance : Variance.t list;
type_separability : Separability.t list;
type_is_newtype : bool;
type_expansion_scope : int;
type_loc : Ocaml_parsing.Location.t;
type_attributes : Ocaml_parsing.Parsetree.attributes;
type_unboxed_default : bool;
type_uid : Uid.t;
type_unboxed_version : type_declaration option;

}

and type_decl_kind =
  (label_declaration, label_declaration, constructor_declaration) type_kind

and unsafe_mode_crossing = {

unsafe_mod_bounds : Mode.Crossing.t;
unsafe_with_bounds : (Allowance.allowed * Allowance.disallowed) with_bounds;

}

and ('lbl, 'lbl_flat, 'cstr) type_kind =

| Type_abstract of type_origin
| Type_record of 'lbl list * record_representation * unsafe_mode_crossing option
| Type_record_unboxed_product of 'lbl_flat list * record_unboxed_product_representation * unsafe_mode_crossing option
| Type_variant of 'cstr list * variant_representation * unsafe_mode_crossing option
| Type_open

and tag =

| Ordinary of {
1. src_index : int;
2. runtime_tag : int;
}
| Extension of Path.t
| Null

and mixed_block_element =

| Value
| Float_boxed
| Float64
| Float32
| Bits8
| Bits16
| Untagged_immediate
| Bits32
| Bits64
| Vec128
| Vec256
| Vec512
| Word
| Product of mixed_product_shape
| Void

and mixed_product_shape = mixed_block_element array

and type_origin =

| Definition
| Rec_check_regularity
| Existential of string

and module_representation = Jkind_types.Sort.t array

and record_representation =

| Record_unboxed
| Record_inlined of tag * constructor_representation * variant_representation
| Record_boxed of Jkind_types.Sort.Const.t array
| Record_float
| Record_ufloat
| Record_mixed of mixed_product_shape

and record_unboxed_product_representation =

| Record_unboxed_product

and variant_representation =

| Variant_unboxed
| Variant_boxed of (constructor_representation * Jkind_types.Sort.Const.t array) array
| Variant_extensible
| Variant_with_null

and constructor_representation =

| Constructor_uniform_value
| Constructor_mixed of mixed_product_shape

and label_declaration = {

ld_id : Ident.t;
ld_mutable : mutability;
ld_modalities : Mode.Modality.Const.t;
ld_type : type_expr;
ld_sort : Jkind_types.Sort.Const.t;
ld_loc : Ocaml_parsing.Location.t;
ld_attributes : Ocaml_parsing.Parsetree.attributes;
ld_uid : Uid.t;

}

and constructor_declaration = {

cd_id : Ident.t;
cd_args : constructor_arguments;
cd_res : type_expr option;
cd_loc : Ocaml_parsing.Location.t;
cd_attributes : Ocaml_parsing.Parsetree.attributes;
cd_uid : Uid.t;

}

and constructor_argument = {

ca_modalities : Mode.Modality.Const.t;
ca_type : type_expr;
ca_sort : Jkind_types.Sort.Const.t;
ca_loc : Ocaml_parsing.Location.t;

}

and constructor_arguments =

| Cstr_tuple of constructor_argument list
| Cstr_record of label_declaration list

val tys_of_constr_args : constructor_arguments -> type_expr list

val find_unboxed_type : 
  type_declaration ->
  (type_expr * Mode.Modality.Const.t) option

type extension_constructor = {

ext_type_path : Path.t;
ext_type_params : type_expr list;
ext_args : constructor_arguments;
ext_shape : constructor_representation;
ext_constant : bool;
ext_ret_type : type_expr option;
ext_private : Ocaml_parsing.Asttypes.private_flag;
ext_loc : Ocaml_parsing.Location.t;
ext_attributes : Ocaml_parsing.Parsetree.attributes;
ext_uid : Uid.t;

}

and type_transparence =

| Type_public
| Type_new
| Type_private

type class_type =

| Cty_constr of Path.t * type_expr list * class_type
| Cty_signature of class_signature
| Cty_arrow of arg_label * type_expr * class_type

type class_declaration = {

cty_params : type_expr list;
mutable cty_type : class_type;
cty_path : Path.t;
cty_new : type_expr option;
cty_variance : Variance.t list;
cty_loc : Ocaml_parsing.Location.t;
cty_attributes : Ocaml_parsing.Parsetree.attributes;
cty_uid : Uid.t;

}

type class_type_declaration = {

clty_params : type_expr list;
clty_type : class_type;
clty_path : Path.t;
clty_hash_type : type_declaration;
clty_variance : Variance.t list;
clty_loc : Ocaml_parsing.Location.t;
clty_attributes : Ocaml_parsing.Parsetree.attributes;
clty_uid : Uid.t;

}

type visibility =

| Exported
| Hidden

type rec_status =

| Trec_not
| Trec_first
| Trec_next

type ext_status =

| Text_first
| Text_next
| Text_exception

type module_presence =

| Mp_present
| Mp_absent

module Aliasability : sig ... end

module type Wrap = sig ... end

module type Wrapped = sig ... end

module Make_wrapped (Wrap : Wrap) : Wrapped with type 'a wrapped = 'a Wrap.t

module Map_wrapped (From : Wrapped) (To : Wrapped) : sig ... end

include Wrapped with type 'a wrapped = 'a

type 'a wrapped = 'a

type value_description = {

val_type : type_expr wrapped;
val_modalities : Mode.Modality.t;
val_kind : value_kind;
val_loc : Ocaml_parsing.Location.t;
val_zero_alloc : Zero_alloc.t;
val_attributes : Ocaml_parsing.Parsetree.attributes;
val_uid : Uid.t;

}

type module_type =

| Mty_ident of Path.t
| Mty_signature of signature
| Mty_functor of functor_parameter * module_type
| Mty_alias of Path.t
| Mty_strengthen of module_type * Path.t * Aliasability.t
| Mty_for_hole

and functor_parameter =

| Unit
| Named of Ident.t option * module_type

and signature = signature_item list wrapped

and signature_item =

| Sig_value of Ident.t * value_description * visibility
| Sig_type of Ident.t * type_declaration * rec_status * visibility
| Sig_typext of Ident.t * extension_constructor * ext_status * visibility
| Sig_module of Ident.t * module_presence * module_declaration * rec_status * visibility
| Sig_modtype of Ident.t * modtype_declaration * visibility
| Sig_class of Ident.t * class_declaration * rec_status * visibility
| Sig_class_type of Ident.t * class_type_declaration * rec_status * visibility

and module_declaration = {

md_type : module_type;
md_modalities : Mode.Modality.t;
md_attributes : Ocaml_parsing.Parsetree.attributes;
md_loc : Ocaml_parsing.Location.t;
md_uid : Uid.t;

}

and modtype_declaration = {

mtd_type : module_type option;
mtd_attributes : Ocaml_parsing.Parsetree.attributes;
mtd_loc : Ocaml_parsing.Location.t;
mtd_uid : Uid.t;

}

val sort_of_signature_item : signature_item -> Jkind_types.Sort.t option

val item_visibility : signature_item -> visibility

type constructor_description = {

cstr_name : string;
cstr_res : type_expr;
cstr_existentials : type_expr list;
cstr_args : constructor_argument list;
cstr_arity : int;
cstr_tag : tag;
cstr_repr : variant_representation;
cstr_shape : constructor_representation;
cstr_constant : bool;
cstr_consts : int;
cstr_nonconsts : int;
cstr_generalized : bool;
cstr_private : Ocaml_parsing.Asttypes.private_flag;
cstr_loc : Ocaml_parsing.Location.t;
cstr_attributes : Ocaml_parsing.Parsetree.attributes;
cstr_inlined : type_declaration option;
cstr_uid : Uid.t;

}

val equal_tag : tag -> tag -> bool

val compare_tag : tag -> tag -> int

val may_equal_constr : 
  constructor_description ->
  constructor_description ->
  bool

val equal_record_representation : 
  record_representation ->
  record_representation ->
  bool

val equal_record_unboxed_product_representation : 
  record_unboxed_product_representation ->
  record_unboxed_product_representation ->
  bool

val equal_variant_representation : 
  variant_representation ->
  variant_representation ->
  bool

type 'a gen_label_description = {

lbl_name : string;
lbl_res : type_expr;
lbl_arg : type_expr;
lbl_mut : mutability;
lbl_modalities : Mode.Modality.Const.t;
lbl_sort : Jkind_types.Sort.Const.t;
lbl_pos : int;
lbl_all : 'a gen_label_description array;
lbl_repres : 'a;
lbl_private : Ocaml_parsing.Asttypes.private_flag;
lbl_loc : Ocaml_parsing.Location.t;
lbl_attributes : Ocaml_parsing.Parsetree.attributes;
lbl_uid : Uid.t;

}

type label_description = record_representation gen_label_description

type unboxed_label_description =
  record_unboxed_product_representation gen_label_description

type _ record_form =

| Legacy : record_representation record_form
| Unboxed_product : record_unboxed_product_representation record_form

This type tracks the distinction between legacy records ({ field }) and unboxed records (#{ field }). Note that Legacy includes normal boxed records, as well as inlined and [@@unboxed] records.

As a GADT, it also lets us avoid duplicating functions that handle both record forms, such as Env.find_label_by_name, which has type 'rep record_form -> Longident.t -> Env.t -> 'rep gen_label_description.

type record_form_packed =

| P : _ record_form -> record_form_packed

val record_form_to_string : _ record_form -> string

val mixed_block_element_of_const_sort : 
  Jkind_types.Sort.Const.t ->
  mixed_block_element

val bound_value_identifiers : signature -> Ident.t list

Extracts the list of "value" identifiers bound by a signature. "Value" identifiers are identifiers for signature components that correspond to a run-time value: values, extensions, modules, classes. Note: manifest primitives do not correspond to a run-time value!

val bound_value_identifiers_and_sorts : 
  signature ->
  (Ident.t * Jkind_types.Sort.t) list

Like bound_value_identifiers, but also return sorts

val signature_item_id : signature_item -> Ident.t

val equal_mixed_block_element : 
  mixed_block_element ->
  mixed_block_element ->
  bool

val compare_mixed_block_element : 
  mixed_block_element ->
  mixed_block_element ->
  int

val mixed_block_element_to_string : mixed_block_element -> string

val mixed_block_element_to_lowercase_string : mixed_block_element -> string

val equal_unsafe_mode_crossing : 
  type_equal:(type_expr -> type_expr -> bool) ->
  unsafe_mode_crossing ->
  unsafe_mode_crossing ->
  bool

type snapshot

val snapshot : unit -> snapshot

val backtrack : cleanup_abbrev:(unit -> unit) -> snapshot -> unit

val undo_first_change_after : snapshot -> unit

val undo_compress : snapshot -> unit

Functions to use when modifying a type (only Ctype?). The old values are logged and reverted on backtracking.

val link_type : type_expr -> type_expr -> unit

val set_type_desc : type_expr -> type_desc -> unit

val set_level : type_expr -> int -> unit

val set_scope : type_expr -> int -> unit

val set_var_jkind : type_expr -> jkind_lr -> unit

val set_name : 
  (Path.t * type_expr list) option ref ->
  (Path.t * type_expr list) option ->
  unit

val link_row_field_ext : inside:row_field -> row_field -> unit

val set_univar : type_expr option ref -> type_expr -> unit

val link_kind : inside:field_kind -> field_kind -> unit

val link_commu : inside:commutable -> commutable -> unit

val set_commu_ok : commutable -> unit

val functor_param_mode : Mode.Alloc.lr

val functor_res_mode : Mode.Alloc.lr

val is_valid : snapshot -> bool

check if a snapshot has been invalidated

val on_backtrack : (unit -> unit) -> unit

also register changes to arbitrary references

val linked_variables : unit -> int

Number of unification variables that have been linked so far. Used to estimate the "cost" of unification.