node of the control flow graph

`type t`````

type of nodes

`include sig ... end`
`val compare : t ‑> t ‑> int`
`type id``= private int```

node id

`include sig ... end`
`val compare_id : id ‑> id ‑> int`
`val equal_id : id ‑> id ‑> bool`
`type nodekind````=`

`|` `Start_node of InferIR.Typ.Procname.t`
`|` `Exit_node of InferIR.Typ.Procname.t`
`|` `Stmt_node of string`
`|` `Join_node`
`|` `Prune_node of bool * InferIR.Sil.if_kind * string` | (** (true/false branch, if_kind, comment) *)
`|` `Skip_node of string`

``

kind of cfg node

`include sig ... end`
`val compare_nodekind : nodekind ‑> nodekind ‑> int`
`val equal_nodekind : nodekind ‑> nodekind ‑> bool`
`val exn_handler_kind : nodekind`

kind of Stmt_node for an exception handler.

`val exn_sink_kind : nodekind`

kind of Stmt_node for an exceptions sink.

`val throw_kind : nodekind`

kind of Stmt_node for a throw instruction.

`val add_locals_ret_declaration : t ‑> InferIR.ProcAttributes.t ‑> InferIR.ProcAttributes.var_data list ‑> unit`

Add declarations for local variables and return variable to the node

`val append_instrs : t ‑> InferIR.Sil.instr list ‑> unit`

Append the instructions to the list of instructions to execute

`val d_instrs : sub_instrs:bool ‑> InferIR.Sil.instr option ‑> t ‑> unit`

Dump extended instructions for the node

`val dummy : InferIR.Typ.Procname.t option ‑> t`

Create a dummy node

`val equal : t ‑> t ‑> bool`

Check if two nodes are equal

`val get_description : InferStdlib.Pp.env ‑> t ‑> string`

Return a description of the node

`val get_distance_to_exit : t ‑> int option`

Get the distance to the exit node, if it has been computed

`val get_exn : t ‑> t list`

Get the exception nodes from the current node

`val get_id : t ‑> id`

Get the unique id of the node

`val get_instrs : t ‑> InferIR.Instrs.not_reversed_t`

Get the instructions to be executed

`val get_kind : t ‑> nodekind`

Get the kind of the current node

`val get_last_loc : t ‑> InferBase.Location.t`

Get the source location of the last instruction in the node

`val get_loc : t ‑> InferBase.Location.t`

Get the source location of the node

`val get_preds : t ‑> t list`

Get the predecessor nodes of the current node

`val get_proc_name : t ‑> InferIR.Typ.Procname.t`

Get the name of the procedure the node belongs to

`val get_succs : t ‑> t list`

Get the successor nodes of the current node

`val hash : t ‑> int`

Hash function for nodes

`val pp : Format.formatter ‑> t ‑> unit`

Pretty print the node

`val pp_id : Format.formatter ‑> id ‑> unit`

Pretty print a node id

`val pp_instrs : InferStdlib.Pp.env ‑> sub_instrs:bool ‑> InferIR.Sil.instr option ‑> Format.formatter ‑> t ‑> unit`

Print extended instructions for the node, highlighting the given subinstruction if present