Module Ppxlib

Standard library for ppx rewriters

ppxlib is meant to be opened globally in your PPX source files.

Opening it comes with two advantages. First, it will shadow the compiler-libs modules. The compiler-libs modules are unstable and aren't meant to be used, so shadowing them is a good protection mechanism. In case you don't want to open Ppxlib, you can open Ocaml_shadow to get the same protection. Second, it will bring several modules in scope, that are useful to have when writing a rewriter:

The core ppxlib entries

Manipulating the AST

module Ast_builder : sig ... end

Ast_builder is a module to generate OCaml AST fragments. It provides a shorter syntax than directly using the Parsetree constructors, as well as a better stability than the constructors.

module Ast_pattern : sig ... end

This module implements first class AST patterns. It allows to destruct and extract values from AST fragments. This gives the same functionality as a pattern-match, but with simpler syntax and more stability than directly pattern-matching on the Parsetree constructors.

module Ast_traverse : sig ... end

This module provides AST traversal classes, such as maps, iterations, folds, etc. on the Parsetree types.

Context-free rewriting

module Context_free : sig ... end

Context free rewriting, to define local rewriting rules that will all be applied at once by the driver.

module Deriving : sig ... end

Deriving code from type declarations.

module Extension : sig ... end

Declare extenders to rewrite extension nodes.

module Expansion_context : sig ... end

The context given to rewriting rules when expanding.

module Code_path : sig ... end

This module contains type and functions for representing and manipulating path to AST nodes.

Other helpers

module Expansion_helpers : sig ... end

Various helpers for expansion, such as quoting expressions in their context, or mangling names.

module Merlin_helpers : sig ... end

Some helpers to annotate the AST so merlin can decide which branches to look at and which branches to ignore.

module Spellcheck : sig ... end

Helpers to provide hints to PPX users for typos or spellchecks.

module Keyword : sig ... end

Small module to check if a string is an OCaml keyword.

module Pp_ast : sig ... end

This module implements pretty printers for the OCaml AST's version used by ppxlib.

module Driver : sig ... end

Interaction with the driver, such as getting/seeting cookies, adding arguments.

module Caller_id : sig ... end

Small helper to find out who is the caller of a function

module Ast_io : sig ... end

A small module to help read bin-annots generated files.

Checks

module Attribute : sig ... end

This module provides hygiene for attributes. The goal is to report misuses of attributes to the user as soon as possible so that no mistyped attribute get silently ignored.

module Reserved_namespaces : sig ... end

Small module to reserve namespaces in attribute names.

Common helper functions

val lident : string -> Longident.t
val gen_symbol : ?prefix:string -> unit -> string

gen_symbol ?prefix () generates a fresh variable name with prefix.

  • parameter prefix

    default = "_x"

val string_of_core_type : Astlib.Ast_502.Parsetree.core_type -> string
val assert_no_attributes : Astlib.Ast_502.Parsetree.attribute list -> unit
val assert_no_attributes_in : Ppxlib__.Ast_traverse0.iter
val attributes_errors : Astlib.Ast_502.Parsetree.attribute list -> Location.Error.t list
val collect_attributes_errors : Location.Error.t list Ppxlib__.Ast_traverse0.fold

get_type_param_name_res tp returns the string identifier associated with tp if it is a type parameter, as a result.

See get_type_param_name_res. Raises a located error in case of failure.

(new type_is_recursive rec_flag tds)#go () returns whether rec_flag, tds is really a recursive type. We disregard recursive occurrences appearing in arrow types. You can override the search for certain type expressions by inheriting from this class.

really_recursive rec_flag tds = (new type_is_recursive rec_flag tds)#go (). See the documentation for type_is_recursive.

convert multi-arg function applications into a cascade of 1-arg applications

val attribute_of_warning : Location.t -> string -> Astlib.Ast_502.Parsetree.attribute

Encode a warning message into an 'ocaml.ppwarning' attribute which can be inserted in a generated Parsetree. The compiler will be responsible for reporting the warning.

