Parsetree (melange.Parsing0.Parsetree)

type constant =

| Pconst_integer(string, option(char))
/*
Integer constants such as 3 3l 3L 3n.
Suffixes [g-z][G-Z] are accepted by the parser. Suffixes except 'l', 'L' and 'n' are rejected by the typechecker
*/
| Pconst_char(char)
/*
Character such as 'c'.
*/
| Pconst_string(string, Location.t, option(string))
/*
Constant string such as "constant" or {delim|other constant|delim}.
The location span the content of the string, without the delimiters.
*/
| Pconst_float(string, option(char))
/*
Float constant such as 3.4, 2e5 or 1.4e-4.
Suffixes g-zG-Z are accepted by the parser. Suffixes are rejected by the typechecker.
*/

;

type location_stack = list(Location.t);

Extension points

type attribute = {

attr_name: Asttypes.loc(string),
attr_payload: payload,
attr_loc: Location.t,

};

Attributes such as [\@id ARG] and [\@\@id ARG].

Metadata containers passed around within the AST. The compiler ignores unknown attributes.

and extension = (Asttypes.loc(string), payload);

Extension points such as [%id ARG] and [%%id ARG].

Sub-language placeholder -- rejected by the typechecker.

and attributes = list(attribute);

and payload =

| PStr(structure)
| PSig(signature)
/*
: SIG in an attribute or an extension point
*/
| PTyp(core_type)
/*
: T in an attribute or an extension point
*/
| PPat(pattern, option(expression))
/*
? P or ? P when E, in an attribute or an extension point
*/

;

Core language

Type expressions

and core_type = {

ptyp_desc: core_type_desc,
ptyp_loc: Location.t,
ptyp_loc_stack: location_stack,
ptyp_attributes: attributes,
/*
... [\@id1] [\@id2]
*/

};

and core_type_desc =

| Ptyp_any
/*
_
*/
| Ptyp_var(string)
/*
A type variable such as 'a
*/
| Ptyp_arrow(Asttypes.arg_label, core_type, core_type)
/*
Ptyp_arrow(lbl, T1, T2) represents:
- T1 -> T2 when lbl is Nolabel,
- ~l:T1 -> T2 when lbl is Labelled,
- ?l:T1 -> T2 when lbl is Optional.
*/
| Ptyp_tuple(list(core_type))
/*
Ptyp_tuple([T1 ; ... ; Tn]) represents a product type T1 * ... * Tn.
Invariant: n >= 2.
*/
| Ptyp_constr(Asttypes.loc(Longident.t), list(core_type))
/*
Ptyp_constr(lident, l) represents:
- tconstr when l=[],
- T tconstr when l=[T],
- (T1, ..., Tn) tconstr when l=[T1 ; ... ; Tn].
*/
| Ptyp_object(list(object_field), Asttypes.closed_flag)
/*
Ptyp_object([ l1:T1; ...; ln:Tn ], flag) represents:
- < l1:T1; ...; ln:Tn > when flag is Closed,
- < l1:T1; ...; ln:Tn; .. > when flag is Open.
*/
| Ptyp_class(Asttypes.loc(Longident.t), list(core_type))
/*
Ptyp_class(tconstr, l) represents:
- #tconstr when l=[],
- T #tconstr when l=[T],
- (T1, ..., Tn) #tconstr when l=[T1 ; ... ; Tn].
*/
| Ptyp_alias(core_type, string)
/*
T as 'a.
*/
| Ptyp_variant(list(row_field), Asttypes.closed_flag, option(list(Asttypes.label)))
/*
Ptyp_variant([`A;`B], flag, labels) represents:
- [ `A|`B ] when flag is Closed, and labels is None,
- [> `A|`B ] when flag is Open, and labels is None,
- [< `A|`B ] when flag is Closed, and labels is Some [],
- [< `A|`B > `X `Y ] when flag is Closed, and labels is Some ["X";"Y"].
*/
| Ptyp_poly(list(Asttypes.loc(string)), core_type)
/*
'a1 ... 'an. T
Can only appear in the following context:
- As the core_type of a Ppat_constraint node corresponding to a constraint on a let-binding:
```
let x : 'a1 ... 'an. T = e ...
```
- Under Cfk_virtual for methods (not values).
- As the core_type of a Pctf_method node.
- As the core_type of a Pexp_poly node.
- As the pld_type field of a label_declaration.
- As a core_type of a Ptyp_object node.
- As the pval_type field of a value_description.
*/
| Ptyp_package(package_type)
/*
(module S).
*/
| Ptyp_extension(extension)
/*
[%id].
*/

