jon.recoil.org

Module Parser_extended.ParsetreeSource

Abstract syntax tree produced by parsing

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

Sourcetype sign =
  1. | Positive
  2. | Negative
Sourcetype constant_desc =
  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_char of char * string
    (*

    Pconst_char (c, s) describes a character c and its literal string representation s.

    e.g. the character '\n' is represented by the literal string "\\n".

    *)
  3. | Pconst_string of string * Ocaml_common.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.

    *)
  4. | 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 are rejected by the typechecker.

    *)
  5. | Pconst_unboxed_integer of sign * string * char option
  6. | Pconst_unboxed_float of sign * string * char option
Sourcetype constant = {
  1. pconst_desc : constant_desc;
  2. pconst_loc : Ocaml_common.Location.t;
}
Sourcetype location_stack = Ocaml_common.Location.t list
Sourcetype modality =
  1. | Modality of string
Sourcetype modalities = modality Asttypes.loc list
Sourcetype mode =
  1. | Mode of string
Sourcetype modes = mode Asttypes.loc list
Sourcetype include_kind =
  1. | Structure
  2. | Functor

Extension points

Sourcetype attribute = {
  1. attr_name : string Asttypes.loc;
  2. attr_payload : payload;
  3. attr_loc : Ocaml_common.Location.t;
}

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

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

Sourceand extension = string Asttypes.loc * payload

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

Sub-language placeholder -- rejected by the typechecker.

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

    : SIG in an attribute or an extension point

    *)
  3. | PTyp of core_type
    (*

    : T in an attribute or an extension point

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

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

    *)
Sourceand ext_attrs = {
  1. attrs_extension : string Asttypes.loc option;
    (*

    Short extension syntax, eg. module%ext Foo ....

    *)
  2. attrs_before : attributes;
    (*

    eg. module Foo [@attr] = ....

    *)
  3. attrs_after : attributes;
    (*

    eg. module Foo = struct end [@@attr].

    *)
}

Core language

