Ppxlib (ppxlib.Ppxlib)

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 Asmlink = 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 Bytelink = 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 Config = 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 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 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 Freshening = Do_not_use_directly

module Genprintval = 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 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 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 Rec_check = 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 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 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 Topcommon = Do_not_use_directly

module Topdirs = Do_not_use_directly

module Topeval = Do_not_use_directly

module Toploop = Do_not_use_directly

module Topmain = 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 Untypeast = 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

Expose some modules from Ppxlib_ast; in particular, overwrite some of the modules above

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

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

include module type of struct include Ast end

type position = Stdlib.Lexing.position = {

pos_fname : string;
pos_lnum : int;
pos_bol : int;
pos_cnum : int;

}

and location = Astlib.Location.t = {

loc_start : position;
loc_end : position;
loc_ghost : bool;

}

and location_stack = location list

and 'a loc = 'a Astlib.Location.loc = {

txt : 'a;
loc : location;

}

and longident = Astlib.Longident.t =

| Lident of string
| Ldot of longident * string
| Lapply of longident * longident

and longident_loc = longident loc

Auxiliary AST types used by parsetree and typedtree.

and rec_flag = Astlib.Ast_500.Asttypes.rec_flag =

| Nonrecursive
| Recursive

and direction_flag = Astlib.Ast_500.Asttypes.direction_flag =

| Upto
| Downto

and private_flag = Astlib.Ast_500.Asttypes.private_flag =

| Private
| Public

and mutable_flag = Astlib.Ast_500.Asttypes.mutable_flag =

| Immutable
| Mutable

and virtual_flag = Astlib.Ast_500.Asttypes.virtual_flag =

| Virtual
| Concrete

and override_flag = Astlib.Ast_500.Asttypes.override_flag =

| Override
| Fresh

and closed_flag = Astlib.Ast_500.Asttypes.closed_flag =

| Closed
| Open

and label = string

and arg_label = Astlib.Ast_500.Asttypes.arg_label =

| Nolabel
| Labelled of string
(*
label:T -> ...
*)
| Optional of string
(*
?label:T -> ...
*)

and variance = Astlib.Ast_500.Asttypes.variance =

| Covariant
| Contravariant
| NoVariance

and injectivity = Astlib.Ast_500.Asttypes.injectivity =

| Injective
| NoInjectivity

Abstract syntax tree produced by parsing

and constant = Astlib.Ast_500.Parsetree.constant =