;

and package_type =
  (Asttypes.loc(Longident.t), list((Asttypes.loc(Longident.t), core_type)));

As package_type typed values:

(S, []) represents (module S),
(S, [(t1, T1) ; ... ; (tn, Tn)]) represents (module S with type t1 = T1 and ... and tn = Tn).

and row_field = {

prf_desc: row_field_desc,
prf_loc: Location.t,
prf_attributes: attributes,

};

and row_field_desc =

| Rtag(Asttypes.loc(Asttypes.label), bool, list(core_type))
/*
Rtag(`A, b, l) represents:
- `A when b is true and l is [],
- `A of T when b is false and l is [T],
- `A of T1 & .. & Tn when b is false and l is [T1;...Tn],
- `A of & T1 & .. & Tn when b is true and l is [T1;...Tn].
- The bool field is true if the tag contains a constant (empty) constructor.
- & occurs when several types are used for the same constructor (see 4.2 in the manual)
*/
| Rinherit(core_type)
/*
[ | t ]
*/

;

and object_field = {

pof_desc: object_field_desc,
pof_loc: Location.t,
pof_attributes: attributes,

};

and object_field_desc =

| Otag(Asttypes.loc(Asttypes.label), core_type)
| Oinherit(core_type)

;

Patterns

and pattern = {

ppat_desc: pattern_desc,
ppat_loc: Location.t,
ppat_loc_stack: location_stack,
ppat_attributes: attributes,
/*
... [\@id1] [\@id2]
*/

};

and pattern_desc =

| Ppat_any
/*
The pattern _.
*/
| Ppat_var(Asttypes.loc(string))
/*
A variable pattern such as x
*/
| Ppat_alias(pattern, Asttypes.loc(string))
/*
An alias pattern such as P as 'a
*/
| Ppat_constant(constant)
/*
Patterns such as 1, 'a', "true", 1.0, 1l, 1L, 1n
*/
| Ppat_interval(constant, constant)
/*
Patterns such as 'a'..'z'.
Other forms of interval are recognized by the parser but rejected by the type-checker.
*/
| Ppat_tuple(list(pattern))
/*
Patterns (P1, ..., Pn).
Invariant: n >= 2
*/
| Ppat_construct(Asttypes.loc(Longident.t), option((list(Asttypes.loc(string)), pattern)))
/*
Ppat_construct(C, args) represents:
- C when args is None,
- C P when args is Some ([], P)
- C (P1, ..., Pn) when args is Some ([], Ppat_tuple [P1; ...; Pn])
- C (type a b) P when args is Some ([a; b], P)
*/
| Ppat_variant(Asttypes.label, option(pattern))
/*
Ppat_variant(`A, pat) represents:
- `A when pat is None,
- `A P when pat is Some P
*/
| Ppat_record(list((Asttypes.loc(Longident.t), pattern)), Asttypes.closed_flag)
/*
Ppat_record([(l1, P1) ; ... ; (ln, Pn)], flag) represents:
- { l1=P1; ...; ln=Pn } when flag is Closed
- { l1=P1; ...; ln=Pn; _} when flag is Open
Invariant: n > 0
*/
| Ppat_array(list(pattern))
/*
Pattern [| P1; ...; Pn |]
*/
| Ppat_or(pattern, pattern)
/*
Pattern P1 | P2
*/
| Ppat_constraint(pattern, core_type)
/*
Pattern (P : T)
*/
| Ppat_type(Asttypes.loc(Longident.t))
/*
Pattern #tconst
*/
| Ppat_lazy(pattern)
/*
Pattern lazy P
*/
| Ppat_unpack(Asttypes.loc(option(string)))
/*
Ppat_unpack(s) represents:
- (module P) when s is Some "P"
- (module _) when s is None
Note: (module P : S) is represented as Ppat_constraint(Ppat_unpack(Some "P"), Ptyp_package S)
*/
| Ppat_exception(pattern)
/*
Pattern exception P
*/
| Ppat_extension(extension)
/*
Pattern [%id]
*/
| Ppat_open(Asttypes.loc(Longident.t), pattern)
/*
Pattern M.(P)
*/

;

Value expressions

and expression = {

pexp_desc: expression_desc,
pexp_loc: Location.t,
pexp_loc_stack: location_stack,
pexp_attributes: attributes,
/*
... [\@id1] [\@id2]
*/

};