val is_polymorphic_variant : Astlib.Ast_502.Parsetree.type_declaration -> sig_:bool -> [> `Definitely | `Maybe | `Surely_not ]
val mk_named_sig : loc:Location.t -> sg_name:string -> handle_polymorphic_variant:bool -> Astlib.Ast_502.Parsetree.type_declaration list -> Astlib.Ast_502.Parsetree.module_type Astlib.Ast_502.Parsetree.include_infos option

mk_named_sig ~loc ~sg_name:"Foo" ~handle_polymorphic_variant tds will generate

include Foo (* or Foo1, Foo2, Foo3 *)
  with type (* ('a, 'b, 'c) *) t := (* ('a, 'b, 'c) *) t

when:

  • there is only one type declaration
  • the type is named t
  • there are less than 4 type parameters
  • there are no constraints on the type parameters

It will take care of giving fresh names to unnamed type parameters.

val exn_to_loc_error : exn -> Location.Error.t

Convert exn to a located error if possible or reraise it otherwise

module With_errors : sig ... end
val valid_string_constant_delimiter : string -> string

valid_string_constant_delimiter x finds a delimiter y such that Pconst_string (x, loc, Some y) is valid.

Modules from other libraries

Expose some modules from Ppxlib_ast.

module Ast = Ppxlib_ast.Ast
module Ast_helper = Ppxlib_ast.Ast_helper
module Asttypes = Ppxlib_ast.Asttypes
module Parse = Ppxlib_ast.Parse
module Parsetree = Ppxlib_ast.Parsetree
module Pprintast = Ppxlib_ast.Pprintast
module Selected_ast = Ppxlib_ast.Selected_ast
module Location : sig ... end

Overrides the Location module of OCaml

module Longident : sig ... end

Overrides the Longident module of OCaml

module Loc : sig ... end

Located items

The whole AST types

Include all the Ast definitions since we need them in every single ppx

include module type of struct include Ast end

Definition of the OCaml AST

type position = Stdlib.Lexing.position = {
  1. pos_fname : string;
  2. pos_lnum : int;
  3. pos_bol : int;
  4. pos_cnum : int;
}
and location = Astlib.Location.t = {
  1. loc_start : position;
  2. loc_end : position;
  3. loc_ghost : bool;
}
and location_stack = location list
and 'a loc = 'a Astlib.Location.loc = {
  1. txt : 'a;
  2. loc : location;
}
and longident = Astlib.Longident.t =
  1. | Lident of string
  2. | Ldot of longident * string
  3. | Lapply of longident * longident
and longident_loc = longident loc

Auxiliary AST types used by parsetree and typedtree.

and rec_flag = Astlib.Ast_502.Asttypes.rec_flag =
  1. | Nonrecursive
  2. | Recursive
and direction_flag = Astlib.Ast_502.Asttypes.direction_flag =
  1. | Upto
  2. | Downto
and private_flag = Astlib.Ast_502.Asttypes.private_flag =
  1. | Private
  2. | Public
and mutable_flag = Astlib.Ast_502.Asttypes.mutable_flag =
  1. | Immutable
  2. | Mutable
and virtual_flag = Astlib.Ast_502.Asttypes.virtual_flag =
  1. | Virtual
  2. | Concrete
and override_flag = Astlib.Ast_502.Asttypes.override_flag =
  1. | Override
  2. | Fresh
and closed_flag = Astlib.Ast_502.Asttypes.closed_flag =
  1. | Closed
  2. | Open
and label = string
and arg_label = Astlib.Ast_502.Asttypes.arg_label =
  1. | Nolabel
  2. | Labelled of string
    (*

    label:T -> ...

    *)
  3. | Optional of string
    (*

    ?label:T -> ...

    *)
and variance = Astlib.Ast_502.Asttypes.variance =
  1. | Covariant
  2. | Contravariant
  3. | NoVariance
and injectivity = Astlib.Ast_502.Asttypes.injectivity =
  1. | Injective
  2. | NoInjectivity

Abstract syntax tree produced by parsing

and constant = Astlib.Ast_502.Parsetree.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_char of char
    (*

    Character such as 'c'.

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

    *)

Extension points

and attribute = Astlib.Ast_502.Parsetree.attribute = {
  1. attr_name : string loc;
  2. attr_payload : payload;
  3. attr_loc : location;
}

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

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

and extension = string loc * payload

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

Sub-language placeholder -- rejected by the typechecker.

and attributes = attribute list
and payload = Astlib.Ast_502.Parsetree.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

    *)

Core language

Type expressions

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

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

    *)
}
and core_type_desc = Astlib.Ast_502.Parsetree.core_type_desc =
  1. | Ptyp_any
    (*

    _

    *)
  2. | Ptyp_var of string
    (*

    A type variable such as 'a

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

    Ptyp_arrow(lbl, T1, T2) represents:

    *)
  4. | Ptyp_tuple of core_type list
    (*

    Ptyp_tuple([T1 ; ... ; Tn]) represents a product type T1 * ... * Tn.

    Invariant: n >= 2.

    *)
  5. | Ptyp_constr of longident_loc * core_type list
    (*

    Ptyp_constr(lident, l) represents:

    • tconstr when l=[],
    • T tconstr when l=[T],
    • (T1, ..., Tn) tconstr when l=[T1 ; ... ; Tn].
    *)
  6. | Ptyp_object of object_field list * 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.
    *)
  7. | Ptyp_class of longident_loc * core_type list
    (*

    Ptyp_class(tconstr, l) represents:

    • #tconstr when l=[],
    • T #tconstr when l=[T],
    • (T1, ..., Tn) #tconstr when l=[T1 ; ... ; Tn].
    *)
  8. | Ptyp_alias of core_type * string loc
    (*

    T as 'a.

    *)
  9. | Ptyp_variant of row_field list * closed_flag * 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"].
    *)
  10. | Ptyp_poly of string loc list * core_type
    (*

    'a1 ... 'an. T

    Can only appear in the following context:

    let x : 'a1 ... 'an. T = e ...
    *)
  11. | Ptyp_package of package_type
    (*

    (module S).

    *)
  12. | Ptyp_open of longident_loc * core_type
    (*

    M.(T)

    *)
  13. | Ptyp_extension of extension
    (*

    [%id].

    *)
and package_type = longident_loc * (longident_loc * core_type) list

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 = Astlib.Ast_502.Parsetree.row_field = {
  1. prf_desc : row_field_desc;
  2. prf_loc : location;
  3. prf_attributes : attributes;
}
and row_field_desc = Astlib.Ast_502.Parsetree.row_field_desc =
  1. | Rtag of label loc * 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 ]

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

Patterns

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

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

    *)
}
and pattern_desc = Astlib.Ast_502.Parsetree.pattern_desc =
  1. | Ppat_any
    (*

    The pattern _.

    *)
  2. | Ppat_var of string loc
    (*

    A variable pattern such as x

    *)
  3. | Ppat_alias of pattern * string 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 pattern list
    (*

    Patterns (P1, ..., Pn).

    Invariant: n >= 2

    *)
  7. | Ppat_construct of longident_loc * (string loc 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)
    *)
  8. | Ppat_variant of label * pattern option
    (*

    Ppat_variant(`A, pat) represents:

    • `A when pat is None,
    • `A P when pat is Some P
    *)
  9. | Ppat_record of (longident_loc * pattern) list * 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

    *)
  10. | Ppat_array of pattern list
    (*

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

    *)
  11. | Ppat_or of pattern * pattern
    (*

    Pattern P1 | P2

    *)
  12. | Ppat_constraint of pattern * core_type
    (*

    Pattern (P : T)

    *)
  13. | Ppat_type of longident_loc
    (*

    Pattern #tconst

    *)
  14. | Ppat_lazy of pattern
    (*

    Pattern lazy P

    *)
  15. | Ppat_unpack of string option 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)

    *)
  16. | Ppat_exception of pattern
    (*

    Pattern exception P

    *)
  17. | Ppat_extension of extension
    (*

    Pattern [%id]

    *)
  18. | Ppat_open of longident_loc * pattern
    (*

    Pattern M.(P)

    *)