Type expressions

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

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

    *)
}
Sourceand arrow_param = {
  1. pap_label : Asttypes.arg_label;
  2. pap_loc : Ocaml_common.Location.t;
    (*

    Location also including the codomain.

    *)
  3. pap_type : core_type;
  4. pap_modes : mode Asttypes.loc list;
}
Sourceand core_type_desc =
  1. | Ptyp_any
    (*

    _

    *)
  2. | Ptyp_var of ty_var
    (*

    A type variable such as 'a

    *)
  3. | Ptyp_arrow of arrow_param list * core_type * mode Asttypes.loc list
    (*

    Ptyp_arrow([lbl, T1, M1], T2, 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 Asttypes.loc option * 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 Asttypes.loc option * 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 Ocaml_common.Longident.t Asttypes.loc * 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 object_field list * Asttypes.obj_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 Ocaml_common.Longident.t Asttypes.loc * 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 core_type * ty_var
    (*

    T as 'a.

    *)
  10. | Ptyp_variant of row_field list * Asttypes.closed_flag * Asttypes.variant_var 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 ty_var list * 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 ...
    *)
  12. | Ptyp_package of package_type
    (*

    (module S).

    *)
  13. | Ptyp_extension of extension
    (*

    [%id].

    *)
  14. | Ptyp_of_kind of jkind_annotation
    (*

    (type : k)

    *)
  15. | Ptyp_constr_unboxed of Ocaml_common.Longident.t Asttypes.loc * core_type list
  16. | Ptyp_quote of core_type
    (*

    <[T]>

    *)
  17. | Ptyp_splice of core_type
    (*

    $T

    *)

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).
Sourceand row_field = {
  1. prf_desc : row_field_desc;
  2. prf_loc : Ocaml_common.Location.t;
  3. prf_attributes : attributes;
}
Sourceand row_field_desc =
  1. | Rtag of Asttypes.variant_var * bool * 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 core_type
    (*

    [ | t ]

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

Patterns

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

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

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

    The pattern _.

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

    A variable pattern such as x

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

    An alias pattern such as P as 'a

    *)
  4. | Ppat_constant of constant
    (*

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

    *)
  5. | Ppat_interval of constant * 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 Asttypes.loc option * 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_unit
    (*

    #()

    *)
  8. | Ppat_unboxed_bool of bool
    (*

    #false or #true

    *)
  9. | Ppat_unboxed_tuple of (string Asttypes.loc option * 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
    *)
  10. | Ppat_construct of Ocaml_common.Longident.t Asttypes.loc * (ty_var list * 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; b], P)
    *)
  11. | Ppat_variant of Asttypes.variant_var * pattern option
    (*

    Ppat_variant(`A, pat) represents:

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

    *)
  13. | Ppat_record_unboxed_product of (Ocaml_common.Longident.t Asttypes.loc * core_type option * pattern option) list * Asttypes.obj_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

    *)
  14. | Ppat_array of Asttypes.mutable_flag * pattern list
    (*

    Pattern [| P1; ...; Pn |] (flag = Mutable) Pattern [: P1; ...; Pn :] (flag = Immutable)

    *)
  15. | Ppat_list of pattern list
    (*

    Pattern [ P1; ...; Pn ]

    *)
  16. | Ppat_or of pattern list
    (*

    Pattern P1 | ... | Pn

    *)
  17. | Ppat_constraint of pattern * core_type option * mode Asttypes.loc list
    (*

    Ppat_constraint(P, tyopt, modes) represents:

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

    Pattern #tconst

    *)
  19. | Ppat_lazy of pattern
    (*

    Pattern lazy P

    *)
  20. | Ppat_unpack of string option Asttypes.loc * package_type option
    (*

    Ppat_unpack(p, s) represents:

    • (module P) when p is Some "P" and s is None
    • (module _) when p is None and s is None
    • (module P : S) when p is Some "P" and s is Some "S"
    • (module _ : S) when p is None and s is Some "S"
    *)
  21. | Ppat_exception of pattern
    (*

    Pattern exception P

    *)
  22. | Ppat_extension of extension
    (*

    Pattern [%id]

    *)
  23. | Ppat_open of Ocaml_common.Longident.t Asttypes.loc * pattern
    (*

    Pattern M.(P)

    *)
  24. | Ppat_cons of pattern list
    (*

    Pattern P1 :: ... :: Pn

    *)

Value expressions

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

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

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

    Identifiers such as x and M.x

    *)
  2. | Pexp_constant of constant
    (*

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

    *)
  3. | Pexp_let of value_bindings * 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.
    *)
  4. | Pexp_function of case list
    (*

    function P1 -> E1 | ... | Pn -> En

    *)
  5. | Pexp_fun of function_param * expression
    (*

    Pexp_fun(P, E) represents:

    • fun P -> E
    • fun ~l:P -> E
    • fun ?l:P -> E
    • fun ?l:(P = E0) -> E
    • fun (type t) -> E
    *)
  6. | Pexp_apply of expression * (Asttypes.arg_label * 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

    *)
  7. | Pexp_match of expression * case list
    (*

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

    *)
  8. | Pexp_try of expression * case list
    (*

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

    *)
  9. | Pexp_tuple of (string Asttypes.loc option * 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.

    *)
  10. | Pexp_unboxed_unit
    (*

    #()

    *)
  11. | Pexp_unboxed_bool of bool
    (*

    #false or #true

    *)
  12. | Pexp_unboxed_tuple of (string Asttypes.loc option * 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

    *)
  13. | Pexp_construct of Ocaml_common.Longident.t Asttypes.loc * 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])
    *)
  14. | Pexp_variant of Asttypes.variant_var * expression option
    (*

    Pexp_variant(`A, exp) represents

    • `A when exp is None
    • `A E when exp is Some E
    *)
  15. | Pexp_record of (Ocaml_common.Longident.t Asttypes.loc * type_constraint option * expression option) list * 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

    *)
  16. | Pexp_record_unboxed_product of (Ocaml_common.Longident.t Asttypes.loc * type_constraint option * expression option) list * 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

    *)
  17. | Pexp_field of expression * Ocaml_common.Longident.t Asttypes.loc
    (*

    E.l

    *)
  18. | Pexp_unboxed_field of expression * Ocaml_common.Longident.t Asttypes.loc
    (*

    E.#l

    *)
  19. | Pexp_setfield of expression * Ocaml_common.Longident.t Asttypes.loc * expression
    (*

    E1.l <- E2

    *)
  20. | Pexp_array of Asttypes.mutable_flag * expression list
    (*

    [| E1; ...; En |] (flag = Mutable) [: E1; ...; En :] (flag = Immutable)

    *)
  21. | Pexp_idx of block_access * unboxed_access list
    (*

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

    *)
  22. | Pexp_list of expression list
    (*

    [ E1; ...; En ]

    *)
  23. | Pexp_ifthenelse of if_branch list * expression option
    (*

    if E1 then E2 else E3

    *)
  24. | Pexp_sequence of expression * expression
    (*

    E1; E2

    *)
  25. | Pexp_while of expression * expression
    (*

    while E1 do E2 done

    *)
  26. | Pexp_for of 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
    *)
  27. | Pexp_constraint of expression * core_type option * mode Asttypes.loc list
    (*

    (E : T @@ modes)

    *)
  28. | Pexp_coerce of expression * core_type option * core_type
    (*

    Pexp_coerce(E, from, T) represents

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

    E # m

    *)
  30. | Pexp_new of Ocaml_common.Longident.t Asttypes.loc
    (*

    new M.c

    *)
  31. | Pexp_setinstvar of Asttypes.label Asttypes.loc * expression
    (*

    x <- 2

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

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

    *)
  33. | Pexp_letmodule of string option Asttypes.loc * modes * functor_parameter Asttypes.loc list * module_expr * expression
    (*

    let module M = ME in E

    *)
  34. | Pexp_letexception of extension_constructor * expression
    (*

    let exception C in E

    *)
  35. | Pexp_assert of expression
    (*

    assert E.

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

    *)
  36. | Pexp_lazy of expression
    (*

    lazy E

    *)
  37. | Pexp_poly of expression * core_type option
    (*

    Used for method bodies.

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

    *)
  38. | Pexp_object of class_structure
    (*

    object ... end

    *)
  39. | Pexp_newtype of ty_var * expression
    (*

    fun (type t) -> E

    *)
  40. | Pexp_pack of module_expr * package_type option
    (*
    • (module M) is represented as Pexp_pack(M, None)
    • (module M : S) is represented as Pexp_pack(M, Some S)
    *)
  41. | Pexp_open of Ocaml_common.Longident.t Asttypes.loc * expression
    (*

    M.(E)

    *)
  42. | Pexp_letopen of open_declaration * expression
    (*
    • let open M in E
    • let open! M in E
    *)
  43. | Pexp_letop of letop
    (*
    • let* P = E0 in E1
    • let* P0 = E00 and* P1 = E01 in E1
    *)
  44. | Pexp_extension of extension
    (*

    [%id]

    *)
  45. | Pexp_unreachable
    (*

    .

    *)
  46. | Pexp_stack of expression
    (*

    stack_ exp

    *)
  47. | Pexp_borrow of expression
    (*

    borrow_ exp

    *)
  48. | Pexp_hole
    (*

    _

    *)
  49. | Pexp_beginend of expression
    (*

    begin E end

    *)
  50. | Pexp_parens of expression
    (*

    (E)

    *)
  51. | Pexp_cons of expression list
    (*

    E1 :: ... :: En

    *)
  52. | Pexp_indexop_access of indexop_access
  53. | Pexp_prefix of string Asttypes.loc * expression
    (*

    op E

    *)
  54. | Pexp_infix of string Asttypes.loc * expression * expression
    (*

    E1 op E2

    *)
  55. | Pexp_list_comprehension of comprehension
    (*

    [BODY ...CLAUSES...]

    *)
  56. | Pexp_array_comprehension of Asttypes.mutable_flag * comprehension
    (*

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

    *)
  57. | Pexp_quote of expression
    (*

    runtime metaprogramming quotations <E>

    *)
  58. | Pexp_splice of expression
    (*

    runtime metaprogramming splicing $(E)

    *)
