Standard library for ppx rewriters

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

`include module type of sig ... 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 Parser := Ocaml_shadow.Parser 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_helper = 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 Asttypes = 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 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 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 Ccomp = Do_not_use_directly`
`module Clambda = 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_offsets = Do_not_use_directly`
`module Cmi_format = Do_not_use_directly`
`module Cmm = Do_not_use_directly`
`module Cmmgen = Do_not_use_directly`
`module Cmo_format = Do_not_use_directly`
`module Cmt_format = Do_not_use_directly`
`module Cmx_format = Do_not_use_directly`
`module Coloring = Do_not_use_directly`
`module Comballoc = Do_not_use_directly`
`module Compdynlink = Do_not_use_directly`
`module Compenv = Do_not_use_directly`
`module Compilation_unit = Do_not_use_directly`
`module Compile = Do_not_use_directly`
`module Compilenv = Do_not_use_directly`
`module Compmisc = Do_not_use_directly`
`module Compplugin = Do_not_use_directly`
`module Config = Do_not_use_directly`
`module Consistbl = Do_not_use_directly`
`module Ctype = 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 Dll = Do_not_use_directly`
`module Docstrings = 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 Env = Do_not_use_directly`
`module Envaux = Do_not_use_directly`
`module Errors = 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_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 Identifiable = 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 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 Interf = Do_not_use_directly`
`module Interval = Do_not_use_directly`
`module Invariant_params = Do_not_use_directly`
`module Lambda = Do_not_use_directly`
`module Lexer = 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 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 Location = Do_not_use_directly`
`module Longident = Do_not_use_directly`
`module Mach = Do_not_use_directly`
`module Main = Do_not_use_directly`
`module Main_args = Do_not_use_directly`
`module Makedepend = Do_not_use_directly`
`module Matching = Do_not_use_directly`
`module Meta = Do_not_use_directly`
`module Middle_end = 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 Outcometree = Do_not_use_directly`
`module Parameter = Do_not_use_directly`
`module Parmatch = Do_not_use_directly`
`module Parse = Do_not_use_directly`
`module Parser = Do_not_use_directly`
`module Parsetree = Do_not_use_directly`
`module Pass_wrapper = Do_not_use_directly`
`module Path = Do_not_use_directly`
`module Pparse = Do_not_use_directly`
`module Pprintast = 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 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 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 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 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 Spacetime_profiling = 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 Syntaxerr = Do_not_use_directly`
`module Tag = Do_not_use_directly`
`module Targetint = Do_not_use_directly`
`module Tast_mapper = Do_not_use_directly`
`module Tbl = Do_not_use_directly`
`module Terminfo = Do_not_use_directly`
`module Topdirs = 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 Typeclass = Do_not_use_directly`
`module Typecore = Do_not_use_directly`
`module Typedecl = Do_not_use_directly`
`module Typedtree = Do_not_use_directly`
`module TypedtreeIter = Do_not_use_directly`
`module TypedtreeMap = 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`

Includes the overrides from Ppxlib_ast, as well as all the Ast definitions since we need them in every single ppx

`include Ppxlib_ast`
`module Ast = Ppxlib_ast.Ast`
`module Ast_helper = Ppxlib_ast.Ast_helper`
`module Ast_magic = Ppxlib_ast__.Import.Selected_ast.Ast.Config`
`module Asttypes = Ppxlib_ast__.Import.Asttypes`
`module Docstrings = Ppxlib_ast.Docstrings`
`module Extra_warnings = Ppxlib_ast__.Warn`
`module Lexer = Ppxlib_ast.Lexer`
`module Parse = Ppxlib_ast.Parse`
`module Parser = Ppxlib_ast.Parser`
`module Parsetree = Ppxlib_ast__.Import.Parsetree`
`module Pprintast = Ppxlib_ast.Pprintast`
`module Select_ast = Ppxlib_ast__.Import.Select_ast`
`module Selected_ast = Ppxlib_ast__.Import.Selected_ast`
`module Syntaxerr = Ppxlib_ast.Syntaxerr`
`module Import_for_core = Ppxlib_ast__.Import`
`include Ast`

Definition of the OCaml AST

`type position``= Lexing.position``=` `{`

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

