Attributes of a procedure.

`type proc_flags``= (string, string) InferStdlib.IStd.Caml.Hashtbl.t```

flags for a procedure

`include sig ... end`
`val compare_proc_flags : proc_flags ‑> proc_flags ‑> int`
`type clang_method_kind````=`

`|` `CPP_INSTANCE`
`|` `OBJC_INSTANCE`
`|` `CPP_CLASS`
`|` `OBJC_CLASS`
`|` `BLOCK`
`|` `C_FUNCTION`

``
`include sig ... end`
`val compare_clang_method_kind : clang_method_kind ‑> clang_method_kind ‑> int`
`val equal_clang_method_kind : clang_method_kind ‑> clang_method_kind ‑> bool`
`val string_of_clang_method_kind : clang_method_kind ‑> string`
`type objc_accessor_type````=`

`|` `Objc_getter of InferIR.Typ.Struct.field`
`|` `Objc_setter of InferIR.Typ.Struct.field`

``
`include sig ... end`
`val compare_objc_accessor_type : objc_accessor_type ‑> objc_accessor_type ‑> int`
`val kind_of_objc_accessor_type : objc_accessor_type ‑> string`
`type var_attribute````=`

`|` `Modify_in_block`

``
`include sig ... end`
`val compare_var_attribute : var_attribute ‑> var_attribute ‑> int`
`val var_attribute_equal : var_attribute ‑> var_attribute ‑> bool`

Equality for var_attribute

`type var_data````=` `{`

`name : InferIR.Mangled.t;`
`typ : InferIR.Typ.t;`
`attributes : var_attribute list;`

`}```
`include sig ... end`
`val compare_var_data : var_data ‑> var_data ‑> int`
`type t````=` `{`

`access : InferIR.PredSymb.access;` | (** visibility access *)
`captured : (InferIR.Mangled.t * InferIR.Typ.t) list;` | (** name and type of variables captured in blocks *)
`mutable did_preanalysis : bool;` | (** true if we performed preanalysis on the CFG for this proc *)
`err_log : InferIR.Errlog.t;` | (** Error log for the procedure *)
`exceptions : string list;` | (** exceptions thrown by the procedure *)
`formals : (InferIR.Mangled.t * InferIR.Typ.t) list;` | (** name and type of formal parameters *)
`const_formals : int list;` | (** list of indices of formals that are const-qualified *)
`by_vals : int list;` | (** list of indices of formals that are passed by-value *)
`func_attributes : InferIR.PredSymb.func_attribute list;`
`is_abstract : bool;` | (** the procedure is abstract *)
`is_bridge_method : bool;` | (** the procedure is a bridge method *)
`is_defined : bool;` | (** true if the procedure is defined, and not just declared *)
`is_cpp_noexcept_method : bool;` | (** the procedure is an C++ method annotated with "noexcept" *)
`is_java_synchronized_method : bool;` | (** the procedure is a Java synchronized method *)
`is_model : bool;` | (** the procedure is a model *)
`is_specialized : bool;` | (** the procedure is a clone specialized for dynamic dispatch handling *)
`is_synthetic_method : bool;` | (** the procedure is a synthetic method *)
`clang_method_kind : clang_method_kind;` | (** the kind of method the procedure is *)
`loc : InferBase.Location.t;` | (** location of this procedure in the source code *)
`translation_unit : InferBase.SourceFile.t option;` | (** translation unit to which the procedure belongs *)
`mutable locals : var_data list;` | (** name, type and attributes of local variables *)
`method_annotation : InferIR.Annot.Method.t;` | (** annotations for all methods *)
`objc_accessor : objc_accessor_type option;` | (** type of ObjC accessor, if any *)
`proc_flags : proc_flags;` | (** flags of the procedure *)
`proc_name : InferIR.Typ.Procname.t;` | (** name of the procedure *)
`ret_type : InferIR.Typ.t;` | (** return type *)
`source_file_captured : InferBase.SourceFile.t;` | (** source file where the procedure was captured *)

`}```
`include sig ... end`
`val compare : t ‑> t ‑> int`
`val default : InferIR.Typ.Procname.t ‑> t`

Create a proc_attributes with default values.

`val pp : Format.formatter ‑> t ‑> unit`
`module SQLite : InferBase.SqliteUtils.Data with type t = t`