jon.recoil.org

Module Parsetree

Abstract syntax tree produced by parsing

Warning: this module is unstable and part of compiler-libs.

type constant =
  1. | Pconst_integer of string * char option
    (*

    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

    *)
  2. | Pconst_unboxed_integer of string * char
    (*

    Integer constants such as #3 #3l #3L #3n.

    A suffix [g-z][G-Z] is required by the parser. Suffixes except 's', 'S', 'l', 'L', 'n', and 'm' are rejected by the typechecker

    *)
  3. | Pconst_char of char
    (*

    Character such as 'c'.

    *)
  4. | Pconst_untagged_char of char
    (*

    Untagged character such as #'c'.

    *)
  5. | Pconst_string of string * Location.t * string option
    (*

    Constant string such as "constant" or {delim|other constant|delim}.

    The location span the content of the string, without the delimiters.

    *)
  6. | Pconst_float of string * char option
    (*

    Float constant such as 3.4, 2e5 or 1.4e-4.

    Suffixes g-zG-Z are accepted by the parser. Suffixes except 's' are rejected by the typechecker.

    *)
  7. | Pconst_unboxed_float of string * char option
    (*

    Float constant such as #3.4, #2e5 or #1.4e-4.

    Suffixes g-zG-Z are accepted by the parser. Suffixes except 's' are rejected by the typechecker.

    *)
type location_stack = Location.t list
type modality =
  1. | Modality of string
type modalities = Parsetree.modality Asttypes.loc list
type mode =
  1. | Mode of string
type modes = Parsetree.mode Asttypes.loc list
type include_kind =
  1. | Structure
  2. | Functor

Extension points

type attribute = {
  1. attr_name : string Asttypes.loc;
  2. attr_payload : Parsetree.payload;
  3. 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 = string Asttypes.loc * Parsetree.payload

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

Sub-language placeholder -- rejected by the typechecker.

and attributes = Parsetree.attribute list
and payload =
  1. | PStr of Parsetree.structure
  2. | PSig of Parsetree.signature
    (*

    : SIG in an attribute or an extension point

    *)
  3. | PTyp of Parsetree.core_type
    (*

    : T in an attribute or an extension point

    *)
  4. | PPat of Parsetree.pattern * Parsetree.expression option
    (*

    ? P or ? P when E, in an attribute or an extension point

    *)

Core language

Type expressions

and core_type = {
  1. ptyp_desc : Parsetree.core_type_desc;
  2. ptyp_loc : Location.t;
  3. ptyp_loc_stack : Parsetree.location_stack;
  4. ptyp_attributes : Parsetree.attributes;
    (*

    ... [\@id1] [\@id2]

    *)
}
and core_type_desc =
  1. | Ptyp_any of Parsetree.jkind_annotation option
    (*

    _ or _ : k

    *)
  2. | Ptyp_var of string * Parsetree.jkind_annotation option
    (*

    A type variable such as 'a or 'a : k

    *)
  3. | Ptyp_arrow of Parsetree.arg_label * Parsetree.core_type * Parsetree.core_type * Parsetree.modes * Parsetree.modes
    (*

    Ptyp_arrow(lbl, T1, T2, M1, M2) represents:

    • T1 @ M1 -> T2 @ M2 when lbl is Nolabel,
    • ~l:(T1 @ M1) -> (T2 @ M2) when lbl is Labelled,
    • ?l:(T1 @ M1) -> (T2 @ M2) when lbl is Optional.
    *)
  4. | Ptyp_tuple of (string option * Parsetree.core_type) list
    (*

    Ptyp_tuple(tl) represents a product type:

    • T1 * ... * Tn when tl is (None,T1);...;(None,Tn)
    • L1:T1 * ... * Ln:Tn when tl is (Some L1,T1);...;(Some Ln,Tn)
    • A mix, e.g. L1:T1 * T2 when tl is (Some L1,T1);(None,T2)

    Invariant: n >= 2.

    *)
  5. | Ptyp_unboxed_tuple of (string option * Parsetree.core_type) list
    (*

    Unboxed tuple types: Ptyp_unboxed_tuple([(Some l1,P1);...;(Some l2,Pn)] represents a product type #(l1:T1 * ... * l2:Tn), and the labels are optional.

    Invariant: n >= 2.

    *)
  6. | Ptyp_constr of Longident.t Asttypes.loc * Parsetree.core_type list
    (*

    Ptyp_constr(lident, l) represents:

    • tconstr when l=[],
    • T tconstr when l=[T],
    • (T1, ..., Tn) tconstr when l=[T1 ; ... ; Tn].
    *)
  7. | Ptyp_object of Parsetree.object_field list * 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.
    *)
  8. | Ptyp_class of Longident.t Asttypes.loc * Parsetree.core_type list
    (*

    Ptyp_class(tconstr, l) represents:

    • #tconstr when l=[],
    • T #tconstr when l=[T],
    • (T1, ..., Tn) #tconstr when l=[T1 ; ... ; Tn].
    *)
  9. | Ptyp_alias of Parsetree.core_type * string Asttypes.loc option * Parsetree.jkind_annotation option
    (*

    T as 'a or T as ('a : k) or T as (_ : k).

    Invariant: the name or jkind annotation is non-None.

    *)
  10. | Ptyp_variant of Parsetree.row_field list * Asttypes.closed_flag * Asttypes.label list option
    (*

    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"].
    *)
  11. | Ptyp_poly of (string Asttypes.loc * Parsetree.jkind_annotation option) list * Parsetree.core_type
    (*

    'a1 ... 'an. T ('a1 : k1) ... ('an : kn). 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 ...
    *)
  12. | Ptyp_package of Parsetree.package_type
    (*

    (module S).

    *)
  13. | Ptyp_open of Longident.t Asttypes.loc * Parsetree.core_type
    (*

    M.(T)

    *)
  14. | Ptyp_quote of Parsetree.core_type
    (*

    <[T]>

    *)
  15. | Ptyp_splice of Parsetree.core_type
    (*

    $T

    *)
  16. | Ptyp_of_kind of Parsetree.jkind_annotation
    (*

    (type : k)

    *)
  17. | Ptyp_extension of Parsetree.extension
    (*

    [%id].

    *)