and expression_desc =

| Pexp_ident(Asttypes.loc(Longident.t))
/*
Identifiers such as x and M.x
*/
| Pexp_constant(constant)
/*
Expressions constant such as 1, 'a', "true", 1.0, 1l, 1L, 1n
*/
| Pexp_let(Asttypes.rec_flag, list(value_binding), expression)
/*
Pexp_let(flag, [(P1,E1) ; ... ; (Pn,En)], E) represents:
- let P1 = E1 and ... and Pn = EN in E when flag is Nonrecursive,
- let rec P1 = E1 and ... and Pn = EN in E when flag is Recursive.
*/
| Pexp_function(list(case))
/*
function P1 -> E1 | ... | Pn -> En
*/
| Pexp_fun(Asttypes.arg_label, option(expression), pattern, expression)
/*
Pexp_fun(lbl, exp0, P, E1) represents:
- fun P -> E1 when lbl is Nolabel and exp0 is None
- fun ~l:P -> E1 when lbl is Labelled l and exp0 is None
- fun ?l:P -> E1 when lbl is Optional l and exp0 is None
- fun ?l:(P = E0) -> E1 when lbl is Optional l and exp0 is Some E0
Notes:
- If E0 is provided, only Optional is allowed.
- fun P1 P2 .. Pn -> E1 is represented as nested Pexp_fun.
- let f P = E is represented using Pexp_fun.
*/
| Pexp_apply(expression, list((Asttypes.arg_label, expression)))
/*
Pexp_apply(E0, [(l1, E1) ; ... ; (ln, En)]) represents E0 ~l1:E1 ... ~ln:En
li can be Nolabel (non labeled argument), Labelled (labelled arguments) or Optional (optional argument).
Invariant: n > 0
*/
| Pexp_match(expression, list(case))
/*
match E0 with P1 -> E1 | ... | Pn -> En
*/
| Pexp_try(expression, list(case))
/*
try E0 with P1 -> E1 | ... | Pn -> En
*/
| Pexp_tuple(list(expression))
/*
Expressions (E1, ..., En)
Invariant: n >= 2
*/
| Pexp_construct(Asttypes.loc(Longident.t), option(expression))
/*
Pexp_construct(C, exp) represents:
- C when exp is None,
- C E when exp is Some E,
- C (E1, ..., En) when exp is Some (Pexp_tuple[E1;...;En])
*/
| Pexp_variant(Asttypes.label, option(expression))
/*
Pexp_variant(`A, exp) represents
- `A when exp is None
- `A E when exp is Some E
*/
| Pexp_record(list((Asttypes.loc(Longident.t), expression)), option(expression))
/*
Pexp_record([(l1,P1) ; ... ; (ln,Pn)], exp0) represents
- { l1=P1; ...; ln=Pn } when exp0 is None
- { E0 with l1=P1; ...; ln=Pn } when exp0 is Some E0
Invariant: n > 0
*/
| Pexp_field(expression, Asttypes.loc(Longident.t))
/*
E.l
*/
| Pexp_setfield(expression, Asttypes.loc(Longident.t), expression)
/*
E1.l <- E2
*/
| Pexp_array(list(expression))
/*
[| E1; ...; En |]
*/
| Pexp_ifthenelse(expression, expression, option(expression))
/*
if E1 then E2 else E3
*/
| Pexp_sequence(expression, expression)
/*
E1; E2
*/
| Pexp_while(expression, expression)
/*
while E1 do E2 done
*/
| Pexp_for(pattern, expression, expression, Asttypes.direction_flag, expression)
/*
Pexp_for(i, E1, E2, direction, E3) represents:
- for i = E1 to E2 do E3 done when direction is Upto
- for i = E1 downto E2 do E3 done when direction is Downto
*/
| Pexp_constraint(expression, core_type)
/*
(E : T)
*/
| Pexp_coerce(expression, option(core_type), core_type)
/*
Pexp_coerce(E, from, T) represents
- (E :> T) when from is None,
- (E : T0 :> T) when from is Some T0.
*/
| Pexp_send(expression, Asttypes.loc(Asttypes.label))
/*
E # m
*/
| Pexp_new(Asttypes.loc(Longident.t))
/*
new M.c
*/
| Pexp_setinstvar(Asttypes.loc(Asttypes.label), expression)
/*
x <- 2
*/
| Pexp_override(list((Asttypes.loc(Asttypes.label), expression)))
/*
{< x1 = E1; ...; xn = En >}
*/
| Pexp_letmodule(Asttypes.loc(option(string)), module_expr, expression)
/*
let module M = ME in E
*/
| Pexp_letexception(extension_constructor, expression)
/*
let exception C in E
*/
| Pexp_assert(expression)
/*
assert E.
Note: assert false is treated in a special way by the type-checker.
*/
| Pexp_lazy(expression)
/*
lazy E
*/
| Pexp_poly(expression, option(core_type))
/*
Used for method bodies.
Can only be used as the expression under Cfk_concrete for methods (not values).
*/
| Pexp_object(class_structure)
/*
object ... end
*/
| Pexp_newtype(Asttypes.loc(string), expression)
/*
fun (type t) -> E
*/
| Pexp_pack(module_expr)
/*
(module ME).
(module ME : S) is represented as Pexp_constraint(Pexp_pack ME, Ptyp_package S)
*/
| Pexp_open(open_declaration, expression)
/*
- M.(E)
- let open M in E
- let open! M in E
*/
| Pexp_letop(letop)
/*
- let* P = E0 in E1
- let* P0 = E00 and* P1 = E01 in E1
*/
| Pexp_extension(extension)
/*
[%id]
*/
| Pexp_unreachable
/*
.
*/