| 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
*)
| Pconst_char of char
(*
Character such as 'c'.
*)
| 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.
*)
| 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_500.Parsetree.attribute = {

attr_name : string loc;
attr_payload : payload;
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_500.Parsetree.payload =

| PStr of structure
| PSig of signature
(*
: SIG in an attribute or an extension point
*)
| PTyp of core_type
(*
: T in an attribute or an extension point
*)
| 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_500.Parsetree.core_type = {

ptyp_desc : core_type_desc;
ptyp_loc : location;
ptyp_loc_stack : location_stack;
ptyp_attributes : attributes;
(*
... [@id1] [@id2]
*)

}

and core_type_desc = Astlib.Ast_500.Parsetree.core_type_desc =

| Ptyp_any
(*
_
*)
| Ptyp_var of string
(*
A type variable such as 'a
*)
| Ptyp_arrow of arg_label * core_type * core_type
(*
Ptyp_arrow(lbl, T1, T2) represents:
- T1 -> T2 when lbl is Nolabel,
- ~l:T1 -> T2 when lbl is Labelled,
- ?l:T1 -> T2 when lbl is Optional.
*)
| Ptyp_tuple of core_type list
(*
Ptyp_tuple([T1 ; ... ; Tn]) represents a product type T1 * ... * Tn.
Invariant: n >= 2.
*)
| 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].
*)
| 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.
*)
| 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].
*)
| Ptyp_alias of core_type * string
(*
T as 'a.
*)
| 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"].
*)
| Ptyp_poly of string loc 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 ...
```
- Under Cfk_virtual for methods (not values).
- As the core_type of a Pctf_method node.
- As the core_type of a Pexp_poly node.
- As the pld_type field of a label_declaration.
- As a core_type of a Ptyp_object node.
- As the pval_type field of a value_description.
*)
| Ptyp_package of package_type
(*
(module S).
*)
| 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_500.Parsetree.row_field = {

prf_desc : row_field_desc;
prf_loc : location;
prf_attributes : attributes;

}

and row_field_desc = Astlib.Ast_500.Parsetree.row_field_desc =

| 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)
*)
| Rinherit of core_type
(*
[ | t ]
*)

and object_field = Astlib.Ast_500.Parsetree.object_field = {

pof_desc : object_field_desc;
pof_loc : location;
pof_attributes : attributes;

}

and object_field_desc = Astlib.Ast_500.Parsetree.object_field_desc =

| Otag of label loc * core_type
| Oinherit of core_type

Patterns

and pattern = Astlib.Ast_500.Parsetree.pattern = {

ppat_desc : pattern_desc;
ppat_loc : location;
ppat_loc_stack : location_stack;
ppat_attributes : attributes;
(*
... [@id1] [@id2]
*)

}

and pattern_desc = Astlib.Ast_500.Parsetree.pattern_desc =

| Ppat_any
(*
The pattern _.
*)
| Ppat_var of string loc
(*
A variable pattern such as x
*)
| Ppat_alias of pattern * string loc
(*
An alias pattern such as P as 'a
*)
| Ppat_constant of constant
(*
Patterns such as 1, 'a', "true", 1.0, 1l, 1L, 1n
*)
| 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.
*)
| Ppat_tuple of pattern list
(*
Patterns (P1, ..., Pn).
Invariant: n >= 2
*)
| 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)
*)
| Ppat_variant of label * pattern option
(*
Ppat_variant(`A, pat) represents:
- `A when pat is None,
- `A P when pat is Some P
*)
| 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
*)
| Ppat_array of pattern list
(*
Pattern [| P1; ...; Pn |]
*)
| Ppat_or of pattern * pattern
(*
Pattern P1 | P2
*)
| Ppat_constraint of pattern * core_type
(*
Pattern (P : T)
*)
| Ppat_type of longident_loc
(*
Pattern #tconst
*)
| Ppat_lazy of pattern
(*
Pattern lazy P
*)
| 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)
*)
| Ppat_exception of pattern
(*
Pattern exception P
*)
| Ppat_extension of extension
(*
Pattern [%id]
*)
| Ppat_open of longident_loc * pattern
(*
Pattern M.(P)
*)

Value expressions

and expression = Astlib.Ast_500.Parsetree.expression = {

pexp_desc : expression_desc;
pexp_loc : location;
pexp_loc_stack : location_stack;
pexp_attributes : attributes;
(*
... [@id1] [@id2]
*)

}

and expression_desc = Astlib.Ast_500.Parsetree.expression_desc =