`}```
`type location``= Ppxlib_ast__.Import.Location.t``=` `{`

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

`}```
`type 'a loc``= 'a Ppxlib_ast__.Import.Location.loc``=` `{`

`txt : 'a;`
`loc : location;`

`}```
`type longident``= Ppxlib_ast__.Import.Longident.t``=`

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

``
`type longident_loc``= longident loc```

Auxiliary AST types used by parsetree and typedtree.

`type rec_flag``= Ppxlib_ast__.Import.Asttypes.rec_flag``=`

`|` `Nonrecursive`
`|` `Recursive`

``
`type direction_flag``= Ppxlib_ast__.Import.Asttypes.direction_flag``=`

`|` `Upto`
`|` `Downto`

``
`type private_flag``= Ppxlib_ast__.Import.Asttypes.private_flag``=`

`|` `Private`
`|` `Public`

``
`type mutable_flag``= Ppxlib_ast__.Import.Asttypes.mutable_flag``=`

`|` `Immutable`
`|` `Mutable`

``
`type virtual_flag``= Ppxlib_ast__.Import.Asttypes.virtual_flag``=`

`|` `Virtual`
`|` `Concrete`

``
`type override_flag``= Ppxlib_ast__.Import.Asttypes.override_flag``=`

`|` `Override`
`|` `Fresh`

``
`type closed_flag``= Ppxlib_ast__.Import.Asttypes.closed_flag``=`

`|` `Closed`
`|` `Open`

``
`type label``= string```
`type arg_label``= Ppxlib_ast__.Import.Asttypes.arg_label``=`

`|` `Nolabel`
`|` `Labelled of string`
`|` `Optional of string`

``
`type variance``= Ppxlib_ast__.Import.Asttypes.variance``=`

`|` `Covariant`
`|` `Contravariant`
`|` `Invariant`

``

Abstract syntax tree produced by parsing

`type constant``= Ppxlib_ast__.Import.Parsetree.constant``=`

`|` `Pconst_integer of string * char option`
`|` `Pconst_char of char`
`|` `Pconst_string of string * string option`
`|` `Pconst_float of string * char option`

``

### Extension points

`type attribute``= string loc * payload```
`type extension``= string loc * payload```
`type attributes``= attribute list```
`type payload``= Ppxlib_ast__.Import.Parsetree.payload``=`

`|` `PStr of structure`
`|` `PSig of signature`
`|` `PTyp of core_type`
`|` `PPat of pattern * expression option`

``

### Core language

`type core_type``= Ppxlib_ast__.Import.Parsetree.core_type``=` `{`

`ptyp_desc : core_type_desc;`
`ptyp_loc : location;`
`ptyp_attributes : attributes;`

`}```
`type core_type_desc``= Ppxlib_ast__.Import.Parsetree.core_type_desc``=`

`|` `Ptyp_any`
`|` `Ptyp_var of string`
`|` `Ptyp_arrow of arg_label * core_type * core_type`
`|` `Ptyp_tuple of core_type list`
`|` `Ptyp_constr of longident_loc * core_type list`
`|` `Ptyp_object of (string loc * attributes * core_type) list * closed_flag`
`|` `Ptyp_class of longident_loc * core_type list`
`|` `Ptyp_alias of core_type * string`
`|` `Ptyp_variant of row_field list * closed_flag * label list option`
`|` `Ptyp_poly of string loc list * core_type`
`|` `Ptyp_package of package_type`
`|` `Ptyp_extension of extension`

``
`type package_type``= longident_loc * (longident_loc * core_type) list```
`type row_field``= Ppxlib_ast__.Import.Parsetree.row_field``=`

`|` `Rtag of label * attributes * bool * core_type list`
`|` `Rinherit of core_type`

``
`type pattern``= Ppxlib_ast__.Import.Parsetree.pattern``=` `{`

`ppat_desc : pattern_desc;`
`ppat_loc : location;`
`ppat_attributes : attributes;`

`}```
`type pattern_desc``= Ppxlib_ast__.Import.Parsetree.pattern_desc``=`