;

and case = {

pc_lhs: pattern,
pc_guard: option(expression),
pc_rhs: expression,

};

Values of type case represents (P -> E) or (P when E0 -> E)

and letop = {

let_: binding_op,
ands: list(binding_op),
body: expression,

};

and binding_op = {

pbop_op: Asttypes.loc(string),
pbop_pat: pattern,
pbop_exp: expression,
pbop_loc: Location.t,

};

Value descriptions

and value_description = {

pval_name: Asttypes.loc(string),
pval_type: core_type,
pval_prim: list(string),
pval_attributes: attributes,
/*
... [\@\@id1] [\@\@id2]
*/
pval_loc: Location.t,

};

Values of type value_description represents:

val x: T, when pval_prim is []
external x: T = "s1" ... "sn" when pval_prim is ["s1";..."sn"]

Type declarations

and type_declaration = {

ptype_name: Asttypes.loc(string),
ptype_params: list((core_type, (Asttypes.variance, Asttypes.injectivity))),
/*
('a1,...'an) t
*/
ptype_cstrs: list((core_type, core_type, Location.t)),
/*
... constraint T1=T1' ... constraint Tn=Tn'
*/
ptype_kind: type_kind,
ptype_private: Asttypes.private_flag,
/*
for = private ...
*/
ptype_manifest: option(core_type),
/*
represents = T
*/
ptype_attributes: attributes,
/*
... [\@\@id1] [\@\@id2]
*/
ptype_loc: Location.t,

};

Here are type declarations and their representation, for various ptype_kind and ptype_manifest values:

type t when type_kind is Ptype_abstract, and manifest is None,
type t = T0 when type_kind is Ptype_abstract, and manifest is Some T0,
type t = C of T | ... when type_kind is Ptype_variant, and manifest is None,
type t = T0 = C of T | ... when type_kind is Ptype_variant, and manifest is Some T0,
type t = {l: T; ...} when type_kind is Ptype_record, and manifest is None,
type t = T0 = {l : T; ...} when type_kind is Ptype_record, and manifest is Some T0,
type t = .. when type_kind is Ptype_open, and manifest is None.

and type_kind =

| Ptype_abstract
| Ptype_variant(list(constructor_declaration))
| Ptype_record(list(label_declaration))
/*
Invariant: non-empty list
*/
| Ptype_open

;

and label_declaration = {

pld_name: Asttypes.loc(string),
pld_mutable: Asttypes.mutable_flag,
pld_type: core_type,
pld_loc: Location.t,
pld_attributes: attributes,
/*
l : T [\@id1] [\@id2]
*/

};

{ ...; l: T; ... } when pld_mutable is Immutable,
{ ...; mutable l: T; ... } when pld_mutable is Mutable.

Note: T can be a Ptyp_poly.

and constructor_declaration = {

pcd_name: Asttypes.loc(string),
pcd_vars: list(Asttypes.loc(string)),
pcd_args: constructor_arguments,
pcd_res: option(core_type),
pcd_loc: Location.t,
pcd_attributes: attributes,
/*
C of ... [\@id1] [\@id2]
*/

};