| Pexp_ident of longident_loc
(*
Identifiers such as x and M.x
*)
| Pexp_constant of constant
(*
Expressions constant such as 1, 'a', "true", 1.0, 1l, 1L, 1n
*)
| 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.
*)
| Pexp_function of cases
(*
function P1 -> E1 | ... | Pn -> En
*)
| Pexp_fun of arg_label * expression option * pattern * expression
(*
Pexp_fun(lbl, exp0, P, E1) represents:
- fun P -> E1 when lbl is Nolabel and exp0 is None
- fun ~l:P -> E1 when lbl is Labelled l and exp0 is None
- fun ?l:P -> E1 when lbl is Optional l and exp0 is None
- fun ?l:(P = E0) -> E1 when lbl is Optional l and exp0 is Some E0
Notes:
- If E0 is provided, only Optional is allowed.
- fun P1 P2 .. Pn -> E1 is represented as nested Pexp_fun.
- let f P = E is represented using Pexp_fun.
*)
| Pexp_apply 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
*)
| Pexp_match of expression * cases
(*
match E0 with P1 -> E1 | ... | Pn -> En
*)
| Pexp_try of expression * cases
(*
try E0 with P1 -> E1 | ... | Pn -> En
*)
| Pexp_tuple of expression list
(*
Expressions (E1, ..., En)
Invariant: n >= 2
*)
| 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])
*)
| Pexp_variant of label * expression option
(*
Pexp_variant(`A, exp) represents
- `A when exp is None
- `A E when exp is Some E
*)
| 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
*)
| Pexp_field of expression * longident_loc
(*
E.l
*)
| Pexp_setfield of expression * longident_loc * expression
(*
E1.l <- E2
*)
| Pexp_array of expression list
(*
[| E1; ...; En |]
*)
| Pexp_ifthenelse of expression * expression * expression option
(*
if E1 then E2 else E3
*)
| Pexp_sequence of expression * expression
(*
E1; E2
*)
| Pexp_while of expression * expression
(*
while E1 do E2 done
*)
| 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
*)
| Pexp_constraint of expression * core_type
(*
(E : T)
*)
| 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.
*)
| Pexp_send of expression * label loc
(*
E # m
*)
| Pexp_new of longident_loc
(*
new M.c
*)
| Pexp_setinstvar of label loc * expression
(*
x <- 2
*)
| Pexp_override of (label loc * expression) list
(*
{< x1 = E1; ...; xn = En >}
*)
| Pexp_letmodule of string option loc * module_expr * expression
(*
let module M = ME in E
*)
| Pexp_letexception of extension_constructor * expression
(*
let exception C in E
*)
| Pexp_assert of expression
(*
assert E.
Note: assert false is treated in a special way by the type-checker.
*)
| Pexp_lazy of expression
(*
lazy E
*)
| 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).
*)
| Pexp_object of class_structure
(*
object ... end
*)
| Pexp_newtype of string loc * expression
(*
fun (type t) -> E
*)
| Pexp_pack of module_expr
(*
(module ME).
(module ME : S) is represented as Pexp_constraint(Pexp_pack ME, Ptyp_package S)
*)
| Pexp_open of open_declaration * expression
(*
- M.(E)
- let open M in E
- let open! M in E
*)
| Pexp_letop of letop
(*
- let* P = E0 in E1
- let* P0 = E00 and* P1 = E01 in E1
*)
| Pexp_extension of extension
(*
[%id]
*)
| Pexp_unreachable
(*
.
*)

and case = Astlib.Ast_500.Parsetree.case = {

pc_lhs : pattern;
pc_guard : expression option;
pc_rhs : expression;

}

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

and letop = Astlib.Ast_500.Parsetree.letop = {

let_ : binding_op;
ands : binding_op list;
body : expression;

}

and binding_op = Astlib.Ast_500.Parsetree.binding_op = {

pbop_op : string loc;
pbop_pat : pattern;
pbop_exp : expression;
pbop_loc : location;

}

Value descriptions

and value_description = Astlib.Ast_500.Parsetree.value_description = {

pval_name : string loc;
pval_type : core_type;
pval_prim : string list;
pval_attributes : attributes;
(*
... [@@id1] [@@id2]
*)
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_500.Parsetree.type_declaration = {

ptype_name : string loc;
ptype_params : (core_type * (variance * injectivity)) list;
(*
('a1,...'an) t
*)
ptype_cstrs : (core_type * core_type * location) list;
(*
... constraint T1=T1' ... constraint Tn=Tn'
*)
ptype_kind : type_kind;
ptype_private : private_flag;
(*
for = private ...
*)
ptype_manifest : core_type option;
(*
represents = T
*)
ptype_attributes : attributes;
(*
... [@@id1] [@@id2]
*)
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_500.Parsetree.type_kind =

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

and label_declaration = Astlib.Ast_500.Parsetree.label_declaration = {

pld_name : string loc;
pld_mutable : mutable_flag;
pld_type : core_type;
pld_loc : location;
pld_attributes : attributes;
(*
l : T [@id1] [@id2]
*)

}

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

Note: T can be a Ptyp_poly.

and constructor_declaration = Astlib.Ast_500.Parsetree.constructor_declaration =
  {

pcd_name : string loc;
pcd_vars : string loc list;
pcd_args : constructor_arguments;
pcd_res : core_type option;
pcd_loc : location;
pcd_attributes : attributes;
(*
C of ... [@id1] [@id2]
*)

}

and constructor_arguments = Astlib.Ast_500.Parsetree.constructor_arguments =

| Pcstr_tuple of core_type list
| 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_500.Parsetree.type_extension = {

ptyext_path : longident_loc;
ptyext_params : (core_type * (variance * injectivity)) list;
ptyext_constructors : extension_constructor list;
ptyext_private : private_flag;
ptyext_loc : location;
ptyext_attributes : attributes;
(*
... @@id1 @@id2
*)

}

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

and extension_constructor = Astlib.Ast_500.Parsetree.extension_constructor = {

pext_name : string loc;
pext_kind : extension_constructor_kind;
pext_loc : location;
pext_attributes : attributes;
(*
C of ... [@id1] [@id2]
*)

}

and type_exception = Astlib.Ast_500.Parsetree.type_exception = {

ptyexn_constructor : extension_constructor;
ptyexn_loc : location;
ptyexn_attributes : attributes;
(*
... [@@id1] [@@id2]
*)

}

Definition of a new exception (exception E).

and extension_constructor_kind =
  Astlib.Ast_500.Parsetree.extension_constructor_kind =

| 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.
*)
| 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_500.Parsetree.class_type = {

pcty_desc : class_type_desc;
pcty_loc : location;
pcty_attributes : attributes;
(*
... [@id1] [@id2]
*)

}

and class_type_desc = Astlib.Ast_500.Parsetree.class_type_desc =

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

and class_signature = Astlib.Ast_500.Parsetree.class_signature = {

pcsig_self : core_type;
pcsig_fields : class_type_field list;

}

Values of type class_signature represents:

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

and class_type_field = Astlib.Ast_500.Parsetree.class_type_field = {

pctf_desc : class_type_field_desc;
pctf_loc : location;
pctf_attributes : attributes;
(*
... [@@id1] [@@id2]
*)

}

and class_type_field_desc = Astlib.Ast_500.Parsetree.class_type_field_desc =

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

and 'a class_infos = 'a Astlib.Ast_500.Parsetree.class_infos = {

pci_virt : virtual_flag;
pci_params : (core_type * (variance * injectivity)) list;
pci_name : string loc;
pci_expr : 'a;
pci_loc : location;
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_500.Parsetree.class_expr = {

pcl_desc : class_expr_desc;
pcl_loc : location;
pcl_attributes : attributes;
(*
... [@id1] [@id2]
*)

}

and class_expr_desc = Astlib.Ast_500.Parsetree.class_expr_desc =

| Pcl_constr of longident_loc * core_type list
(*
c and ['a1, ..., 'an] c
*)
| Pcl_structure of class_structure
(*
object ... end
*)
| 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.
*)
| 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
*)
| 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.
*)
| Pcl_constraint of class_expr * class_type
(*
(CE : CT)
*)
| Pcl_extension of extension
(*
[%id]
*)
| Pcl_open of open_description * class_expr
(*
let open M in CE
*)

and class_structure = Astlib.Ast_500.Parsetree.class_structure = {

pcstr_self : pattern;
pcstr_fields : class_field list;

}

Values of type class_structure represents:

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

and class_field = Astlib.Ast_500.Parsetree.class_field = {

pcf_desc : class_field_desc;
pcf_loc : location;
pcf_attributes : attributes;
(*
... [@@id1] [@@id2]
*)

}

and class_field_desc = Astlib.Ast_500.Parsetree.class_field_desc =

| 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
*)
| Pcf_val of label loc * mutable_flag * class_field_kind
(*
Pcf_val(x,flag, kind) represents:
- val x = E when flag is Immutable and kind is Cfk_concrete(Fresh, E)
- val virtual x: T when flag is Immutable and kind is Cfk_virtual(T)
- val mutable x = E when flag is Mutable and kind is Cfk_concrete(Fresh, E)
- val mutable virtual x: T when flag is Mutable and kind is Cfk_virtual(T)
*)
| Pcf_method of label loc * private_flag * class_field_kind
(*
- method x = E (E can be a Pexp_poly)
- method virtual x: T (T can be a Ptyp_poly)
*)
| Pcf_constraint of core_type * core_type
(*
constraint T1 = T2
*)
| Pcf_initializer of expression
(*
initializer E
*)
| Pcf_attribute of attribute
(*
[@@@id]
*)
| Pcf_extension of extension
(*
[%%id]
*)

and class_field_kind = Astlib.Ast_500.Parsetree.class_field_kind =

| Cfk_virtual of core_type
| 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_500.Parsetree.module_type = {

pmty_desc : module_type_desc;
pmty_loc : location;
pmty_attributes : attributes;
(*
... [@id1] [@id2]
*)

}

and module_type_desc = Astlib.Ast_500.Parsetree.module_type_desc =

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

and functor_parameter = Astlib.Ast_500.Parsetree.functor_parameter =

| Unit
(*
()
*)
| 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_500.Parsetree.signature_item = {

psig_desc : signature_item_desc;
psig_loc : location;

}

and signature_item_desc = Astlib.Ast_500.Parsetree.signature_item_desc =

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

and module_declaration = Astlib.Ast_500.Parsetree.module_declaration = {

pmd_name : string option loc;
pmd_type : module_type;
pmd_attributes : attributes;
(*
... [@@id1] [@@id2]
*)
pmd_loc : location;

}

Values of type module_declaration represents S : MT

and module_substitution = Astlib.Ast_500.Parsetree.module_substitution = {

pms_name : string loc;
pms_manifest : longident_loc;
pms_attributes : attributes;
(*
... [@@id1] [@@id2]
*)
pms_loc : location;

}

Values of type module_substitution represents S := M

and module_type_declaration = Astlib.Ast_500.Parsetree.module_type_declaration =
  {

pmtd_name : string loc;
pmtd_type : module_type option;
pmtd_attributes : attributes;
(*
... [@@id1] [@@id2]
*)
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_500.Parsetree.open_infos = {

popen_expr : 'a;
popen_override : override_flag;
popen_loc : location;
popen_attributes : attributes;

}

Values of type 'a open_infos represents:

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

and open_description = 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_500.Parsetree.include_infos = {

pincl_mod : 'a;
pincl_loc : location;
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_500.Parsetree.with_constraint =

| 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.
*)
| Pwith_module of longident_loc * longident_loc
(*
with module X.Y = Z
*)
| Pwith_modtype of longident_loc * module_type
(*
with module type X.Y = Z
*)
| Pwith_modtypesubst of longident_loc * module_type
(*
with module type X.Y := sig end
*)
| Pwith_typesubst of longident_loc * type_declaration
(*
with type X.t := ..., same format as [Pwith_type]
*)
| Pwith_modsubst of longident_loc * longident_loc
(*
with module X.Y := Z
*)

Value expressions for the module language

and module_expr = Astlib.Ast_500.Parsetree.module_expr = {

pmod_desc : module_expr_desc;
pmod_loc : location;
pmod_attributes : attributes;
(*
... [@id1] [@id2]
*)

}

and module_expr_desc = Astlib.Ast_500.Parsetree.module_expr_desc =

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

and structure = structure_item list

and structure_item = Astlib.Ast_500.Parsetree.structure_item = {

pstr_desc : structure_item_desc;
pstr_loc : location;

}

and structure_item_desc = Astlib.Ast_500.Parsetree.structure_item_desc =

| Pstr_eval of expression * attributes
(*
E
*)
| 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.
*)
| Pstr_primitive of value_description
(*
- val x: T
- external x: T = "s1" ... "sn"
*)
| Pstr_type of rec_flag * type_declaration list
(*
type t1 = ... and ... and tn = ...
*)
| Pstr_typext of type_extension
(*
type t1 += ...
*)
| Pstr_exception of type_exception
(*
- exception C of T
- exception C = M.X
*)
| Pstr_module of module_binding
(*
module X = ME
*)
| Pstr_recmodule of module_binding list
(*
module rec X1 = ME1 and ... and Xn = MEn
*)
| Pstr_modtype of module_type_declaration
(*
module type S = MT
*)
| Pstr_open of open_declaration
(*
open X
*)
| Pstr_class of class_declaration list
(*
class c1 = ... and ... and cn = ...
*)
| Pstr_class_type of class_type_declaration list
(*
class type ct1 = ... and ... and ctn = ...
*)
| Pstr_include of include_declaration
(*
include ME
*)
| Pstr_attribute of attribute
(*
[@@@id]
*)
| Pstr_extension of extension * attributes
(*
[%%id]
*)

and value_binding = Astlib.Ast_500.Parsetree.value_binding = {

pvb_pat : pattern;
pvb_expr : expression;
pvb_attributes : attributes;
pvb_loc : location;

}

and module_binding = Astlib.Ast_500.Parsetree.module_binding = {

pmb_name : string option loc;
pmb_expr : module_expr;
pmb_attributes : attributes;
pmb_loc : location;

}

Values of type module_binding represents module X = ME

Toplevel

Toplevel phrases

and toplevel_phrase = Astlib.Ast_500.Parsetree.toplevel_phrase =

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

and toplevel_directive = Astlib.Ast_500.Parsetree.toplevel_directive = {

pdir_name : string loc;
pdir_arg : directive_argument option;
pdir_loc : location;

}

and directive_argument = Astlib.Ast_500.Parsetree.directive_argument = {

pdira_desc : directive_argument_desc;
pdira_loc : location;

}

and directive_argument_desc = Astlib.Ast_500.Parsetree.directive_argument_desc =

| Pdir_string of string
| Pdir_int of string * char option
| Pdir_ident of longident
| Pdir_bool of bool

and cases = case list

class virtual map : object ... end

class virtual iter : object ... end

class virtual +'b fold : object ... end

class virtual +'b fold_map : object ... end

class virtual +'b map_with_context : object ... end

class virtual +'b lift : object ... end

class virtual [+'b, +'c] lift_map_with_context : object ... end

module Ast_builder : sig ... end

Helpers for build OCaml AST fragments

module Ast_pattern : sig ... end

First class AST patterns

module Ast_traverse : sig ... end

AST traversal classes

module Attribute : sig ... end

Attribute hygiene

module Code_path : sig ... end

module Caller_id : sig ... end

module Context_free : sig ... end

Context free rewriting

module Deriving : sig ... end

Deriving code from type declarations

module Driver : sig ... end

module Expansion_context : sig ... end

module Extension : sig ... end

module File_path : sig ... end

Return the path used as root in a file

module Keyword : sig ... end

module Loc : sig ... end

Located items

module Location : sig ... end

Overrides the Location module of OCaml

module Longident : sig ... end

Overrides the Longident module of OCaml

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 Reserved_namespaces : sig ... end

module Spellcheck : sig ... end

module Quoter : sig ... end

Generate expressions in a hygienic way.

module Ast_io : sig ... end

val lident : string -> Longident.t

val core_type_of_type_declaration : 
  Astlib.Ast_500.Parsetree.type_declaration ->
  Astlib.Ast_500.Parsetree.core_type

val name_type_params_in_td_res : 
  Astlib.Ast_500.Parsetree.type_declaration ->
  (Astlib.Ast_500.Parsetree.type_declaration,
    Location.Error.t Stdppx.NonEmptyList.t)
    Stdlib.result

val name_type_params_in_td : 
  Astlib.Ast_500.Parsetree.type_declaration ->
  Astlib.Ast_500.Parsetree.type_declaration

val combinator_type_of_type_declaration : 
  Astlib.Ast_500.Parsetree.type_declaration ->
  f:
    (loc:Location.t ->
      Astlib.Ast_500.Parsetree.core_type ->
      Astlib.Ast_500.Parsetree.core_type) ->
  Astlib.Ast_500.Parsetree.core_type

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_500.Parsetree.core_type -> string

val assert_no_attributes : Astlib.Ast_500.Parsetree.attribute list -> unit

val assert_no_attributes_in : Ppxlib__.Ast_traverse0.iter

val attributes_errors : 
  Astlib.Ast_500.Parsetree.attribute list ->
  Location.Error.t list

val collect_attributes_errors : 
  Location.Error.t list Ppxlib__.Ast_traverse0.fold

val get_type_param_name_res : 
  (Astlib.Ast_500.Parsetree.core_type
   * (Astlib.Ast_500.Asttypes.variance * Astlib.Ast_500.Asttypes.injectivity)) ->
  (string Loc.t, Location.Error.t Stdppx.NonEmptyList.t) Stdlib.result

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

val get_type_param_name : 
  (Astlib.Ast_500.Parsetree.core_type
   * (Astlib.Ast_500.Asttypes.variance * Astlib.Ast_500.Asttypes.injectivity)) ->
  string Loc.t

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

class  type_is_recursive : Astlib.Ast_500.Asttypes.rec_flag -> Astlib.Ast_500.Parsetree.type_declaration
                                         list -> object ... end

(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.

val really_recursive : 
  Astlib.Ast_500.Asttypes.rec_flag ->
  Astlib.Ast_500.Parsetree.type_declaration list ->
  Astlib.Ast_500.Asttypes.rec_flag

really_recursive rec_flag tds = (new type_is_recursive rec_flag tds)#go ()

val loc_of_payload : Astlib.Ast_500.Parsetree.attribute -> Location.t

val loc_of_attribute : Astlib.Ast_500.Parsetree.attribute -> Location.t

val loc_of_extension : 
  (string Astlib.Location.loc * Astlib.Ast_500.Parsetree.payload) ->
  Location.t

val curry_applications : 
  Astlib.Ast_500.Parsetree.expression ->
  Astlib.Ast_500.Parsetree.expression

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

val attribute_of_warning : 
  Location.t ->
  string ->
  Astlib.Ast_500.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_500.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_500.Parsetree.type_declaration list ->
  Astlib.Ast_500.Parsetree.module_type Astlib.Ast_500.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.

module With_errors : sig ... end