`|` `Ppat_any`
`|` `Ppat_var of string loc`
`|` `Ppat_alias of pattern * string loc`
`|` `Ppat_constant of constant`
`|` `Ppat_interval of constant * constant`
`|` `Ppat_tuple of pattern list`
`|` `Ppat_construct of longident_loc * pattern option`
`|` `Ppat_variant of label * pattern option`
`|` `Ppat_record of (longident_loc * pattern) list * closed_flag`
`|` `Ppat_array of pattern list`
`|` `Ppat_or of pattern * pattern`
`|` `Ppat_constraint of pattern * core_type`
`|` `Ppat_type of longident_loc`
`|` `Ppat_lazy of pattern`
`|` `Ppat_unpack of string loc`
`|` `Ppat_exception of pattern`
`|` `Ppat_extension of extension`
`|` `Ppat_open of longident_loc * pattern`

``
`type expression``= Ppxlib_ast__.Import.Parsetree.expression``=` `{`

`pexp_desc : expression_desc;`
`pexp_loc : location;`
`pexp_attributes : attributes;`

`}```
`type expression_desc``= Ppxlib_ast__.Import.Parsetree.expression_desc``=`

`|` `Pexp_ident of longident_loc`
`|` `Pexp_constant of constant`
`|` `Pexp_let of rec_flag * value_binding list * expression`
`|` `Pexp_function of case list`
`|` `Pexp_fun of arg_label * expression option * pattern * expression`
`|` `Pexp_apply of expression * (arg_label * expression) list`
`|` `Pexp_match of expression * case list`
`|` `Pexp_try of expression * case list`
`|` `Pexp_tuple of expression list`
`|` `Pexp_construct of longident_loc * expression option`
`|` `Pexp_variant of label * expression option`
`|` `Pexp_record of (longident_loc * expression) list * expression option`
`|` `Pexp_field of expression * longident_loc`
`|` `Pexp_setfield of expression * longident_loc * expression`
`|` `Pexp_array of expression list`
`|` `Pexp_ifthenelse of expression * expression * expression option`
`|` `Pexp_sequence of expression * expression`
`|` `Pexp_while of expression * expression`
`|` `Pexp_for of pattern * expression * expression * direction_flag * expression`
`|` `Pexp_constraint of expression * core_type`
`|` `Pexp_coerce of expression * core_type option * core_type`
`|` `Pexp_send of expression * string loc`
`|` `Pexp_new of longident_loc`
`|` `Pexp_setinstvar of string loc * expression`
`|` `Pexp_override of (string loc * expression) list`
`|` `Pexp_letmodule of string loc * module_expr * expression`
`|` `Pexp_letexception of extension_constructor * expression`
`|` `Pexp_assert of expression`
`|` `Pexp_lazy of expression`
`|` `Pexp_poly of expression * core_type option`
`|` `Pexp_object of class_structure`
`|` `Pexp_newtype of string loc * expression`
`|` `Pexp_pack of module_expr`
`|` `Pexp_open of override_flag * longident_loc * expression`
`|` `Pexp_extension of extension`
`|` `Pexp_unreachable`

``
`type case``= Ppxlib_ast__.Import.Parsetree.case``=` `{`

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

`}```
`type value_description``= Ppxlib_ast__.Import.Parsetree.value_description``=` `{`

`pval_name : string loc;`
`pval_type : core_type;`
`pval_prim : string list;`
`pval_attributes : attributes;`
`pval_loc : location;`

`}```
`type type_declaration``= Ppxlib_ast__.Import.Parsetree.type_declaration``=` `{`

`ptype_name : string loc;`
`ptype_params : (core_type * variance) list;`
`ptype_cstrs : (core_type * core_type * location) list;`
`ptype_kind : type_kind;`
`ptype_private : private_flag;`
`ptype_manifest : core_type option;`
`ptype_attributes : attributes;`
`ptype_loc : location;`

`}```
`type type_kind``= Ppxlib_ast__.Import.Parsetree.type_kind``=`

`|` `Ptype_abstract`
`|` `Ptype_variant of constructor_declaration list`
`|` `Ptype_record of label_declaration list`
`|` `Ptype_open`

``
`type label_declaration``= Ppxlib_ast__.Import.Parsetree.label_declaration``=` `{`

`pld_name : string loc;`
`pld_mutable : mutable_flag;`
`pld_type : core_type;`
`pld_loc : location;`
`pld_attributes : attributes;`

