Unit_info (melange.Melange_compiler_libs.Unit

Module name convention and computation

type modname = string;

type filename = string;

type file_prefix = string;

let modulize: string => modname;

modulize s capitalizes the first letter of s.

let normalize: string => string;

normalize s uncapitalizes the first letter of s.

let modname_from_source: filename => modname;

modname_from_source filename is modulize stem where stem is the basename of the filename filename stripped from all its extensions. For instance, modname_from_source "/pa.th/x.ml.pp" is "X".

Module name validation function

let is_unit_name: modname => bool;

is_unit_name ~strict name is true only if name can be used as a valid module name.

Metadata for compilation unit

type t;

Metadata for a compilation unit:

the module name associated to the unit
the filename prefix (dirname + basename with all extensions stripped) for compilation artifacts
the input source file For instance, when calling ocamlopt dir/x.mli -o target/y.cmi,
the input source file is dir/x.mli
the module name is Y
the prefix is target/y

let source_file: t => filename;

source_file u is the source file of u.

let prefix: t => file_prefix;

prefix u is the filename prefix of the unit.

let modname: t => modname;

modname u or artifact_modname a is the module name of the unit or compilation artifact.

let check_unit_name: t => unit;

check_unit_name u prints a warning if the derived module name modname u should not be used as a module name as specified by is_unit_name ~strict:true.

let make: ?check_modname:bool => source_file:filename => file_prefix => t;

make ~check ~source_file prefix associates both the source_file and the module name modname_from_source target_prefix to the prefix filesystem path prefix.

If check_modname=true, this function emits a warning if the derived module name is not valid according to check_unit_name.

module Artifact: { ... };

Derived build artifact metadata

let cmi: t => Artifact.t;

Those functions derive a specific artifact metadata from an unit metadata.

let cmo: t => Artifact.t;

let cmx: t => Artifact.t;

let obj: t => Artifact.t;

let cmt: t => Artifact.t;

let cmti: t => Artifact.t;

let annot: t => Artifact.t;

let companion_obj: Artifact.t => Artifact.t;

The functions below change the type of an artifact by updating the extension of its filename. Those functions purposefully do not cover all artifact kinds because we want to track which artifacts are assumed to be bundled together.

let companion_cmt: Artifact.t => Artifact.t;

let companion_cmi: Artifact.t => Artifact.t;

Beware that companion_cmi a strips all extensions from the filename of a before adding the ".cmi" suffix contrarily to the other functions which only remove the rightmost extension. In other words, the companion cmi of a file something.d.cmo is something.cmi and not something.d.cmi.

Mli and cmi derived from implementation files

The compilation of module implementation changes in presence of mli and cmi files, the function belows help to handle this.

let mli_from_source: t => filename;

mli_from_source u is the interface source filename associated to the unit u. The actual suffix depends on Config.interface_suffix.

let mli_from_artifact: Artifact.t => filename;

mli_from_artifact t is the name of the interface source file derived from the artifact t. This variant is necessary when handling artifacts derived from an unknown source files (e.g. packed modules).

let is_cmi: Artifact.t => bool;

Check if the artifact is a cmi

let find_normalized_cmi: t => Artifact.t;

find_normalized_cmi u finds in the load_path a file matching the module name modname u.

raises Not_found
if no such cmi exists