and arg_label = Asttypes.arg_label =
  1. | Nolabel
  2. | Labelled of string
  3. | Optional of string

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 = {
  1. prf_desc : Parsetree.row_field_desc;
  2. prf_loc : Location.t;
  3. prf_attributes : Parsetree.attributes;
}
and row_field_desc =
  1. | Rtag of Asttypes.label Asttypes.loc * bool * Parsetree.core_type list
    (*

    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)
    *)
  2. | Rinherit of Parsetree.core_type
    (*

    [ | t ]

    *)
and object_field = {
  1. pof_desc : Parsetree.object_field_desc;
  2. pof_loc : Location.t;
  3. pof_attributes : Parsetree.attributes;
}
and object_field_desc =
  1. | Otag of Asttypes.label Asttypes.loc * Parsetree.core_type
  2. | Oinherit of Parsetree.core_type

Patterns

and pattern = {
  1. ppat_desc : Parsetree.pattern_desc;
  2. ppat_loc : Location.t;
  3. ppat_loc_stack : Parsetree.location_stack;
  4. ppat_attributes : Parsetree.attributes;
    (*

    ... [\@id1] [\@id2]

    *)
}
and pattern_desc =
  1. | Ppat_any
    (*

    The pattern _.

    *)
  2. | Ppat_var of string Asttypes.loc
    (*

    A variable pattern such as x

    *)
  3. | Ppat_alias of Parsetree.pattern * string Asttypes.loc
    (*

    An alias pattern such as P as 'a

    *)
  4. | Ppat_constant of Parsetree.constant
    (*

    Patterns such as 1, 'a', "true", 1.0, 1l, 1L, 1n

    *)
  5. | Ppat_interval of Parsetree.constant * Parsetree.constant
    (*

    Patterns such as 'a'..'z'.

    Other forms of interval are recognized by the parser but rejected by the type-checker.

    *)
  6. | Ppat_tuple of (string option * Parsetree.pattern) list * Asttypes.closed_flag
    (*

    Ppat_tuple(pl, Closed) represents

    • (P1, ..., Pn) when pl is (None, P1);...;(None, Pn)
    • (~L1:P1, ..., ~Ln:Pn) when pl is (Some L1, P1);...;(Some Ln, Pn)
    • A mix, e.g. (~L1:P1, P2) when pl is (Some L1, P1);(None, P2)
    • If pattern is open, then it also ends in a ..

    Invariant:

    • If Closed, n >= 2.
    • If Open, n >= 1.
    *)
  7. | Ppat_unboxed_tuple of (string option * Parsetree.pattern) list * Asttypes.closed_flag
    (*

    Unboxed tuple patterns: #(l1:P1, ..., ln:Pn) is ([(Some l1,P1);...;(Some l2,Pn)], Closed), and the labels are optional. An Open pattern ends in ...

    Invariant:

    • If Closed, n >= 2
    • If Open, n >= 1
    *)
  8. | Ppat_construct of Longident.t Asttypes.loc * ((string Asttypes.loc * Parsetree.jkind_annotation option) list * Parsetree.pattern) option
    (*

    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, None; b, None], P)
    • C (type (a : k) b) P when args is Some ([a, Some k; b, None], P)
    *)
  9. | Ppat_variant of Asttypes.label * Parsetree.pattern option
    (*

    Ppat_variant(`A, pat) represents:

    • `A when pat is None,
    • `A P when pat is Some P
    *)
  10. | Ppat_record of (Longident.t Asttypes.loc * Parsetree.pattern) list * 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

    *)
  11. | Ppat_record_unboxed_product of (Longident.t Asttypes.loc * Parsetree.pattern) list * Asttypes.closed_flag
    (*

    Ppat_record_unboxed_product([(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

    *)
  12. | Ppat_array of Asttypes.mutable_flag * Parsetree.pattern list
    (*

    Pattern [| P1; ...; Pn |] or [: P1; ...; Pn :]

    *)
  13. | Ppat_or of Parsetree.pattern * Parsetree.pattern
    (*

    Pattern P1 | P2

    *)
  14. | Ppat_constraint of Parsetree.pattern * Parsetree.core_type option * Parsetree.modes
    (*

    Ppat_constraint(tyopt, modes) represents:

    • (P : ty @@ modes) when tyopt is Some ty
    • (P @ modes) when tyopt is None
    *)
  15. | Ppat_type of Longident.t Asttypes.loc
    (*

    Pattern #tconst

    *)
  16. | Ppat_lazy of Parsetree.pattern
    (*

    Pattern lazy P

    *)
  17. | Ppat_unpack of string option Asttypes.loc
    (*

    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)

    *)
  18. | Ppat_exception of Parsetree.pattern
    (*

    Pattern exception P

    *)
  19. | Ppat_extension of Parsetree.extension
    (*

    Pattern [%id]

    *)
  20. | Ppat_open of Longident.t Asttypes.loc * Parsetree.pattern
    (*

    Pattern M.(P)

    *)

Value expressions

and expression = {
  1. pexp_desc : Parsetree.expression_desc;
  2. pexp_loc : Location.t;
  3. pexp_loc_stack : Parsetree.location_stack;
  4. pexp_attributes : Parsetree.attributes;
    (*

    ... [\@id1] [\@id2]

    *)
}
and expression_desc =
  1. | Pexp_ident of Longident.t Asttypes.loc
    (*

    Identifiers such as x and M.x

    *)
  2. | Pexp_constant of Parsetree.constant
    (*

    Expressions constant such as 1, 'a', "true", 1.0, 1l, 1L, 1n

    *)
  3. | Pexp_let of Asttypes.mutable_flag * Asttypes.rec_flag * Parsetree.value_binding list * Parsetree.expression
    (*

    Pexp_let(mut, rec, [(P1,E1) ; ... ; (Pn,En)], E) represents:

    • let P1 = E1 and ... and Pn = EN in E when rec is Nonrecursive and mut = Immutable.
    • let rec P1 = E1 and ... and Pn = EN in E when rec is Recursive and mut = Immutable.
    • let mutable P1 = E1 in E when rec is Nonrecursive and mut = Mutable. Invariant: If mut = Mutable then n = 1 and rec = Nonrecursive
    *)
  4. | Pexp_function of Parsetree.function_param list * Parsetree.function_constraint * Parsetree.function_body
    (*

    Pexp_function ([P1; ...; Pn], C, body) represents any construct involving fun or function, including:

    • fun P1 ... Pn -> E when body = Pfunction_body E
    • fun P1 ... Pn -> function p1 -> e1 | ... | pm -> em when body = Pfunction_cases [ p1 -> e1; ...; pm -> em ] C represents a type constraint or coercion placed immediately before the arrow, e.g. fun P1 ... Pn : ty -> ... when C = Some (Pconstraint ty).

    A function must have parameters. Pexp_function (params, _, body) must have non-empty params or a Pfunction_cases _ body.

    *)
  5. | Pexp_apply of Parsetree.expression * (Parsetree.arg_label * Parsetree.expression) list
    (*

    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

    *)
  6. | Pexp_match of Parsetree.expression * Parsetree.case list
    (*

    match E0 with P1 -> E1 | ... | Pn -> En

    *)
  7. | Pexp_try of Parsetree.expression * Parsetree.case list
    (*

    try E0 with P1 -> E1 | ... | Pn -> En

    *)
  8. | Pexp_tuple of (string option * Parsetree.expression) list
    (*

    Pexp_tuple(el) represents

    • (E1, ..., En) when el is (None, E1);...;(None, En)
    • (~L1:E1, ..., ~Ln:En) when el is (Some L1, E1);...;(Some Ln, En)
    • A mix, e.g.: (~L1:E1, E2) when el is (Some L1, E1); (None, E2)

    Invariant: n >= 2

    *)
  9. | Pexp_unboxed_tuple of (string option * Parsetree.expression) list
    (*

    Unboxed tuple expressions: Pexp_unboxed_tuple([(Some l1,P1);...;(Some l2,Pn)]) represents #(l1:E1, ..., ln:En), and the labels are optional.

    Invariant: n >= 2

    *)
  10. | Pexp_construct of Longident.t Asttypes.loc * Parsetree.expression option
    (*

    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])
    *)
  11. | Pexp_variant of Asttypes.label * Parsetree.expression option
    (*

    Pexp_variant(`A, exp) represents

    • `A when exp is None
    • `A E when exp is Some E
    *)
  12. | Pexp_record of (Longident.t Asttypes.loc * Parsetree.expression) list * Parsetree.expression option
    (*

    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

    *)
  13. | Pexp_record_unboxed_product of (Longident.t Asttypes.loc * Parsetree.expression) list * Parsetree.expression option
    (*

    Pexp_record_unboxed_product([(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

    *)
  14. | Pexp_field of Parsetree.expression * Longident.t Asttypes.loc
    (*

    E.l

    *)
  15. | Pexp_unboxed_field of Parsetree.expression * Longident.t Asttypes.loc
    (*

    E.#l

    *)
  16. | Pexp_setfield of Parsetree.expression * Longident.t Asttypes.loc * Parsetree.expression
    (*

    E1.l <- E2

    *)
  17. | Pexp_array of Asttypes.mutable_flag * Parsetree.expression list
    (*

    [| E1; ...; En |] or [: E1; ...; En :]

    *)
  18. | Pexp_idx of Parsetree.block_access * Parsetree.unboxed_access list
    (*

    (BA1 UA1 UA2 ...) e.g. (.foo.#bar.#baz) Above, BA1=.foo, UA1=.#bar, and UA2=#.baz

    *)
  19. | Pexp_ifthenelse of Parsetree.expression * Parsetree.expression * Parsetree.expression option
    (*

    if E1 then E2 else E3

    *)
  20. | Pexp_sequence of Parsetree.expression * Parsetree.expression
    (*

    E1; E2

    *)
  21. | Pexp_while of Parsetree.expression * Parsetree.expression
    (*

    while E1 do E2 done

    *)
  22. | Pexp_for of Parsetree.pattern * Parsetree.expression * Parsetree.expression * Asttypes.direction_flag * Parsetree.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
    *)
  23. | Pexp_constraint of Parsetree.expression * Parsetree.core_type option * Parsetree.modes
    (*

    (E : T @@ modes)

    *)
  24. | Pexp_coerce of Parsetree.expression * Parsetree.core_type option * Parsetree.core_type
    (*

    Pexp_coerce(E, from, T) represents

    • (E :> T) when from is None,
    • (E : T0 :> T) when from is Some T0.
    *)
  25. | Pexp_send of Parsetree.expression * Asttypes.label Asttypes.loc
    (*

    E # m

    *)
  26. | Pexp_new of Longident.t Asttypes.loc
    (*

    new M.c

    *)
  27. | Pexp_setvar of Asttypes.label Asttypes.loc * Parsetree.expression
    (*

    x <- 2

    Represents both setting an instance variable and setting a mutable variable.

    *)
  28. | Pexp_override of (Asttypes.label Asttypes.loc * Parsetree.expression) list
    (*

    {< x1 = E1; ...; xn = En >}

    *)
  29. | Pexp_letmodule of string option Asttypes.loc * Parsetree.module_expr * Parsetree.expression
    (*

    let module M = ME in E

    *)
  30. | Pexp_letexception of Parsetree.extension_constructor * Parsetree.expression
    (*

    let exception C in E

    *)
  31. | Pexp_assert of Parsetree.expression
    (*

    assert E.

    Note: assert false is treated in a special way by the type-checker.

    *)
  32. | Pexp_lazy of Parsetree.expression
    (*

    lazy E

    *)
  33. | Pexp_poly of Parsetree.expression * Parsetree.core_type option
    (*

    Used for method bodies.

    Can only be used as the expression under Cfk_concrete for methods (not values).

    *)
  34. | Pexp_object of Parsetree.class_structure
    (*

    object ... end

    *)
  35. | Pexp_newtype of string Asttypes.loc * Parsetree.jkind_annotation option * Parsetree.expression
    (*

    fun (type t) -> E or fun (type t : k) -> E

    *)
  36. | Pexp_pack of Parsetree.module_expr
    (*

    (module ME).

    (module ME : S) is represented as Pexp_constraint(Pexp_pack ME, Ptyp_package S)

    *)
  37. | Pexp_open of Parsetree.open_declaration * Parsetree.expression
    (*
    • M.(E)
    • let open M in E
    • let open! M in E
    *)
  38. | Pexp_letop of Parsetree.letop
    (*
    • let* P = E0 in E1
    • let* P0 = E00 and* P1 = E01 in E1
    *)
  39. | Pexp_extension of Parsetree.extension
    (*

    [%id]

    *)
  40. | Pexp_unreachable
    (*

    .

    *)
  41. | Pexp_stack of Parsetree.expression
    (*

    stack_ exp

    *)
  42. | Pexp_comprehension of Parsetree.comprehension_expression
    (*

    [? BODY ...CLAUSES... ?], where:

    • ? is either "" (list), : (immutable array), or | (array).
    • BODY is an expression.
    • CLAUSES is a series of comprehension_clause.
    *)
  43. | Pexp_overwrite of Parsetree.expression * Parsetree.expression
    (*

    overwrite_ exp with exp

    *)
  44. | Pexp_quote of Parsetree.expression
    (*

    runtime metaprogramming quotations <E>

    *)
  45. | Pexp_splice of Parsetree.expression
    (*

    runtime metaprogramming splicing $(E)

    *)
  46. | Pexp_hole
    (*

    _

    *)
and case = {
  1. pc_lhs : Parsetree.pattern;
  2. pc_guard : Parsetree.expression option;
  3. pc_rhs : Parsetree.expression;
}

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

and letop = {
  1. let_ : Parsetree.binding_op;
  2. ands : Parsetree.binding_op list;
  3. body : Parsetree.expression;
}
and binding_op = {
  1. pbop_op : string Asttypes.loc;
  2. pbop_pat : Parsetree.pattern;
  3. pbop_exp : Parsetree.expression;
  4. pbop_loc : Location.t;
}
and function_param_desc =
  1. | Pparam_val of Parsetree.arg_label * Parsetree.expression option * Parsetree.pattern
    (*

    Pparam_val (lbl, exp0, P) represents the parameter:

    Note: If E0 is provided, only Optional is allowed.

    *)
  2. | Pparam_newtype of string Asttypes.loc * Parsetree.jkind_annotation option
    (*

    Pparam_newtype x represents the parameter (type x). x carries the location of the identifier, whereas the pparam_loc on the enclosing function_param node is the location of the (type x) as a whole.

    Multiple parameters (type a b c) are represented as multiple Pparam_newtype nodes, let's say:

     [ { pparam_kind = Pparam_newtype a; pparam_loc = loc1 };
     { pparam_kind = Pparam_newtype b; pparam_loc = loc2 };
     { pparam_kind = Pparam_newtype c; pparam_loc = loc3 };
   ]

    Here, the first loc loc1 is the location of (type a b c), and the subsequent locs loc2 and loc3 are the same as loc1, except marked as ghost locations. The locations on a, b, c, correspond to the variables a, b, and c in the source code.

    *)
and function_param = {
  1. pparam_loc : Location.t;
  2. pparam_desc : Parsetree.function_param_desc;
}
and function_body =
  1. | Pfunction_body of Parsetree.expression
  2. | Pfunction_cases of Parsetree.case list * Location.t * Parsetree.attributes
    (*

    In Pfunction_cases (_, loc, attrs), the location extends from the start of the function keyword to the end of the last case. The compiler will only use typechecking-related attributes from attrs, e.g. enabling or disabling a warning.

    *)

See the comment on Pexp_function.

and type_constraint =
  1. | Pconstraint of Parsetree.core_type
  2. | Pcoerce of Parsetree.core_type option * Parsetree.core_type
    (*

    See the comment on Pexp_function.

    *)
and function_constraint = {
  1. mode_annotations : Parsetree.modes;
    (*

    The mode annotation placed on a function let-binding, e.g. let local_ f x : int -> int = .... The local_ syntax is parsed into two nodes: the field here, and pvb_modes. This field only affects the interpretation of ret_type_constraint, while the latter is translated in typecore to Pexp_constraint to contrain the mode of the function. (* CR zqian: This field is not failthful representation of the user syntax, and complicates pprintast. It should be removed and their functionality should be moved to pvb_modes. *)

    *)
  2. ret_mode_annotations : Parsetree.modes;
    (*

    The mode annotation placed on a function's body, e.g. let f x : int -> int @@ local = .... This field constrains the mode of function's body.

    *)
  3. ret_type_constraint : Parsetree.type_constraint option;
    (*

    The type constraint placed on a function's body.

    *)
}

See the comment on Pexp_function.

and block_access =
  1. | Baccess_field of Longident.t Asttypes.loc
    (*

    .foo

    *)
  2. | Baccess_array of Asttypes.mutable_flag * Asttypes.index_kind * Parsetree.expression
    (*

    Mutable array accesses: .(E), .L(E), .l(E), .S(E), .s(E), .n(E) Immutable array accesses: .:(E), .:L(E), .:l(E), .:S(E), .:s(E), .:n(E)

    Indexed by int, int64#, int32#, int16#, int8#, or nativeint#, respectively.

    *)
  3. | Baccess_block of Asttypes.mutable_flag * Parsetree.expression
    (*

    Access using another block index: .idx_imm(E), .idx_mut(E) (usually followed by unboxed accesses, to deepen the index).

    *)
and unboxed_access =
  1. | Uaccess_unboxed_field of Longident.t Asttypes.loc
    (*

    .#foo

    *)
and comprehension_iterator =
  1. | Pcomp_range of {
    1. start : Parsetree.expression;
    2. stop : Parsetree.expression;
    3. direction : Asttypes.direction_flag;
    }
    (*

    "= START to STOP" (direction = Upto) "= START downto STOP" (direction = Downto)

    *)
  2. | Pcomp_in of Parsetree.expression
    (*

    "in EXPR"

    *)
and comprehension_clause_binding = {
  1. pcomp_cb_pattern : Parsetree.pattern;
  2. pcomp_cb_iterator : Parsetree.comprehension_iterator;
  3. pcomp_cb_attributes : Parsetree.attributes;
}

@... PAT (in/=) ...

and comprehension_clause =
  1. | Pcomp_for of Parsetree.comprehension_clause_binding list
    (*

    "for PAT (in/=) ... and PAT (in/=) ... and ..."; must be nonempty

    *)
  2. | Pcomp_when of Parsetree.expression
    (*

    "when EXPR"

    *)
and comprehension = {
  1. pcomp_body : Parsetree.expression;
    (*

    The body/generator of the comprehension

    *)
  2. pcomp_clauses : Parsetree.comprehension_clause list;
    (*

    The clauses of the comprehension; must be nonempty

    *)
}
and comprehension_expression =
  1. | Pcomp_list_comprehension of Parsetree.comprehension
    (*

    [BODY ...CLAUSES...]

    *)
  2. | Pcomp_array_comprehension of Asttypes.mutable_flag * Parsetree.comprehension
    (*

    [|BODY ...CLAUSES...|] (flag = Mutable) [:BODY ...CLAUSES...:] (flag = Immutable) (only allowed with -extension immutable_arrays)

    *)

Value descriptions

and value_description = {
  1. pval_name : string Asttypes.loc;
  2. pval_type : Parsetree.core_type;
  3. pval_modalities : Parsetree.modalities;
  4. pval_prim : string list;
  5. pval_attributes : Parsetree.attributes;
    (*

    ... [\@\@id1] [\@\@id2]

    *)
  6. 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 = {
  1. ptype_name : string Asttypes.loc;
  2. ptype_params : (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list;
    (*

    ('a1,...'an) t

    *)
  3. ptype_cstrs : (Parsetree.core_type * Parsetree.core_type * Location.t) list;
    (*

    ... constraint T1=T1' ... constraint Tn=Tn'

    *)
  4. ptype_kind : Parsetree.type_kind;
  5. ptype_private : Asttypes.private_flag;
    (*

    for = private ...

    *)
  6. ptype_manifest : Parsetree.core_type option;
    (*

    represents = T

    *)
  7. ptype_attributes : Parsetree.attributes;
    (*

    ... [\@\@id1] [\@\@id2]

    *)
  8. ptype_jkind_annotation : Parsetree.jkind_annotation option;
    (*

    for : jkind

    *)
  9. 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 =
  1. | Ptype_abstract
  2. | Ptype_variant of Parsetree.constructor_declaration list
  3. | Ptype_record of Parsetree.label_declaration list
    (*

    Invariant: non-empty list

    *)
  4. | Ptype_record_unboxed_product of Parsetree.label_declaration list
    (*

    Invariant: non-empty list

    *)
  5. | Ptype_open
and label_declaration = {
  1. pld_name : string Asttypes.loc;
  2. pld_mutable : Asttypes.mutable_flag;
  3. pld_modalities : Parsetree.modalities;
  4. pld_type : Parsetree.core_type;
  5. pld_loc : Location.t;
  6. pld_attributes : Parsetree.attributes;
    (*

    l : T [\@id1] [\@id2]

    *)
}

Note: T can be a Ptyp_poly.

and constructor_declaration = {
  1. pcd_name : string Asttypes.loc;
  2. pcd_vars : (string Asttypes.loc * Parsetree.jkind_annotation option) list;
    (*

    jkind annotations are C : ('a : kind1) ('a2 : kind2). ...

    *)
  3. pcd_args : Parsetree.constructor_arguments;
  4. pcd_res : Parsetree.core_type option;
  5. pcd_loc : Location.t;
  6. pcd_attributes : Parsetree.attributes;
    (*

    C of ... [\@id1] [\@id2]

    *)
}
and constructor_argument = {
  1. pca_modalities : Parsetree.modalities;
  2. pca_type : Parsetree.core_type;
  3. pca_loc : Location.t;
}
and constructor_arguments =
  1. | Pcstr_tuple of Parsetree.constructor_argument list
  2. | Pcstr_record of Parsetree.label_declaration list
    (*

    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 = {
  1. ptyext_path : Longident.t Asttypes.loc;
  2. ptyext_params : (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list;
  3. ptyext_constructors : Parsetree.extension_constructor list;
  4. ptyext_private : Asttypes.private_flag;
  5. ptyext_loc : Location.t;
  6. ptyext_attributes : Parsetree.attributes;
    (*

    ... \@\@id1 \@\@id2

    *)
}

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

and extension_constructor = {
  1. pext_name : string Asttypes.loc;
  2. pext_kind : Parsetree.extension_constructor_kind;
  3. pext_loc : Location.t;
  4. pext_attributes : Parsetree.attributes;
    (*

    C of ... [\@id1] [\@id2]

    *)
}
and type_exception = {
  1. ptyexn_constructor : Parsetree.extension_constructor;
  2. ptyexn_loc : Location.t;
  3. ptyexn_attributes : Parsetree.attributes;
    (*

    ... [\@\@id1] [\@\@id2]

    *)
}

Definition of a new exception (exception E).

and extension_constructor_kind =
  1. | Pext_decl of (string Asttypes.loc * Parsetree.jkind_annotation option) list * Parsetree.constructor_arguments * Parsetree.core_type option
    (*

    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 : k)... . T1 * ... * Tn -> T0 when

      • existentials is [('a : k);...],
      • c_args is [T1; ... ; Tn],
      • t_opt is Some T0.
    *)
  2. | Pext_rebind of Longident.t Asttypes.loc
    (*

    Pext_rebind(D) re-export the constructor D with the new name C

    *)

Class language

Type expressions for the class language

and class_type = {
  1. pcty_desc : Parsetree.class_type_desc;
  2. pcty_loc : Location.t;
  3. pcty_attributes : Parsetree.attributes;
    (*

    ... [\@id1] [\@id2]

    *)
}
and class_type_desc =
  1. | Pcty_constr of Longident.t Asttypes.loc * Parsetree.core_type list
    (*
    • c
    • ['a1, ..., 'an] c
    *)
  2. | Pcty_signature of Parsetree.class_signature
    (*

    object ... end

    *)
  3. | Pcty_arrow of Parsetree.arg_label * Parsetree.core_type * Parsetree.class_type
    (*

    Pcty_arrow(lbl, T, CT) represents:

    *)
  4. | Pcty_extension of Parsetree.extension
    (*

    %id

    *)
  5. | Pcty_open of Parsetree.open_description * Parsetree.class_type
    (*

    let open M in CT

    *)
and class_signature = {
  1. pcsig_self : Parsetree.core_type;
  2. pcsig_fields : Parsetree.class_type_field list;
}

Values of type class_signature represents:

and class_type_field = {
  1. pctf_desc : Parsetree.class_type_field_desc;
  2. pctf_loc : Location.t;
  3. pctf_attributes : Parsetree.attributes;
    (*

    ... [\@\@id1] [\@\@id2]

    *)
}
and class_type_field_desc =
  1. | Pctf_inherit of Parsetree.class_type
    (*

    inherit CT

    *)
  2. | Pctf_val of Asttypes.label Asttypes.loc * Asttypes.mutable_flag * Asttypes.virtual_flag * Parsetree.core_type
    (*

    val x: T

    *)
  3. | Pctf_method of Asttypes.label Asttypes.loc * Asttypes.private_flag * Asttypes.virtual_flag * Parsetree.core_type
    (*

    method x: T

    Note: T can be a Ptyp_poly.

    *)
  4. | Pctf_constraint of Parsetree.core_type * Parsetree.core_type
    (*

    constraint T1 = T2

    *)
  5. | Pctf_attribute of Parsetree.attribute
    (*

    [\@\@\@id]

    *)
  6. | Pctf_extension of Parsetree.extension
    (*

    [%%id]

    *)
and 'a class_infos = {
  1. pci_virt : Asttypes.virtual_flag;
  2. pci_params : (Parsetree.core_type * (Asttypes.variance * Asttypes.injectivity)) list;
  3. pci_name : string Asttypes.loc;
  4. pci_expr : 'a;
  5. pci_loc : Location.t;
  6. pci_attributes : Parsetree.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_type_declaration = Parsetree.class_type Parsetree.class_infos

Value expressions for the class language

and class_expr = {
  1. pcl_desc : Parsetree.class_expr_desc;
  2. pcl_loc : Location.t;
  3. pcl_attributes : Parsetree.attributes;
    (*

    ... [\@id1] [\@id2]

    *)
}
and class_expr_desc =
  1. | Pcl_constr of Longident.t Asttypes.loc * Parsetree.core_type list
    (*

    c and ['a1, ..., 'an] c

    *)
  2. | Pcl_structure of Parsetree.class_structure
    (*

    object ... end

    *)
  3. | Pcl_fun of Parsetree.arg_label * Parsetree.expression option * Parsetree.pattern * Parsetree.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.
    *)
  4. | Pcl_apply of Parsetree.class_expr * (Parsetree.arg_label * Parsetree.expression) list
    (*

    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

    *)
  5. | Pcl_let of Asttypes.rec_flag * Parsetree.value_binding list * Parsetree.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.
    *)
  6. | Pcl_constraint of Parsetree.class_expr * Parsetree.class_type
    (*

    (CE : CT)

    *)
  7. | Pcl_extension of Parsetree.extension
    (*

    [%id]

    *)
  8. | Pcl_open of Parsetree.open_description * Parsetree.class_expr
    (*

    let open M in CE

    *)
and class_structure = {
  1. pcstr_self : Parsetree.pattern;
  2. pcstr_fields : Parsetree.class_field list;
}

Values of type class_structure represents:

and class_field = {
  1. pcf_desc : Parsetree.class_field_desc;
  2. pcf_loc : Location.t;
  3. pcf_attributes : Parsetree.attributes;
    (*

    ... [\@\@id1] [\@\@id2]

    *)
}
and class_field_desc =
  1. | Pcf_inherit of Asttypes.override_flag * Parsetree.class_expr * string Asttypes.loc option
    (*

    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
    *)
  2. | Pcf_val of Asttypes.label Asttypes.loc * Asttypes.mutable_flag * Parsetree.class_field_kind
    (*

    Pcf_val(x,flag, kind) represents:

    *)
  3. | Pcf_method of Asttypes.label Asttypes.loc * Asttypes.private_flag * Parsetree.class_field_kind
    (**)
  4. | Pcf_constraint of Parsetree.core_type * Parsetree.core_type
    (*

    constraint T1 = T2

    *)
  5. | Pcf_initializer of Parsetree.expression
    (*

    initializer E

    *)
  6. | Pcf_attribute of Parsetree.attribute
    (*

    [\@\@\@id]

    *)
  7. | Pcf_extension of Parsetree.extension
    (*

    [%%id]

    *)
and class_field_kind =
  1. | Cfk_virtual of Parsetree.core_type
  2. | Cfk_concrete of Asttypes.override_flag * Parsetree.expression

Module language

Type expressions for the module language

and module_type = {
  1. pmty_desc : Parsetree.module_type_desc;
  2. pmty_loc : Location.t;
  3. pmty_attributes : Parsetree.attributes;
    (*

    ... [\@id1] [\@id2]

    *)
}
and module_type_desc =
  1. | Pmty_ident of Longident.t Asttypes.loc
    (*

    Pmty_ident(S) represents S

    *)
  2. | Pmty_signature of Parsetree.signature
    (*

    sig ... end

    *)
  3. | Pmty_functor of Parsetree.functor_parameter * Parsetree.module_type * Parsetree.modes
    (*

    functor(X : MT1 @@ modes) -> MT2 @ modes

    *)
  4. | Pmty_with of Parsetree.module_type * Parsetree.with_constraint list
    (*

    MT with ...

    *)
  5. | Pmty_typeof of Parsetree.module_expr
    (*

    module type of ME

    *)
  6. | Pmty_extension of Parsetree.extension
    (*

    [%id]

    *)
  7. | Pmty_alias of Longident.t Asttypes.loc
    (*

    (module M)

    *)
  8. | Pmty_strengthen of Parsetree.module_type * Longident.t Asttypes.loc
    (*

    MT with S

    *)
and functor_parameter =
  1. | Unit
    (*

    ()

    *)
  2. | Named of string option Asttypes.loc * Parsetree.module_type * Parsetree.modes
    (*

    Named(name, MT) represents:

    • (X : MT @@ modes) when name is Some X,
    • (_ : MT @@ modes) when name is None
    *)
and signature = {
  1. psg_modalities : Parsetree.modalities;
  2. psg_items : Parsetree.signature_item list;
  3. psg_loc : Location.t;
}
and signature_item = {
  1. psig_desc : Parsetree.signature_item_desc;
  2. psig_loc : Location.t;
}
and signature_item_desc =
  1. | Psig_value of Parsetree.value_description
    (*
    • val x: T
    • external x: T = "s1" ... "sn"
    *)
  2. | Psig_type of Asttypes.rec_flag * Parsetree.type_declaration list
    (*

    type t1 = ... and ... and tn = ...

    *)
  3. | Psig_typesubst of Parsetree.type_declaration list
    (*

    type t1 := ... and ... and tn := ...

    *)
  4. | Psig_typext of Parsetree.type_extension
    (*

    type t1 += ...

    *)
  5. | Psig_exception of Parsetree.type_exception
    (*

    exception C of T

    *)
  6. | Psig_module of Parsetree.module_declaration
    (*

    module X = M and module X : MT

    *)
  7. | Psig_modsubst of Parsetree.module_substitution
    (*

    module X := M

    *)
  8. | Psig_recmodule of Parsetree.module_declaration list
    (*

    module rec X1 : MT1 and ... and Xn : MTn

    *)
  9. | Psig_modtype of Parsetree.module_type_declaration
    (*

    module type S = MT and module type S

    *)
  10. | Psig_modtypesubst of Parsetree.module_type_declaration
    (*

    module type S := ...

    *)
  11. | Psig_open of Parsetree.open_description
    (*

    open X

    *)
  12. | Psig_include of Parsetree.include_description * Parsetree.modalities
    (*

    include MT

    *)
  13. | Psig_class of Parsetree.class_description list
    (*

    class c1 : ... and ... and cn : ...

    *)
  14. | Psig_class_type of Parsetree.class_type_declaration list
    (*

    class type ct1 = ... and ... and ctn = ...

    *)
  15. | Psig_attribute of Parsetree.attribute
    (*

    [\@\@\@id]

    *)
  16. | Psig_extension of Parsetree.extension * Parsetree.attributes
    (*

    [%%id]

    *)
  17. | Psig_kind_abbrev of string Asttypes.loc * Parsetree.jkind_annotation
    (*

    kind_abbrev_ name = k

    *)
and module_declaration = {
  1. pmd_name : string option Asttypes.loc;
  2. pmd_type : Parsetree.module_type;
  3. pmd_modalities : Parsetree.modalities;
  4. pmd_attributes : Parsetree.attributes;
    (*

    ... [\@\@id1] [\@\@id2]

    *)
  5. pmd_loc : Location.t;
}

Values of type module_declaration represents S : MT

and module_substitution = {
  1. pms_name : string Asttypes.loc;
  2. pms_manifest : Longident.t Asttypes.loc;
  3. pms_attributes : Parsetree.attributes;
    (*

    ... [\@\@id1] [\@\@id2]

    *)
  4. pms_loc : Location.t;
}

Values of type module_substitution represents S := M

and module_type_declaration = {
  1. pmtd_name : string Asttypes.loc;
  2. pmtd_type : Parsetree.module_type option;
  3. pmtd_attributes : Parsetree.attributes;
    (*

    ... [\@\@id1] [\@\@id2]

    *)
  4. 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 'a open_infos = {
  1. popen_expr : 'a;
  2. popen_override : Asttypes.override_flag;
  3. popen_loc : Location.t;
  4. popen_attributes : Parsetree.attributes;
}

Values of type 'a open_infos represents:

Values of type open_description represents:

  • open M.N
  • open M(N).O

Values of type open_declaration represents:

  • open M.N
  • open M(N).O
  • open struct ... end
and 'a include_infos = {
  1. pincl_kind : Parsetree.include_kind;
  2. pincl_mod : 'a;
  3. pincl_loc : Location.t;
  4. pincl_attributes : Parsetree.attributes;
}

Values of type include_description represents include MT

Values of type include_declaration represents include ME

and with_constraint =
  1. | Pwith_type of Longident.t Asttypes.loc * Parsetree.type_declaration
    (*

    with type X.t = ...

    Note: the last component of the longident must match the name of the type_declaration.

    *)
  2. | Pwith_module of Longident.t Asttypes.loc * Longident.t Asttypes.loc
    (*

    with module X.Y = Z

    *)
  3. | Pwith_modtype of Longident.t Asttypes.loc * Parsetree.module_type
    (*

    with module type X.Y = Z

    *)
  4. | Pwith_modtypesubst of Longident.t Asttypes.loc * Parsetree.module_type
    (*

    with module type X.Y := sig end

    *)
  5. | Pwith_typesubst of Longident.t Asttypes.loc * Parsetree.type_declaration
    (*

    with type X.t := ..., same format as [Pwith_type]

    *)
  6. | Pwith_modsubst of Longident.t Asttypes.loc * Longident.t Asttypes.loc
    (*

    with module X.Y := Z

    *)

Value expressions for the module language

and module_expr = {
  1. pmod_desc : Parsetree.module_expr_desc;
  2. pmod_loc : Location.t;
  3. pmod_attributes : Parsetree.attributes;
    (*

    ... [\@id1] [\@id2]

    *)
}
and module_expr_desc =
  1. | Pmod_ident of Longident.t Asttypes.loc
    (*

    X

    *)
  2. | Pmod_structure of Parsetree.structure
    (*

    struct ... end

    *)
  3. | Pmod_functor of Parsetree.functor_parameter * Parsetree.module_expr
    (*

    functor(X : MT1) -> ME

    *)
  4. | Pmod_apply of Parsetree.module_expr * Parsetree.module_expr
    (*

    ME1(ME2)

    *)
  5. | Pmod_apply_unit of Parsetree.module_expr
    (*

    ME1()

    *)
  6. | Pmod_constraint of Parsetree.module_expr * Parsetree.module_type option * Parsetree.modes
    (*
    • (ME : MT @@ modes)
    • (ME @ modes)
    • (ME : MT)
    *)
  7. | Pmod_unpack of Parsetree.expression
    (*

    (val E)

    *)
  8. | Pmod_extension of Parsetree.extension
    (*

    [%id]

    *)
  9. | Pmod_instance of Parsetree.module_instance
    (*

    Foo(Param1)(Arg1(Param2)(Arg2)) [@jane.non_erasable.instances]

    The name of an instance module. Gets converted to Global.Name.t in the OxCaml compiler.

    *)
and module_instance = {
  1. pmod_instance_head : string;
  2. pmod_instance_args : (string * Parsetree.module_instance) list;
}

M(P1)(MI1)...(Pn)(MIn)

and structure = Parsetree.structure_item list
and structure_item = {
  1. pstr_desc : Parsetree.structure_item_desc;
  2. pstr_loc : Location.t;
}
and structure_item_desc =
  1. | Pstr_eval of Parsetree.expression * Parsetree.attributes
    (*

    E

    *)
  2. | Pstr_value of Asttypes.rec_flag * Parsetree.value_binding list
    (*

    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.
    *)
  3. | Pstr_primitive of Parsetree.value_description
    (*
    • val x: T
    • external x: T = "s1" ... "sn"
    *)
  4. | Pstr_type of Asttypes.rec_flag * Parsetree.type_declaration list
    (*

    type t1 = ... and ... and tn = ...

    *)
  5. | Pstr_typext of Parsetree.type_extension
    (*

    type t1 += ...

    *)
  6. | Pstr_exception of Parsetree.type_exception
    (*
    • exception C of T
    • exception C = M.X
    *)
  7. | Pstr_module of Parsetree.module_binding
    (*

    module X = ME

    *)
  8. | Pstr_recmodule of Parsetree.module_binding list
    (*

    module rec X1 = ME1 and ... and Xn = MEn

    *)
  9. | Pstr_modtype of Parsetree.module_type_declaration
    (*

    module type S = MT

    *)
  10. | Pstr_open of Parsetree.open_declaration
    (*

    open X

    *)
  11. | Pstr_class of Parsetree.class_declaration list
    (*

    class c1 = ... and ... and cn = ...

    *)
  12. | Pstr_class_type of Parsetree.class_type_declaration list
    (*

    class type ct1 = ... and ... and ctn = ...

    *)
  13. | Pstr_include of Parsetree.include_declaration
    (*

    include ME

    *)
  14. | Pstr_attribute of Parsetree.attribute
    (*

    [\@\@\@id]

    *)
  15. | Pstr_extension of Parsetree.extension * Parsetree.attributes
    (*

    [%%id]

    *)
  16. | Pstr_kind_abbrev of string Asttypes.loc * Parsetree.jkind_annotation
    (*

    kind_abbrev_ name = k

    *)
and value_constraint =
  1. | Pvc_constraint of {
    1. locally_abstract_univars : string Asttypes.loc list;
    2. typ : Parsetree.core_type;
    }
  2. | Pvc_coercion of {
    1. ground : Parsetree.core_type option;
    2. coercion : Parsetree.core_type;
    }
    (*
    • Pvc_constraint { locally_abstract_univars=[]; typ} is a simple type constraint on a value binding: let x : typ
    • More generally, in Pvc_constraint { locally_abstract_univars; typ} locally_abstract_univars is the list of locally abstract type variables in let x: type a ... . typ
    • Pvc_coercion { ground=None; coercion } represents let x :> typ
    • Pvc_coercion { ground=Some g; coercion } represents let x : g :> typ
    *)
and value_binding = {
  1. pvb_pat : Parsetree.pattern;
  2. pvb_expr : Parsetree.expression;
  3. pvb_constraint : Parsetree.value_constraint option;
  4. pvb_modes : Parsetree.modes;
  5. pvb_attributes : Parsetree.attributes;
  6. pvb_loc : Location.t;
}

let pat : type_constraint = exp

and module_binding = {
  1. pmb_name : string option Asttypes.loc;
  2. pmb_expr : Parsetree.module_expr;
  3. pmb_attributes : Parsetree.attributes;
  4. pmb_loc : Location.t;
}

Values of type module_binding represents module X = ME

and jkind_annotation_desc =
  1. | Pjk_default
  2. | Pjk_abbreviation of string
  3. | Pjk_mod of Parsetree.jkind_annotation * Parsetree.modes
  4. | Pjk_with of Parsetree.jkind_annotation * Parsetree.core_type * Parsetree.modalities
  5. | Pjk_kind_of of Parsetree.core_type
  6. | Pjk_product of Parsetree.jkind_annotation list
and jkind_annotation = {
  1. pjkind_loc : Location.t;
  2. pjkind_desc : Parsetree.jkind_annotation_desc;
}

Toplevel

Toplevel phrases

type toplevel_phrase =
  1. | Ptop_def of Parsetree.structure
  2. | Ptop_dir of Parsetree.toplevel_directive
    (*

    #use, #load ...

    *)
and toplevel_directive = {
  1. pdir_name : string Asttypes.loc;
  2. pdir_arg : Parsetree.directive_argument option;
  3. pdir_loc : Location.t;
}
and directive_argument = {
  1. pdira_desc : Parsetree.directive_argument_desc;
  2. pdira_loc : Location.t;
}
and directive_argument_desc =
  1. | Pdir_string of string
  2. | Pdir_int of string * char option
  3. | Pdir_ident of Longident.t
  4. | Pdir_bool of bool