`}```
`type constructor_declaration``= Ppxlib_ast__.Import.Parsetree.constructor_declaration``=` `{`

`pcd_name : string loc;`
`pcd_args : constructor_arguments;`
`pcd_res : core_type option;`
`pcd_loc : location;`
`pcd_attributes : attributes;`

`}```
`type constructor_arguments``= Ppxlib_ast__.Import.Parsetree.constructor_arguments``=`

`|` `Pcstr_tuple of core_type list`
`|` `Pcstr_record of label_declaration list`

``
`type type_extension``= Ppxlib_ast__.Import.Parsetree.type_extension``=` `{`

`ptyext_path : longident_loc;`
`ptyext_params : (core_type * variance) list;`
`ptyext_constructors : extension_constructor list;`
`ptyext_private : private_flag;`
`ptyext_attributes : attributes;`

`}```
`type extension_constructor``= Ppxlib_ast__.Import.Parsetree.extension_constructor``=` `{`

`pext_name : string loc;`
`pext_kind : extension_constructor_kind;`
`pext_loc : location;`
`pext_attributes : attributes;`

`}```
`type extension_constructor_kind``= Ppxlib_ast__.Import.Parsetree.extension_constructor_kind``=`

`|` `Pext_decl of constructor_arguments * core_type option`
`|` `Pext_rebind of longident_loc`

``

### Class language

`type class_type``= Ppxlib_ast__.Import.Parsetree.class_type``=` `{`

`pcty_desc : class_type_desc;`
`pcty_loc : location;`
`pcty_attributes : attributes;`

`}```
`type class_type_desc``= Ppxlib_ast__.Import.Parsetree.class_type_desc``=`

`|` `Pcty_constr of longident_loc * core_type list`
`|` `Pcty_signature of class_signature`
`|` `Pcty_arrow of arg_label * core_type * class_type`
`|` `Pcty_extension of extension`

``
`type class_signature``= Ppxlib_ast__.Import.Parsetree.class_signature``=` `{`

`pcsig_self : core_type;`
`pcsig_fields : class_type_field list;`

`}```
`type class_type_field``= Ppxlib_ast__.Import.Parsetree.class_type_field``=` `{`

`pctf_desc : class_type_field_desc;`
`pctf_loc : location;`
`pctf_attributes : attributes;`

`}```
`type class_type_field_desc``= Ppxlib_ast__.Import.Parsetree.class_type_field_desc``=`

`|` `Pctf_inherit of class_type`
`|` `Pctf_val of string loc * mutable_flag * virtual_flag * core_type`
`|` `Pctf_method of string loc * private_flag * virtual_flag * core_type`
`|` `Pctf_constraint of core_type * core_type`
`|` `Pctf_attribute of attribute`
`|` `Pctf_extension of extension`

``
`type 'a class_infos``= 'a Ppxlib_ast__.Import.Parsetree.class_infos``=` `{`

`pci_virt : virtual_flag;`
`pci_params : (core_type * variance) list;`
`pci_name : string loc;`
`pci_expr : 'a;`
`pci_loc : location;`
`pci_attributes : attributes;`

`}```
`type class_description``= class_type class_infos```
`type class_type_declaration``= class_type class_infos```
`type class_expr``= Ppxlib_ast__.Import.Parsetree.class_expr``=` `{`

`pcl_desc : class_expr_desc;`
`pcl_loc : location;`
`pcl_attributes : attributes;`

`}```
`type class_expr_desc``= Ppxlib_ast__.Import.Parsetree.class_expr_desc``=`

`|` `Pcl_constr of longident_loc * core_type list`
`|` `Pcl_structure of class_structure`
`|` `Pcl_fun of arg_label * expression option * pattern * class_expr`
`|` `Pcl_apply of class_expr * (arg_label * expression) list`
`|` `Pcl_let of rec_flag * value_binding list * class_expr`
`|` `Pcl_constraint of class_expr * class_type`
`|` `Pcl_extension of extension`

``
`type class_structure``= Ppxlib_ast__.Import.Parsetree.class_structure``=` `{`

`pcstr_self : pattern;`
`pcstr_fields : class_field list;`

`}```
`type class_field``= Ppxlib_ast__.Import.Parsetree.class_field``=` `{`