Sourceand block_access =
  1. | Baccess_field of Ocaml_common.Longident.t Asttypes.loc
    (*

    .foo

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

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

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

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

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

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

    .#foo

    *)
Sourceand iterator =
  1. | Range of {
    1. start : expression;
    2. stop : expression;
    3. direction : Asttypes.direction_flag;
    }
    (*

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

    *)
  2. | In of expression
    (*

    "in EXPR"

    *)
Sourceand clause_binding = {
  1. pattern : pattern;
  2. iterator : iterator;
  3. attributes : attribute list;
}

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

Sourceand clause =
  1. | For of clause_binding list
    (*

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

    *)
  2. | When of expression
    (*

    "when EXPR"

    *)
Sourceand comprehension = {
  1. comp_body : expression;
    (*

    The body/generator of the comprehension

    *)
  2. clauses : clause list;
    (*

    The clauses of the comprehension; must be nonempty

    *)
}
Sourceand indexop_access = {
  1. pia_lhs : expression;
  2. pia_kind : indexop_access_kind;
  3. pia_paren : Asttypes.paren_kind;
  4. pia_rhs : expression option;
}
Sourceand indexop_access_kind =
  1. | Builtin of expression
    (*

    arr.(i) arr.(i) <- e str.[i] str.[i] <- c bar.{i1; i2; ..} bar.{i1; i2; ..} <- e

    *)
  2. | Dotop of Ocaml_common.Longident.t Asttypes.loc option * string * expression list
    (*

    foo.Path.%{i1, i2, ..} <- e

    *)
