Module for Procedure Names.

`module Java : sig ... end`

Type of java procedure names.

`module ObjC_Cpp : sig ... end`
`type c````= private` `{`

`name : QualifiedCppName.t;`
`mangled : string option;`
`template_args : template_spec_info;`

`}```

Type of c procedure names.

`type block_name`````

Type of Objective C block names.

`type t````=`

`|` `Java of Java.t`
`|` `C of c`
`|` `Linters_dummy_method`
`|` `Block of block_name`
`|` `ObjC_Cpp of ObjC_Cpp.t`
`|` `WithBlockParameters of t * block_name list`

``

Type of procedure names. WithBlockParameters is used for creating an instantiation of a method that contains block parameters and it's called with concrete blocks. For example: foo(Block block) (); bar() (my_block) is executed as foo_my_block() (); where foo_my_block is created with WithBlockParameters (foo, `my_block`)

`include sig ... end`
`val compare : t ‑> t ‑> int`
`val block_name_of_procname : t ‑> block_name`
`val equal : t ‑> t ‑> bool`
`module Hash : InferStdlib.IStd.Caml.Hashtbl.S with type Hash.key = t`

Hash tables with proc names as keys.

`module Map : InferStdlib.PrettyPrintable.PPMap with type PPMap.key = t`

Maps from proc names.

`module Set : InferStdlib.PrettyPrintable.PPSet with type PPSet.elt = t`

Sets of proc names.

`module SQLite : sig ... end`
`module SQLiteList : InferBase.SqliteUtils.Data with type t = t list`
`val c : QualifiedCppName.t ‑> string ‑> template_spec_info ‑> c`

Create a C procedure name from plain and mangled name.

`val empty_block : t`

Empty block name.

`val from_string_c_fun : string ‑> t`

Convert a string to a proc name.

`val get_language : t ‑> InferBase.Language.t`

Return the language of the procedure.

`val get_method : t ‑> string`

Return the method/function of a procname.

`val is_objc_block : t ‑> bool`

Return whether the procname is a block procname.

`val hash_pname : t ‑> int`

Hash function for procname.

`val is_c_method : t ‑> bool`

Return true this is an Objective-C/C++ method name.

`val is_clang : t ‑> bool`

Return true if this is a C, C++, or Objective-C procedure name

`val is_constructor : t ‑> bool`

Check if this is a constructor.

`val is_java : t ‑> bool`

Check if this is a Java procedure name.

`val mangled_objc_block : string ‑> t`

Create an objc block name.

`val with_block_parameters : t ‑> block_name list ‑> t`

Create a procedure name instantiated with block parameters from a base procedure name and a list of block procedure names (the arguments).

`val objc_cpp_replace_method_name : t ‑> string ‑> t`
`val is_infer_undefined : t ‑> bool`

Check if this is a special Infer undefined procedure.

`val get_global_name_of_initializer : t ‑> string option`

Return the name of the global for which this procedure is the initializer if this is an initializer, None otherwise.

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

Pretty print a proc name.

`val replace_class : t ‑> Name.t ‑> t`

Replace the class name component of a procedure name. In case of Java, replace package and class name.

`val is_method_in_objc_protocol : t ‑> bool`
`val to_string : t ‑> string`

Convert a proc name to a string for the user to see.

`val to_simplified_string : ?⁠withclass:bool ‑> t ‑> string`

Convert a proc name into a easy string for the user to see in an IDE.

`val hashable_name : t ‑> string`

Print the procedure name in a format suitable for computing the bug hash

`val to_unique_id : t ‑> string`

Convert a proc name into a unique identifier.

`val to_filename : ?⁠crc_only:bool ‑> t ‑> string`

Convert a proc name to a filename or only to its crc.

`val get_qualifiers : t ‑> QualifiedCppName.t`

get qualifiers of C/objc/C++ method/function