`pcf_desc : class_field_desc;`
`pcf_loc : location;`
`pcf_attributes : attributes;`

`}```
`type class_field_desc``= Ppxlib_ast__.Import.Parsetree.class_field_desc``=`

`|` `Pcf_inherit of override_flag * class_expr * string loc option`
`|` `Pcf_val of string loc * mutable_flag * class_field_kind`
`|` `Pcf_method of string loc * private_flag * class_field_kind`
`|` `Pcf_constraint of core_type * core_type`
`|` `Pcf_initializer of expression`
`|` `Pcf_attribute of attribute`
`|` `Pcf_extension of extension`

``
`type class_field_kind``= Ppxlib_ast__.Import.Parsetree.class_field_kind``=`

`|` `Cfk_virtual of core_type`
`|` `Cfk_concrete of override_flag * expression`

``
`type class_declaration``= class_expr class_infos```

### Module language

`type module_type``= Ppxlib_ast__.Import.Parsetree.module_type``=` `{`

`pmty_desc : module_type_desc;`
`pmty_loc : location;`
`pmty_attributes : attributes;`

`}```
`type module_type_desc``= Ppxlib_ast__.Import.Parsetree.module_type_desc``=`

`|` `Pmty_ident of longident_loc`
`|` `Pmty_signature of signature`
`|` `Pmty_functor of string loc * module_type option * module_type`
`|` `Pmty_with of module_type * with_constraint list`
`|` `Pmty_typeof of module_expr`
`|` `Pmty_extension of extension`
`|` `Pmty_alias of longident_loc`

``
`type signature``= signature_item list```
`type signature_item``= Ppxlib_ast__.Import.Parsetree.signature_item``=` `{`

`psig_desc : signature_item_desc;`
`psig_loc : location;`

`}```
`type signature_item_desc``= Ppxlib_ast__.Import.Parsetree.signature_item_desc``=`

`|` `Psig_value of value_description`
`|` `Psig_type of rec_flag * type_declaration list`
`|` `Psig_typext of type_extension`
`|` `Psig_exception of extension_constructor`
`|` `Psig_module of module_declaration`
`|` `Psig_recmodule of module_declaration list`
`|` `Psig_modtype of module_type_declaration`
`|` `Psig_open of open_description`
`|` `Psig_include of include_description`
`|` `Psig_class of class_description list`
`|` `Psig_class_type of class_type_declaration list`
`|` `Psig_attribute of attribute`
`|` `Psig_extension of extension * attributes`

``
`type module_declaration``= Ppxlib_ast__.Import.Parsetree.module_declaration``=` `{`

`pmd_name : string loc;`
`pmd_type : module_type;`
`pmd_attributes : attributes;`
`pmd_loc : location;`

`}```
`type module_type_declaration``= Ppxlib_ast__.Import.Parsetree.module_type_declaration``=` `{`

`pmtd_name : string loc;`
`pmtd_type : module_type option;`
`pmtd_attributes : attributes;`
`pmtd_loc : location;`

`}```
`type open_description``= Ppxlib_ast__.Import.Parsetree.open_description``=` `{`

`popen_lid : longident_loc;`
`popen_override : override_flag;`
`popen_loc : location;`
`popen_attributes : attributes;`

`}```
`type 'a include_infos``= 'a Ppxlib_ast__.Import.Parsetree.include_infos``=` `{`

`pincl_mod : 'a;`
`pincl_loc : location;`
`pincl_attributes : attributes;`

`}```
`type include_description``= module_type include_infos```
`type include_declaration``= module_expr include_infos```
`type with_constraint``= Ppxlib_ast__.Import.Parsetree.with_constraint``=`

`|` `Pwith_type of longident_loc * type_declaration`
`|` `Pwith_module of longident_loc * longident_loc`
`|` `Pwith_typesubst of type_declaration`
`|` `Pwith_modsubst of string loc * longident_loc`

``
`type module_expr``= Ppxlib_ast__.Import.Parsetree.module_expr``=` `{`

`pmod_desc : module_expr_desc;`
`pmod_loc : location;`
`pmod_attributes : attributes;`

`}```
`type module_expr_desc``= Ppxlib_ast__.Import.Parsetree.module_expr_desc``=`

