Module Ocaml_typing.Typedtree

Projection requires boxing. unique_use describes the usage of the unboxed field as argument to boxing.

Projection does not require boxing. unique_use describes the usage of the field as the result of direct projection.

P : T pat_desc = P ; pat_extra = (Tpat_constraint T, _, _) :: ...

#tconst pat_desc = disjunction ; pat_extra = (Tpat_type (P, "tconst"), _, _) :: ...

where disjunction is a Tpat_or _ representing the branches of tconst.

(module P) pat_desc = Tpat_var "P" ; pat_extra = (Tpat_unpack, _, _) :: ... (module _) pat_desc = Tpat_any ; pat_extra = (Tpat_unpack, _, _) :: ...

_

x

P as a

1, 'a', "true", 1.0, 1l, 1L, 1n

(P1, ..., Pn) (None,P1); ...; (None,Pn)) (L1:P1, ... Ln:Pn) (Some L1,P1); ...; (Some Ln,Pn)) Any mix, e.g. (L1:P1, P2) (Some L1,P1); ...; (None,P2))

Invariant: n >= 2

#(P1, ..., Pn) (None,P1,s1); ...; (None,Pn,sn)) #(L1:P1, ... Ln:Pn) (Some L1,P1,s1); ...; (Some Ln,Pn,sn)) Any mix, e.g. #(L1:P1, P2) (Some L1,P1,s1); ...; (None,P2,s2))

Invariant: n >= 2

C (, None) C P (P, None) C (P1, ..., Pn) (P1; ...; Pn, None) C (P : t) (P, Some (, t)) C (P1, ..., Pn : t) (P1; ...; Pn, Some (, t)) C (type a) (P : t) (P, Some (a, t)) C (type a) (P1, ..., Pn : t) (P1; ...; Pn, Some (a, None, t)) C (type (a : k)) (P1, ..., Pn : t) (P1; ...; Pn, Some (a, Some k, t))

`A (None) `A P (Some P)

See Types.row_desc for an explanation of the last parameter.

l1=P1; ...; ln=Pn (flag = Closed) l1=P1; ...; ln=Pn; _ (flag = Open)

Invariant: n > 0

# l1=P1; ...; ln=Pn (flag = Closed) # l1=P1; ...; ln=Pn; _ (flag = Open)

Invariant: n > 0

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

lazy P

P

Invariant: Tpat_value pattern should not carry pat_attributes or pat_extra metadata coming from user syntax, which must be on the inner pattern node -- to facilitate searching for a certain value pattern constructor with a specific attributed.

To enforce this restriction, we made the argument of the Tpat_value constructor a private synonym of pattern, requiring you to use the as_computation_pattern function below instead of using the Tpat_value constructor directly.

exception P

P1 | P2

row_desc = Some _ when translating Ppat_type _, None otherwise.

E : T

E :> T Texp_coerce (None, T) E : T0 :> T Texp_coerce (Some T0, T)

Used for method bodies.

fun (type t : immediate) ->

The Ident.t and Uid.t fields are unused by the compiler, but Merlin needs them. Merlin cannot be cleanly patched to include these fields because Merlin must be able to deserialize typedtrees produced by the compiler. Thus, we include them here, as the cost of tracking this additional information is minimal.

stack_ E

E : _ @@ M

x M.x

1, 'a', "true", 1.0, 1l, 1L, 1n

let P1 = E1 and ... and Pn = EN in E (flag = Nonrecursive) let rec P1 = E1 and ... and Pn = EN in E (flag = Recursive)

let mutable P = E in E'

fun P0 P1 -> function p1 -> e1 | p2 -> e2 (body = Tfunction_cases _) fun P0 P1 -> E (body = Tfunction_body _) This construct has the same arity as the originating Pexp_function. Arity determines when side-effects for effectful parameters are run (e.g. optional argument defaults, matching against lazy patterns). Parameters' effects are run left-to-right when an n-ary function is saturated with n arguments.