Value expressions

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

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

    *)
}
and expression_desc = Astlib.Ast_502.Parsetree.expression_desc =
  1. | Pexp_ident of longident_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 rec_flag * value_binding list * 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 function_param list * type_constraint option * 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 expression * (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

    *)
  6. | Pexp_match of expression * cases
    (*

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

    *)
  7. | Pexp_try of expression * cases
    (*

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

    *)
  8. | Pexp_tuple of expression list
    (*

    Expressions (E1, ..., En)

    Invariant: n >= 2

    *)
  9. | Pexp_construct of longident_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])
    *)
  10. | Pexp_variant of label * expression option
    (*

    Pexp_variant(`A, exp) represents

    • `A when exp is None
    • `A E when exp is Some E
    *)
  11. | Pexp_record of (longident_loc * expression) 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

    *)
  12. | Pexp_field of expression * longident_loc
    (*

    E.l

    *)
  13. | Pexp_setfield of expression * longident_loc * expression
    (*

    E1.l <- E2

    *)
  14. | Pexp_array of expression list
    (*

    [| E1; ...; En |]

    *)
  15. | Pexp_ifthenelse of expression * expression * expression option
    (*

    if E1 then E2 else E3

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

    E1; E2

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

    while E1 do E2 done

    *)
  18. | Pexp_for of pattern * expression * expression * 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
    *)
  19. | Pexp_constraint of expression * core_type
    (*

    (E : T)

    *)
  20. | 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.
    *)
  21. | Pexp_send of expression * label loc
    (*

    E # m

    *)
  22. | Pexp_new of longident_loc
    (*

    new M.c

    *)
  23. | Pexp_setinstvar of label loc * expression
    (*

    x <- 2

    *)
  24. | Pexp_override of (label loc * expression) list
    (*

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

    *)
  25. | Pexp_letmodule of string option loc * module_expr * expression
    (*

    let module M = ME in E

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

    let exception C in E

    *)
  27. | Pexp_assert of expression
    (*

    assert E.

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

    *)
  28. | Pexp_lazy of expression
    (*

    lazy E

    *)
  29. | 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).

    *)
  30. | Pexp_object of class_structure
    (*

    object ... end

    *)
  31. | Pexp_newtype of string loc * expression
    (*

    fun (type t) -> E

    *)
  32. | Pexp_pack of module_expr
    (*

    (module ME).

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

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

    [%id]

    *)
  36. | Pexp_unreachable
    (*

    .

    *)
and case = Astlib.Ast_502.Parsetree.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)

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

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

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

    *)
  2. | Pparam_newtype of string loc
    (*

    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 = Astlib.Ast_502.Parsetree.function_param = {
  1. pparam_loc : location;
  2. pparam_desc : function_param_desc;
}
and function_body = Astlib.Ast_502.Parsetree.function_body =
  1. | Pfunction_body of expression
  2. | Pfunction_cases of cases * location * 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 = Astlib.Ast_502.Parsetree.type_constraint =
  1. | Pconstraint of core_type
  2. | Pcoerce of core_type option * core_type
    (*

    See the comment on Pexp_function.

    *)

Value descriptions

and value_description = Astlib.Ast_502.Parsetree.value_description = {
  1. pval_name : string loc;
  2. pval_type : core_type;
  3. pval_prim : string list;
  4. pval_attributes : attributes;
    (*

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

    *)
  5. pval_loc : location;
}

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

    ('a1,...'an) t

    *)
  3. ptype_cstrs : (core_type * core_type * location) list;
    (*

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

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

    for = private ...

    *)
  6. ptype_manifest : core_type option;
    (*

    represents = T

    *)
  7. ptype_attributes : attributes;
    (*

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

    *)
  8. ptype_loc : location;
}

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 = Astlib.Ast_502.Parsetree.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_open
and label_declaration = Astlib.Ast_502.Parsetree.label_declaration = {
  1. pld_name : string loc;
  2. pld_mutable : mutable_flag;
  3. pld_type : core_type;
  4. pld_loc : location;
  5. pld_attributes : attributes;
    (*

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

    *)
}

Note: T can be a Ptyp_poly.

and constructor_declaration = Astlib.Ast_502.Parsetree.constructor_declaration = {
  1. pcd_name : string loc;
  2. pcd_vars : string loc list;
  3. pcd_args : constructor_arguments;
  4. pcd_res : core_type option;
  5. pcd_loc : location;
  6. pcd_attributes : attributes;
    (*

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

    *)
}
and constructor_arguments = Astlib.Ast_502.Parsetree.constructor_arguments =
  1. | Pcstr_tuple of core_type list
  2. | Pcstr_record of 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 = Astlib.Ast_502.Parsetree.type_extension = {
  1. ptyext_path : longident_loc;
  2. ptyext_params : (core_type * (variance * injectivity)) list;
  3. ptyext_constructors : extension_constructor list;
  4. ptyext_private : private_flag;
  5. ptyext_loc : location;
  6. ptyext_attributes : attributes;
    (*

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

    *)
}

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

and extension_constructor = Astlib.Ast_502.Parsetree.extension_constructor = {
  1. pext_name : string loc;
  2. pext_kind : extension_constructor_kind;
  3. pext_loc : location;
  4. pext_attributes : attributes;
    (*

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

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

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

    *)
}

Definition of a new exception (exception E).

and extension_constructor_kind = Astlib.Ast_502.Parsetree.extension_constructor_kind =
  1. | Pext_decl of string loc 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 longident_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 = Astlib.Ast_502.Parsetree.class_type = {
  1. pcty_desc : class_type_desc;
  2. pcty_loc : location;
  3. pcty_attributes : attributes;
    (*

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

    *)
}
and class_type_desc = Astlib.Ast_502.Parsetree.class_type_desc =
  1. | Pcty_constr of longident_loc * core_type list
    (*
    • c
    • ['a1, ..., 'an] c
    *)
  2. | Pcty_signature of class_signature
    (*

    object ... end

    *)
  3. | Pcty_arrow of arg_label * core_type * 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

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

Values of type class_signature represents:

and class_type_field = Astlib.Ast_502.Parsetree.class_type_field = {
  1. pctf_desc : class_type_field_desc;
  2. pctf_loc : location;
  3. pctf_attributes : attributes;
    (*

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

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

    inherit CT

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

    val x: T

    *)
  3. | Pctf_method of label loc * private_flag * virtual_flag * 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]

    *)
and 'a class_infos = 'a Astlib.Ast_502.Parsetree.class_infos = {
  1. pci_virt : virtual_flag;
  2. pci_params : (core_type * (variance * injectivity)) list;
  3. pci_name : string loc;
  4. pci_expr : 'a;
  5. pci_loc : location;
  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.

and class_description = class_type class_infos
and class_type_declaration = class_type class_infos

Value expressions for the class language

and class_expr = Astlib.Ast_502.Parsetree.class_expr = {
  1. pcl_desc : class_expr_desc;
  2. pcl_loc : location;
  3. pcl_attributes : attributes;
    (*

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

    *)
}
and class_expr_desc = Astlib.Ast_502.Parsetree.class_expr_desc =
  1. | Pcl_constr of longident_loc * core_type list
    (*

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

    *)
  2. | Pcl_structure of class_structure
    (*

    object ... end

    *)
  3. | Pcl_fun of 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 * (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 rec_flag * value_binding list * 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

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

Values of type class_structure represents:

and class_field = Astlib.Ast_502.Parsetree.class_field = {
  1. pcf_desc : class_field_desc;
  2. pcf_loc : location;
  3. pcf_attributes : attributes;
    (*

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

    *)
}
and class_field_desc = Astlib.Ast_502.Parsetree.class_field_desc =
  1. | Pcf_inherit of override_flag * class_expr * string 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 label loc * mutable_flag * class_field_kind
    (*

    Pcf_val(x,flag, kind) represents:

    *)
  3. | Pcf_method of label loc * private_flag * 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]

    *)
and class_field_kind = Astlib.Ast_502.Parsetree.class_field_kind =
  1. | Cfk_virtual of core_type
  2. | Cfk_concrete of override_flag * expression
and class_declaration = class_expr class_infos

Module language

Type expressions for the module language

and module_type = Astlib.Ast_502.Parsetree.module_type = {
  1. pmty_desc : module_type_desc;
  2. pmty_loc : location;
  3. pmty_attributes : attributes;
    (*

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

    *)
}
and module_type_desc = Astlib.Ast_502.Parsetree.module_type_desc =
  1. | Pmty_ident of longident_loc
    (*

    Pmty_ident(S) represents S

    *)
  2. | Pmty_signature of signature
    (*

    sig ... end

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

    functor(X : MT1) -> MT2

    *)
  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 longident_loc
    (*

    (module M)

    *)
and functor_parameter = Astlib.Ast_502.Parsetree.functor_parameter =
  1. | Unit
    (*

    ()

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

    Named(name, MT) represents:

    • (X : MT) when name is Some X,
    • (_ : MT) when name is None
    *)
and signature = signature_item list
and signature_item = Astlib.Ast_502.Parsetree.signature_item = {
  1. psig_desc : signature_item_desc;
  2. psig_loc : location;
}
and signature_item_desc = Astlib.Ast_502.Parsetree.signature_item_desc =
  1. | Psig_value of value_description
    (*
    • val x: T
    • external x: T = "s1" ... "sn"
    *)
  2. | Psig_type of 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_exception of type_exception
    (*

    exception C of T

    *)
  6. | Psig_module of module_declaration
    (*

    module X = M and module X : MT

    *)
  7. | Psig_modsubst of module_substitution
    (*

    module X := M

    *)
  8. | Psig_recmodule of module_declaration list
    (*

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

    *)
  9. | Psig_modtype of module_type_declaration
    (*

    module type S = MT and module type S

    *)
  10. | Psig_modtypesubst of module_type_declaration
    (*

    module type S := ...

    *)
  11. | Psig_open of open_description
    (*

    open X

    *)
  12. | Psig_include of include_description
    (*

    include MT

    *)
  13. | Psig_class of class_description list
    (*

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

    *)
  14. | Psig_class_type of class_type_declaration list
    (*

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

    *)
  15. | Psig_attribute of attribute
    (*

    [\@\@\@id]

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

    [%%id]

    *)
and module_declaration = Astlib.Ast_502.Parsetree.module_declaration = {
  1. pmd_name : string option loc;
  2. pmd_type : module_type;
  3. pmd_attributes : attributes;
    (*

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

    *)
  4. pmd_loc : location;
}

Values of type module_declaration represents S : MT

and module_substitution = Astlib.Ast_502.Parsetree.module_substitution = {
  1. pms_name : string loc;
  2. pms_manifest : longident_loc;
  3. pms_attributes : attributes;
    (*

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

    *)
  4. pms_loc : location;
}

Values of type module_substitution represents S := M

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

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

    *)
  4. pmtd_loc : location;
}

Values of type module_type_declaration represents:

  • S = MT,
  • S for abstract module type declaration, when pmtd_type is None.
and 'a open_infos = 'a Astlib.Ast_502.Parsetree.open_infos = {
  1. popen_expr : 'a;
  2. popen_override : override_flag;
  3. popen_loc : location;
  4. popen_attributes : attributes;
}

Values of type 'a open_infos represents:

and open_description = longident_loc open_infos

Values of type open_description represents:

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

Values of type open_declaration represents:

  • open M.N
  • open M(N).O
  • open struct ... end
and 'a include_infos = 'a Astlib.Ast_502.Parsetree.include_infos = {
  1. pincl_mod : 'a;
  2. pincl_loc : location;
  3. pincl_attributes : attributes;
}
and include_description = module_type include_infos

Values of type include_description represents include MT

and include_declaration = module_expr include_infos

Values of type include_declaration represents include ME

and with_constraint = Astlib.Ast_502.Parsetree.with_constraint =
  1. | Pwith_type of longident_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 longident_loc * longident_loc
    (*

    with module X.Y = Z

    *)
  3. | Pwith_modtype of longident_loc * module_type
    (*

    with module type X.Y = Z

    *)
  4. | Pwith_modtypesubst of longident_loc * module_type
    (*

    with module type X.Y := sig end

    *)
  5. | Pwith_typesubst of longident_loc * type_declaration
    (*

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

    *)
  6. | Pwith_modsubst of longident_loc * longident_loc
    (*

    with module X.Y := Z

    *)

Value expressions for the module language

and module_expr = Astlib.Ast_502.Parsetree.module_expr = {
  1. pmod_desc : module_expr_desc;
  2. pmod_loc : location;
  3. pmod_attributes : attributes;
    (*

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

    *)
}
and module_expr_desc = Astlib.Ast_502.Parsetree.module_expr_desc =
  1. | Pmod_ident of longident_loc
    (*

    X

    *)
  2. | Pmod_structure of structure
    (*

    struct ... end

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

    functor(X : MT1) -> ME

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

    ME1(ME2)

    *)
  5. | Pmod_apply_unit of module_expr
    (*

    ME1()

    *)
  6. | Pmod_constraint of module_expr * module_type
    (*

    (ME : MT)

    *)
  7. | Pmod_unpack of expression
    (*

    (val E)

    *)
  8. | Pmod_extension of extension
    (*

    [%id]

    *)
and structure = structure_item list
and structure_item = Astlib.Ast_502.Parsetree.structure_item = {
  1. pstr_desc : structure_item_desc;
  2. pstr_loc : location;
}
and structure_item_desc = Astlib.Ast_502.Parsetree.structure_item_desc =
  1. | Pstr_eval of expression * attributes
    (*

    E

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

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

    *)
  5. | Pstr_typext of type_extension
    (*

    type t1 += ...

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

    module X = ME

    *)
  8. | Pstr_recmodule of module_binding list
    (*

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

    *)
  9. | Pstr_modtype of module_type_declaration
    (*

    module type S = MT

    *)
  10. | Pstr_open of open_declaration
    (*

    open X

    *)
  11. | Pstr_class of class_declaration list
    (*

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

    *)
  12. | Pstr_class_type of class_type_declaration list
    (*

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

    *)
  13. | Pstr_include of include_declaration
    (*

    include ME

    *)
  14. | Pstr_attribute of attribute
    (*

    [\@\@\@id]

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

    [%%id]

    *)
and value_constraint = Astlib.Ast_502.Parsetree.value_constraint =
  1. | Pvc_constraint of {
    1. locally_abstract_univars : string loc list;
    2. typ : core_type;
    }
  2. | Pvc_coercion of {
    1. ground : core_type option;
    2. coercion : core_type;
    }
and value_binding = Astlib.Ast_502.Parsetree.value_binding = {
  1. pvb_pat : pattern;
  2. pvb_expr : expression;
  3. pvb_constraint : value_constraint option;
  4. pvb_attributes : attributes;
  5. pvb_loc : location;
}
and module_binding = Astlib.Ast_502.Parsetree.module_binding = {
  1. pmb_name : string option loc;
  2. pmb_expr : module_expr;
  3. pmb_attributes : attributes;
  4. pmb_loc : location;
}

Values of type module_binding represents module X = ME

Toplevel

Toplevel phrases

and toplevel_phrase = Astlib.Ast_502.Parsetree.toplevel_phrase =
  1. | Ptop_def of structure
  2. | Ptop_dir of toplevel_directive
    (*

    #use, #load ...

    *)
and toplevel_directive = Astlib.Ast_502.Parsetree.toplevel_directive = {
  1. pdir_name : string loc;
  2. pdir_arg : directive_argument option;
  3. pdir_loc : location;
}
and directive_argument = Astlib.Ast_502.Parsetree.directive_argument = {
  1. pdira_desc : directive_argument_desc;
  2. pdira_loc : location;
}
and directive_argument_desc = Astlib.Ast_502.Parsetree.directive_argument_desc =
  1. | Pdir_string of string
  2. | Pdir_int of string * char option
  3. | Pdir_ident of longident
  4. | Pdir_bool of bool
and cases = case list
class virtual map : object ... end
class virtual iter : object ... end
class virtual 'acc fold : object ... end
class virtual 'acc fold_map : object ... end
class virtual 'ctx map_with_context : object ... end
class virtual 'res lift : object ... end
class virtual ['ctx, 'res] lift_map_with_context : object ... end

Make sure code using Ppxlib doesn't refer to compiler-libs without being explicit about it:

include sig ... end
include module type of struct include Ocaml_shadow end with module Ast_helper := Ocaml_shadow.Ast_helper with module Asttypes := Ocaml_shadow.Asttypes with module Docstrings := Ocaml_shadow.Docstrings with module Identifiable := Ocaml_shadow.Identifiable with module Lexer := Ocaml_shadow.Lexer with module Location := Ocaml_shadow.Location with module Longident := Ocaml_shadow.Longident with module Parse := Ocaml_shadow.Parse with module Parsetree := Ocaml_shadow.Parsetree with module Pprintast := Ocaml_shadow.Pprintast with module Syntaxerr := Ocaml_shadow.Syntaxerr
module Do_not_use_directly = Ocaml_shadow.Do_not_use_directly
module Afl_instrument = Do_not_use_directly
module Alias_analysis = Do_not_use_directly
module Allocated_const = Do_not_use_directly
module Annot = Do_not_use_directly
module Arch = Do_not_use_directly
module Arg_helper = Do_not_use_directly
module Asmgen = Do_not_use_directly
module Asmlibrarian = Do_not_use_directly
module Asmpackager = Do_not_use_directly
module Ast_invariants = Do_not_use_directly
module Ast_iterator = Do_not_use_directly
module Ast_mapper = Do_not_use_directly
module Attr_helper = Do_not_use_directly
module Augment_specialised_args = Do_not_use_directly
module Backend_intf = Do_not_use_directly
module Backend_var = Do_not_use_directly
module Binutils = Do_not_use_directly
module Branch_relaxation = Do_not_use_directly
module Branch_relaxation_intf = Do_not_use_directly
module Btype = Do_not_use_directly
module Build_export_info = Do_not_use_directly
module Build_path_prefix_map = Do_not_use_directly
module Builtin_attributes = Do_not_use_directly
module Bytegen = Do_not_use_directly
module Bytelibrarian = Do_not_use_directly
module Bytepackager = Do_not_use_directly
module Bytesections = Do_not_use_directly
module CSE = Do_not_use_directly
module CSEgen = Do_not_use_directly
module CamlinternalMenhirLib = Do_not_use_directly
module Ccomp = Do_not_use_directly
module Clambda = Do_not_use_directly
module Clambda_primitives = Do_not_use_directly
module Clflags = Do_not_use_directly
module Closure = Do_not_use_directly
module Closure_conversion = Do_not_use_directly
module Closure_conversion_aux = Do_not_use_directly
module Closure_element = Do_not_use_directly
module Closure_id = Do_not_use_directly
module Closure_middle_end = Do_not_use_directly
module Closure_offsets = Do_not_use_directly
module Closure_origin = Do_not_use_directly
module Cmi_format = Do_not_use_directly
module Cmm = Do_not_use_directly
module Cmm_helpers = Do_not_use_directly
module Cmm_invariants = Do_not_use_directly
module Cmmgen = Do_not_use_directly
module Cmmgen_state = Do_not_use_directly
module Cmo_format = Do_not_use_directly
module Cmt2annot = Do_not_use_directly
module Cmt_format = Do_not_use_directly
module Cmx_format = Do_not_use_directly
module Cmxs_format = Do_not_use_directly
module Coloring = Do_not_use_directly
module Comballoc = Do_not_use_directly
module Compenv = Do_not_use_directly
module Compilation_unit = Do_not_use_directly
module Compile = Do_not_use_directly
module Compile_common = Do_not_use_directly
module Compilenv = Do_not_use_directly
module Compmisc = Do_not_use_directly
module Compression = Do_not_use_directly
module Config = Do_not_use_directly
module Config_boot = Do_not_use_directly
module Config_main = Do_not_use_directly
module Consistbl = Do_not_use_directly
module Convert_primitives = Do_not_use_directly
module Ctype = Do_not_use_directly
module Dataflow = Do_not_use_directly
module Datarepr = Do_not_use_directly
module Deadcode = Do_not_use_directly
module Debuginfo = Do_not_use_directly
module Depend = Do_not_use_directly
module Diffing = Do_not_use_directly
module Diffing_with_keys = Do_not_use_directly
module Dll = Do_not_use_directly
module Domainstate = Do_not_use_directly
module Effect_analysis = Do_not_use_directly
module Emit = Do_not_use_directly
module Emitaux = Do_not_use_directly
module Emitcode = Do_not_use_directly
module Emitenv = Do_not_use_directly
module Env = Do_not_use_directly
module Envaux = Do_not_use_directly
module Errors = Do_not_use_directly
module Errortrace = Do_not_use_directly
module Errortrace_report = Do_not_use_directly
module Export_id = Do_not_use_directly
module Export_info = Do_not_use_directly
module Export_info_for_pack = Do_not_use_directly
module Expunge = Do_not_use_directly
module Extract_projections = Do_not_use_directly
module Find_recursive_functions = Do_not_use_directly
module Flambda = Do_not_use_directly
module Flambda_invariants = Do_not_use_directly
module Flambda_iterators = Do_not_use_directly
module Flambda_middle_end = Do_not_use_directly
module Flambda_to_clambda = Do_not_use_directly
module Flambda_utils = Do_not_use_directly
module Format_doc = Do_not_use_directly
module Freshening = Do_not_use_directly
module Genprintval = Do_not_use_directly
module Gprinttyp = Do_not_use_directly
module Id_types = Do_not_use_directly
module Ident = Do_not_use_directly
module Import_approx = Do_not_use_directly
module Includeclass = Do_not_use_directly
module Includecore = Do_not_use_directly
module Includemod = Do_not_use_directly
module Includemod_errorprinter = Do_not_use_directly
module Inconstant_idents = Do_not_use_directly
module Initialize_symbol_to_let_symbol = Do_not_use_directly
module Inline_and_simplify = Do_not_use_directly
module Inline_and_simplify_aux = Do_not_use_directly
module Inlining_cost = Do_not_use_directly
module Inlining_decision = Do_not_use_directly
module Inlining_decision_intf = Do_not_use_directly
module Inlining_stats = Do_not_use_directly
module Inlining_stats_types = Do_not_use_directly
module Inlining_transforms = Do_not_use_directly
module Instruct = Do_not_use_directly
module Int_replace_polymorphic_compare = Do_not_use_directly
module Interf = Do_not_use_directly
module Internal_variable_names = Do_not_use_directly
module Interval = Do_not_use_directly
module Invariant_params = Do_not_use_directly
module Lambda = Do_not_use_directly
module Lazy_backtrack = Do_not_use_directly
module Lift_code = Do_not_use_directly
module Lift_constants = Do_not_use_directly
module Lift_let_to_initialize_symbol = Do_not_use_directly
module Linear = Do_not_use_directly
module Linear_format = Do_not_use_directly
module Linearize = Do_not_use_directly
module Linkage_name = Do_not_use_directly
module Linkdeps = Do_not_use_directly
module Linscan = Do_not_use_directly
module Liveness = Do_not_use_directly
module Load_path = Do_not_use_directly
module Local_store = Do_not_use_directly
module Mach = Do_not_use_directly
module Main = Do_not_use_directly
module Main_args = Do_not_use_directly
module Maindriver = Do_not_use_directly
module Makedepend = Do_not_use_directly
module Matching = Do_not_use_directly
module Meta = Do_not_use_directly
module Misc = Do_not_use_directly
module Mtype = Do_not_use_directly
module Mutable_variable = Do_not_use_directly
module Numbers = Do_not_use_directly
module Opcodes = Do_not_use_directly
module Oprint = Do_not_use_directly
module Optcompile = Do_not_use_directly
module Opterrors = Do_not_use_directly
module Optmain = Do_not_use_directly
module Optmaindriver = Do_not_use_directly
module Out_type = Do_not_use_directly
module Outcometree = Do_not_use_directly
module Parameter = Do_not_use_directly
module Parmatch = Do_not_use_directly
module Parser = Do_not_use_directly
module Pass_wrapper = Do_not_use_directly
module Path = Do_not_use_directly
module Patterns = Do_not_use_directly
module Persistent_env = Do_not_use_directly
module Polling = Do_not_use_directly
module Pparse = Do_not_use_directly
module Predef = Do_not_use_directly
module Primitive = Do_not_use_directly
module Printast = Do_not_use_directly
module Printclambda = Do_not_use_directly
module Printclambda_primitives = Do_not_use_directly
module Printcmm = Do_not_use_directly
module Printinstr = Do_not_use_directly
module Printlambda = Do_not_use_directly
module Printlinear = Do_not_use_directly
module Printmach = Do_not_use_directly
module Printpat = Do_not_use_directly
module Printtyp = Do_not_use_directly
module Printtyped = Do_not_use_directly
module Proc = Do_not_use_directly
module Profile = Do_not_use_directly
module Projection = Do_not_use_directly
module Rawprinttyp = Do_not_use_directly
module Ref_to_variables = Do_not_use_directly
module Reg = Do_not_use_directly
module Reload = Do_not_use_directly
module Reloadgen = Do_not_use_directly
module Remove_free_vars_equal_to_args = Do_not_use_directly
module Remove_unused_arguments = Do_not_use_directly
module Remove_unused_closure_vars = Do_not_use_directly
module Remove_unused_program_constructs = Do_not_use_directly
module Runtimedef = Do_not_use_directly
module Schedgen = Do_not_use_directly
module Scheduling = Do_not_use_directly
module Selectgen = Do_not_use_directly
module Selection = Do_not_use_directly
module Semantics_of_primitives = Do_not_use_directly
module Set_of_closures_id = Do_not_use_directly
module Set_of_closures_origin = Do_not_use_directly
module Shape = Do_not_use_directly
module Shape_reduce = Do_not_use_directly
module Share_constants = Do_not_use_directly
module Signature_group = Do_not_use_directly
module Simple_value_approx = Do_not_use_directly
module Simplif = Do_not_use_directly
module Simplify_boxed_integer_ops = Do_not_use_directly
module Simplify_boxed_integer_ops_intf = Do_not_use_directly
module Simplify_common = Do_not_use_directly
module Simplify_primitives = Do_not_use_directly
module Spill = Do_not_use_directly
module Split = Do_not_use_directly
module Stackframe = Do_not_use_directly
module Stackframegen = Do_not_use_directly
module Static_exception = Do_not_use_directly
module Strmatch = Do_not_use_directly
module Strongly_connected_components = Do_not_use_directly
module Stypes = Do_not_use_directly
module Subst = Do_not_use_directly
module Switch = Do_not_use_directly
module Symbol = Do_not_use_directly
module Symtable = Do_not_use_directly
module Tag = Do_not_use_directly
module Targetint = Do_not_use_directly
module Tast_iterator = Do_not_use_directly
module Tast_mapper = Do_not_use_directly
module Terminfo = Do_not_use_directly
module Thread_sanitizer = Do_not_use_directly
module Tmc = Do_not_use_directly
module Topcommon = Do_not_use_directly
module Topdirs = Do_not_use_directly
module Topeval = Do_not_use_directly
module Tophooks = Do_not_use_directly
module Toploop = Do_not_use_directly
module Topmain = Do_not_use_directly
module Topprinters = Do_not_use_directly
module Topstart = Do_not_use_directly
module Trace = Do_not_use_directly
module Translattribute = Do_not_use_directly
module Translclass = Do_not_use_directly
module Translcore = Do_not_use_directly
module Translmod = Do_not_use_directly
module Translobj = Do_not_use_directly
module Translprim = Do_not_use_directly
module Traverse_for_exported_symbols = Do_not_use_directly
module Type_immediacy = Do_not_use_directly
module Typeclass = Do_not_use_directly
module Typecore = Do_not_use_directly
module Typedecl = Do_not_use_directly
module Typedecl_immediacy = Do_not_use_directly
module Typedecl_properties = Do_not_use_directly
module Typedecl_separability = Do_not_use_directly
module Typedecl_unboxed = Do_not_use_directly
module Typedecl_variance = Do_not_use_directly
module Typedtree = Do_not_use_directly
module Typemod = Do_not_use_directly
module Typeopt = Do_not_use_directly
module Types = Do_not_use_directly
module Typetexp = Do_not_use_directly
module Un_anf = Do_not_use_directly
module Unbox_closures = Do_not_use_directly
module Unbox_free_vars_of_closures = Do_not_use_directly
module Unbox_specialised_args = Do_not_use_directly
module Unit_info = Do_not_use_directly
module Untypeast = Do_not_use_directly
module Value_rec_check = Do_not_use_directly
module Value_rec_compiler = Do_not_use_directly
module Value_rec_types = Do_not_use_directly
module Var_within_closure = Do_not_use_directly
module Variable = Do_not_use_directly
module Warnings = Do_not_use_directly
module X86_ast = Do_not_use_directly
module X86_dsl = Do_not_use_directly
module X86_gas = Do_not_use_directly
module X86_masm = Do_not_use_directly
module X86_proc = Do_not_use_directly