`|` `Pmod_ident of longident_loc`
`|` `Pmod_structure of structure`
`|` `Pmod_functor of string loc * module_type option * module_expr`
`|` `Pmod_apply of module_expr * module_expr`
`|` `Pmod_constraint of module_expr * module_type`
`|` `Pmod_unpack of expression`
`|` `Pmod_extension of extension`

``
`type structure``= structure_item list```
`type structure_item``= Ppxlib_ast__.Import.Parsetree.structure_item``=` `{`

`pstr_desc : structure_item_desc;`
`pstr_loc : location;`

`}```
`type structure_item_desc``= Ppxlib_ast__.Import.Parsetree.structure_item_desc``=`

`|` `Pstr_eval of expression * attributes`
`|` `Pstr_value of rec_flag * value_binding list`
`|` `Pstr_primitive of value_description`
`|` `Pstr_type of rec_flag * type_declaration list`
`|` `Pstr_typext of type_extension`
`|` `Pstr_exception of extension_constructor`
`|` `Pstr_module of module_binding`
`|` `Pstr_recmodule of module_binding list`
`|` `Pstr_modtype of module_type_declaration`
`|` `Pstr_open of open_description`
`|` `Pstr_class of class_declaration list`
`|` `Pstr_class_type of class_type_declaration list`
`|` `Pstr_include of include_declaration`
`|` `Pstr_attribute of attribute`
`|` `Pstr_extension of extension * attributes`

``
`type value_binding``= Ppxlib_ast__.Import.Parsetree.value_binding``=` `{`

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

`}```
`type module_binding``= Ppxlib_ast__.Import.Parsetree.module_binding``=` `{`

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

`}```

### Toplevel

`type toplevel_phrase``= Ppxlib_ast__.Import.Parsetree.toplevel_phrase``=`

`|` `Ptop_def of structure`
`|` `Ptop_dir of string * directive_argument`

``
`type directive_argument``= Ppxlib_ast__.Import.Parsetree.directive_argument``=`

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

``
`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`
`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 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 Extension : sig ... end`
`module File_path : sig ... end`

Return the path used as root in a file

`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 = Ppxlib__.Name.Reserved_namespaces`
`module Spellcheck : sig ... end`
`include Ppxlib__.Common`
`val lident : Ppxlib__.Import.string ‑> Longident.t`
`val core_type_of_type_declaration : Ppxlib__.Import.type_declaration ‑> Ppxlib__.Import.core_type`
`val name_type_params_in_td : Ppxlib__.Import.type_declaration ‑> Ppxlib__.Import.type_declaration`
`val combinator_type_of_type_declaration : Ppxlib__.Import.type_declaration ‑> f:(loc:Location.t ‑> Ppxlib__.Import.core_type ‑> Ppxlib__.Import.core_type) ‑> Ppxlib__.Import.core_type`
`val gen_symbol : ?⁠prefix:Ppxlib__.Import.string ‑> Ppxlib__.Import.unit ‑> Ppxlib__.Import.string`

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

- Parameter prefix: default = "_x"

`val string_of_core_type : Ppxlib__.Import.core_type ‑> Ppxlib__.Import.string`
`val assert_no_attributes : Ppxlib__.Import.attributes ‑> Ppxlib__.Import.unit`
`val assert_no_attributes_in : Ast_traverse.iter`
`val get_type_param_name : (Ppxlib__.Import.core_type * Ppxlib__.Import.variance) ‑> Ppxlib__.Import.string Loc.t`

`get_tparam_id tp` returns the string identifier associated with `tp` if it is a type parameter.

`class type_is_recursive : Ppxlib__.Import.rec_flag ‑> Ppxlib__.Import.type_declaration Ppxlib__.Import.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 : Ppxlib__.Import.rec_flag ‑> Ppxlib__.Import.type_declaration Ppxlib__.Import.list ‑> Ppxlib__.Import.rec_flag`

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

`val loc_of_payload : Ppxlib__.Import.attribute ‑> Location.t`
`val loc_of_attribute : Ppxlib__.Import.attribute ‑> Location.t`
`val curry_applications : Ppxlib__.Import.expression ‑> Ppxlib__.Import.expression`

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

`val attribute_of_warning : Location.t ‑> Ppxlib__.Import.string ‑> Ppxlib__.Import.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.