and constructor_arguments =

| Pcstr_tuple(list(core_type))
| Pcstr_record(list(label_declaration))
/*
Values of type constructor_declaration represents the constructor arguments of:
- C of T1 * ... * Tn when res = None, and args = Pcstr_tuple [T1; ... ; Tn],
- C: T0 when res = Some T0, and args = Pcstr_tuple [],
- C: T1 * ... * Tn -> T0 when res = Some T0, and args = Pcstr_tuple [T1; ... ; Tn],
- C of {...} when res = None, and args = Pcstr_record [...],
- C: {...} -> T0 when res = Some T0, and args = Pcstr_record [...].
*/

;

and type_extension = {

ptyext_path: Asttypes.loc(Longident.t),
ptyext_params: list((core_type, (Asttypes.variance, Asttypes.injectivity))),
ptyext_constructors: list(extension_constructor),
ptyext_private: Asttypes.private_flag,
ptyext_loc: Location.t,
ptyext_attributes: attributes,
/*
... \@\@id1 \@\@id2
*/

};

Definition of new extensions constructors for the extensive sum type t (type t += ...).

and extension_constructor = {

pext_name: Asttypes.loc(string),
pext_kind: extension_constructor_kind,
pext_loc: Location.t,
pext_attributes: attributes,
/*
C of ... [\@id1] [\@id2]
*/

};

and type_exception = {

ptyexn_constructor: extension_constructor,
ptyexn_loc: Location.t,
ptyexn_attributes: attributes,
/*
... [\@\@id1] [\@\@id2]
*/

};

Definition of a new exception (exception E).

and extension_constructor_kind =

| Pext_decl(list(Asttypes.loc(string)), constructor_arguments, option(core_type))
/*
Pext_decl(existentials, c_args, t_opt) describes a new extension constructor. It can be:
- C of T1 * ... * Tn when:
  - existentials is [],
  - c_args is [T1; ...; Tn],
  - t_opt is None
- C: T0 when
  - existentials is [],
  - c_args is [],
  - t_opt is Some T0.
- C: T1 * ... * Tn -> T0 when
  - existentials is [],
  - c_args is [T1; ...; Tn],
  - t_opt is Some T0.
- C: 'a... . T1 * ... * Tn -> T0 when
  - existentials is ['a;...],
  - c_args is [T1; ... ; Tn],
  - t_opt is Some T0.
*/
| Pext_rebind(Asttypes.loc(Longident.t))
/*
Pext_rebind(D) re-export the constructor D with the new name C
*/

;

Class language

Type expressions for the class language

and class_type = {

pcty_desc: class_type_desc,
pcty_loc: Location.t,
pcty_attributes: attributes,
/*
... [\@id1] [\@id2]
*/

};

and class_type_desc =

| Pcty_constr(Asttypes.loc(Longident.t), list(core_type))
/*
- c
- ['a1, ..., 'an] c
*/
| Pcty_signature(class_signature)
/*
object ... end
*/
| Pcty_arrow(Asttypes.arg_label, core_type, class_type)
/*
Pcty_arrow(lbl, T, CT) represents:
- T -> CT when lbl is Nolabel,
- ~l:T -> CT when lbl is Labelled l,
- ?l:T -> CT when lbl is Optional l.
*/
| Pcty_extension(extension)
/*
%id
*/
| Pcty_open(open_description, class_type)
/*
let open M in CT
*/

;

and class_signature = {

pcsig_self: core_type,
pcsig_fields: list(class_type_field),

};

Values of type class_signature represents:

