package ocamlformat-mlx-lib
Install
Dune Dependency
Authors
Maintainers
Sources
sha256=4557bcca3d2bd2b6d37b046a84a82a1bed83e46e45e363c0b209d30d70c0ec77
sha512=2802651c733bf3535ce9d2e4e533729da75b17e9507d911f4d79d1a68f35ddfb82db1daf8815a46d57a9937dea5b5466d523739c217ace0e446738208037ec2d
doc/ocamlformat-mlx-lib.parser_extended/Ocamlformat_parser_extended/Parsetree/index.html
Module Ocamlformat_parser_extended.Parsetree
Source
Abstract syntax tree produced by parsing
Warning: this module is unstable and part of compiler-libs.
type constant = {
pconst_desc : constant_desc;
pconst_loc : Ocamlformat_ocaml_common.Location.t;
}
and constant_desc =
| 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 * string
(*Pconst_char (c, s)
describes a characterc
and its literal string representations
.e.g. the character
*)'\n'
is represented by the literal string"\\n"
.| Pconst_string of string * Ocamlformat_ocaml_common.Location.t * string option
(*Constant string such as
"constant"
or{delim|other constant|delim}
.The location span the content of the string, without the delimiters.
*)| Pconst_float of string * char option
(*Float constant such as
3.4
,2e5
or1.4e-4
.Suffixes
*)g-z
G-Z
are accepted by the parser. Suffixes are rejected by the typechecker.
Extension points
type attribute = {
attr_name : string Asttypes.loc;
attr_payload : payload;
attr_loc : Ocamlformat_ocaml_common.Location.t;
}
Attributes such as [\@id ARG]
and [\@\@id ARG]
.
Metadata containers passed around within the AST. The compiler ignores unknown attributes.
Extension points such as [%id ARG] and [%%id ARG]
.
Sub-language placeholder -- rejected by the typechecker.
and ext_attrs = {
attrs_extension : string Asttypes.loc option;
(*Short extension syntax, eg.
*)module%ext Foo ...
.attrs_before : attributes;
(*eg.
*)module Foo [@attr] = ...
.attrs_after : attributes;
(*eg.
*)module Foo = struct end [@@attr]
.
}
Core language
Type expressions
and core_type = {
ptyp_desc : core_type_desc;
ptyp_loc : Ocamlformat_ocaml_common.Location.t;
ptyp_loc_stack : location_stack;
ptyp_attributes : attributes;
(*
*)... [\@id1] [\@id2]
}
and arrow_param = {
pap_label : Asttypes.arg_label;
pap_loc : Ocamlformat_ocaml_common.Location.t;
(*Location also including the codomain.
*)pap_type : core_type;
}
and core_type_desc =
| Ptyp_any
(*
*)_
| Ptyp_var of string
(*A type variable such as
*)'a
| Ptyp_arrow of arrow_param list * core_type
| Ptyp_tuple of core_type list
(*Ptyp_tuple([T1 ; ... ; Tn])
represents a product typeT1 * ... * Tn
.Invariant:
*)n >= 2
.| Ptyp_constr of Ocamlformat_ocaml_common.Longident.t Asttypes.loc * core_type list
(*Ptyp_constr(lident, l)
represents:tconstr
whenl=[]
,T tconstr
whenl=[T]
,(T1, ..., Tn) tconstr
whenl=[T1 ; ... ; Tn]
.
| Ptyp_object of object_field list * Asttypes.obj_closed_flag
| Ptyp_class of Ocamlformat_ocaml_common.Longident.t Asttypes.loc * core_type list
(*Ptyp_class(tconstr, l)
represents:#tconstr
whenl=[]
,T #tconstr
whenl=[T]
,(T1, ..., Tn) #tconstr
whenl=[T1 ; ... ; Tn]
.
| Ptyp_alias of core_type * string Asttypes.loc
(*
*)T as 'a
.| Ptyp_variant of row_field list * Asttypes.closed_flag * Asttypes.variant_var list option
| Ptyp_poly of string Asttypes.loc list * core_type
(*'a1 ... 'an. T
Can only appear in the following context:
As the
core_type
of aPpat_constraint
node corresponding to a constraint on a let-binding:let x : 'a1 ... 'an. T = e ...
- As the
pld_type
field of alabel_declaration
.
- As a
core_type
of aPtyp_object
node.
- As the
pval_type
field of avalue_description
.
| Ptyp_package of package_type
(*
*)(module S)
.| Ptyp_open of Ocamlformat_ocaml_common.Longident.t Asttypes.loc * core_type
(*
*)M.(T)
| Ptyp_extension of extension
(*
*)[%id]
.
and package_type =
Ocamlformat_ocaml_common.Longident.t Asttypes.loc
* (Ocamlformat_ocaml_common.Longident.t Asttypes.loc * core_type) list
* attributes
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 = {
prf_desc : row_field_desc;
prf_loc : Ocamlformat_ocaml_common.Location.t;
prf_attributes : attributes;
}
and row_field_desc =
| Rtag of Asttypes.variant_var * bool * core_type list
(*Rtag(`A, b, l)
represents:`A
whenb
istrue
andl
is[]
,`A of T
whenb
isfalse
andl
is[T]
,`A of T1 & .. & Tn
whenb
isfalse
andl
is[T1;...Tn]
,`A of & T1 & .. & Tn
whenb
istrue
andl
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 = {
pof_desc : object_field_desc;
pof_loc : Ocamlformat_ocaml_common.Location.t;
pof_attributes : attributes;
}
and object_field_desc =
| Otag of Asttypes.label Asttypes.loc * core_type
| Oinherit of core_type
Patterns
and pattern = {
ppat_desc : pattern_desc;
ppat_loc : Ocamlformat_ocaml_common.Location.t;
ppat_loc_stack : location_stack;
ppat_attributes : attributes;
(*
*)... [\@id1] [\@id2]
}
and pattern_desc =
| Ppat_any
(*The pattern
*)_
.| Ppat_var of string Asttypes.loc
(*A variable pattern such as
*)x
| Ppat_alias of pattern * string Asttypes.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 Ocamlformat_ocaml_common.Longident.t Asttypes.loc * (string Asttypes.loc list * pattern) option
(*Ppat_construct(C, args)
represents:C
whenargs
isNone
,C P
whenargs
isSome ([], P)
C (P1, ..., Pn)
whenargs
isSome ([], Ppat_tuple [P1; ...; Pn])
C (type a b) P
whenargs
isSome ([a; b], P)
| Ppat_variant of Asttypes.variant_var * pattern option
(*Ppat_variant(`A, pat)
represents:`A
whenpat
isNone
,`A P
whenpat
isSome P
| Ppat_record of (Ocamlformat_ocaml_common.Longident.t Asttypes.loc * core_type option * pattern option) list * Asttypes.obj_closed_flag
| Ppat_array of pattern list
(*Pattern
*)[| P1; ...; Pn |]
| Ppat_list of pattern list
(*Pattern
*)[ P1; ...; Pn ]
| Ppat_or of pattern list
(*Pattern
*)P1 | ... | Pn
| Ppat_constraint of pattern * core_type
(*Pattern
*)(P : T)
| Ppat_type of Ocamlformat_ocaml_common.Longident.t Asttypes.loc
(*Pattern
*)#tconst
| Ppat_lazy of pattern
(*Pattern
*)lazy P
| Ppat_unpack of string option Asttypes.loc * package_type option
(*Ppat_unpack(p, s)
represents:(module P)
whenp
isSome "P"
ands
isNone
(module _)
whenp
isNone
ands
isNone
(module P : S)
whenp
isSome "P"
ands
isSome "S"
(module _ : S)
whenp
isNone
ands
isSome "S"
| Ppat_exception of pattern
(*Pattern
*)exception P
| Ppat_effect of pattern * pattern
| Ppat_extension of extension
(*Pattern
*)[%id]
| Ppat_open of Ocamlformat_ocaml_common.Longident.t Asttypes.loc * pattern
(*Pattern
*)M.(P)
| Ppat_cons of pattern list
(*Pattern
*)P1 :: ... :: Pn
Value expressions
and expression = {
pexp_desc : expression_desc;
pexp_loc : Ocamlformat_ocaml_common.Location.t;
pexp_loc_stack : location_stack;
pexp_attributes : attributes;
(*
*)... [\@id1] [\@id2]
}
and expression_desc =
| Pexp_ident of Ocamlformat_ocaml_common.Longident.t Asttypes.loc
(*Identifiers such as
*)x
andM.x
| Pexp_constant of constant
(*Expressions constant such as
*)1
,'a'
,"true"
,1.0
,1l
,1L
,1n
| Pexp_let of value_bindings * expression * Ocamlformat_ocaml_common.Location.t
(*Pexp_let(flag, [(P1,E1) ; ... ; (Pn,En)], E, loc_in)
represents:let P1 = E1 and ... and Pn = EN in E
whenflag
isNonrecursive
,let rec P1 = E1 and ... and Pn = EN in E
whenflag
isRecursive
.loc_in
is the location of thein
keyword.
| Pexp_function of expr_function_param list * type_constraint option * function_body
(*Pexp_function ([P1; ...; Pn], C, body)
represents any construct involvingfun
orfunction
, including:fun P1 ... Pn -> E
whenbody = Pfunction_body E
fun P1 ... Pn -> function p1 -> e1 | ... | pm -> em
whenbody = Pfunction_cases [ p1 -> e1; ...; pm -> em ]
C
represents a type constraint or coercion placed immediately before the arrow, e.g.fun P1 ... Pn : ty -> ...
whenC = Some (Pconstraint ty)
.A function must have parameters.
*)Pexp_function (params, _, body)
must have non-emptyparams
or aPfunction_cases _
body.| Pexp_apply of expression * (Asttypes.arg_label * expression) list
| Pexp_match of expression * case list
(*
*)match E0 with P1 -> E1 | ... | Pn -> En
| Pexp_try of expression * case list
(*
*)try E0 with P1 -> E1 | ... | Pn -> En
| Pexp_tuple of expression list
(*Expressions
(E1, ..., En)
Invariant:
*)n >= 2
| Pexp_construct of Ocamlformat_ocaml_common.Longident.t Asttypes.loc * expression option
(*Pexp_construct(C, exp)
represents:C
whenexp
isNone
,C E
whenexp
isSome E
,C (E1, ..., En)
whenexp
isSome (Pexp_tuple[E1;...;En])
| Pexp_variant of Asttypes.variant_var * expression option
(*Pexp_variant(`A, exp)
represents`A
whenexp
isNone
`A E
whenexp
isSome E
| Pexp_record of (Ocamlformat_ocaml_common.Longident.t Asttypes.loc * type_constraint option * expression option) list * expression option
(*Pexp_record([(l1,P1) ; ... ; (ln,Pn)], exp0)
represents{ l1=P1; ...; ln=Pn }
whenexp0
isNone
{ E0 with l1=P1; ...; ln=Pn }
whenexp0
isSome E0
Invariant:
*)n > 0
| Pexp_field of expression * Ocamlformat_ocaml_common.Longident.t Asttypes.loc
(*
*)E.l
| Pexp_setfield of expression * Ocamlformat_ocaml_common.Longident.t Asttypes.loc * expression
(*
*)E1.l <- E2
| Pexp_array of expression list
(*
*)[| E1; ...; En |]
| Pexp_list of expression list
(*
*)[ E1; ...; En ]
| Pexp_ifthenelse of if_branch list * (expression * Ocamlformat_ocaml_common.Location.t) option
(*
*)Pexp_ifthenelse (if_branches, Some (else_expr, else_keyword_loc)
| Pexp_sequence of expression * expression
(*
*)E1; E2
| Pexp_while of expression * expression
(*
*)while E1 do E2 done
| Pexp_for of pattern * expression * expression * Asttypes.direction_flag * expression
| 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)
whenfrom
isNone
,(E : T0 :> T)
whenfrom
isSome T0
.
| Pexp_send of expression * Asttypes.label Asttypes.loc
(*
*)E # m
| Pexp_new of Ocamlformat_ocaml_common.Longident.t Asttypes.loc
(*
*)new M.c
| Pexp_setinstvar of Asttypes.label Asttypes.loc * expression
(*
*)x <- 2
| Pexp_override of (Asttypes.label Asttypes.loc * expression) list
(*
*){< x1 = E1; ...; xn = En >}
| Pexp_letmodule of string option Asttypes.loc * functor_parameter Asttypes.loc list * 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_object of class_structure
(*
*)object ... end
| Pexp_pack of module_expr * package_type option
(*(module M)
is represented asPexp_pack(M, None)
(module M : S)
is represented asPexp_pack(M, Some S)
| Pexp_open of Ocamlformat_ocaml_common.Longident.t Asttypes.loc * expression
(*
*)M.(E)
| Pexp_letopen of open_declaration * expression
(*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
(*
*).
| Pexp_hole
(*
*)_
| Pexp_beginend of expression
(*
*)begin E end
| Pexp_parens of expression
(*
*)(E)
| Pexp_cons of expression list
(*
*)E1 :: ... :: En
| Pexp_indexop_access of indexop_access
| Pexp_prefix of string Asttypes.loc * expression
(*
*)op E
| Pexp_infix of string Asttypes.loc * expression * expression
(*
*)E1 op E2
and indexop_access = {
pia_lhs : expression;
pia_kind : indexop_access_kind;
pia_paren : Asttypes.paren_kind;
pia_rhs : expression option;
}
and indexop_access_kind =
| Builtin of expression
(*
*)arr.(i)
arr.(i) <- e
str.[i]
str.[i] <- c
bar.{i1; i2; ..}
bar.{i1; i2; ..} <- e
| Dotop of Ocamlformat_ocaml_common.Longident.t Asttypes.loc option * string * expression list
(*
*)foo.Path.%{i1, i2, ..} <- e
and if_branch = {
if_cond : expression;
if_body : expression;
if_attrs : attributes;
(*
*)... [\@id1] [\@id2]
if_loc_then : Ocamlformat_ocaml_common.Location.t;
(*Location of the
*)then
keyword, for comment attachment.
}
Values of type case
represents (P -> E)
or (P when E0 -> E)
and letop = {
let_ : binding_op;
ands : binding_op list;
body : expression;
loc_in : Ocamlformat_ocaml_common.Location.t;
}
and binding_op = {
pbop_op : string Asttypes.loc;
pbop_pat : pattern;
pbop_args : expr_function_param list;
pbop_typ : value_constraint option;
pbop_exp : expression;
pbop_is_pun : bool;
pbop_loc : Ocamlformat_ocaml_common.Location.t;
}
and function_param_desc =
| Pparam_val of pparam_val
(*Pparam_val (lbl, exp0, P)
represents the parameter:P
whenlbl
isNolabel
andexp0
isNone
~l:P
whenlbl
isLabelled l
andexp0
isNone
?l:P
whenlbl
isOptional l
andexp0
isNone
?l:(P = E0)
whenlbl
isOptional l
andexp0
isSome E0
Note: If
*)E0
is provided, onlyOptional
is allowed.| Pparam_newtype of string Asttypes.loc list
(*Pparam_newtype x
represents the parameter(type x)
.x
carries the location of the identifier, whereas thepparam_loc
on the enclosingfunction_param
node is the location of the(type x)
as a whole.Multiple parameters
(type a b c)
are represented as multiplePparam_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 locsloc2
andloc3
are the same asloc1
, except marked as ghost locations. The locations ona
,b
,c
, correspond to the variablesa
,b
, andc
in the source code.
and function_body =
| Pfunction_body of expression
| Pfunction_cases of case list * Ocamlformat_ocaml_common.Location.t * attributes
(*In
*)Pfunction_cases (_, loc, attrs)
, the location extends from the start of thefunction
keyword to the end of the last case. The compiler will only use typechecking-related attributes fromattrs
, e.g. enabling or disabling a warning.
See the comment on Pexp_function
.
Value descriptions
and value_description = {
pval_name : string Asttypes.loc;
pval_type : core_type;
pval_prim : string Asttypes.loc list;
pval_attributes : ext_attrs;
(*
*)... [\@\@id1] [\@\@id2]
pval_loc : Ocamlformat_ocaml_common.Location.t;
}
Values of type value_description
represents:
Type declarations
and type_declaration = {
ptype_name : string Asttypes.loc;
ptype_params : (core_type * Asttypes.variance_and_injectivity) list;
(*
*)('a1,...'an) t
ptype_cstrs : (core_type * core_type * Ocamlformat_ocaml_common.Location.t) list;
(*
*)... constraint T1=T1' ... constraint Tn=Tn'
ptype_kind : type_kind;
ptype_private : Asttypes.private_flag;
(*for
*)= private ...
ptype_manifest : core_type option;
(*represents
*)= T
ptype_attributes : ext_attrs;
(*
*)... [\@\@id1] [\@\@id2]
ptype_loc : Ocamlformat_ocaml_common.Location.t;
}
Here are type declarations and their representation, for various ptype_kind
and ptype_manifest
values:
type t
whentype_kind
isPtype_abstract
, andmanifest
isNone
,type t = T0
whentype_kind
isPtype_abstract
, andmanifest
isSome T0
,type t = C of T | ...
whentype_kind
isPtype_variant
, andmanifest
isNone
,type t = T0 = C of T | ...
whentype_kind
isPtype_variant
, andmanifest
isSome T0
,type t = {l: T; ...}
whentype_kind
isPtype_record
, andmanifest
isNone
,type t = T0 = {l : T; ...}
whentype_kind
isPtype_record
, andmanifest
isSome T0
,type t = ..
whentype_kind
isPtype_open
, andmanifest
isNone
.
and 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 = {
pld_name : string Asttypes.loc;
pld_mutable : Asttypes.mutable_flag;
pld_type : core_type;
pld_loc : Ocamlformat_ocaml_common.Location.t;
pld_attributes : attributes;
(*
*)l : T [\@id1] [\@id2]
}
{ ...; l: T; ... }
whenpld_mutable
isImmutable
,{ ...; mutable l: T; ... }
whenpld_mutable
isMutable
.
Note: T
can be a Ptyp_poly
.
and constructor_declaration = {
pcd_name : string Asttypes.loc;
pcd_vars : string Asttypes.loc list;
pcd_args : constructor_arguments;
pcd_res : core_type option;
pcd_loc : Ocamlformat_ocaml_common.Location.t;
pcd_attributes : attributes;
(*
*)C of ... [\@id1] [\@id2]
}
and constructor_arguments =
| Pcstr_tuple of core_type list
| Pcstr_record of Ocamlformat_ocaml_common.Location.t * label_declaration list
(*Values of type
constructor_declaration
represents the constructor arguments of:C of T1 * ... * Tn
whenres = None
, andargs = Pcstr_tuple [T1; ... ; Tn]
,C: T0
whenres = Some T0
, andargs = Pcstr_tuple []
,C: T1 * ... * Tn -> T0
whenres = Some T0
, andargs = Pcstr_tuple [T1; ... ; Tn]
,C of {...}
whenres = None
, andargs = Pcstr_record [...]
,C: {...} -> T0
whenres = Some T0
, andargs = Pcstr_record [...]
.
and type_extension = {
ptyext_path : Ocamlformat_ocaml_common.Longident.t Asttypes.loc;
ptyext_params : (core_type * Asttypes.variance_and_injectivity) list;
ptyext_constructors : extension_constructor list;
ptyext_private : Asttypes.private_flag;
ptyext_loc : Ocamlformat_ocaml_common.Location.t;
ptyext_attributes : ext_attrs;
(*...
*)\@\@id1
\@\@id2
}
Definition of new extensions constructors for the extensive sum type t
(type t += ...
).
and extension_constructor = {
pext_name : string Asttypes.loc;
pext_kind : extension_constructor_kind;
pext_loc : Ocamlformat_ocaml_common.Location.t;
pext_attributes : attributes;
(*
*)C of ... [\@id1] [\@id2]
}
and type_exception = {
ptyexn_constructor : extension_constructor;
ptyexn_loc : Ocamlformat_ocaml_common.Location.t;
ptyexn_attributes : ext_attrs;
(*
*)... [\@\@id1] [\@\@id2]
}
Definition of a new exception (exception E
).
and extension_constructor_kind =
| Pext_decl of string Asttypes.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
isNone
C: T0
whenexistentials
is[]
,c_args
is[]
,t_opt
isSome T0
.
C: T1 * ... * Tn -> T0
whenexistentials
is[]
,c_args
is[T1; ...; Tn]
,t_opt
isSome T0
.
C: 'a... . T1 * ... * Tn -> T0
whenexistentials
is['a;...]
,c_args
is[T1; ... ; Tn]
,t_opt
isSome T0
.
| Pext_rebind of Ocamlformat_ocaml_common.Longident.t Asttypes.loc
(*
*)Pext_rebind(D)
re-export the constructorD
with the new nameC
Class language
Type expressions for the class language
and class_type = {
pcty_desc : class_type_desc;
pcty_loc : Ocamlformat_ocaml_common.Location.t;
pcty_attributes : attributes;
(*
*)... [\@id1] [\@id2]
}
and class_type_desc =
| Pcty_constr of Ocamlformat_ocaml_common.Longident.t Asttypes.loc * core_type list
(*c
['a1, ..., 'an] c
| Pcty_signature of class_signature
(*
*)object ... end
| Pcty_arrow of arrow_param list * class_type
(*Pcty_arrow(lbl, T, CT)
represents:T -> CT
whenlbl
isNolabel
,~l:T -> CT
whenlbl
isLabelled l
,?l:T -> CT
whenlbl
isOptional l
.
| Pcty_extension of extension
(*
*)%id
| Pcty_open of open_description * class_type
(*
*)let open M in CT
Values of type class_signature
represents:
object('selfpat) ... end
object ... end
whenpcsig_self
isNone
and class_type_field = {
pctf_desc : class_type_field_desc;
pctf_loc : Ocamlformat_ocaml_common.Location.t;
pctf_attributes : attributes;
(*
*)... [\@\@id1] [\@\@id2]
}
and class_type_field_desc =
| Pctf_inherit of class_type
(*
*)inherit CT
| Pctf_val of Asttypes.label Asttypes.loc * Asttypes.mutable_virtual * core_type
(*
*)val x: T
| Pctf_method of Asttypes.label Asttypes.loc * Asttypes.private_virtual * core_type
(*
*)method x: T
| Pctf_constraint of core_type * core_type
(*
*)constraint T1 = T2
| Pctf_attribute of attribute
(*
*)[\@\@\@id]
| Pctf_extension of extension
(*
*)[%%id]
and 'a class_infos = {
pci_virt : Asttypes.virtual_flag;
pci_params : (core_type * Asttypes.variance_and_injectivity) list;
pci_name : string Asttypes.loc;
pci_args : class_function_param list;
pci_constraint : class_type option;
pci_expr : 'a;
pci_loc : Ocamlformat_ocaml_common.Location.t;
pci_attributes : ext_attrs;
(*
*)... [\@\@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.
Value expressions for the class language
and class_expr = {
pcl_desc : class_expr_desc;
pcl_loc : Ocamlformat_ocaml_common.Location.t;
pcl_attributes : attributes;
(*
*)... [\@id1] [\@id2]
}
and class_expr_desc =
| Pcl_constr of Ocamlformat_ocaml_common.Longident.t Asttypes.loc * core_type list
(*
*)c
and['a1, ..., 'an] c
| Pcl_structure of class_structure
(*
*)object ... end
| Pcl_fun of class_function_param list * class_expr
(*Pcl_fun(P, CE)
represents:fun P -> CE
fun ~l:P -> CE
fun ?l:P -> CE
fun ?l:(P = E0) -> CE
| Pcl_apply of class_expr * (Asttypes.arg_label * expression) list
(*Pcl_apply(CE, [(l1,E1) ; ... ; (ln,En)])
representsCE ~l1:E1 ... ~ln:En
.li
can be empty (non labeled argument) or start with?
(optional argument).Invariant:
*)n > 0
| Pcl_let of value_bindings * class_expr * Ocamlformat_ocaml_common.Location.t
(*Pcl_let(rec, [(P1, E1); ... ; (Pn, En)], CE, loc_in)
represents:let P1 = E1 and ... and Pn = EN in CE
whenrec
isNonrecursive
,let rec P1 = E1 and ... and Pn = EN in CE
whenrec
isRecursive
.loc_in
is the location of thein
keyword.
| 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
Values of type class_structure
represents:
object(selfpat) ... end
object ... end
whenpcstr_self
isNone
and class_field = {
pcf_desc : class_field_desc;
pcf_loc : Ocamlformat_ocaml_common.Location.t;
pcf_attributes : attributes;
(*
*)... [\@\@id1] [\@\@id2]
}
and class_field_desc =
| Pcf_inherit of Asttypes.override_flag * class_expr * string Asttypes.loc option
| Pcf_val of Asttypes.label Asttypes.loc * Asttypes.mutable_virtual * class_field_value_kind
(*Pcf_val(x,flag, kind)
represents:val x = E
whenflag
isImmutable
andkind
isCfk_concrete(Fresh, E)
val virtual x: T
whenflag
isImmutable
andkind
isCfk_virtual(T)
val mutable x = E
whenflag
isMutable
andkind
isCfk_concrete(Fresh, E)
val mutable virtual x: T
whenflag
isMutable
andkind
isCfk_virtual(T)
| Pcf_method of Asttypes.label Asttypes.loc * Asttypes.private_virtual * class_field_method_kind
(*method x = E
method virtual x: T
| 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 'a class_field_kind =
| Cfk_virtual of core_type
| Cfk_concrete of Asttypes.override_flag * 'a * expression
and class_field_method_kind =
(expr_function_param list * value_constraint option) class_field_kind
Module language
Type expressions for the module language
and module_type = {
pmty_desc : module_type_desc;
pmty_loc : Ocamlformat_ocaml_common.Location.t;
pmty_attributes : attributes;
(*
*)... [\@id1] [\@id2]
}
and module_type_desc =
| Pmty_ident of Ocamlformat_ocaml_common.Longident.t Asttypes.loc
(*
*)Pmty_ident(S)
representsS
| Pmty_signature of signature
(*
*)sig ... end
| Pmty_functor of functor_parameter Asttypes.loc list * module_type * bool
(*
*)functor (X1 : MT1) ... (Xn : MTn) -> MT
, third argument codes whether the short syntax is used.| 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 Ocamlformat_ocaml_common.Longident.t Asttypes.loc
(*
*)(module M)
and functor_parameter =
| Unit
(*
*)()
| Named of string option Asttypes.loc * module_type
(*Named(name, MT)
represents:(X : MT)
whenname
isSome X
,(_ : MT)
whenname
isNone
and signature_item = {
psig_desc : signature_item_desc;
psig_loc : Ocamlformat_ocaml_common.Location.t;
}
and signature_item_desc =
| Psig_value of value_description
(*val x: T
external x: T = "s1" ... "sn"
| Psig_type of Asttypes.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
andmodule 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
andmodule 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 = {
pmd_name : string option Asttypes.loc;
pmd_args : functor_parameter Asttypes.loc list;
pmd_type : module_type;
pmd_ext_attrs : ext_attrs;
pmd_loc : Ocamlformat_ocaml_common.Location.t;
}
Values of type module_declaration
represents S : MT
and module_substitution = {
pms_name : string Asttypes.loc;
pms_manifest : Ocamlformat_ocaml_common.Longident.t Asttypes.loc;
pms_ext_attrs : ext_attrs;
pms_loc : Ocamlformat_ocaml_common.Location.t;
}
Values of type module_substitution
represents S := M
and module_type_declaration = {
pmtd_name : string Asttypes.loc;
pmtd_type : module_type option;
pmtd_ext_attrs : ext_attrs;
pmtd_loc : Ocamlformat_ocaml_common.Location.t;
}
Values of type module_type_declaration
represents:
S = MT
,S
for abstract module type declaration, whenpmtd_type
isNone
.
and 'a open_infos = {
popen_expr : 'a;
popen_override : Asttypes.override_flag;
popen_loc : Ocamlformat_ocaml_common.Location.t;
popen_attributes : ext_attrs;
}
Values of type 'a open_infos
represents:
open! X
whenpopen_override
isOverride
(silences the "used identifier shadowing" warning)open X
whenpopen_override
isFresh
Values of type open_description
represents:
open M.N
open M(N).O
Values of type open_declaration
represents:
open M.N
open M(N).O
open struct ... end
and 'a include_infos = {
pincl_mod : 'a;
pincl_loc : Ocamlformat_ocaml_common.Location.t;
pincl_attributes : ext_attrs;
}
Values of type include_description
represents include MT
Values of type include_declaration
represents include ME
and with_constraint =
| Pwith_type of Ocamlformat_ocaml_common.Longident.t Asttypes.loc * type_declaration
(*with type X.t = ...
Note: the last component of the longident must match the name of the type_declaration.
*)| Pwith_module of Ocamlformat_ocaml_common.Longident.t Asttypes.loc * Ocamlformat_ocaml_common.Longident.t Asttypes.loc
(*
*)with module X.Y = Z
| Pwith_modtype of Ocamlformat_ocaml_common.Longident.t Asttypes.loc * module_type
(*
*)with module type X.Y = Z
| Pwith_modtypesubst of Ocamlformat_ocaml_common.Longident.t Asttypes.loc * module_type
(*
*)with module type X.Y := sig end
| Pwith_typesubst of Ocamlformat_ocaml_common.Longident.t Asttypes.loc * type_declaration
(*
*)with type X.t := ..., same format as [Pwith_type]
| Pwith_modsubst of Ocamlformat_ocaml_common.Longident.t Asttypes.loc * Ocamlformat_ocaml_common.Longident.t Asttypes.loc
(*
*)with module X.Y := Z
Value expressions for the module language
and module_expr = {
pmod_desc : module_expr_desc;
pmod_loc : Ocamlformat_ocaml_common.Location.t;
pmod_attributes : attributes;
(*
*)... [\@id1] [\@id2]
}
and module_expr_desc =
| Pmod_ident of Ocamlformat_ocaml_common.Longident.t Asttypes.loc
(*
*)X
| Pmod_structure of structure
(*
*)struct ... end
| Pmod_functor of functor_parameter Asttypes.loc list * module_expr
(*
*)functor (X1 : MT1) ... (Xn : MTn) -> ME
| Pmod_apply of module_expr * module_expr
(*
*)ME1(ME2)
| Pmod_apply_unit of module_expr * Ocamlformat_ocaml_common.Location.t
(*
*)ME1()
. The location argument correspond to the()
.| Pmod_constraint of module_expr * module_type
(*
*)(ME : MT)
| Pmod_unpack of expression * package_type option * package_type option
(*
*)(val E : M1 :> M2)
| Pmod_extension of extension
(*
*)[%id]
| Pmod_hole
(*
*)_
and structure_item = {
pstr_desc : structure_item_desc;
pstr_loc : Ocamlformat_ocaml_common.Location.t;
}
and structure_item_desc =
| Pstr_eval of expression * attributes
(*
*)E
| Pstr_value of value_bindings
(*Pstr_value(rec, [(P1, E1 ; ... ; (Pn, En))])
represents:let P1 = E1 and ... and Pn = EN
whenrec
isNonrecursive
,let rec P1 = E1 and ... and Pn = EN
whenrec
isRecursive
.
| Pstr_primitive of value_description
(*val x: T
external x: T = "s1" ... "sn"
| Pstr_type of Asttypes.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_constraint =
| Pvc_constraint of {
locally_abstract_univars : string Asttypes.loc list;
typ : core_type;
}
| Pvc_coercion of {
}
(*Pvc_constraint { locally_abstract_univars=[]; typ}
is a simple type constraint on a value binding:let x : typ
- More generally, in
Pvc_constraint { locally_abstract_univars; typ}
locally_abstract_univars
is the list of locally abstract type variables inlet x: type a ... . typ
Pvc_coercion { ground=None; coercion }
representslet x :> typ
Pvc_coercion { ground=Some g; coercion }
representslet x : g :> typ
and value_binding = {
pvb_pat : pattern;
pvb_args : expr_function_param list;
pvb_body : function_body;
(*For bindings that are not functions, this is
*)Pfunction_body expr
.pvb_constraint : value_constraint option;
pvb_is_pun : bool;
pvb_attributes : ext_attrs;
pvb_loc : Ocamlformat_ocaml_common.Location.t;
}
let pat : type_constraint = exp
and module_binding = {
pmb_name : string option Asttypes.loc;
pmb_args : functor_parameter Asttypes.loc list;
pmb_expr : module_expr;
pmb_ext_attrs : ext_attrs;
pmb_loc : Ocamlformat_ocaml_common.Location.t;
}
Values of type module_binding
represents module X = ME
Toplevel
Toplevel phrases
type toplevel_phrase =
| Ptop_def of structure
| Ptop_dir of toplevel_directive
(*
*)#use
,#load
...
and toplevel_directive = {
pdir_name : string Asttypes.loc;
pdir_arg : directive_argument option;
pdir_loc : Ocamlformat_ocaml_common.Location.t;
}
and directive_argument = {
pdira_desc : directive_argument_desc;
pdira_loc : Ocamlformat_ocaml_common.Location.t;
}
and directive_argument_desc =
| Pdir_string of string
| Pdir_int of string * char option
| Pdir_ident of Ocamlformat_ocaml_common.Longident.t
| Pdir_bool of bool