Extension points
type attribute = Parsetree.attribute
type attributes = attribute list
Core language
type pattern = {
pat_desc : pattern_desc;
pat_loc : Location.t;
pat_extra : (pat_extra * Location.t * attributes) list;
pat_type : Types.type_expr;
mutable pat_env : Env.t;
pat_attributes : attributes;
}
and pat_extra =
| Tpat_constraint of core_type
P : T
pat_desc = P ; pat_extra = (Tpat_constraint T, _, _) :: ...
| Tpat_type of Path.t * Longident.t Asttypes.loc
#tconst
pat_desc = disjunction ; pat_extra = (Tpat_type (P, "tconst"), _, _) :: ...
where
disjunction
is aTpat_or _
representing the branches oftconst
.| Tpat_open of Path.t * Longident.t Asttypes.loc * Env.t
| Tpat_unpack
(module P)
pat_desc = Tpat_var "P" ; pat_extra = (Tpat_unpack, _, _) :: ...
and pattern_desc =
| Tpat_any
_
| Tpat_var of Ident.t * string Asttypes.loc
x
| Tpat_alias of pattern * Ident.t * string Asttypes.loc
P as a
| Tpat_constant of Asttypes.constant
1, 'a', "true", 1.0, 1l, 1L, 1n
| Tpat_tuple of pattern list
(P1, ..., Pn)
Invariant: n >= 2
| Tpat_construct of Longident.t Asttypes.loc * Types.constructor_description * pattern list
C C P
P
C (P1, ..., Pn)P1; ...; Pn
| Tpat_variant of Asttypes.label * pattern option * Types.row_desc Stdlib.ref
`A (None) `A P (Some P)
See
Types.row_desc
for an explanation of the last parameter.| Tpat_record of (Longident.t Asttypes.loc * Types.label_description * pattern) list * Asttypes.closed_flag
l1=P1; ...; ln=Pn
(flag = Closed)l1=P1; ...; ln=Pn; _
(flag = Open)Invariant: n > 0
| Tpat_array of pattern list
| P1; ...; Pn |
| Tpat_or of pattern * pattern * Types.row_desc option
P1 | P2
row_desc
=Some _
when translatingPpat_type _
,None
otherwise.| Tpat_lazy of pattern
lazy P
| Tpat_exception of pattern
exception P
and expression = {
exp_desc : expression_desc;
exp_loc : Location.t;
exp_extra : (exp_extra * Location.t * attributes) list;
exp_type : Types.type_expr;
exp_env : Env.t;
exp_attributes : attributes;
}
and exp_extra =
| Texp_constraint of core_type
E : T
| Texp_coerce of core_type option * core_type
E :> T
Texp_coerce (None, T)
E : T0 :> TTexp_coerce (Some T0, T)
| Texp_poly of core_type option
Used for method bodies.
| Texp_newtype of string
fun (type t) ->
and expression_desc =
| Texp_ident of Path.t * Longident.t Asttypes.loc * Types.value_description
x M.x
| Texp_constant of Asttypes.constant
1, 'a', "true", 1.0, 1l, 1L, 1n
| Texp_let of Asttypes.rec_flag * value_binding list * expression
let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive) let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)
| Texp_function of {
arg_label : Asttypes.arg_label;
param : Ident.t;
cases : case list;
partial : partial;
}
Pexp_fun
andPexp_function
both translate toTexp_function
. SeeParsetree
for more details.param
is the identifier that is to be used to name the parameter of the function.partial =
Partial
if the pattern match is partialTotal
otherwise.| Texp_apply of expression * (Asttypes.arg_label * expression option) list
E0 ~l1:E1 ... ~ln:En
The expression can be None if the expression is abstracted over this argument. It currently appears when a label is applied.
For example: let f x ~y = x + y in f ~y:3
The resulting typedtree for the application is: Texp_apply (Texp_ident "f/1037",
(Nolabel, None); (Labelled "y", Some (Texp_constant Const_int 3))
)| Texp_match of expression * case list * partial
match E0 with | P1 -> E1 | P2 | exception P3 -> E2 | exception P4 -> E3
Texp_match (E0, [(P1, E1); (P2 | exception P3, E2); (exception P4, E3)], _)
| Texp_try of expression * case list
try E with P1 -> E1 | ... | PN -> EN
| Texp_tuple of expression list
(E1, ..., EN)
| Texp_construct of Longident.t Asttypes.loc * Types.constructor_description * expression list
C C E
E
C (E1, ..., En)E1;...;En
| Texp_variant of Asttypes.label * expression option
| Texp_record of {
fields : (Types.label_description * record_label_definition) array;
representation : Types.record_representation;
extended_expression : expression option;
}
l1=P1; ...; ln=Pn
(extended_expression = None)E0 with l1=P1; ...; ln=Pn
(extended_expression = Some E0)Invariant: n > 0
If the type is
l1: t1; l2: t2
, the expressionE0 with t2=P2
is represented as Texp_recordfields = [| l1, Kept t1; l2 Override P2 |]; representation; extended_expression = Some E0
| Texp_field of expression * Longident.t Asttypes.loc * Types.label_description
| Texp_setfield of expression * Longident.t Asttypes.loc * Types.label_description * expression
| Texp_array of expression list
| Texp_ifthenelse of expression * expression * expression option
| Texp_sequence of expression * expression
| Texp_while of expression * expression
| Texp_for of Ident.t * Parsetree.pattern * expression * expression * Asttypes.direction_flag * expression
| Texp_send of expression * meth * expression option
| Texp_new of Path.t * Longident.t Asttypes.loc * Types.class_declaration
| Texp_instvar of Path.t * Path.t * string Asttypes.loc
| Texp_setinstvar of Path.t * Path.t * string Asttypes.loc * expression
| Texp_override of Path.t * (Path.t * string Asttypes.loc * expression) list
| Texp_letmodule of Ident.t * string Asttypes.loc * Types.module_presence * module_expr * expression
| Texp_letexception of extension_constructor * expression
| Texp_assert of expression
| Texp_lazy of expression
| Texp_object of class_structure * string list
| Texp_pack of module_expr
| Texp_letop of {
let_ : binding_op;
ands : binding_op list;
param : Ident.t;
body : case;
partial : partial;
}
| Texp_unreachable
| Texp_extension_constructor of Longident.t Asttypes.loc * Path.t
| Texp_open of open_declaration * expression
let open
!
M in eand meth =
| Tmeth_name of string
| Tmeth_val of Ident.t
and case = {
c_lhs : pattern;
c_guard : expression option;
c_rhs : expression;
}
and record_label_definition =
| Kept of Types.type_expr
| Overridden of Longident.t Asttypes.loc * expression
and binding_op = {
bop_op_path : Path.t;
bop_op_name : string Asttypes.loc;
bop_op_val : Types.value_description;
bop_op_type : Types.type_expr;
bop_exp : expression;
bop_loc : Location.t;
}
and class_expr = {
cl_desc : class_expr_desc;
cl_loc : Location.t;
cl_type : Types.class_type;
cl_env : Env.t;
cl_attributes : attributes;
}
and class_expr_desc =
| Tcl_ident of Path.t * Longident.t Asttypes.loc * core_type list
| Tcl_structure of class_structure
| Tcl_fun of Asttypes.arg_label * pattern * (Ident.t * expression) list * class_expr * partial
| Tcl_apply of class_expr * (Asttypes.arg_label * expression option) list
| Tcl_let of Asttypes.rec_flag * value_binding list * (Ident.t * expression) list * class_expr
| Tcl_constraint of class_expr * class_type option * string list * string list * Types.Concr.t
| Tcl_open of open_description * class_expr
and class_structure = {
cstr_self : pattern;
cstr_fields : class_field list;
cstr_type : Types.class_signature;
cstr_meths : Ident.t Types.Meths.t;
}
and class_field = {
cf_desc : class_field_desc;
cf_loc : Location.t;
cf_attributes : attributes;
}
and class_field_kind =
| Tcfk_virtual of core_type
| Tcfk_concrete of Asttypes.override_flag * expression
and class_field_desc =
| Tcf_inherit of Asttypes.override_flag * class_expr * string option * (string * Ident.t) list * (string * Ident.t) list
| Tcf_val of string Asttypes.loc * Asttypes.mutable_flag * Ident.t * class_field_kind * bool
| Tcf_method of string Asttypes.loc * Asttypes.private_flag * class_field_kind
| Tcf_constraint of core_type * core_type
| Tcf_initializer of expression
| Tcf_attribute of attribute
and module_expr = {
mod_desc : module_expr_desc;
mod_loc : Location.t;
mod_type : Types.module_type;
mod_env : Env.t;
mod_attributes : attributes;
}
and module_type_constraint =
| Tmodtype_implicit
The module type constraint has been synthesized during typechecking.
| Tmodtype_explicit of module_type
The module type was in the source file.
Annotations for
Tmod_constraint
.
and module_expr_desc =
| Tmod_ident of Path.t * Longident.t Asttypes.loc
| Tmod_structure of structure
| Tmod_functor of Ident.t * string Asttypes.loc * module_type option * module_expr
| Tmod_apply of module_expr * module_expr * module_coercion
| Tmod_constraint of module_expr * Types.module_type * module_type_constraint * module_coercion
ME (constraint = Tmodtype_implicit) (ME : MT) (constraint = Tmodtype_explicit MT)
| Tmod_unpack of expression * Types.module_type
and structure = {
str_items : structure_item list;
str_type : Types.signature;
str_final_env : Env.t;
}
and structure_item = {
str_desc : structure_item_desc;
str_loc : Location.t;
str_env : Env.t;
}
and structure_item_desc =
| Tstr_eval of expression * attributes
| Tstr_value of Asttypes.rec_flag * value_binding list
| Tstr_primitive of value_description
| Tstr_type of Asttypes.rec_flag * type_declaration list
| Tstr_typext of type_extension
| Tstr_exception of type_exception
| Tstr_module of module_binding
| Tstr_recmodule of module_binding list
| Tstr_modtype of module_type_declaration
| Tstr_open of open_declaration
| Tstr_class of (class_declaration * string list) list
| Tstr_class_type of (Ident.t * string Asttypes.loc * class_type_declaration) list
| Tstr_include of include_declaration
| Tstr_attribute of attribute
and module_binding = {
mb_id : Ident.t;
mb_name : string Asttypes.loc;
mb_presence : Types.module_presence;
mb_expr : module_expr;
mb_attributes : attributes;
mb_loc : Location.t;
}
and value_binding = {
vb_pat : pattern;
vb_expr : expression;
vb_attributes : attributes;
vb_loc : Location.t;
}
and module_coercion =
| Tcoerce_none
| Tcoerce_structure of (int * module_coercion) list * (Ident.t * int * module_coercion) list
| Tcoerce_functor of module_coercion * module_coercion
| Tcoerce_primitive of primitive_coercion
| Tcoerce_alias of Env.t * Path.t * module_coercion
and module_type = {
mty_desc : module_type_desc;
mty_type : Types.module_type;
mty_env : Env.t;
mty_loc : Location.t;
mty_attributes : attributes;
}
and module_type_desc =
| Tmty_ident of Path.t * Longident.t Asttypes.loc
| Tmty_signature of signature
| Tmty_functor of Ident.t * string Asttypes.loc * module_type option * module_type
| Tmty_with of module_type * (Path.t * Longident.t Asttypes.loc * with_constraint) list
| Tmty_typeof of module_expr
| Tmty_alias of Path.t * Longident.t Asttypes.loc
and primitive_coercion = {
pc_desc : Primitive.description;
pc_type : Types.type_expr;
pc_env : Env.t;
pc_loc : Location.t;
}
and signature = {
sig_items : signature_item list;
sig_type : Types.signature;
sig_final_env : Env.t;
}
and signature_item = {
sig_desc : signature_item_desc;
sig_env : Env.t;
sig_loc : Location.t;
}
and signature_item_desc =
| Tsig_value of value_description
| Tsig_type of Asttypes.rec_flag * type_declaration list
| Tsig_typesubst of type_declaration list
| Tsig_typext of type_extension
| Tsig_exception of type_exception
| Tsig_module of module_declaration
| Tsig_modsubst of module_substitution
| Tsig_recmodule of module_declaration list
| Tsig_modtype of module_type_declaration
| Tsig_open of open_description
| Tsig_include of include_description
| Tsig_class of class_description list
| Tsig_class_type of class_type_declaration list
| Tsig_attribute of attribute
and module_declaration = {
md_id : Ident.t;
md_name : string Asttypes.loc;
md_presence : Types.module_presence;
md_type : module_type;
md_attributes : attributes;
md_loc : Location.t;
}
and module_substitution = {
ms_id : Ident.t;
ms_name : string Asttypes.loc;
ms_manifest : Path.t;
ms_txt : Longident.t Asttypes.loc;
ms_attributes : attributes;
ms_loc : Location.t;
}
and module_type_declaration = {
mtd_id : Ident.t;
mtd_name : string Asttypes.loc;
mtd_type : module_type option;
mtd_attributes : attributes;
mtd_loc : Location.t;
}
and 'a open_infos = {
open_expr : 'a;
open_bound_items : Types.signature;
open_override : Asttypes.override_flag;
open_env : Env.t;
open_loc : Location.t;
open_attributes : attribute list;
}
and open_description = (Path.t * Longident.t Asttypes.loc) open_infos
and open_declaration = module_expr open_infos
and 'a include_infos = {
incl_mod : 'a;
incl_type : Types.signature;
incl_loc : Location.t;
incl_attributes : attribute list;
}
and include_description = module_type include_infos
and include_declaration = module_expr include_infos
and with_constraint =
| Twith_type of type_declaration
| Twith_module of Path.t * Longident.t Asttypes.loc
| Twith_typesubst of type_declaration
| Twith_modsubst of Path.t * Longident.t Asttypes.loc
and core_type = {
mutable ctyp_desc : core_type_desc;
mutable because of
Typeclass.declare_method
mutable ctyp_type : Types.type_expr;
mutable because of
Typeclass.declare_method
ctyp_env : Env.t;
ctyp_loc : Location.t;
ctyp_attributes : attributes;
}
and core_type_desc =
| Ttyp_any
| Ttyp_var of string
| Ttyp_arrow of Asttypes.arg_label * core_type * core_type
| Ttyp_tuple of core_type list
| Ttyp_constr of Path.t * Longident.t Asttypes.loc * core_type list
| Ttyp_object of object_field list * Asttypes.closed_flag
| Ttyp_class of Path.t * Longident.t Asttypes.loc * core_type list
| Ttyp_alias of core_type * string
| Ttyp_variant of row_field list * Asttypes.closed_flag * Asttypes.label list option
| Ttyp_poly of string list * core_type
| Ttyp_package of package_type
and package_type = {
pack_path : Path.t;
pack_fields : (Longident.t Asttypes.loc * core_type) list;
pack_type : Types.module_type;
pack_txt : Longident.t Asttypes.loc;
}
and row_field = {
rf_desc : row_field_desc;
rf_loc : Location.t;
rf_attributes : attributes;
}
and row_field_desc =
| Ttag of string Asttypes.loc * bool * core_type list
| Tinherit of core_type
and object_field = {
of_desc : object_field_desc;
of_loc : Location.t;
of_attributes : attributes;
}
and object_field_desc =
| OTtag of string Asttypes.loc * core_type
| OTinherit of core_type
and value_description = {
val_id : Ident.t;
val_name : string Asttypes.loc;
val_desc : core_type;
val_val : Types.value_description;
val_prim : string list;
val_loc : Location.t;
val_attributes : attributes;
}
and type_declaration = {
typ_id : Ident.t;
typ_name : string Asttypes.loc;
typ_params : (core_type * Asttypes.variance) list;
typ_type : Types.type_declaration;
typ_cstrs : (core_type * core_type * Location.t) list;
typ_kind : type_kind;
typ_private : Asttypes.private_flag;
typ_manifest : core_type option;
typ_loc : Location.t;
typ_attributes : attributes;
}
and type_kind =
| Ttype_abstract
| Ttype_variant of constructor_declaration list
| Ttype_record of label_declaration list
| Ttype_open
and label_declaration = {
ld_id : Ident.t;
ld_name : string Asttypes.loc;
ld_mutable : Asttypes.mutable_flag;
ld_type : core_type;
ld_loc : Location.t;
ld_attributes : attributes;
}
and constructor_declaration = {
cd_id : Ident.t;
cd_name : string Asttypes.loc;
cd_args : constructor_arguments;
cd_res : core_type option;
cd_loc : Location.t;
cd_attributes : attributes;
}
and constructor_arguments =
| Cstr_tuple of core_type list
| Cstr_record of label_declaration list
and type_extension = {
tyext_path : Path.t;
tyext_txt : Longident.t Asttypes.loc;
tyext_params : (core_type * Asttypes.variance) list;
tyext_constructors : extension_constructor list;
tyext_private : Asttypes.private_flag;
tyext_loc : Location.t;
tyext_attributes : attributes;
}
and type_exception = {
tyexn_constructor : extension_constructor;
tyexn_loc : Location.t;
tyexn_attributes : attribute list;
}
and extension_constructor = {
ext_id : Ident.t;
ext_name : string Asttypes.loc;
ext_type : Types.extension_constructor;
ext_kind : extension_constructor_kind;
ext_loc : Location.t;
ext_attributes : attributes;
}
and extension_constructor_kind =
| Text_decl of constructor_arguments * core_type option
| Text_rebind of Path.t * Longident.t Asttypes.loc
and class_type = {
cltyp_desc : class_type_desc;
cltyp_type : Types.class_type;
cltyp_env : Env.t;
cltyp_loc : Location.t;
cltyp_attributes : attributes;
}
and class_type_desc =
| Tcty_constr of Path.t * Longident.t Asttypes.loc * core_type list
| Tcty_signature of class_signature
| Tcty_arrow of Asttypes.arg_label * core_type * class_type
| Tcty_open of open_description * class_type
and class_signature = {
csig_self : core_type;
csig_fields : class_type_field list;
csig_type : Types.class_signature;
}
and class_type_field = {
ctf_desc : class_type_field_desc;
ctf_loc : Location.t;
ctf_attributes : attributes;
}
and class_type_field_desc =
| Tctf_inherit of class_type
| Tctf_val of string * Asttypes.mutable_flag * Asttypes.virtual_flag * core_type
| Tctf_method of string * Asttypes.private_flag * Asttypes.virtual_flag * core_type
| Tctf_constraint of core_type * core_type
| Tctf_attribute of attribute
and class_declaration = class_expr class_infos
and class_description = class_type class_infos
and class_type_declaration = class_type class_infos
and 'a class_infos = {
ci_virt : Asttypes.virtual_flag;
ci_params : (core_type * Asttypes.variance) list;
ci_id_name : string Asttypes.loc;
ci_id_class : Ident.t;
ci_id_class_type : Ident.t;
ci_id_object : Ident.t;
ci_id_typehash : Ident.t;
ci_expr : 'a;
ci_decl : Types.class_declaration;
ci_type_decl : Types.class_type_declaration;
ci_loc : Location.t;
ci_attributes : attributes;
}
val iter_pattern_desc : (pattern -> unit) -> pattern_desc -> unit
val map_pattern_desc : (pattern -> pattern) -> pattern_desc -> pattern_desc
val let_bound_idents : value_binding list -> Ident.t list
val rev_let_bound_idents : value_binding list -> Ident.t list
val let_bound_idents_with_loc : value_binding list -> (Ident.t * string Asttypes.loc * Types.type_expr) list
val alpha_pat : (Ident.t * Ident.t) list -> pattern -> pattern
Alpha conversion of patterns
val mknoloc : 'a -> 'a Asttypes.loc
val mkloc : 'a -> Location.t -> 'a Asttypes.loc
val pat_bound_idents : pattern -> Ident.t list
val pat_bound_idents_full : pattern -> (Ident.t * string Asttypes.loc * Types.type_expr) list
val split_pattern : pattern -> pattern option * pattern option
Splits an or pattern into its value (left) and exception (right) parts.