jon.recoil.org

Module Ocaml_typing.PrinttypSource

Sourceval namespaced_ident : Shape.Sig_component_kind.t -> Ident.t -> string
Sourceval tree_of_path : Path.t -> Outcometree.out_ident
Sourceval string_of_path : Path.t -> string

Print a type path taking account of -short-paths. Calls should be within wrap_printing_env.

Sourcemodule Out_name : sig ... end
type namespace := Shape.Sig_component_kind.t option
Sourceval strings_of_paths : namespace -> Path.t list -> string list

Print a list of paths, using the same naming context to avoid name collisions

Sourceval string_of_label : Types.arg_label -> string
Sourceval wrap_printing_env : ?error:bool -> Env.t -> (unit -> 'a) -> 'a
Sourceval shorten_type_path : Env.t -> Path.t -> Path.t
Sourceval shorten_module_type_path : Env.t -> Path.t -> Path.t
Sourceval shorten_module_path : Env.t -> Path.t -> Path.t
Sourceval shorten_class_type_path : Env.t -> Path.t -> Path.t
Sourcemodule Naming_context : sig ... end
Sourcemodule Conflicts : sig ... end

The Conflicts module keeps track of conflicts arising when attributing names to identifiers and provides functions that can print explanations for these conflict in error messages

Sourceval reset : unit -> unit

Print out a type. This will pick names for type variables, and will not reuse names for common type variables shared across multiple type expressions. (It will also reset the printing state, which matters for other type formatters such as prepared_type_expr.) If you want multiple types to use common names for type variables, see prepare_for_printing and prepared_type_expr.

Prints a modality. If it is the identity modality, prints id, which defaults to nothing.

Sourceval prepare_for_printing : Types.type_expr list -> unit

prepare_for_printing resets the global printing environment, a la reset, and prepares the types for printing by reserving names and marking loops. Any type variables that are shared between multiple types in the input list will be given the same name when printed with prepared_type_expr.

Sourceval add_type_to_preparation : Types.type_expr -> unit

add_type_to_preparation ty extend a previous type expression preparation to the type expression ty

The function prepared_type_expr is a less-safe but more-flexible version of type_expr that should only be called on type_exprs that have been passed to prepare_for_printing. Unlike type_expr, this function does no extra work before printing a type; in particular, this means that any loops in the type expression may cause a stack overflow (see #8860) since this function does not mark any loops. The benefit of this is that if multiple type expressions are prepared simultaneously and then printed with prepared_type_expr, they will use the same names for the same type variables.

Sourceval tree_of_type_scheme : Types.type_expr -> Outcometree.out_type

shared_type_scheme is very similar to type_scheme, but does not reset the printing context first. This is intended to be used in cases where the printing should have a particularly wide context, such as documentation generators; most use cases, such as error messages, have narrower contexts for which type_scheme is better suited.

Sourceval type_declaration_for_merlin : print_non_value_inferred_jkind:bool -> Ident.t -> Ocaml_utils.Format_doc.formatter -> Types.type_declaration -> unit

Like type_declaration.

print_non_value_inferred_jkind is a setting controlled by merlin verbosity levels. When it's true, merlin will print the inferred layout annotations on type declarations, except if the layout is value. If the layout is value, a layout is printed in exactly the cases that type_declaration prints a layout.

E.g. When this flag is true, type t = A is printed as type t : immediate = A.

Sourceval type_scheme_for_merlin : print_non_value_jkind_on_type_variables:bool -> Ocaml_utils.Format_doc.formatter -> Types.type_expr -> unit

Like type_scheme.

print_non_value_jkind_on_type_variables is a setting controlled by merlin verbosity levels. When it's true, merlin will print layout annotations for type variables when the layout isn't merely value. The annotations are printed as a comment following the type.

E.g. When this flag is true, 'a -> 'b is printed as:

  'a -> 'b (* 'a : float64 *)

if 'a has layout float64 and 'b has layout value.

Sourceval tree_of_value_description : Ident.t -> Types.value_description -> Outcometree.out_sig_item
Sourceval add_constructor_to_preparation : Types.constructor_declaration -> unit
Sourceval add_type_declaration_to_preparation : Ident.t -> Types.type_declaration -> unit
Sourceval add_extension_constructor_to_preparation : Types.extension_constructor -> unit
Sourceval tree_of_jkind_declaration : Ident.t -> Types.jkind_declaration -> Outcometree.out_sig_item
Sourceval tree_of_modtype : ?abbrev:bool -> Types.module_type -> Outcometree.out_module_type
Sourceval tree_of_modtype_declaration : ?abbrev:bool -> Ident.t -> Types.modtype_declaration -> Outcometree.out_sig_item
Sourceval expand_module_type : (Env.t -> Types.module_type -> Types.module_type) ref
Sourceval functor_parameters : sep:unit Ocaml_utils.Format_doc.printer -> ('b -> Ocaml_utils.Format_doc.formatter -> unit) -> (Ident.t option * 'b) list -> Ocaml_utils.Format_doc.formatter -> unit

Print a list of functor parameters while adjusting the printing environment for each functor argument.

Currently, we are disabling disambiguation for functor argument name to avoid the need to track the moving association between identifiers and syntactic names in situation like:

got: (X: sig module type T end) (Y:X.T) (X:sig module type T end) (Z:X.T) expect: (_: sig end) (Y:X.T) (_:sig end) (Z:X.T)

Sourcetype type_or_scheme =
  1. | Type
  2. | Type_scheme
Sourceval tree_of_signature : Types.signature -> Outcometree.out_sig_item list
Sourcemodule Compat : sig ... end
Sourcemodule Subtype : sig ... end
Sourceval print_items : (Env.t -> Types.signature_item -> 'a option) -> Env.t -> Types.signature_item list -> (Outcometree.out_sig_item * 'a option) list
Sourcetype typobject_repr = {
  1. fields : (string * Types.type_expr) list;
  2. open_row : bool;
}
Sourcetype typvariant_repr = {
  1. fields : (string * bool * Types.type_expr list) list;
  2. name : (Path.t * Types.type_expr list) option;
  3. closed : bool;
  4. present : (string * Types.row_field) list;
  5. all_present : bool;
  6. tags : string list option;
}
Sourceval tree_of_typobject_repr : Types.type_expr -> typobject_repr
Sourceval tree_of_typvariant_repr : Types.row_desc -> typvariant_repr
Sourceval rewrite_double_underscore_paths : Env.t -> Path.t -> Path.t
Sourceval rewrite_double_underscore_longidents : Env.t -> Ocaml_parsing.Longident.t -> Ocaml_parsing.Longident.t
Sourceval printed_signature : string -> Format.formatter -> Types.signature -> unit

printed_signature sourcefile ppf sg print the signature sg of sourcefile with potential warnings for name collisions