Module Desugared.Name_resolution

Builds a context that allows for mapping each name to a precise uid, taking lexical scopes into account

Name resolution context

type unique_rulename =
  1. | Ambiguous of Catala_utils.Pos.t list
  2. | Unique of Shared_ast.RuleName.t Catala_utils.Mark.pos
type scope_def_context = {
  1. default_exception_rulename : unique_rulename option;
  2. label_idmap : Shared_ast.LabelName.t Shared_ast.Ident.Map.t;
}
type scope_context = {
  1. var_idmap : Shared_ast.scope_var_or_subscope Shared_ast.Ident.Map.t;
    (*

    All variables, including scope variables and subscopes

    *)
  2. scope_defs_contexts : scope_def_context Ast.ScopeDef.Map.t;
    (*

    What is the default rule to refer to for unnamed exceptions, if any

    *)
  3. scope_in_struct : Shared_ast.StructName.t;
  4. scope_out_struct : Shared_ast.StructName.t;
  5. sub_scopes : Shared_ast.ScopeName.Set.t;
    (*

    Other scopes referred to by this scope. Used for dependency analysis

    *)
  6. scope_visibility : Shared_ast.visibility;
}

Inside a scope, we distinguish between the variables and the subscopes.

Types of the fields of a struct

Types of the payloads of the cases of an enum

type var_sig = {
  1. var_sig_typ : Shared_ast.typ;
  2. var_sig_is_condition : bool;
  3. var_sig_parameters : (Catala_utils.Uid.MarkedString.info * Shared_ast.typ) list Catala_utils.Mark.pos option;
  4. var_sig_io : Surface.Ast.scope_decl_context_io;
  5. var_sig_states_idmap : Shared_ast.StateName.t Shared_ast.Ident.Map.t;
  6. var_sig_states_list : Shared_ast.StateName.t list;
}
type typedef =
  1. | TStruct of Shared_ast.StructName.t
  2. | TEnum of Shared_ast.EnumName.t
  3. | TScope of Shared_ast.ScopeName.t * Shared_ast.scope_info
    (*

    Implicitly defined output struct

    *)

Capitalised type names share a namespace on the user side, but may correspond to only one of the following

type module_context = {
  1. current_module : Shared_ast.ModuleName.t option;
    (*

    The current path being processed. Used for generating the Uids.

    *)
  2. typedefs : typedef Shared_ast.Ident.Map.t;
    (*

    Gathers the names of the scopes, structs and enums

    *)
  3. field_idmap : Shared_ast.StructField.t Shared_ast.StructName.Map.t Shared_ast.Ident.Map.t;
    (*

    The names of the struct fields. Names of fields can be shared between different structs. Note that fields from submodules are included here for the root module, because disambiguating there is helpful.

    *)
  4. constructor_idmap : Shared_ast.EnumConstructor.t Shared_ast.EnumName.Map.t Shared_ast.Ident.Map.t;
    (*

    The names of the enum constructors. Constructor names can be shared between different enums. Note that constructors from its submodules are included here for the root module, because disambiguating there is helpful.

    *)
  5. topdefs : Shared_ast.TopdefName.t Shared_ast.Ident.Map.t;
    (*

    Global definitions

    *)
  6. used_modules : Shared_ast.ModuleName.t Shared_ast.Ident.Map.t;
    (*

    Module aliases and the modules they point to

    *)
  7. is_external : bool;
}

Context for name resolution, valid within a given module

type context = {
  1. scopes : scope_context Shared_ast.ScopeName.Map.t;
    (*

    For each scope, its context

    *)
  2. topdefs : (Shared_ast.typ * Shared_ast.visibility) Shared_ast.TopdefName.Map.t;
    (*

    Types associated with the global definitions

    *)
  3. structs : (struct_context * Shared_ast.visibility) Shared_ast.StructName.Map.t;
    (*

    For each struct, its context

    *)
  4. enums : (enum_context * Shared_ast.visibility) Shared_ast.EnumName.Map.t;
    (*

    For each enum, its context

    *)
  5. var_typs : var_sig Shared_ast.ScopeVar.Map.t;
    (*

    The signatures of each scope variable declared

    *)
  6. modules : module_context Shared_ast.ModuleName.Map.t;
    (*

    The map to the interfaces of all modules (transitively) used by the program. References are made through local.used_modules

    *)
  7. local : module_context;
    (*

    Local context of the root module corresponding to the program being analysed

    *)
}

Global context used throughout Surface.Desugaring

Helpers

val raise_unsupported_feature : string -> Catala_utils.Pos.t -> 'a

Temporary function raising an error message saying that a feature is not supported yet

val raise_unknown_identifier : string -> Shared_ast.Ident.t Catala_utils.Mark.pos -> 'a

Function to call whenever an identifier used somewhere has not been declared in the program previously

Emits a user error if the module name is not found

Emits a user error if the module name is not found

Gets the type associated to an uid

val is_var_cond : context -> Shared_ast.ScopeVar.t -> bool
val get_scope_context : context -> Shared_ast.ScopeName.t -> scope_context

Get the corresponding scope context from the context, looking up into nested submodules as necessary, following the path information in the scope name

Get the variable uid inside the scope given in argument

Get the subscope uid inside the scope given in argument

val is_subscope_uid : Shared_ast.ScopeName.t -> context -> Shared_ast.Ident.t -> bool

is_subscope_uid scope_uid ctxt y returns true if y belongs to the subscopes of scope_uid.

Checks if the var_uid belongs to the scope scope_uid

val is_def_cond : context -> Ast.ScopeDef.t -> bool
val is_type_cond : Surface.Ast.typ -> bool

Usage: get_def_key var_name var_state scope_uid ctxt pos

val surface_rule_to_def : Surface.Ast.rule -> Surface.Ast.definition

Translates a Surface.rule into the corresponding Surface.definition

Find an enum definition from the typedefs, failing if there is none or it has a different kind

Find a struct definition from the typedefs (possibly an implicit output struct from a scope), failing if there is none or it has a different kind

Find a scope definition from the typedefs, failing if there is none or it has a different kind

Returns the context corresponding to the given module path; raises a user error if the module is not found

val process_type : context -> Surface.Ast.typ -> Shared_ast.typ

Convert a surface base type to an AST type

API

Derive the context from metadata, in one pass over the declarations