Utility methods to support the translation of clang ast constructs into sil instructions.

`type continuation````=` `{`

`break : InferIR.Procdesc.Node.t list;`
`continue : InferIR.Procdesc.Node.t list;`
`return_temp : bool;` | (** true if temps should not be removed in the node but returned to ancestors *)

`}```
`type priority_node````=`

`|` `Free`
`|` `Busy of InferGenerated.Clang_ast_t.pointer`

``
`type trans_state````=` `{`

`context : InferModules.CContext.t;` | (** current context of the translation *)
`succ_nodes : InferIR.Procdesc.Node.t list;` | (** successor nodes in the cfg *)
`continuation : continuation option;` | (** current continuation *)
`priority : priority_node;`
`var_exp_typ : (InferIR.Exp.t * InferIR.Typ.t) option;`
`opaque_exp : (InferIR.Exp.t * InferIR.Typ.t) option;`
`is_fst_arg_objc_method_call : bool;`

`}```

A translation state. It provides the translation function with the info it needs to carry on the translation.

`val default_trans_state : InferModules.CContext.t ‑> trans_state`
`type control````=` `{`

`root_nodes : InferIR.Procdesc.Node.t list;` | (** Top cfg nodes (root) created by the translation *)
`leaf_nodes : InferIR.Procdesc.Node.t list;` | (** Bottom cfg nodes (leaf) created by the translate *)
`instrs : InferIR.Sil.instr list;` | (** list of SIL instruction that need to be placed in cfg nodes of the parent *)
`initd_exps : InferIR.Exp.t list;` | (** list of expressions that are initialised by the instructions *)

`}```

Part of the translation result that is (loosely) related to control flow graph construction. More importantly, this is the part of a `trans_result` that some internal translation functions work on when constructing a `trans_result` before the other components of the translation result are available (such as the return expression). This is made into a separate type to make intermediate computations easier to write and easier to typecheck.

`type trans_result````=` `{`

`control : control;`
`return : InferIR.Exp.t * InferIR.Typ.t;` | (** value returned by the translated statement *)
`method_name : InferIR.Typ.Procname.t option;` | (** in the specific case of translating a method call in C++, we get the method name called at the same time we get the `this` object that contains the method. The `this` instance object is returned as the `return` field, while the method to call is filled in here. This field is `None` in all other cases. *)
`is_cpp_call_virtual : bool;`

`}```

A translation result. It is returned by the translation function.

`val empty_control : control`
`val mk_trans_result : ?⁠method_name:InferIR.BuiltinDecl.t ‑> ?⁠is_cpp_call_virtual:bool ‑> (InferIR.Exp.t * InferIR.Typ.typ) ‑> control ‑> trans_result`
`val undefined_expression : unit ‑> InferIR.Exp.t`
`val collect_controls : InferIR.Procdesc.t ‑> control list ‑> control`

Collect the results of translating a list of instructions, and link up the nodes created.

`val collect_trans_results : InferIR.Procdesc.t ‑> return:(InferIR.Exp.t * InferIR.Typ.t) ‑> trans_result list ‑> trans_result`
`val is_return_temp : continuation option ‑> bool`
`val mk_cond_continuation : continuation option ‑> continuation option`
`val define_condition_side_effects : (InferIR.Exp.t * InferIR.Typ.t) ‑> InferIR.Sil.instr list ‑> InferBase.Location.t ‑> (InferIR.Exp.t * InferIR.Typ.t) * InferIR.Sil.instr list`
`val source_range_of_stmt : InferGenerated.Clang_ast_t.stmt ‑> InferGenerated.Clang_ast_t.source_range`
`val extract_stmt_from_singleton : InferGenerated.Clang_ast_t.stmt list ‑> InferGenerated.Clang_ast_t.source_range ‑> string ‑> InferGenerated.Clang_ast_t.stmt`
`val is_null_stmt : InferGenerated.Clang_ast_t.stmt ‑> bool`
`val dereference_value_from_result : ?⁠strip_pointer:bool ‑> InferGenerated.Clang_ast_t.source_range ‑> InferBase.Location.t ‑> trans_result ‑> trans_result`

Given a `trans_result`, create a temporary variable with dereferenced value of an expression assigned to it

`val cast_operation : InferGenerated.Clang_ast_t.cast_kind ‑> (InferIR.Exp.t * InferIR.Typ.t) ‑> InferIR.Typ.t ‑> InferBase.Location.t ‑> InferIR.Sil.instr list * (InferIR.Exp.t * InferIR.Typ.t)`
`val trans_assertion : trans_state ‑> InferBase.Location.t ‑> trans_result`
`val contains_opaque_value_expr : InferGenerated.Clang_ast_t.stmt ‑> bool`
`val builtin_trans : trans_state ‑> InferGenerated.Clang_ast_t.source_range ‑> InferBase.Location.t ‑> trans_result list ‑> InferIR.Typ.Procname.t ‑> trans_result option`
`val cxx_method_builtin_trans : trans_state ‑> InferGenerated.Clang_ast_t.source_range ‑> InferBase.Location.t ‑> trans_result list ‑> InferIR.Typ.Procname.t ‑> trans_result option`
`val new_or_alloc_trans : trans_state ‑> InferBase.Location.t ‑> InferGenerated.Clang_ast_t.stmt_info ‑> InferGenerated.Clang_ast_t.qual_type ‑> InferIR.Typ.Name.t option ‑> string ‑> trans_result`
`val cpp_new_trans : InferBase.Location.t ‑> InferIR.Typ.t ‑> InferIR.Exp.t option ‑> (InferIR.Exp.t * InferIR.Typ.typ) list ‑> trans_result`
`module Nodes : sig ... end`

Module for creating cfg nodes and other utility functions related to them.

`module PriorityNode : sig ... end`

priority_node is used to enforce some kind of policy for creating nodes in the cfg. Certain elements of the AST _must_ create nodes therefore there is no need for them to use priority_node. Certain elements instead need or need not to create a node depending of certain factors. When an element of the latter kind wants to create a node it must claim priority first (like taking a lock). priority can be claimes only when it is free. If an element of AST succedes in claiming priority its id (pointer) is recorded in priority. After an element has finished it frees the priority. In general an AST element E checks if an ancestor has claimed priority. If priority is already claimed E does not have to create a node. If priority is free then it means E has to create the node. Then E claims priority and release it afterward.

`module GotoLabel : sig ... end`

Module for translating goto instructions by keeping a map of labels.

`module Loops : sig ... end`

Module that provides utility functions for translating different types of loops.

`module Scope : sig ... end`

Module that provides utilities for scopes

`module Self : sig ... end`

This module handles the translation of the variable self which is challenging because self is used both as a variable in instance method calls and also as a type in class method calls.

`val is_logical_negation_of_int : InferIR.Tenv.t ‑> InferGenerated.Clang_ast_t.expr_info ‑> InferGenerated.Clang_ast_t.unary_operator_info ‑> bool`
`val mk_fresh_void_exp_typ : unit ‑> InferIR.Exp.t * InferIR.Typ.t`
`val mk_fresh_void_id_typ : unit ‑> InferIR.Ident.t * InferIR.Typ.t`
`val mk_fresh_void_return : unit ‑> (InferIR.Ident.t * InferIR.Typ.t) * (InferIR.Exp.t * InferIR.Typ.t)`
`val last_or_mk_fresh_void_exp_typ : (InferIR.Exp.t * InferIR.Typ.t) list ‑> InferIR.Exp.t * InferIR.Typ.t`