Sourceand if_branch = {
  1. if_cond : expression;
  2. if_body : expression;
  3. if_attrs : attributes;
    (*

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

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

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

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

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

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

    *)
  2. | Pparam_newtype of ty_var list
    (*

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

    *)
Sourceand function_param = {
  1. pparam_loc : Ocaml_common.Location.t;
  2. pparam_desc : function_param_desc;
}
Sourceand type_constraint =
  1. | Pconstraint of core_type
  2. | Pcoerce of core_type option * core_type

Value descriptions

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

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

    *)
  6. pval_loc : Ocaml_common.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

Sourceand type_declaration = {
  1. ptype_name : string Asttypes.loc;
  2. ptype_params : (core_type * Asttypes.variance_and_injectivity) list;
    (*

    ('a1,...'an) t

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

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

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

    for = private ...

    *)
  6. ptype_manifest : core_type option;
    (*

    represents = T

    *)
  7. ptype_attributes : attributes;
    (*

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

    *)
  8. ptype_loc : Ocaml_common.Location.t;
  9. ptype_jkind : jkind_annotation Asttypes.loc option;
}

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

    Invariant: non-empty list

    *)
  4. | Ptype_record_unboxed_product of label_declaration list
    (*

    Invariant: non-empty list

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

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

    *)
}

Note: T can be a Ptyp_poly.

Sourceand constructor_declaration = {
  1. pcd_name : string Asttypes.loc;
  2. pcd_vars : ty_var list;
  3. pcd_args : constructor_arguments;
  4. pcd_res : core_type option;
  5. pcd_loc : Ocaml_common.Location.t;
  6. pcd_attributes : attributes;
    (*

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

    *)
}
Sourceand constructor_argument = {
  1. pca_modalities : modality Asttypes.loc list;
  2. pca_type : core_type;
  3. pca_loc : Ocaml_common.Location.t;
}
Sourceand constructor_arguments =
  1. | Pcstr_tuple of constructor_argument list
  2. | Pcstr_record of Ocaml_common.Location.t * 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 [...].
    *)
Sourceand type_extension = {
  1. ptyext_path : Ocaml_common.Longident.t Asttypes.loc;
  2. ptyext_params : (core_type * Asttypes.variance_and_injectivity) list;
  3. ptyext_constructors : extension_constructor list;
  4. ptyext_private : Asttypes.private_flag;
  5. ptyext_loc : Ocaml_common.Location.t;
  6. ptyext_attributes : attributes;
    (*

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

    *)
}

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

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

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

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

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

    *)
}