object('selfpat) ... end
object ... end when pcsig_self is Ptyp_any

and class_type_field = {

pctf_desc: class_type_field_desc,
pctf_loc: Location.t,
pctf_attributes: attributes,
/*
... [\@\@id1] [\@\@id2]
*/

};

and class_type_field_desc =

| Pctf_inherit(class_type)
/*
inherit CT
*/
| Pctf_val((Asttypes.loc(Asttypes.label), Asttypes.mutable_flag, Asttypes.virtual_flag, core_type))
/*
val x: T
*/
| Pctf_method((Asttypes.loc(Asttypes.label), Asttypes.private_flag, Asttypes.virtual_flag, core_type))
/*
method x: T
Note: T can be a Ptyp_poly.
*/
| Pctf_constraint((core_type, core_type))
/*
constraint T1 = T2
*/
| Pctf_attribute(attribute)
/*
[\@\@\@id]
*/
| Pctf_extension(extension)
/*
[%%id]
*/

;

and class_infos('a) = {

pci_virt: Asttypes.virtual_flag,
pci_params: list((core_type, (Asttypes.variance, Asttypes.injectivity))),
pci_name: Asttypes.loc(string),
pci_expr: 'a,
pci_loc: Location.t,
pci_attributes: attributes,
/*
... [\@\@id1] [\@\@id2]
*/

};

Values of type class_expr class_infos represents:

class c = ...
class ['a1,...,'an] c = ...
class virtual c = ...

They are also used for "class type" declaration.

and class_description = class_infos(class_type);

and class_type_declaration = class_infos(class_type);

Value expressions for the class language

and class_expr = {

pcl_desc: class_expr_desc,
pcl_loc: Location.t,
pcl_attributes: attributes,
/*
... [\@id1] [\@id2]
*/

};

and class_expr_desc =

| Pcl_constr(Asttypes.loc(Longident.t), list(core_type))
/*
c and ['a1, ..., 'an] c
*/
| Pcl_structure(class_structure)
/*
object ... end
*/
| Pcl_fun(Asttypes.arg_label, option(expression), pattern, class_expr)
/*
Pcl_fun(lbl, exp0, P, CE) represents:
- fun P -> CE when lbl is Nolabel and exp0 is None,
- fun ~l:P -> CE when lbl is Labelled l and exp0 is None,
- fun ?l:P -> CE when lbl is Optional l and exp0 is None,
- fun ?l:(P = E0) -> CE when lbl is Optional l and exp0 is Some E0.
*/
| Pcl_apply(class_expr, list((Asttypes.arg_label, expression)))
/*
Pcl_apply(CE, [(l1,E1) ; ... ; (ln,En)]) represents CE ~l1:E1 ... ~ln:En. li can be empty (non labeled argument) or start with ? (optional argument).
Invariant: n > 0
*/
| Pcl_let(Asttypes.rec_flag, list(value_binding), class_expr)
/*
Pcl_let(rec, [(P1, E1); ... ; (Pn, En)], CE) represents:
- let P1 = E1 and ... and Pn = EN in CE when rec is Nonrecursive,
- let rec P1 = E1 and ... and Pn = EN in CE when rec is Recursive.
*/
| Pcl_constraint(class_expr, class_type)
/*
(CE : CT)
*/
| Pcl_extension(extension)
/*
[%id]
*/
| Pcl_open(open_description, class_expr)
/*
let open M in CE
*/

;

and class_structure = {

pcstr_self: pattern,
pcstr_fields: list(class_field),

};

Values of type class_structure represents:

object(selfpat) ... end
object ... end when pcstr_self is Ppat_any

and class_field = {

pcf_desc: class_field_desc,
pcf_loc: Location.t,
pcf_attributes: attributes,
/*
... [\@\@id1] [\@\@id2]
*/

};

and class_field_desc =

| Pcf_inherit(Asttypes.override_flag, class_expr, option(Asttypes.loc(string)))
/*
Pcf_inherit(flag, CE, s) represents:
- inherit CE when flag is Fresh and s is None,
- inherit CE as x when flag is Fresh and s is Some x,
- inherit! CE when flag is Override and s is None,
- inherit! CE as x when flag is Override and s is Some x
*/
| Pcf_val((Asttypes.loc(Asttypes.label), Asttypes.mutable_flag, class_field_kind))
/*
Pcf_val(x,flag, kind) represents:
- val x = E when flag is Immutable and kind is Cfk_concrete(Fresh, E)
- val virtual x: T when flag is Immutable and kind is Cfk_virtual(T)
- val mutable x = E when flag is Mutable and kind is Cfk_concrete(Fresh, E)
- val mutable virtual x: T when flag is Mutable and kind is Cfk_virtual(T)
*/
| Pcf_method((Asttypes.loc(Asttypes.label), Asttypes.private_flag, class_field_kind))
/*
- method x = E (E can be a Pexp_poly)
- method virtual x: T (T can be a Ptyp_poly)
*/
| Pcf_constraint((core_type, core_type))
/*
constraint T1 = T2
*/
| Pcf_initializer(expression)
/*
initializer E
*/
| Pcf_attribute(attribute)
/*
[\@\@\@id]
*/
| Pcf_extension(extension)
/*
[%%id]
*/

;

and class_field_kind =

| Cfk_virtual(core_type)
| Cfk_concrete(Asttypes.override_flag, expression)

;

and class_declaration = class_infos(class_expr);

Module language

Type expressions for the module language

and module_type = {

pmty_desc: module_type_desc,
pmty_loc: Location.t,
pmty_attributes: attributes,
/*
... [\@id1] [\@id2]
*/

};

and module_type_desc =

| Pmty_ident(Asttypes.loc(Longident.t))
/*
Pmty_ident(S) represents S
*/
| Pmty_signature(signature)
/*
sig ... end
*/
| Pmty_functor(functor_parameter, module_type)
/*
functor(X : MT1) -> MT2
*/
| Pmty_with(module_type, list(with_constraint))
/*
MT with ...
*/
| Pmty_typeof(module_expr)
/*
module type of ME
*/
| Pmty_extension(extension)
/*
[%id]
*/
| Pmty_alias(Asttypes.loc(Longident.t))
/*
(module M)
*/

;

and functor_parameter =

| Unit
/*
()
*/
| Named(Asttypes.loc(option(string)), module_type)
/*
Named(name, MT) represents:
- (X : MT) when name is Some X,
- (_ : MT) when name is None
*/

;

and signature = list(signature_item);

and signature_item = {

psig_desc: signature_item_desc,
psig_loc: Location.t,

};

and signature_item_desc =

| Psig_value(value_description)
/*
- val x: T
- external x: T = "s1" ... "sn"
*/
| Psig_type(Asttypes.rec_flag, list(type_declaration))
/*
type t1 = ... and ... and tn = ...
*/
| Psig_typesubst(list(type_declaration))
/*
type t1 := ... and ... and tn := ...
*/
| Psig_typext(type_extension)
/*
type t1 += ...
*/
| Psig_exception(type_exception)
/*
exception C of T
*/
| Psig_module(module_declaration)
/*
module X = M and module X : MT
*/
| Psig_modsubst(module_substitution)
/*
module X := M
*/
| Psig_recmodule(list(module_declaration))
/*
module rec X1 : MT1 and ... and Xn : MTn
*/
| Psig_modtype(module_type_declaration)
/*
module type S = MT and module type S
*/
| Psig_modtypesubst(module_type_declaration)
/*
module type S := ...
*/
| Psig_open(open_description)
/*
open X
*/
| Psig_include(include_description)
/*
include MT
*/
| Psig_class(list(class_description))
/*
class c1 : ... and ... and cn : ...
*/
| Psig_class_type(list(class_type_declaration))
/*
class type ct1 = ... and ... and ctn = ...
*/
| Psig_attribute(attribute)
/*
[\@\@\@id]
*/
| Psig_extension(extension, attributes)
/*
[%%id]
*/

;

and module_declaration = {

pmd_name: Asttypes.loc(option(string)),
pmd_type: module_type,
pmd_attributes: attributes,
/*
... [\@\@id1] [\@\@id2]
*/
pmd_loc: Location.t,

};

Values of type module_declaration represents S : MT

and module_substitution = {

pms_name: Asttypes.loc(string),
pms_manifest: Asttypes.loc(Longident.t),
pms_attributes: attributes,
/*
... [\@\@id1] [\@\@id2]
*/
pms_loc: Location.t,

};

Values of type module_substitution represents S := M

and module_type_declaration = {

pmtd_name: Asttypes.loc(string),
pmtd_type: option(module_type),
pmtd_attributes: attributes,
/*
... [\@\@id1] [\@\@id2]
*/
pmtd_loc: Location.t,

};

Values of type module_type_declaration represents:

S = MT,
S for abstract module type declaration, when pmtd_type is None.

and open_infos('a) = {

popen_expr: 'a,
popen_override: Asttypes.override_flag,
popen_loc: Location.t,
popen_attributes: attributes,

};

Values of type 'a open_infos represents:

open! X when popen_override is Override (silences the "used identifier shadowing" warning)
open X when popen_override is Fresh

and open_description = open_infos(Asttypes.loc(Longident.t));

Values of type open_description represents:

open M.N
open M(N).O

and open_declaration = open_infos(module_expr);

Values of type open_declaration represents:

open M.N
open M(N).O
open struct ... end

and include_infos('a) = {

pincl_mod: 'a,
pincl_loc: Location.t,
pincl_attributes: attributes,

};

and include_description = include_infos(module_type);

Values of type include_description represents include MT

and include_declaration = include_infos(module_expr);

Values of type include_declaration represents include ME

and with_constraint =

| Pwith_type(Asttypes.loc(Longident.t), type_declaration)
/*
with type X.t = ...
Note: the last component of the longident must match the name of the type_declaration.
*/
| Pwith_module(Asttypes.loc(Longident.t), Asttypes.loc(Longident.t))
/*
with module X.Y = Z
*/
| Pwith_modtype(Asttypes.loc(Longident.t), module_type)
/*
with module type X.Y = Z
*/
| Pwith_modtypesubst(Asttypes.loc(Longident.t), module_type)
/*
with module type X.Y := sig end
*/
| Pwith_typesubst(Asttypes.loc(Longident.t), type_declaration)
/*
with type X.t := ..., same format as [Pwith_type]
*/
| Pwith_modsubst(Asttypes.loc(Longident.t), Asttypes.loc(Longident.t))
/*
with module X.Y := Z
*/

;

Value expressions for the module language

and module_expr = {

pmod_desc: module_expr_desc,
pmod_loc: Location.t,
pmod_attributes: attributes,
/*
... [\@id1] [\@id2]
*/

};

and module_expr_desc =

| Pmod_ident(Asttypes.loc(Longident.t))
/*
X
*/
| Pmod_structure(structure)
/*
struct ... end
*/
| Pmod_functor(functor_parameter, module_expr)
/*
functor(X : MT1) -> ME
*/
| Pmod_apply(module_expr, module_expr)
/*
ME1(ME2)
*/
| Pmod_constraint(module_expr, module_type)
/*
(ME : MT)
*/
| Pmod_unpack(expression)
/*
(val E)
*/
| Pmod_extension(extension)
/*
[%id]
*/

;

and structure = list(structure_item);

and structure_item = {

pstr_desc: structure_item_desc,
pstr_loc: Location.t,

};

and structure_item_desc =

| Pstr_eval(expression, attributes)
/*
E
*/
| Pstr_value(Asttypes.rec_flag, list(value_binding))
/*
Pstr_value(rec, [(P1, E1 ; ... ; (Pn, En))]) represents:
- let P1 = E1 and ... and Pn = EN when rec is Nonrecursive,
- let rec P1 = E1 and ... and Pn = EN when rec is Recursive.
*/
| Pstr_primitive(value_description)
/*
- val x: T
- external x: T = "s1" ... "sn"
*/
| Pstr_type(Asttypes.rec_flag, list(type_declaration))
/*
type t1 = ... and ... and tn = ...
*/
| Pstr_typext(type_extension)
/*
type t1 += ...
*/
| Pstr_exception(type_exception)
/*
- exception C of T
- exception C = M.X
*/
| Pstr_module(module_binding)
/*
module X = ME
*/
| Pstr_recmodule(list(module_binding))
/*
module rec X1 = ME1 and ... and Xn = MEn
*/
| Pstr_modtype(module_type_declaration)
/*
module type S = MT
*/
| Pstr_open(open_declaration)
/*
open X
*/
| Pstr_class(list(class_declaration))
/*
class c1 = ... and ... and cn = ...
*/
| Pstr_class_type(list(class_type_declaration))
/*
class type ct1 = ... and ... and ctn = ...
*/
| Pstr_include(include_declaration)
/*
include ME
*/
| Pstr_attribute(attribute)
/*
[\@\@\@id]
*/
| Pstr_extension(extension, attributes)
/*
[%%id]
*/

;

and value_binding = {

pvb_pat: pattern,
pvb_expr: expression,
pvb_attributes: attributes,
pvb_loc: Location.t,

};

and module_binding = {

pmb_name: Asttypes.loc(option(string)),
pmb_expr: module_expr,
pmb_attributes: attributes,
pmb_loc: Location.t,

};

Values of type module_binding represents module X = ME

Toplevel

Toplevel phrases

type toplevel_phrase =

| Ptop_def(structure)
| Ptop_dir(toplevel_directive)
/*
#use, #load ...
*/

;

and toplevel_directive = {

pdir_name: Asttypes.loc(string),
pdir_arg: option(directive_argument),
pdir_loc: Location.t,

};

and directive_argument = {

pdira_desc: directive_argument_desc,
pdira_loc: Location.t,

};

and directive_argument_desc =

| Pdir_string(string)
| Pdir_int(string, option(char))
| Pdir_ident(Longident.t)
| Pdir_bool(bool)

;