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 =
| Ambiguous of Catala_utils.Pos.t list
| Unique of Shared_ast.RuleName.t Catala_utils.Mark.pos
type scope_def_context = {
default_exception_rulename : unique_rulename option;
label_idmap : Shared_ast.LabelName.t Shared_ast.IdentName.Map.t;
}
type scope_var_or_subscope =
| ScopeVar of Shared_ast.ScopeVar.t
| SubScope of Shared_ast.SubScopeName.t * Shared_ast.ScopeName.t
type scope_context = {
var_idmap : scope_var_or_subscope Shared_ast.IdentName.Map.t;(*

All variables, including scope variables and subscopes

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

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

*)
sub_scopes : Shared_ast.ScopeName.Set.t;(*

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

*)
}

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 = {
var_sig_typ : Shared_ast.typ;
var_sig_is_condition : bool;
var_sig_parameters : (Catala_utils.Uid.MarkedString.info * Shared_ast.typ) list Catala_utils.Mark.pos option;
var_sig_io : Surface.Ast.scope_decl_context_io;
var_sig_states_idmap : Shared_ast.StateName.t Shared_ast.IdentName.Map.t;
var_sig_states_list : Shared_ast.StateName.t list;
}
type typedef =
| TStruct of Shared_ast.StructName.t
| TEnum of Shared_ast.EnumName.t
| TScope of Shared_ast.ScopeName.t * Shared_ast.scope_out_struct(*

Implicitly defined output struct

*)

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

type context = {
local_var_idmap : Ast.expr Shared_ast.Var.t Shared_ast.IdentName.Map.t;(*

Inside a definition, local variables can be introduced by functions arguments or pattern matching

*)
typedefs : typedef Shared_ast.IdentName.Map.t;(*

Gathers the names of the scopes, structs and enums

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

The names of the struct fields. Names of fields can be shared between different structs

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

The names of the enum constructors. Constructor names can be shared between different enums

*)
scopes : scope_context Shared_ast.ScopeName.Map.t;(*

For each scope, its context

*)
topdefs : Shared_ast.TopdefName.t Shared_ast.IdentName.Map.t;(*

Global definitions

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

For each struct, its context

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

For each enum, its context

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

The signatures of each scope variable declared

*)
}

Main 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.IdentName.t Catala_utils.Mark.pos -> 'a

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

Gets the type associated to an uid

val is_var_cond : context -> Shared_ast.ScopeVar.t -> bool

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.IdentName.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 get_def_typ : context -> Ast.ScopeDef.t -> Shared_ast.typ

Retrieves the type of a scope definition from the context

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

Adds a binding to the context

Usage: get_def_key var_name var_state scope_uid ctxt pos

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

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

Convert a surface base type to an AST type

API

val form_context : Surface.Ast.program -> context

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