Definition of a new exception (exception E).

Sourceand extension_constructor_kind =
  1. | Pext_decl of ty_var list * constructor_arguments * 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... . T1 * ... * Tn -> T0 when

      • existentials is ['a;...],
      • c_args is [T1; ... ; Tn],
      • t_opt is Some T0.
    *)
  2. | Pext_rebind of Ocaml_common.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

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

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

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

    object ... end

    *)
  3. | Pcty_arrow of arrow_param list * class_type
    (*

    Pcty_arrow(lbl, T, CT) represents:

    *)
  4. | Pcty_extension of extension
    (*

    %id

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

    let open M in CT

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

Values of type class_signature represents:

  • object('selfpat) ... end
  • object ... end when pcsig_self is None
Sourceand class_type_field = {
  1. pctf_desc : class_type_field_desc;
  2. pctf_loc : Ocaml_common.Location.t;
  3. pctf_attributes : attributes;
    (*

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

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

    inherit CT

    *)
  2. | Pctf_val of Asttypes.label Asttypes.loc * Asttypes.mutable_virtual * core_type
    (*

    val x: T

    *)
  3. | Pctf_method of Asttypes.label Asttypes.loc * Asttypes.private_virtual * core_type
    (*

    method x: T

    Note: T can be a Ptyp_poly.

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

    constraint T1 = T2

    *)
  5. | Pctf_attribute of attribute
    (*

    [\@\@\@id]

    *)
  6. | Pctf_extension of extension
    (*

    [%%id]

    *)
Sourceand 'a class_infos = {
  1. pci_virt : Asttypes.virtual_flag;
  2. pci_params : (core_type * Asttypes.variance_and_injectivity) list;
  3. pci_name : string Asttypes.loc;
  4. pci_expr : 'a;
  5. pci_loc : Ocaml_common.Location.t;
  6. 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.

Sourceand class_description = class_type class_infos
Sourceand class_type_declaration = class_type class_infos

Value expressions for the class language

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

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

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

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

    *)
  2. | Pcl_structure of class_structure
    (*

    object ... end

    *)
  3. | Pcl_fun of Asttypes.arg_label * expression option * 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.
    *)
  4. | Pcl_apply of class_expr * (Asttypes.arg_label * 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 value_bindings * 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 class_expr * class_type
    (*

    (CE : CT)

    *)
  7. | Pcl_extension of extension
    (*

    [%id]

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

    let open M in CE

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

Values of type class_structure represents:

  • object(selfpat) ... end
  • object ... end when pcstr_self is None
Sourceand class_field = {
  1. pcf_desc : class_field_desc;
  2. pcf_loc : Ocaml_common.Location.t;
  3. pcf_attributes : attributes;
    (*

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

    *)
}
Sourceand class_field_desc =
  1. | Pcf_inherit of Asttypes.override_flag * 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_virtual * class_field_kind
    (*

    Pcf_val(x,flag, kind) represents:

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

    constraint T1 = T2

    *)
  5. | Pcf_initializer of expression
    (*

    initializer E

    *)
  6. | Pcf_attribute of attribute
    (*

    [\@\@\@id]

    *)
  7. | Pcf_extension of extension
    (*

    [%%id]

    *)
Sourceand class_field_kind =
  1. | Cfk_virtual of core_type
  2. | Cfk_concrete of Asttypes.override_flag * expression
Sourceand class_declaration = class_expr class_infos

Module language

Type expressions for the module language

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

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

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

    Pmty_ident(S) represents S

    *)
  2. | Pmty_signature of signature
    (*

    sig ... end

    *)
  3. | Pmty_functor of functor_parameter Asttypes.loc list * module_type * modes
    (*

    functor (X1 : MT1) ... (Xn : MTn) -> MT @ MM

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

    MT with ...

    *)
  5. | Pmty_typeof of module_expr
    (*

    module type of ME

    *)
  6. | Pmty_extension of extension
    (*

    [%id]

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

    (module M)

    *)
  8. | Pmty_strengthen of module_type * Ocaml_common.Longident.t Asttypes.loc
Sourceand functor_parameter =
  1. | Unit
    (*

    ()

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

    Named(name, MT, MM) represents:

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

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

    *)
  3. | Psig_typesubst of type_declaration list
    (*

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

    *)
  4. | Psig_typext of type_extension
    (*

    type t1 += ...

    *)
  5. | Psig_kind_abbrev of kind_abbreviation
  6. | Psig_exception of type_exception
    (*

    exception C of T

    *)
  7. | Psig_module of module_declaration
    (*

    module X = M and module X : MT

    *)
  8. | Psig_modsubst of module_substitution
    (*

    module X := M

    *)
  9. | Psig_recmodule of module_declaration list
    (*

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

    *)
  10. | Psig_modtype of module_type_declaration
    (*

    module type S = MT and module type S

    *)
  11. | Psig_modtypesubst of module_type_declaration
    (*

    module type S := ...

    *)
  12. | Psig_open of open_description
    (*

    open X

    *)
  13. | Psig_include of include_description * modalities
    (*

    include MT

    *)
  14. | Psig_class of class_description list
    (*

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

    *)
  15. | Psig_class_type of class_type_declaration list
    (*

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

    *)
  16. | Psig_attribute of attribute
    (*

    [\@\@\@id]

    *)
  17. | Psig_extension of extension * attributes
    (*

    [%%id]

    *)
Sourceand module_declaration = {
  1. pmd_name : string option Asttypes.loc;
  2. pmd_modalities : modalities;
  3. pmd_args : functor_parameter Asttypes.loc list;
  4. pmd_type : module_type;
  5. pmd_mode : modes;
  6. pmd_ext_attrs : ext_attrs;
  7. pmd_loc : Ocaml_common.Location.t;
}

Values of type module_declaration represents S : MT

Sourceand module_substitution = {
  1. pms_name : string Asttypes.loc;
  2. pms_manifest : Ocaml_common.Longident.t Asttypes.loc;
  3. pms_ext_attrs : ext_attrs;
  4. pms_loc : Ocaml_common.Location.t;
}

Values of type module_substitution represents S := M

Sourceand module_type_declaration = {
  1. pmtd_name : string Asttypes.loc;
  2. pmtd_type : module_type option;
  3. pmtd_ext_attrs : ext_attrs;
  4. pmtd_loc : Ocaml_common.Location.t;
}

Values of type module_type_declaration represents:

  • S = MT,
  • S for abstract module type declaration, when pmtd_type is None.
Sourceand 'a open_infos = {
  1. popen_expr : 'a;
  2. popen_override : Asttypes.override_flag;
  3. popen_loc : Ocaml_common.Location.t;
  4. popen_attributes : attributes;
}

Values of type 'a open_infos represents:

Values of type open_description represents:

  • open M.N
  • open M(N).O
Sourceand open_declaration = module_expr open_infos

Values of type open_declaration represents:

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

Values of type include_description represents include MT

Sourceand include_declaration = module_expr include_infos

Values of type include_declaration represents include ME

Sourceand with_constraint =
  1. | Pwith_type of Ocaml_common.Longident.t Asttypes.loc * 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 Ocaml_common.Longident.t Asttypes.loc * Ocaml_common.Longident.t Asttypes.loc
    (*

    with module X.Y = Z

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

    with module type X.Y = Z

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

    with module type X.Y := sig end

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

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

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

    with module X.Y := Z

    *)

Value expressions for the module language

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

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

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

    X

    *)
  2. | Pmod_structure of structure
    (*

    struct ... end

    *)
  3. | Pmod_functor of functor_parameter Asttypes.loc list * module_expr
    (*

    functor (X1 : MT1) ... (Xn : MTn) -> ME

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

    ME1(ME2)

    *)
  5. | Pmod_apply_unit of module_expr * Ocaml_common.Location.t
    (*

    ME1(). The location argument correspond to the ().

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

    (val E : M1 :> M2)

    *)
  8. | Pmod_extension of extension
    (*

    [%id]

    *)
  9. | Pmod_hole
    (*

    _

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

    E

    *)
  2. | Pstr_value of value_bindings
    (*

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

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

    *)
  5. | Pstr_typext of type_extension
    (*

    type t1 += ...

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

    module X = ME

    *)
  9. | Pstr_recmodule of module_binding list
    (*

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

    *)
  10. | Pstr_modtype of module_type_declaration
    (*

    module type S = MT

    *)
  11. | Pstr_open of open_declaration
    (*

    open X

    *)
  12. | Pstr_class of class_declaration list
    (*

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

    *)
  13. | Pstr_class_type of class_type_declaration list
    (*

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

    *)
  14. | Pstr_include of include_declaration
    (*

    include ME

    *)
  15. | Pstr_attribute of attribute
    (*

    [\@\@\@id]

    *)
  16. | Pstr_extension of extension * attributes
    (*

    [%%id]

    *)