E0 ~l1:E1 ... ~ln:En

The expression can be Omitted if the expression is abstracted over this argument. It currently appears when a label is applied.

For example: let f x ~y = x + y in f ~y:3

The resulting typedtree for the application is: Texp_apply (Texp_ident "f/1037", (Nolabel, Omitted _); (Labelled "y", Some (Texp_constant Const_int 3)) )

The Zero_alloc.assume option records the optional @zero_alloc assume attribute that may appear on applications.

match E0 with | P1 -> E1 | P2 | exception P3 -> E2 | exception P4 -> E3

Texp_match (E0, sort_of_E0, [(P1, E1); (P2 | exception P3, E2); (exception P4, E3)], _)

try E with P1 -> E1 | ... | PN -> EN

Texp_tuple(el) represents

• (E1, ..., En) when el is (None, E1);...;(None, En),
• (L1:E1, ..., Ln:En) when el is (Some L1, E1);...;(Some Ln, En),
• Any mix, e.g. (L1: E1, E2) when el is (Some L1, E1); (None, E2)

Texp_unboxed_tuple(el) represents

• #(E1, ..., En) when el is (None, E1, s1);...;(None, En, sn),
• #(L1:E1, ..., Ln:En) when el is (Some L1, E1, s1);...;(Some Ln, En, sn),
• Any mix, e.g. #(L1: E1, E2) when el is (Some L1, E1, s1); (None, E2, s2)

C C E E C (E1, ..., En) E1;...;En

alloc_mode is the allocation mode of the construct, or None if the constructor is Cstr_unboxed or Cstr_constant, in which case it does not need allocation.

alloc_mode is the allocation mode of the variant, or None if the variant has no argument, in which case it does not need allocation.

l1=P1; ...; ln=Pn (extended_expression = None) E0 with l1=P1; ...; ln=Pn (extended_expression = Some E0)

Invariant: n > 0

If the type is l1: t1; l2: t2 , the expression E0 with t2=P2 is represented as Texp_record fields = [| l1, Kept t1; l2 Override P2 |]; representation; extended_expression = Some E0 alloc_mode is the allocation mode of the record, or None if it is Record_unboxed, in which case it does not need allocation.

# l1=P1; ...; ln=Pn (extended_expression = None) # E0 with l1=P1; ...; ln=Pn (extended_expression = Some E0)

Invariant: n > 0

If the type is # l1: t1; l2: t2 , the expression # E0 with t2=P2 is represented as Texp_record_unboxed_product fields = [| l1, Kept t1; l2 Override P2 |]; representation; extended_expression = Some E0

• The sort is the sort of the whole record (which may be non-value if the record is @

  @unboxed

  ).

• texp_field_boxing provides extra information depending on if the projection requires boxing.

alloc_mode translates to the modify_mode of the record

let open! M in e

overwrite_ exp with exp

_

Tparam_pat p is a non-optional argument with pattern p.

Tparam_optional_default (p, e, sort) is an optional argument p with default value e, i.e. ?x:(p = e). If the parameter is of type a option, the pattern and expression are of type a. sort is the sort of e.

The function body binds a final argument in Tfunction_cases, and this argument is pattern-matched against the cases.

The module type constraint has been synthesized during typechecking.

The module type was in the source file.

ME (constraint = Tmodtype_implicit) (ME : MT) (constraint = Tmodtype_explicit MT)

External declaration coerced to a regular value.

  module M : sig val ext : a -> b end =
  struct external ext : a -> b = "my_c_function" end

Only occurs inside a Tcoerce_structure coercion.

Module alias coerced to a regular module.

  module M : sig module Sub : T end =
  struct module Sub = Some_alias end

Only occurs inside a Tcoerce_structure coercion.

Ttyp_call_pos represents the type of the value of a Position argument (lbl:[%call_pos] -> ...).

item_declaration groups together items that correspond to the syntactic category of "declarations" which include types, values, modules, etc. declarations in signatures and their definitions in implementations.