Module Sarek_parse_helpers

Convert ppxlib location to Sarek location

Parse exception

A functor application inside a type path (F(X).t). flatten used to return [] for it, so the type came out named "" — and an unresolvable name is turned into an empty placeholder record by Sarek_types.type_of_type_expr, not into an error.

A labelled or optional argument in an ARROW TYPE. Ptyp_arrow's label used to be read as _, so x:int -> int and int -> int parsed to the same TEArrow — the label was dropped from the type while the corresponding parameter is refused outright by collect_fun_params.

Parse a core_type to type_expr.

The final arm refuses rather than returning a placeholder: it used to answer TEConstr ("unknown", []) for every core_type shape not listed, and Sarek_types.type_of_type_expr maps an unrecognised constructor to TRecord (name, []) — an empty record type. So an annotation the parser could not read became a phantom type named "unknown" that unified with nothing and was reported, if at all, as a type error somewhere else (backlog-192).

A GADT-style constructor declaration (C : int -> t). pcd_res and pcd_vars were never read, so the return type and the existential binders were dropped and the constructor was recorded as if it had been written C of int — for a parameterised type that is a different declaration.

Extract type annotation from a Ppxlib pattern if present

An as alias in a BINDER position (let (p as x) = e, fun (p as x) ->). extract_name_from_pattern used to answer the alias name and throw the inner pattern away, so every name p bound was silently absent from the kernel environment and surfaced later as an unbound variable — pointing at the USE, not at the alias.

let x :> t = e — a coercion on a binding.

let f : type a. ... — a locally abstract type on a binding.

The declared type of a let binding, from EITHER spelling.

let (x : t) = e puts the annotation in the PATTERN (Ppat_constraint). let x : t = e — the spelling almost everything in this tree uses — puts it in pvb_constraint instead, and that field was never read: the annotation was silently dropped, so a kernel-local let sum : float = ... was typed by inference with the declared width ignored, and an annotated module constant was dropped entirely by Sarek_parse.parse_payload for want of a type (backlog-192).

Both are read here, pattern first.

Extract variable name from a Ppxlib pattern

Extract parameter from pparam_desc

Existential type binders on a constructor pattern (C (type a) p). The binder list in Ppat_construct's payload was read as _, so the pattern parsed as the plain C p and the locally abstract type simply was not there.

Parse a Ppxlib pattern to Sarek pattern

Parse a binary operator

Parse a unary operator

A coercion in a function's return position (fun x :> t -> e).

An annotation with fewer arrows than the function has parameters. Shared between the two places that put a declared type into a RESULT slot.

Strip n leading arrows off a type, or None if it has fewer than n.

The declared RESULT type of a function expression, if it has one.

Pexp_function's type_constraint option slot is where OCaml >= 5.1 puts the : t of let f (x : int32) : int32 = ... — NOT in the pattern. It was read as _ by collect_fun_params, so every kernel helper's declared return type was silently discarded and the helper's result type came from inference alone (backlog-192).

EVERY Pexp_function on the way down is inspected, not just the outermost. An earlier revision of this function read only the outermost and justified it by saying a nested one "belongs to that inner function and not to the binding" — which is false, because collect_fun_params below DESCENDS through Pfunction_body and merges the inner function's parameters into the binding's list. After that flattening there is no inner function left for the annotation to belong to, and let f (x : int32) = fun (y : int32) : float32 -> ... had its float32 dropped while the flattened spelling of the same function had it honoured. Measured: the two spellings compiled to different verdicts, exit 0 versus a unification error.

The LAST constraint on the way down wins, and it is peeled by the number of parameters collected AFTER it — because a constraint sitting above further parameters describes a FUNCTION type, not the flattened result. let f (x : int32) : (int32 -> int32) = fun (y : int32) -> y therefore yields int32, not the arrow. Too few arrows is refused rather than half-applied.