Sourceand value_constraint =
  1. | Pvc_constraint of {
    1. locally_abstract_univars : ty_var list;
    2. typ : core_type;
    }
  2. | Pvc_coercion of {
    1. ground : core_type option;
    2. coercion : 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
    *)
Sourceand value_binding = {
  1. pvb_pat : pattern;
  2. pvb_expr : expression;
  3. pvb_constraint : value_constraint option;
    (*

    the modes on the bound value (not the RHS)

    *)
  4. pvb_modes : modes;
    (*

    the local_ on the bound value (not the RHS)

    *)
  5. pvb_local : bool;
  6. pvb_is_pun : bool;
  7. pvb_attributes : attributes;
  8. pvb_loc : Ocaml_common.Location.t;
}

let pat : type_constraint = exp

Sourceand value_bindings = {
  1. pvbs_bindings : value_binding list;
  2. pvbs_mutable : Asttypes.mutable_flag;
  3. pvbs_rec : Asttypes.rec_flag;
  4. pvbs_extension : string Asttypes.loc option;
}
Sourceand module_binding = {
  1. pmb_name : string option Asttypes.loc;
  2. pmb_modes : modes;
    (*

    The modes on the identifier

    *)
  3. pmb_args : functor_parameter Asttypes.loc list;
  4. pmb_expr : module_expr;
  5. pmb_ext_attrs : ext_attrs;
  6. pmb_loc : Ocaml_common.Location.t;
}

Values of type module_binding represents module X = ME

Sourceand jkind_const_annotation = string Ocaml_common.Location.loc
Sourceand jkind_annotation =
  1. | Default
  2. | Abbreviation of jkind_const_annotation
  3. | Mod of jkind_annotation Asttypes.loc * modes
  4. | With of jkind_annotation Asttypes.loc * core_type * modalities
  5. | Kind_of of core_type
  6. | Product of jkind_annotation Asttypes.loc list
Sourceand ty_var = string option Asttypes.loc * jkind_annotation Asttypes.loc option
Sourceand kind_abbreviation = string Asttypes.loc * jkind_annotation Asttypes.loc

Toplevel

Toplevel phrases

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

    #use, #load ...

    *)
  3. | Ptop_lex of lexer_directive
Sourceand toplevel_directive = {
  1. pdir_name : string Asttypes.loc;
  2. pdir_arg : directive_argument option;
  3. pdir_loc : Ocaml_common.Location.t;
}
Sourceand directive_argument = {
  1. pdira_desc : directive_argument_desc;
  2. pdira_loc : Ocaml_common.Location.t;
}
Sourceand directive_argument_desc =
  1. | Pdir_string of string
  2. | Pdir_int of string * char option
  3. | Pdir_ident of Ocaml_common.Longident.t
  4. | Pdir_bool of bool
Sourceand syntax_directive = {
  1. psyn_mode : string Asttypes.loc;
  2. psyn_toggle : bool;
}

Lexer directives: ugly hack to avoid their deletion

Sourceand lexer_directive_desc =
  1. | Plex_syntax of syntax_directive
Sourceand lexer_directive = {
  1. plex_desc : lexer_directive_desc;
  2. plex_loc : Ocaml_common.Location.t;
}
Sourcetype repl_phrase = {
  1. prepl_phrase : toplevel_phrase;
  2. prepl_output : string;
}