[IR] Make template info part of Typename.t, rename Typename to Typ.Name

Reviewed By: jberdine

Differential Revision: D4722070

fbshipit-source-id: 0bf8996
master
Andrzej Kotulski 8 years ago committed by Facebook Github Bot
parent 089600bdcd
commit 42947ea9d9

@ -198,7 +198,7 @@ let load_defined_attributes cache_none::cache_none proc_name =>
corresponds to the class definition. */
let get_correct_type_from_objc_class_name type_name =>
/* ToDo: this function should return a type that includes a reference to the tenv computed by:
let class_method = Typ.Procname.get_default_objc_class_method (Typename.name type_name);
let class_method = Typ.Procname.get_default_objc_class_method (Typ.Name.name type_name);
switch (find_tenv_from_class_of_proc class_method) {
| Some tenv =>
*/

@ -27,7 +27,7 @@ let load_defined_attributes: cache_none::bool => Typ.Procname.t => option ProcAt
/** Given the name of an ObjC class, extract the type from the tenv where the class was defined. We
do this by adding a method that is unique to each class, and then finding the tenv that
corresponds to the class definition. */
let get_correct_type_from_objc_class_name: Typename.t => option Typ.t;
let get_correct_type_from_objc_class_name: Typ.Name.t => option Typ.t;
/* Find the file where the procedure was captured, if a cfg for that file exists.
Return also a boolean indicating whether the procedure is defined in an

@ -23,7 +23,7 @@ let create_procname name =
let create_objc_class_method class_name method_name =
let method_kind = Typ.Procname.ObjCClassMethod in
let tname = Typename.Objc.from_string class_name in
let tname = Typ.Name.Objc.from_string class_name in
let pname = Typ.Procname.ObjC_Cpp
(Typ.Procname.objc_cpp tname method_name method_kind Typ.NoTemplate) in
register pname;

@ -72,7 +72,7 @@ exception Frontend_warning of string * Localise.error_desc * L.ml_loc
exception Checkers of string * Localise.error_desc
exception Inherently_dangerous_function of Localise.error_desc
exception Internal_error of Localise.error_desc
exception Java_runtime_exception of Typename.t * string * Localise.error_desc
exception Java_runtime_exception of Typ.Name.t * string * Localise.error_desc
exception Leak of
bool * Sil.hpred * (visibility * Localise.error_desc)
* bool * PredSymb.resource * L.ml_loc
@ -209,7 +209,7 @@ let recognize_exception exn =
(Localise.from_string "Invalid_argument",
desc, None, Exn_system, Low, None, Nocat)
| Java_runtime_exception (exn_name, _, desc) ->
let exn_str = Typename.name exn_name in
let exn_str = Typ.Name.name exn_name in
(Localise.from_string exn_str, desc, None, Exn_user, High, None, Prover)
| Leak (fp_part, _, (exn_vis, error_desc), done_array_abstraction, resource, ml_loc) ->
if done_array_abstraction

@ -67,7 +67,7 @@ exception Checkers of string * Localise.error_desc
exception Frontend_warning of string * Localise.error_desc * Logging.ml_loc
exception Inherently_dangerous_function of Localise.error_desc
exception Internal_error of Localise.error_desc
exception Java_runtime_exception of Typename.t * string * Localise.error_desc
exception Java_runtime_exception of Typ.Name.t * string * Localise.error_desc
exception Leak of
bool * Sil.hpred * (visibility * Localise.error_desc)
* bool * PredSymb.resource * Logging.ml_loc

@ -304,7 +304,7 @@ let rec format_typ = function
| Typ.Tptr (typ, _) when Config.curr_language_is Config.Java ->
format_typ typ
| Typ.Tstruct name ->
Typename.name name
Typ.Name.name name
| typ ->
Typ.to_string typ
@ -465,7 +465,7 @@ let deref_str_uninitialized alloc_att_opt =
let java_unchecked_exn_desc proc_name exn_name pre_str : error_desc =
{ no_desc with descriptions = [
Typ.Procname.to_string proc_name;
"can throw " ^ (Typename.name exn_name);
"can throw " ^ (Typ.Name.name exn_name);
"whenever " ^ pre_str];
}
@ -744,8 +744,8 @@ let desc_leak hpred_type_opt value_str_opt resource_opt resource_action_opt loc
s, " to ", " on " in
let typ_str =
match hpred_type_opt with
| Some (Exp.Sizeof (Tstruct (TN_csu (Class _, _) as name), _, _)) ->
" of type " ^ Typename.name name ^ " "
| Some (Exp.Sizeof (Tstruct (TN_csu (Class _, _, _) as name), _, _)) ->
" of type " ^ Typ.Name.name name ^ " "
| _ -> " " in
let desc_str =
match resource_opt with

@ -249,7 +249,7 @@ val desc_buffer_overrun : string -> string -> error_desc
val desc_null_test_after_dereference : string -> int -> Location.t -> error_desc
val java_unchecked_exn_desc : Typ.Procname.t -> Typename.t -> string -> error_desc
val java_unchecked_exn_desc : Typ.Procname.t -> Typ.Name.t -> string -> error_desc
val desc_context_leak :
Typ.Procname.t -> Typ.t -> Ident.fieldname ->

@ -210,7 +210,7 @@ struct
is_core_lib lib styp
| Typ.Tstruct name ->
let core_lib_types = core_lib_to_type_list lib in
List.mem ~equal:String.equal core_lib_types (Typename.name name)
List.mem ~equal:String.equal core_lib_types (Typ.Name.name name)
| _ -> false
let is_core_foundation_type typ =

@ -19,12 +19,12 @@ let list_to_string list =>
if (Int.equal (List.length list) 0) {
"( sub )"
} else {
"- {" ^ String.concat sep::", " (List.map f::Typename.name list) ^ "}"
"- {" ^ String.concat sep::", " (List.map f::Typ.Name.name list) ^ "}"
};
type t' =
| Exact /** denotes the current type only */
| Subtypes (list Typename.t)
| Subtypes (list Typ.Name.t)
[@@deriving compare];
let equal_modulo_flag (st1, _) (st2, _) => [%compare.equal : t'] st1 st2;
@ -56,17 +56,16 @@ let max_result res1 res2 =>
res1
};
let is_interface tenv (class_name: Typename.t) =>
let is_interface tenv (class_name: Typ.Name.t) =>
switch (class_name, Tenv.lookup tenv class_name) {
| (TN_csu (Class Java) _, Some {fields: [], methods: []}) => true
| (TN_csu (Class Java) _ _, Some {fields: [], methods: []}) => true
| _ => false
};
let is_root_class class_name =>
switch class_name {
| Typename.TN_csu (Csu.Class Csu.Java) _ =>
Typename.equal class_name Typename.Java.java_lang_object
| Typename.TN_csu (Csu.Class Csu.CPP) _ => false
| Typ.TN_csu (Csu.Class Csu.Java) _ _ => Typ.Name.equal class_name Typ.Name.Java.java_lang_object
| Typ.TN_csu (Csu.Class Csu.CPP) _ _ => false
| _ => false
};
@ -85,7 +84,7 @@ let check_subclass_tenv tenv c1 c2 :result => {
}
}
and check cn :result =>
if (Typename.equal cn c2) {
if (Typ.Name.equal cn c2) {
Yes
} else {
switch (Tenv.lookup tenv cn) {
@ -103,7 +102,7 @@ let check_subclass_tenv tenv c1 c2 :result => {
let module SubtypesMap = Caml.Map.Make {
/* pair of subtypes */
type t = (Typename.t, Typename.t) [@@deriving compare];
type t = (Typ.Name.t, Typ.Name.t) [@@deriving compare];
};
let check_subtype = {
@ -168,7 +167,7 @@ let join (s1, flag1) (s2, flag2) => {
switch (s1, s2) {
| (Exact, _) => s2
| (_, Exact) => s1
| (Subtypes l1, Subtypes l2) => Subtypes (list_intersect Typename.equal l1 l2)
| (Subtypes l1, Subtypes l2) => Subtypes (list_intersect Typ.Name.equal l1 l2)
};
let flag = join_flag flag1 flag2;
(s, flag)
@ -177,7 +176,7 @@ let join (s1, flag1) (s2, flag2) => {
let update_flag c1 c2 flag flag' =>
switch flag {
| INSTOF =>
if (Typename.equal c1 c2) {
if (Typ.Name.equal c1 c2) {
flag
} else {
flag'
@ -205,7 +204,7 @@ let normalize_subtypes t_opt c1 c2 flag1 flag2 => {
| Some t =>
switch t {
| Exact => Some (t, new_flag)
| Subtypes l => Some (Subtypes (List.sort cmp::Typename.compare l), new_flag)
| Subtypes l => Some (Subtypes (List.sort cmp::Typ.Name.compare l), new_flag)
}
| None => None
}
@ -220,7 +219,7 @@ let subtypes_to_string t =>
/* c is a subtype when it does not appear in the list l of no-subtypes */
let no_subtype_in_list tenv c l => not (List.exists f::(is_known_subtype tenv c) l);
let is_strict_subtype tenv c1 c2 => is_known_subtype tenv c1 c2 && not (Typename.equal c1 c2);
let is_strict_subtype tenv c1 c2 => is_known_subtype tenv c1 c2 && not (Typ.Name.equal c1 c2);
/* checks for redundancies when adding c to l
Xi in A - { X1,..., Xn } is redundant in two cases:
@ -329,13 +328,13 @@ let case_analysis_basic tenv (c1, st) (c2, (_, flag2)) => {
} else if (is_known_subtype tenv c2 c1) {
switch st {
| (Exact, _) =>
if (Typename.equal c1 c2) {
if (Typ.Name.equal c1 c2) {
(Some st, None)
} else {
(None, Some st)
}
| (Subtypes _, _) =>
if (Typename.equal c1 c2) {
if (Typ.Name.equal c1 c2) {
(Some st, None)
} else {
(Some st, Some st)

@ -35,21 +35,21 @@ let join: t => t => t;
[case_analysis] returns a pair:
- whether [st1] and [st2] admit [c1 <: c2], and in case returns the updated subtype [st1]
- whether [st1] and [st2] admit [not(c1 <: c2)], and in case returns the updated subtype [st1] */
let case_analysis: Tenv.t => (Typename.t, t) => (Typename.t, t) => (option t, option t);
let case_analysis: Tenv.t => (Typ.Name.t, t) => (Typ.Name.t, t) => (option t, option t);
/** [is_known_subtype tenv c1 c2] returns true if there is enough information in [tenv] to prove
that [c1] is a subtype of [c2].
Note that [not (is_known_subtype tenv c1 c2) == true] does not imply
that [is_known_not_subtype tenv c1 c2 == true] */
let is_known_subtype: Tenv.t => Typename.t => Typename.t => bool;
let is_known_subtype: Tenv.t => Typ.Name.t => Typ.Name.t => bool;
/** [is_known_not_subtype tenv c1 c2] returns true if there is enough information in [tenv] to prove
that [c1] is not a subtype of [c2].
Note that [not (is_known_not_subtype tenv c1 c2) == true] does not imply
that [is_known_subtype tenv c1 c2 == true] */
let is_known_not_subtype: Tenv.t => Typename.t => Typename.t => bool;
let is_known_not_subtype: Tenv.t => Typ.Name.t => Typ.Name.t => bool;
let subtypes_to_string: t => string;

@ -15,8 +15,8 @@ let module Hashtbl = Caml.Hashtbl;
/** Hash tables on strings. */
let module TypenameHash = Hashtbl.Make {
type t = Typename.t;
let equal tn1 tn2 => Typename.equal tn1 tn2;
type t = Typ.Name.t;
let equal tn1 tn2 => Typ.Name.equal tn1 tn2;
let hash = Hashtbl.hash;
};
@ -28,7 +28,7 @@ let pp fmt (tenv: t) =>
TypenameHash.iter
(
fun name typ => {
Format.fprintf fmt "@[<6>NAME: %s@." (Typename.to_string name);
Format.fprintf fmt "@[<6>NAME: %s@." (Typ.Name.to_string name);
Format.fprintf fmt "@[<6>TYPE: %a@." (Typ.Struct.pp Pp.text name) typ
}
)
@ -74,13 +74,13 @@ let lookup tenv name :option Typ.Struct.t =>
try (Some (TypenameHash.find tenv name)) {
| Not_found =>
/* ToDo: remove the following additional lookups once C/C++ interop is resolved */
switch (name: Typename.t) {
| TN_csu Struct m =>
try (Some (TypenameHash.find tenv (TN_csu (Class CPP) m))) {
switch (name: Typ.Name.t) {
| TN_csu Struct m templ =>
try (Some (TypenameHash.find tenv (TN_csu (Class CPP) m templ))) {
| Not_found => None
}
| TN_csu (Class CPP) m =>
try (Some (TypenameHash.find tenv (TN_csu Struct m))) {
| TN_csu (Class CPP) m templ =>
try (Some (TypenameHash.find tenv (TN_csu Struct m templ))) {
| Not_found => None
}
| _ => None

@ -14,7 +14,7 @@ type t; /** Type for type environment. */
/** Add a (name,typename) pair to the global type environment. */
let add: t => Typename.t => Typ.Struct.t => unit;
let add: t => Typ.Name.t => Typ.Struct.t => unit;
/** Create a new type environment. */
@ -22,11 +22,11 @@ let create: unit => t;
/** Fold a function over the elements of the type environment. */
let fold: (Typename.t => Typ.Struct.t => 'a => 'a) => t => 'a => 'a;
let fold: (Typ.Name.t => Typ.Struct.t => 'a => 'a) => t => 'a => 'a;
/** iterate over a type environment */
let iter: (Typename.t => Typ.Struct.t => unit) => t => unit;
let iter: (Typ.Name.t => Typ.Struct.t => unit) => t => unit;
/** Load a type environment from a file */
@ -34,7 +34,7 @@ let load_from_file: DB.filename => option t;
/** Look up a name in the global type environment. */
let lookup: t => Typename.t => option Typ.Struct.t;
let lookup: t => Typ.Name.t => option Typ.Struct.t;
/** Construct a struct_typ, normalizing field types */
@ -44,15 +44,15 @@ let mk_struct:
fields::Typ.Struct.fields? =>
statics::Typ.Struct.fields? =>
methods::list Typ.Procname.t? =>
supers::list Typename.t? =>
supers::list Typ.Name.t? =>
annots::Annot.Item.t? =>
specialization::Typ.template_spec_info? =>
Typename.t =>
Typ.Name.t =>
Typ.Struct.t;
/** Check if typename is found in t */
let mem: t => Typename.t => bool;
let mem: t => Typ.Name.t => bool;
/** print a type environment */

@ -131,8 +131,15 @@ let module T = {
| Tvoid /** void type */
| Tfun bool /** function type with noreturn attribute */
| Tptr t ptr_kind /** pointer type */
| Tstruct Typename.t /** structured value type name */
| Tstruct name /** structured value type name */
| Tarray t static_length /** array type with statically fixed length */
[@@deriving compare]
and name =
| TN_csu Csu.t Mangled.t template_spec_info
[@@deriving compare]
and template_spec_info =
| NoTemplate
| Template (string, list (option t))
[@@deriving compare];
let equal = [%compare.equal : t];
let hash = Hashtbl.hash;
@ -140,6 +147,57 @@ let module T = {
include T;
let module Name = {
type t = name [@@deriving compare];
let equal = [%compare.equal : t];
let to_string =
fun
| TN_csu csu name _ => Csu.name csu ^ " " ^ Mangled.to_string name;
let pp f typename => F.fprintf f "%s" (to_string typename);
let name =
fun
| TN_csu _ name _ => Mangled.to_string name;
let from_string_kind class_kind class_name_str =>
TN_csu (Csu.Class class_kind) (Mangled.from_string class_name_str) NoTemplate;
let is_class_kind class_kind =>
fun
| TN_csu (Class kind) _ _ when Csu.equal_class_kind class_kind kind => true
| _ => false;
let module C = {
let from_string name_str => TN_csu Csu.Struct (Mangled.from_string name_str) NoTemplate;
let union_from_string name_str => TN_csu Csu.Union (Mangled.from_string name_str) NoTemplate;
};
let module Java = {
let from_string = from_string_kind Csu.Java;
let from_package_class package_name class_name =>
if (String.equal package_name "") {
from_string class_name
} else {
from_string (package_name ^ "." ^ class_name)
};
let is_class = is_class_kind Csu.Java;
let java_lang_object = from_string "java.lang.Object";
let java_io_serializable = from_string "java.io.Serializable";
let java_lang_cloneable = from_string "java.lang.Cloneable";
};
let module Cpp = {
let from_string = from_string_kind Csu.CPP;
let from_template_string template_spec_info name =>
TN_csu (Csu.Class Csu.CPP) (Mangled.from_string name) template_spec_info;
let is_class = is_class_kind Csu.CPP;
};
let module Objc = {
let from_string = from_string_kind Csu.Objc;
let protocol_from_string name_str =>
TN_csu Csu.Protocol (Mangled.from_string name_str) NoTemplate;
let is_class = is_class_kind Csu.Objc;
};
let module Set = Caml.Set.Make {
type nonrec t = t;
let compare = compare;
};
};
/** {2 Sets and maps of types} */
let module Set = Caml.Set.Make T;
@ -163,9 +221,9 @@ let rec pp_full pe f =>
fun
| Tstruct tname =>
if (Pp.equal_print_kind pe.Pp.kind Pp.HTML) {
F.fprintf f "%s" (Typename.to_string tname |> Escape.escape_xml)
F.fprintf f "%s" (Name.to_string tname |> Escape.escape_xml)
} else {
F.fprintf f "%s" (Typename.to_string tname)
F.fprintf f "%s" (Name.to_string tname)
}
| Tint ik => F.fprintf f "%s" (ikind_to_string ik)
| Tfloat fk => F.fprintf f "%s" (fkind_to_string fk)
@ -236,7 +294,7 @@ let array_elem default_opt =>
let is_class_of_kind typ ck =>
switch typ {
| Tstruct (TN_csu (Class ck') _) => Csu.equal_class_kind ck ck'
| Tstruct (TN_csu (Class ck') _ _) => Csu.equal_class_kind ck ck'
| _ => false
};
@ -286,16 +344,10 @@ let rec java_from_string =
let stripped_typ = String.sub typ_str pos::0 len::(String.length typ_str - 2);
Tptr (Tarray (java_from_string stripped_typ) None) Pk_pointer
}
| typ_str => Tstruct (Typename.Java.from_string typ_str);
| typ_str => Tstruct (Name.Java.from_string typ_str);
type typ = t [@@deriving compare];
/* template instantiation arguments */
type template_spec_info =
| NoTemplate
| Template (string, list (option t))
[@@deriving compare];
let module Procname = {
/* e.g. ("", "int") for primitive types or ("java.io", "PrintWriter") for objects */
type java_type = (option string, string);
@ -312,7 +364,7 @@ let module Procname = {
type java = {
method_name: string,
parameters: list java_type,
class_name: Typename.t,
class_name: Name.t,
return_type: option java_type, /* option because constructors have no return type */
kind: method_kind
}
@ -332,7 +384,7 @@ let module Procname = {
/** Type of Objective C and C++ procedure names: method signatures. */
type objc_cpp = {
method_name: string,
class_name: Typename.t,
class_name: Name.t,
kind: objc_cpp_method_kind,
template_args: template_spec_info
}
@ -403,7 +455,7 @@ let module Procname = {
| Some (x, y) => (Some x, y)
| None => (None, package_classname)
};
let split_typename typename => split_classname (Typename.name typename);
let split_typename typename => split_classname (Name.name typename);
let c (name: string) (mangled: string) (template_args: template_spec_info) => {
name,
mangled: Some mangled,
@ -447,7 +499,7 @@ let module Procname = {
/** Replace the class name component of a procedure name.
In case of Java, replace package and class name. */
let replace_class t (new_class: Typename.t) =>
let replace_class t (new_class: Name.t) =>
switch t {
| Java j => Java {...j, class_name: new_class}
| ObjC_Cpp osig => ObjC_Cpp {...osig, class_name: new_class}
@ -457,11 +509,11 @@ let module Procname = {
};
/** Get the class name of a Objective-C/C++ procedure name. */
let objc_cpp_get_class_name objc_cpp => Typename.name objc_cpp.class_name;
let objc_cpp_get_class_name objc_cpp => Name.name objc_cpp.class_name;
let objc_cpp_get_class_type_name objc_cpp => objc_cpp.class_name;
/** Return the package.classname of a java procname. */
let java_get_class_name (j: java) => Typename.name j.class_name;
let java_get_class_name (j: java) => Name.name j.class_name;
/** Return the package.classname as a typename of a java procname. */
let java_get_class_type_name (j: java) => j.class_name;
@ -594,7 +646,7 @@ let module Procname = {
| Java js =>
switch (List.rev js.parameters) {
| [(_, s), ...par'] =>
if (is_anonymous_inner_class_name (Typename.Java.from_string s)) {
if (is_anonymous_inner_class_name (Name.Java.from_string s)) {
Some (Java {...js, parameters: List.rev par'})
} else {
None
@ -735,10 +787,10 @@ let module Procname = {
let c_method_to_string osig detail_level =>
switch detail_level {
| Simple => osig.method_name
| Non_verbose => Typename.name osig.class_name ^ "_" ^ osig.method_name
| Non_verbose => Name.name osig.class_name ^ "_" ^ osig.method_name
| Verbose =>
let m_str = c_method_kind_verbose_str osig.kind;
Typename.name osig.class_name ^ "_" ^ osig.method_name ^ m_str
Name.name osig.class_name ^ "_" ^ osig.method_name ^ m_str
};
/** Very verbose representation of an existing Procname.t */
@ -797,7 +849,7 @@ let module Procname = {
| C {name} => QualifiedCppName.qualifiers_of_qual_name name
| ObjC_Cpp objc_cpp =>
List.append
(QualifiedCppName.qualifiers_of_qual_name (Typename.name objc_cpp.class_name))
(QualifiedCppName.qualifiers_of_qual_name (Name.name objc_cpp.class_name))
[objc_cpp.method_name]
| _ => []
};
@ -834,19 +886,19 @@ let module Struct = {
type t = {
fields: fields, /** non-static fields */
statics: fields, /** static fields */
supers: list Typename.t, /** superclasses */
supers: list Name.t, /** superclasses */
methods: list Procname.t, /** methods defined */
annots: Annot.Item.t, /** annotations */
specialization: template_spec_info /** template specialization */
};
type lookup = Typename.t => option t;
type lookup = Name.t => option t;
let pp pe name f {fields, supers, methods, annots} =>
if Config.debug_mode {
/* change false to true to print the details of struct */
F.fprintf
f
"%a \n\tfields: {%a\n\t}\n\tsupers: {%a\n\t}\n\tmethods: {%a\n\t}\n\tannots: {%a\n\t}"
Typename.pp
Name.pp
name
(
Pp.seq (
@ -855,14 +907,14 @@ let module Struct = {
)
)
fields
(Pp.seq (fun f n => F.fprintf f "\n\t\t%a" Typename.pp n))
(Pp.seq (fun f n => F.fprintf f "\n\t\t%a" Name.pp n))
supers
(Pp.seq (fun f m => F.fprintf f "\n\t\t%a" Procname.pp m))
methods
Annot.Item.pp
annots
} else {
F.fprintf f "%a" Typename.pp name
F.fprintf f "%a" Name.pp name
};
let internal_mk_struct
default::default=?

@ -77,10 +77,67 @@ type t =
| Tvoid /** void type */
| Tfun bool /** function type with noreturn attribute */
| Tptr t ptr_kind /** pointer type */
| Tstruct Typename.t /** structured value type name */
| Tstruct name /** structured value type name */
| Tarray t static_length /** array type with statically fixed length */
[@@deriving compare]
and name =
| TN_csu Csu.t Mangled.t template_spec_info
[@@deriving compare]
and template_spec_info =
| NoTemplate
| Template (string, list (option t))
[@@deriving compare];
let module Name: {
/** Named types. */
type t = name [@@deriving compare];
/** Equality for typenames */
let equal: t => t => bool;
/** convert the typename to a string */
let to_string: t => string;
let pp: Format.formatter => t => unit;
/** name of the typename without qualifier */
let name: t => string;
let module C: {let from_string: string => t; let union_from_string: string => t;};
let module Java: {
/** Create a typename from a Java classname in the form "package.class" */
let from_string: string => t;
/** Create a typename from a package name and a class name */
let from_package_class: string => string => t;
/** [is_class name] holds if [name] names a Java class */
let is_class: t => bool;
let java_lang_object: t;
let java_io_serializable: t;
let java_lang_cloneable: t;
};
let module Cpp: {
/** Create a typename from a C++ classname */
let from_string: string => t;
let from_template_string: template_spec_info => string => t;
/** [is_class name] holds if [name] names a C++ class */
let is_class: t => bool;
};
let module Objc: {
/** Create a typename from a Objc classname */
let from_string: string => t;
let protocol_from_string: string => t;
/** [is_class name] holds if [name] names a Objc class */
let is_class: t => bool;
};
let module Set: Caml.Set.S with type elt = t;
};
/** Equality for types. */
let equal: t => t => bool;
@ -119,7 +176,7 @@ let d_list: list t => unit;
/** The name of a type */
let name: t => option Typename.t;
let name: t => option Name.t;
/** turn a *T into a T. fails if [t] is not a pointer type */
@ -150,12 +207,6 @@ let unsome: string => option t => t;
type typ = t;
/* template instantiation arguments */
type template_spec_info =
| NoTemplate
| Template (string, list (option t))
[@@deriving compare];
let module Procname: {
/** Module for Procedure Names. */
@ -222,7 +273,7 @@ let module Procname: {
let hash_pname: t => int;
/** Check if a class string is an anoynmous inner class name. */
let is_anonymous_inner_class_name: Typename.t => bool;
let is_anonymous_inner_class_name: Name.t => bool;
/** Check if this is an Objective-C/C++ method name. */
let is_c_method: t => bool;
@ -247,7 +298,7 @@ let module Procname: {
/** Create a Java procedure name from its
class_name method_name args_type_name return_type_name method_kind. */
let java: Typename.t => option java_type => string => list java_type => method_kind => java;
let java: Name.t => option java_type => string => list java_type => method_kind => java;
/** Replace the parameters of a java procname. */
let java_replace_parameters: java => list java_type => java;
@ -259,12 +310,12 @@ let module Procname: {
let mangled_objc_block: string => t;
/** Create an objc procedure name from a class_name and method_name. */
let objc_cpp: Typename.t => string => objc_cpp_method_kind => template_spec_info => objc_cpp;
let get_default_objc_class_method: Typename.t => t;
let objc_cpp: Name.t => string => objc_cpp_method_kind => template_spec_info => objc_cpp;
let get_default_objc_class_method: Name.t => t;
/** Get the class name of a Objective-C/C++ procedure name. */
let objc_cpp_get_class_name: objc_cpp => string;
let objc_cpp_get_class_type_name: objc_cpp => Typename.t;
let objc_cpp_get_class_type_name: objc_cpp => Name.t;
/** Create ObjC method type from a bool is_instance. */
let objc_method_kind_of_bool: bool => objc_cpp_method_kind;
@ -273,7 +324,7 @@ let module Procname: {
let java_get_class_name: java => string;
/** Return the class name as a typename of a java procedure name. */
let java_get_class_type_name: java => Typename.t;
let java_get_class_type_name: java => Name.t;
/** Return the simple class name of a java procedure name. */
let java_get_simple_class_name: java => string;
@ -345,7 +396,7 @@ let module Procname: {
/** Replace the class name component of a procedure name.
In case of Java, replace package and class name. */
let replace_class: t => Typename.t => t;
let replace_class: t => Name.t => t;
/** Given a package.class_name string, look for the latest dot and split the string
in two (package, class_name). */
@ -377,15 +428,15 @@ let module Struct: {
type t = private {
fields: fields, /** non-static fields */
statics: fields, /** static fields */
supers: list Typename.t, /** supers */
supers: list Name.t, /** supers */
methods: list Procname.t, /** methods defined */
annots: Annot.Item.t, /** annotations */
specialization: template_spec_info /** template specialization */
};
type lookup = Typename.t => option t;
type lookup = Name.t => option t;
/** Pretty print a struct type. */
let pp: Pp.env => Typename.t => F.formatter => t => unit;
let pp: Pp.env => Name.t => F.formatter => t => unit;
/** Construct a struct_typ, normalizing field types */
let internal_mk_struct:
@ -393,7 +444,7 @@ let module Struct: {
fields::fields? =>
statics::fields? =>
methods::list Procname.t? =>
supers::list Typename.t? =>
supers::list Name.t? =>
annots::Annot.Item.t? =>
specialization::template_spec_info? =>
unit =>

@ -756,7 +756,7 @@ let execute_alloc mk can_return_null
evaluate_char_sizeof (Exp.Const (Const.Cint len))
| Exp.Sizeof _ -> e in
let size_exp, procname = match args with
| [(Exp.Sizeof (Tstruct (TN_csu (Class Objc, _) as name) as s, len, subt), _)] ->
| [(Exp.Sizeof (Tstruct (TN_csu (Class Objc, _, _) as name) as s, len, subt), _)] ->
let struct_type =
match AttributesTable.get_correct_type_from_objc_class_name name with
| Some struct_type -> struct_type

@ -45,7 +45,7 @@ module Path : sig
val d_stats : t -> unit
(** extend a path with a new node reached from the given session, with an optional string for exceptions *)
val extend : Procdesc.Node.t -> Typename.t option -> session -> t -> t
val extend : Procdesc.Node.t -> Typ.Name.t option -> session -> t -> t
(** extend a path with a new node reached from the given session, with an optional string for exceptions *)
val add_description : t -> string -> t
@ -54,7 +54,7 @@ module Path : sig
val iter_all_nodes_nocalls : (Procdesc.Node.t -> unit) -> t -> unit
val iter_shortest_sequence :
(int -> t -> int -> Typename.t option -> unit) -> PredSymb.path_pos option -> t -> unit
(int -> t -> int -> Typ.Name.t option -> unit) -> PredSymb.path_pos option -> t -> unit
(** join two paths *)
val join : t -> t -> t
@ -94,7 +94,7 @@ end = struct
(* INVARIANT: stats are always set to dummy_stats unless we are in the middle of a traversal *)
(* in particular: a new traversal cannot be initiated during an existing traversal *)
| Pstart of Procdesc.Node.t * _stats (** start node *)
| Pnode of Procdesc.Node.t * Typename.t option * session * t * _stats * _string_option
| Pnode of Procdesc.Node.t * Typ.Name.t option * session * t * _stats * _string_option
(** we got to [node] from last [session] perhaps propagating exception [exn_opt],
and continue with [path]. *)
| Pjoin of t * t * _stats (** join of two paths *)
@ -267,7 +267,7 @@ end = struct
If a node is reached via an exception,
pass the exception information to [f] on the previous node *)
let iter_shortest_sequence_filter
(f : int -> t -> int -> Typename.t option -> unit)
(f : int -> t -> int -> Typ.Name.t option -> unit)
(filter: Procdesc.Node.t -> bool) (path: t) : unit =
let rec doit level session path prev_exn_opt = match path with
| Pstart _ -> f level path session prev_exn_opt
@ -295,7 +295,7 @@ end = struct
[f level path session exn_opt] is passed the current nesting [level] and [path]
and previous [session] and possible exception [exn_opt] *)
let iter_shortest_sequence
(f : int -> t -> int -> Typename.t option -> unit)
(f : int -> t -> int -> Typ.Name.t option -> unit)
(pos_opt : PredSymb.path_pos option) (path: t) : unit =
let filter node = match pos_opt with
| None -> true
@ -472,7 +472,7 @@ end = struct
match exn_opt with
| None -> "", []
| Some exn_name ->
let exn_str = Typename.name exn_name in
let exn_str = Typ.Name.name exn_name in
if String.equal exn_str ""
then "exception", [(Io_infer.Xml.tag_kind,"exception")]
else

@ -40,7 +40,7 @@ module Path : sig
val d_stats : t -> unit
(** extend a path with a new node reached from the given session, with an optional string for exceptions *)
val extend : Procdesc.Node.t -> Typename.t option -> session -> t -> t
val extend : Procdesc.Node.t -> Typ.Name.t option -> session -> t -> t
val add_description : t -> string -> t
@ -53,7 +53,7 @@ module Path : sig
[f level path session exn_opt] is passed the current nesting [level] and [path]
and previous [session] and possible exception [exn_opt] *)
val iter_shortest_sequence :
(int -> t -> int -> Typename.t option -> unit) -> PredSymb.path_pos option -> t -> unit
(int -> t -> int -> Typ.Name.t option -> unit) -> PredSymb.path_pos option -> t -> unit
(** join two paths *)
val join : t -> t -> t

@ -38,7 +38,7 @@ let rec remove_redundancy have_same_key acc = function
let rec is_java_class tenv (typ: Typ.t) =
match typ with
| Tstruct name -> Typename.Java.is_class name
| Tstruct name -> Typ.Name.Java.is_class name
| Tarray (inner_typ, _) | Tptr (inner_typ, _) -> is_java_class tenv inner_typ
| _ -> false
@ -1506,7 +1506,7 @@ let expand_hpred_pointer =
| Sizeof (cnt_typ, len, st) ->
(* type of struct at adr_base is unknown (typically Tvoid), but
type of contents is known, so construct struct type for single fld:cnt_typ *)
let name = Typename.C.from_string ("counterfeit" ^ string_of_int !count) in
let name = Typ.Name.C.from_string ("counterfeit" ^ string_of_int !count) in
incr count ;
let fields = [(fld, cnt_typ, Annot.Item.empty)] in
ignore (Tenv.mk_struct tenv ~fields name) ;
@ -1549,16 +1549,16 @@ struct
(** check if t1 is a subtype of t2, in Java *)
let rec check_subtype_java tenv (t1: Typ.t) (t2: Typ.t) =
match t1, t2 with
| Tstruct (TN_csu (Class Java, _) as cn1), Tstruct (TN_csu (Class Java, _) as cn2) ->
| Tstruct (TN_csu (Class Java, _, _) as cn1), Tstruct (TN_csu (Class Java, _, _) as cn2) ->
Subtype.is_known_subtype tenv cn1 cn2
| Tarray (dom_type1, _), Tarray (dom_type2, _) ->
check_subtype_java tenv dom_type1 dom_type2
| Tptr (dom_type1, _), Tptr (dom_type2, _) ->
check_subtype_java tenv dom_type1 dom_type2
| Tarray _, Tstruct (TN_csu (Class Java, _) as cn2) ->
Typename.equal cn2 Typename.Java.java_io_serializable
|| Typename.equal cn2 Typename.Java.java_lang_cloneable
|| Typename.equal cn2 Typename.Java.java_lang_object
| Tarray _, Tstruct (TN_csu (Class Java, _, _) as cn2) ->
Typ.Name.equal cn2 Typ.Name.Java.java_io_serializable
|| Typ.Name.equal cn2 Typ.Name.Java.java_lang_cloneable
|| Typ.Name.equal cn2 Typ.Name.Java.java_lang_object
| _ -> check_subtype_basic_type t1 t2
(** check if t1 is a subtype of t2 *)
@ -1573,12 +1573,12 @@ struct
let rec case_analysis_type tenv ((t1: Typ.t), st1) ((t2: Typ.t), st2) =
match t1, t2 with
| Tstruct (TN_csu (Class Java, _) as cn1), Tstruct (TN_csu (Class Java, _) as cn2) ->
| Tstruct (TN_csu (Class Java, _, _) as cn1), Tstruct (TN_csu (Class Java, _, _) as cn2) ->
Subtype.case_analysis tenv (cn1, st1) (cn2, st2)
| Tstruct (TN_csu (Class Java, _) as cn1), Tarray _
when (Typename.equal cn1 Typename.Java.java_io_serializable
|| Typename.equal cn1 Typename.Java.java_lang_cloneable
|| Typename.equal cn1 Typename.Java.java_lang_object) &&
| Tstruct (TN_csu (Class Java, _, _) as cn1), Tarray _
when (Typ.Name.equal cn1 Typ.Name.Java.java_io_serializable
|| Typ.Name.equal cn1 Typ.Name.Java.java_lang_cloneable
|| Typ.Name.equal cn1 Typ.Name.Java.java_lang_object) &&
st1 <> Subtype.exact ->
Some st1, None
| Tstruct cn1, Tstruct cn2
@ -1982,7 +1982,7 @@ and sigma_imply tenv calc_index_frame calc_missing subs prop1 sigma2 : (subst2 *
| Config.Clang ->
Exp.Sizeof (Typ.Tarray (Typ.Tint Typ.IChar, Some len), None, Subtype.exact)
| Config.Java ->
let object_type = Typename.Java.from_string "java.lang.String" in
let object_type = Typ.Name.Java.from_string "java.lang.String" in
Exp.Sizeof (Tstruct object_type, None, Subtype.exact) in
Sil.Hpointsto (root, sexp, const_string_texp) in
let mk_constant_class_hpred s = (* creat an hpred from a constant class *)
@ -1992,7 +1992,7 @@ and sigma_imply tenv calc_index_frame calc_missing subs prop1 sigma2 : (subst2 *
([(Ident.create_fieldname (Mangled.from_string "java.lang.Class.name") 0,
Sil.Eexp ((Exp.Const (Const.Cstr s), Sil.Inone)))], Sil.inst_none) in
let class_texp =
let class_type = Typename.Java.from_string "java.lang.Class" in
let class_type = Typ.Name.Java.from_string "java.lang.Class" in
Exp.Sizeof (Tstruct class_type, None, Subtype.exact) in
Sil.Hpointsto (root, sexp, class_texp) in
try

@ -668,7 +668,7 @@ let add_guarded_by_constraints tenv prop lexp pdesc =
| Typ.Procname.Java java_pname ->
let current_class_type_name = (Typ.Procname.java_get_class_type_name java_pname) in
let comparison class_type_name _ =
guarded_by_str_is_class_this (Typename.to_string class_type_name) guarded_by_str in
guarded_by_str_is_class_this (Typ.Name.to_string class_type_name) guarded_by_str in
PatternMatch.supertype_exists tenv comparison current_class_type_name
| _ -> false in
@ -815,7 +815,7 @@ let add_guarded_by_constraints tenv prop lexp pdesc =
let str_is_read_write_lock str = String.is_suffix ~suffix:"ReadWriteUpdateLock" str ||
String.is_suffix ~suffix:"ReadWriteLock" str in
match typ with
| Typ.Tstruct name -> str_is_read_write_lock (Typename.name name)
| Typ.Tstruct name -> str_is_read_write_lock (Typ.Name.name name)
| Typ.Tptr (typ, _) -> is_read_write_lock typ
| _ -> false in
let has_lock guarded_by_exp =

@ -482,19 +482,19 @@ let method_exists right_proc_name methods =
let resolve_method tenv class_name proc_name =
let found_class =
let visited = ref Typename.Set.empty in
let rec resolve (class_name: Typename.t) =
visited := Typename.Set.add class_name !visited;
let visited = ref Typ.Name.Set.empty in
let rec resolve (class_name: Typ.Name.t) =
visited := Typ.Name.Set.add class_name !visited;
let right_proc_name =
Typ.Procname.replace_class proc_name class_name in
match class_name, Tenv.lookup tenv class_name with
| TN_csu (Class _, _), Some { methods; supers } ->
| TN_csu (Class _, _, _), Some { methods; supers } ->
if method_exists right_proc_name methods then
Some right_proc_name
else
(match supers with
| super_classname:: _ ->
if not (Typename.Set.mem super_classname !visited)
if not (Typ.Name.Set.mem super_classname !visited)
then resolve super_classname
else None
| _ -> None)
@ -503,7 +503,7 @@ let resolve_method tenv class_name proc_name =
match found_class with
| None ->
Logging.d_strln
("Couldn't find method in the hierarchy of type "^(Typename.name class_name));
("Couldn't find method in the hierarchy of type "^(Typ.Name.name class_name));
proc_name
| Some proc_name ->
proc_name
@ -601,7 +601,7 @@ let resolve_java_pname tenv prop args pname_java call_flags : Typ.Procname.java
~f:(fun accu (arg_exp, _) name ->
match resolve_typename prop arg_exp with
| Some class_name ->
(Typ.Procname.split_classname (Typename.name class_name)) :: accu
(Typ.Procname.split_classname (Typ.Name.name class_name)) :: accu
| None -> name :: accu)
~init:[] args (Typ.Procname.java_get_parameters resolved_pname_java) |> List.rev in
Typ.Procname.java_replace_parameters resolved_pname_java resolved_params in
@ -670,7 +670,7 @@ let call_constructor_url_update_args pname actual_params =
let url_pname =
Typ.Procname.Java
(Typ.Procname.java
(Typename.Java.from_string "java.net.URL") None "<init>"
(Typ.Name.Java.from_string "java.net.URL") None "<init>"
[(Some "java.lang"), "String"] Typ.Procname.Non_Static) in
if (Typ.Procname.equal url_pname pname) then
(match actual_params with

@ -45,4 +45,4 @@ val prune : Tenv.t -> positive:bool -> Exp.t -> Prop.normal Prop.t -> Propset.t
the procname that the method name will actually resolve to at runtime. For example, if we have a
procname like Foo.toString() and Foo does not override toString(), we must resolve the call to
toString(). We will end up with Super.toString() where Super is some superclass of Foo. *)
val resolve_method : Tenv.t -> Typename.t -> Typ.Procname.t -> Typ.Procname.t
val resolve_method : Tenv.t -> Typ.Name.t -> Typ.Procname.t -> Typ.Procname.t

@ -471,7 +471,7 @@ let texp_star tenv texp1 texp2 =
| _ -> ftal_sub ftal1 ftal2' end in
let typ_star (t1: Typ.t) (t2: Typ.t) =
match t1, t2 with
| Tstruct (TN_csu (csu1, _) as name1), Tstruct (TN_csu (csu2, _) as name2)
| Tstruct (TN_csu (csu1, _, _) as name1), Tstruct (TN_csu (csu2, _, _) as name2)
when Csu.equal csu1 csu2 -> (
match Tenv.lookup tenv name1, Tenv.lookup tenv name2 with
| Some { fields = fields1 }, Some { fields = fields2 } when ftal_sub fields1 fields2 ->

@ -34,7 +34,7 @@ val create_cast_exception :
val prop_is_exn : Typ.Procname.t -> 'a Prop.t -> bool
(** when prop is an exception, return the exception name *)
val prop_get_exn_name : Typ.Procname.t -> 'a Prop.t -> Typename.t option
val prop_get_exn_name : Typ.Procname.t -> 'a Prop.t -> Typ.Name.t option
(** search in prop contains an error state *)
val lookup_custom_errors : 'a Prop.t -> string option

@ -264,7 +264,7 @@ let functions_with_tainted_params = [
let java_method_to_procname java_method =
Typ.Procname.Java
(Typ.Procname.java
(Typename.Java.from_string java_method.classname)
(Typ.Name.Java.from_string java_method.classname)
(Some (Typ.Procname.split_classname java_method.ret_type))
java_method.method_name
(List.map ~f:Typ.Procname.split_classname java_method.params)
@ -273,7 +273,7 @@ let java_method_to_procname java_method =
(* turn string specificiation of an objc method into a procname *)
let objc_method_to_procname objc_method =
let method_kind = Typ.Procname.objc_method_kind_of_bool (not objc_method.is_static) in
let typename = Typename.Objc.from_string objc_method.classname in
let typename = Typ.Name.Objc.from_string objc_method.classname in
Typ.Procname.ObjC_Cpp
(Typ.Procname.objc_cpp typename objc_method.method_name method_kind Typ.NoTemplate)

@ -341,13 +341,13 @@ module TransferFunctions (CFG : ProcCfg.S) = struct
let exec_instr (astate : Domain.astate) ({ ProcData.pdesc; tenv; extras; } as proc_data) _ =
let is_container_write pn tenv = match pn with
| Typ.Procname.Java java_pname ->
let typename = Typename.Java.from_string (Typ.Procname.java_get_class_name java_pname) in
let typename = Typ.Name.Java.from_string (Typ.Procname.java_get_class_name java_pname) in
let is_container_write_ typename _ =
match Typename.name typename, Typ.Procname.java_get_method java_pname with
match Typ.Name.name typename, Typ.Procname.java_get_method java_pname with
| "java.util.List", ("add" | "addAll" | "clear" | "remove" | "set") -> true
| "java.util.Map", ("clear" | "put" | "putAll" | "remove") -> true
| _ -> false in
let is_threadsafe_collection typename _ = match Typename.name typename with
let is_threadsafe_collection typename _ = match Typ.Name.name typename with
| "java.util.concurrent.ConcurrentMap" | "java.util.concurrent.CopyOnWriteArrayList" ->
true
| _ ->
@ -750,7 +750,7 @@ let is_immutable_collection_class class_name tenv =
PatternMatch.supertype_exists
tenv
(fun typename _ ->
List.mem ~equal:String.equal immutable_collections (Typename.name typename))
List.mem ~equal:String.equal immutable_collections (Typ.Name.name typename))
class_name
let is_call_to_builder_class_method = function
@ -942,9 +942,9 @@ let get_current_class_and_threadsafe_superclasses tenv pname =
let calculate_addendum_message tenv pname =
match get_current_class_and_threadsafe_superclasses tenv pname with
| Some (current_class,thread_safe_annotated_classes) ->
if not (List.mem ~equal:Typename.equal thread_safe_annotated_classes current_class) then
if not (List.mem ~equal:Typ.Name.equal thread_safe_annotated_classes current_class) then
match thread_safe_annotated_classes with
| hd::_ -> F.asprintf "\n Note: Superclass %a is marked @ThreadSafe." Typename.pp hd
| hd::_ -> F.asprintf "\n Note: Superclass %a is marked @ThreadSafe." Typ.Name.pp hd
| [] -> ""
else ""
| _ -> ""

@ -116,7 +116,7 @@ let is_modeled_expensive tenv = function
| Typ.Procname.Java proc_name_java as proc_name ->
not (BuiltinDecl.is_declared proc_name) &&
let is_subclass =
let classname = Typename.Java.from_string (Typ.Procname.java_get_class_name proc_name_java) in
let classname = Typ.Name.Java.from_string (Typ.Procname.java_get_class_name proc_name_java) in
PatternMatch.is_subtype_of_str tenv classname in
Inferconfig.modeled_expensive_matcher is_subclass proc_name
| _ ->
@ -127,7 +127,7 @@ let is_allocator tenv pname =
| Typ.Procname.Java pname_java ->
let is_throwable () =
let class_name =
Typename.Java.from_string (Typ.Procname.java_get_class_name pname_java) in
Typ.Name.Java.from_string (Typ.Procname.java_get_class_name pname_java) in
PatternMatch.is_throwable tenv class_name in
Typ.Procname.is_constructor pname
&& not (BuiltinDecl.is_declared pname)

@ -200,7 +200,7 @@ let callback_check_write_to_parcel_java
String.equal (Typ.Procname.java_get_method pname_java) "writeToParcel" in
let expr_match () = Exp.is_this this_expr in
let type_match () =
let class_name = Typename.Java.from_string "android.os.Parcelable" in
let class_name = Typ.Name.Java.from_string "android.os.Parcelable" in
match this_type with
| Typ.Tptr (Tstruct name, _) | Tstruct name ->
PatternMatch.is_immediate_subtype tenv name class_name

@ -31,12 +31,12 @@ let callback_fragment_retains_view_java
| _ -> false in
(* is [fldname] a View type declared by [class_typename]? *)
let is_declared_view_typ class_typename (fldname, fld_typ, _) =
let fld_classname = Typename.Java.from_string (Ident.java_fieldname_get_class fldname) in
Typename.equal fld_classname class_typename && fld_typ_is_view fld_typ in
let fld_classname = Typ.Name.Java.from_string (Ident.java_fieldname_get_class fldname) in
Typ.Name.equal fld_classname class_typename && fld_typ_is_view fld_typ in
if is_on_destroy_view then
begin
let class_typename =
Typename.Java.from_string (Typ.Procname.java_get_class_name pname_java) in
Typ.Name.Java.from_string (Typ.Procname.java_get_class_name pname_java) in
match Tenv.lookup tenv class_typename with
| Some { fields } when AndroidFramework.is_fragment tenv class_typename ->
let declared_view_fields =

@ -25,8 +25,8 @@ let check_immutable_cast tenv curr_pname curr_pdesc typ_expected typ_found_opt l
] in
let in_casts expected given =
List.exists ~f:(fun (x, y) ->
String.equal (Typename.name expected) x
&& String.equal (Typename.name given) y
String.equal (Typ.Name.name expected) x
&& String.equal (Typ.Name.name given) y
) casts in
match PatternMatch.type_get_class_name typ_expected,
PatternMatch.type_get_class_name typ_found with
@ -38,8 +38,8 @@ let check_immutable_cast tenv curr_pname curr_pdesc typ_expected typ_found_opt l
"Method %s returns %a but the return type is %a. \
Make sure that users of this method do not try to modify the collection."
(Typ.Procname.to_simplified_string curr_pname)
Typename.pp name_given
Typename.pp name_expected in
Typ.Name.pp name_given
Typ.Name.pp name_expected in
Checkers.ST.report_error tenv
curr_pname
curr_pdesc

@ -26,7 +26,7 @@ type taint_spec = {
let type_is_object typ =
match typ with
| Typ.Tptr (Tstruct name, _) -> Typename.equal name Typename.Java.java_lang_object
| Typ.Tptr (Tstruct name, _) -> Typ.Name.equal name Typ.Name.Java.java_lang_object
| _ -> false
let java_proc_name_with_class_method pn_java class_with_path method_name =
@ -56,16 +56,16 @@ let rec supertype_find_map_opt tenv f name =
let is_immediate_subtype tenv this_type_name super_type_name =
match Tenv.lookup tenv this_type_name with
| Some {supers} -> List.exists ~f:(Typename.equal super_type_name) supers
| Some {supers} -> List.exists ~f:(Typ.Name.equal super_type_name) supers
| None -> false
(** return true if [typ0] <: [typ1] *)
let is_subtype tenv name0 name1 =
supertype_exists tenv (fun name _ -> Typename.equal name name1) name0
supertype_exists tenv (fun name _ -> Typ.Name.equal name name1) name0
let is_subtype_of_str tenv cn1 classname_str =
let typename = Typename.Java.from_string classname_str in
Typename.equal cn1 typename ||
let typename = Typ.Name.Java.from_string classname_str in
Typ.Name.equal cn1 typename ||
is_subtype tenv cn1 typename
(** The type the method is invoked on *)
@ -98,32 +98,32 @@ let type_get_annotation tenv (typ: Typ.t): Annot.Item.t option =
)
| _ -> None
let type_has_direct_supertype tenv (typ : Typ.t) (class_name : Typename.t) =
List.exists ~f:(fun cn -> Typename.equal cn class_name) (type_get_direct_supertypes tenv typ)
let type_has_direct_supertype tenv (typ : Typ.t) (class_name : Typ.Name.t) =
List.exists ~f:(fun cn -> Typ.Name.equal cn class_name) (type_get_direct_supertypes tenv typ)
let type_has_supertype
(tenv: Tenv.t)
(typ: Typ.t)
(class_name: Typename.t): bool =
(class_name: Typ.Name.t): bool =
let rec has_supertype typ visited =
if Typ.Set.mem typ visited then
false
else
let supers = type_get_direct_supertypes tenv typ in
let match_supertype cn =
let match_name () = Typename.equal cn class_name in
let match_name () = Typ.Name.equal cn class_name in
let has_indirect_supertype () = has_supertype (Typ.Tstruct cn) (Typ.Set.add typ visited) in
(match_name () || has_indirect_supertype ()) in
List.exists ~f:match_supertype supers in
has_supertype typ Typ.Set.empty
let type_is_nested_in_direct_supertype tenv t n =
let is_nested_in cn1 cn2 = String.is_prefix ~prefix:(Typename.name cn1 ^ "$") (Typename.name cn2) in
let is_nested_in cn1 cn2 = String.is_prefix ~prefix:(Typ.Name.name cn1 ^ "$") (Typ.Name.name cn2) in
List.exists ~f:(is_nested_in n) (type_get_direct_supertypes tenv t)
let rec get_type_name = function
| Typ.Tstruct name ->
Typename.name name
Typ.Name.name name
| Typ.Tptr (t, _) -> get_type_name t
| _ -> "_"
@ -252,7 +252,7 @@ let type_is_class typ =
| _ -> false
let initializer_classes =
List.map ~f:Typename.Java.from_string
List.map ~f:Typ.Name.Java.from_string
[
"android.app.Activity";
"android.app.Application";
@ -346,7 +346,7 @@ let override_exists f tenv proc_name =
f proc_name ||
match proc_name with
| Typ.Procname.Java proc_name_java ->
let type_name = Typename.Java.from_string (Typ.Procname.java_get_class_name proc_name_java) in
let type_name = Typ.Name.Java.from_string (Typ.Procname.java_get_class_name proc_name_java) in
List.exists
~f:(super_type_exists tenv)
(type_get_direct_supertypes tenv (Typ.Tstruct type_name))

@ -51,21 +51,21 @@ val is_getter : Typ.Procname.java -> bool
val is_setter : Typ.Procname.java -> bool
(** Is the type a direct subtype of the typename? *)
val is_immediate_subtype : Tenv.t -> Typename.t -> Typename.t -> bool
val is_immediate_subtype : Tenv.t -> Typ.Name.t -> Typ.Name.t -> bool
(** Is the type a transitive subtype of the typename? *)
val is_subtype : Tenv.t -> Typename.t -> Typename.t -> bool
val is_subtype : Tenv.t -> Typ.Name.t -> Typ.Name.t -> bool
(** Resolve [typ_str] in [tenv], then check [typ] <: [typ_str] *)
val is_subtype_of_str : Tenv.t -> Typename.t -> string -> bool
val is_subtype_of_str : Tenv.t -> Typ.Name.t -> string -> bool
(** Holds iff the predicate holds on a supertype of the named type, including the type itself *)
val supertype_exists : Tenv.t -> (Typename.t -> Typ.Struct.t -> bool) -> Typename.t -> bool
val supertype_exists : Tenv.t -> (Typ.Name.t -> Typ.Struct.t -> bool) -> Typ.Name.t -> bool
(** Return the first non-None result found when applying the given function to supertypes of the
named type, including the type itself *)
val supertype_find_map_opt :
Tenv.t -> (Typename.t -> Typ.Struct.t -> 'a option) -> Typename.t -> 'a option
Tenv.t -> (Typ.Name.t -> Typ.Struct.t -> 'a option) -> Typ.Name.t -> 'a option
(** Get the name of the type of a constant *)
val java_get_const_type_name : Const.t -> string
@ -93,16 +93,16 @@ val override_iter : (Typ.Procname.t -> unit) -> Tenv.t -> Typ.Procname.t -> unit
val type_get_annotation : Tenv.t -> Typ.t -> Annot.Item.t option
(** Get the class name of the type *)
val type_get_class_name : Typ.t -> Typename.t option
val type_get_class_name : Typ.t -> Typ.Name.t option
val type_get_direct_supertypes : Tenv.t -> Typ.t -> Typename.t list
val type_get_direct_supertypes : Tenv.t -> Typ.t -> Typ.Name.t list
val type_has_direct_supertype : Tenv.t -> Typ.t -> Typename.t -> bool
val type_has_direct_supertype : Tenv.t -> Typ.t -> Typ.Name.t -> bool
(** Is the type a class type *)
val type_is_class : Typ.t -> bool
val type_is_nested_in_direct_supertype : Tenv.t -> Typ.t -> Typename.t -> bool
val type_is_nested_in_direct_supertype : Tenv.t -> Typ.t -> Typ.Name.t -> bool
(** Is the type java.lang.Object *)
val type_is_object : Typ.t -> bool
@ -111,14 +111,14 @@ val type_is_object : Typ.t -> bool
val get_fields_nullified : Procdesc.t -> Ident.FieldSet.t
(** [is_exception tenv class_name] checks if class_name is of type java.lang.Exception *)
val is_exception : Tenv.t -> Typename.t -> bool
val is_exception : Tenv.t -> Typ.Name.t -> bool
(** [is_throwable tenv class_name] checks if class_name is of type java.lang.Throwable *)
val is_throwable : Tenv.t -> Typename.t -> bool
val is_throwable : Tenv.t -> Typ.Name.t -> bool
(** [is_runtime_exception tenv class_name] checks if classname is
of type java.lang.RuntimeException *)
val is_runtime_exception : Tenv.t -> Typename.t -> bool
val is_runtime_exception : Tenv.t -> Typ.Name.t -> bool
(** tests whether any class attributes (e.g., @ThreadSafe) pass check of first argument,
including supertypes*)
@ -130,4 +130,4 @@ val check_current_class_attributes : (Annot.Item.t -> bool) -> Tenv.t -> Typ.Pro
(** find superclasss with attributes (e.g., @ThreadSafe), including current class*)
val find_superclasses_with_attributes : (Annot.Item.t -> bool) -> Tenv.t
-> Typename.t -> Typename.t list
-> Typ.Name.t -> Typ.Name.t list

@ -113,10 +113,10 @@ let mk_fresh_block_procname defining_proc =
Typ.Procname.mangled_objc_block name
let get_class_typename method_decl_info =
let get_class_typename ?tenv method_decl_info =
let class_ptr = Option.value_exn method_decl_info.Clang_ast_t.di_parent_pointer in
match CAst_utils.get_decl class_ptr with
| Some class_decl -> CType_decl.get_record_typename class_decl
| Some class_decl -> CType_decl.get_record_typename ?tenv class_decl
| None -> assert false
module NoAstDecl = struct
@ -143,10 +143,10 @@ let from_decl translation_unit_context ?tenv meth_decl =
| CXXDestructorDecl (decl_info, name_info, _, fdi, mdi) ->
let mangled = get_mangled_method_name fdi mdi in
let method_name = CAst_utils.get_unqualified_name name_info in
let class_typename = get_class_typename decl_info in
let class_typename = get_class_typename ?tenv decl_info in
mk_cpp_method ?tenv class_typename method_name ~meth_decl mangled
| ObjCMethodDecl (decl_info, name_info, mdi) ->
let class_typename = get_class_typename decl_info in
let class_typename = get_class_typename ?tenv decl_info in
let method_name = name_info.Clang_ast_t.ni_name in
let is_instance = mdi.Clang_ast_t.omdi_is_instance_method in
let method_kind = Typ.Procname.objc_method_kind_of_bool is_instance in

@ -19,9 +19,9 @@ module NoAstDecl : sig
val c_function_of_string :
CFrontend_config.translation_unit_context -> Tenv.t -> string -> Typ.Procname.t
val cpp_method_of_string : Tenv.t -> Typename.t -> string -> Typ.Procname.t
val cpp_method_of_string : Tenv.t -> Typ.Name.t -> string -> Typ.Procname.t
val objc_method_of_string_kind : Typename.t -> string -> Typ.Procname.objc_cpp_method_kind ->
val objc_method_of_string_kind : Typ.Name.t -> string -> Typ.Procname.objc_cpp_method_kind ->
Typ.Procname.t
end

@ -24,16 +24,16 @@ let remove_pointer_to_typ typ =
let objc_classname_of_type typ =
match typ with
| Typ.Tstruct name -> name
| Typ.Tfun _ -> Typename.Objc.from_string CFrontend_config.objc_object
| Typ.Tfun _ -> Typ.Name.Objc.from_string CFrontend_config.objc_object
| _ ->
Logging.out_debug
"Classname of type cannot be extracted in type %s" (Typ.to_string typ);
Typename.Objc.from_string "undefined"
Typ.Name.Objc.from_string "undefined"
let is_class typ =
match typ with
| Typ.Tptr (Tstruct name, _) ->
String.equal (Typename.name name) CFrontend_config.objc_class
String.equal (Typ.Name.name name) CFrontend_config.objc_class
| _ -> false
let rec return_type_of_function_type_ptr type_ptr =

@ -13,7 +13,7 @@ open! IStd
val add_pointer_to_typ : Typ.t -> Typ.t
val objc_classname_of_type : Typ.t -> Typename.t
val objc_classname_of_type : Typ.t -> Typ.Name.t
val remove_pointer_to_typ : Typ.t -> Typ.t

@ -32,7 +32,7 @@ let add_predefined_basic_types () =
CAst_utils.update_sil_types_map tp return_type in
let sil_void_type = CType_to_sil_type.sil_type_of_builtin_type_kind `Void in
let sil_char_type = CType_to_sil_type.sil_type_of_builtin_type_kind `Char_S in
let sil_nsarray_type = Typ.Tstruct (Typename.Objc.from_string CFrontend_config.nsarray_cl) in
let sil_nsarray_type = Typ.Tstruct (Typ.Name.Objc.from_string CFrontend_config.nsarray_cl) in
let sil_id_type = CType_to_sil_type.get_builtin_objc_type `ObjCId in
add_basic_type create_int_type `Int;
add_basic_type create_void_type `Void;
@ -55,33 +55,12 @@ let create_c_record_typename opt_type =
| `Type s ->
(let buf = Str.split (Str.regexp "[ \t]+") s in
match buf with
| "struct":: _ -> Typename.C.from_string
| "class":: _ -> Typename.Cpp.from_string
| "union":: _ -> Typename.C.union_from_string
| _ -> Typename.C.from_string)
| "struct":: _ -> Typ.Name.C.from_string
| "class":: _ -> Typ.Name.Cpp.from_string
| "union":: _ -> Typ.Name.C.union_from_string
| _ -> Typ.Name.C.from_string)
| _ -> assert false
(* We need to take the name out of the type as the struct can be anonymous*)
let get_record_typename decl =
let open Clang_ast_t in
match decl with
| RecordDecl (_, name_info, opt_type, _, _, _, _) ->
CAst_utils.get_qualified_name name_info |> create_c_record_typename opt_type
| CXXRecordDecl (_, name_info, _, _, _, _, _, _)
| ClassTemplateSpecializationDecl (_, name_info, _, _, _, _, _, _, _) ->
(* we use Csu.Class for C++ because we expect Csu.Class csu from *)
(* types that have methods. And in C++ struct/class/union can have methods *)
CAst_utils.get_qualified_name name_info |> Typename.Cpp.from_string
| ObjCInterfaceDecl (_, name_info, _, _, _)
| ObjCImplementationDecl (_, name_info, _, _, _)
| ObjCProtocolDecl (_, name_info, _, _, _)
| ObjCCategoryDecl (_, name_info, _, _, _)
| ObjCCategoryImplDecl (_, name_info, _, _, _) ->
CAst_utils.get_qualified_name name_info |> Typename.Objc.from_string
| _ -> assert false
let get_record_name decl = get_record_typename decl |> Typename.name
let get_class_template_name = function
| Clang_ast_t.ClassTemplateDecl (_, name_info, _ ) -> CAst_utils.get_qualified_name name_info
| _ -> assert false
@ -99,12 +78,6 @@ let get_superclass_decls decl =
List.map ~f:get_decl_or_fail base_ptr
| _ -> []
(** fetches list of superclasses for C++ classes *)
let get_superclass_list_cpp decl =
let base_decls = get_superclass_decls decl in
let get_super_field super_decl = Typename.Cpp.from_string (get_record_name super_decl) in
List.map ~f:get_super_field base_decls
let get_translate_as_friend_decl decl_list =
let is_translate_as_friend_name (_, name_info) =
let translate_as_str = "infer_traits::TranslateAsType" in
@ -181,23 +154,54 @@ and get_template_specialization tenv = function
Typ.Template (tname, args_in_sil)
| _ -> Typ.NoTemplate
(* We need to take the name out of the type as the struct can be anonymous
If tenv is not passed, then template instantiaion information may be incorrect,
as it defaults to Typ.NoTemplate *)
and get_record_typename ?tenv decl =
let open Clang_ast_t in
match decl with
| RecordDecl (_, name_info, opt_type, _, _, _, _) ->
CAst_utils.get_qualified_name name_info |> create_c_record_typename opt_type
| CXXRecordDecl (_, name_info, _, _, _, _, _, _)
| ClassTemplateSpecializationDecl (_, name_info, _, _, _, _, _, _, _) ->
(* we use Csu.Class for C++ because we expect Csu.Class csu from *)
(* types that have methods. And in C++ struct/class/union can have methods *)
let name_str = CAst_utils.get_qualified_name name_info in
let templ_info = match tenv with
| Some t -> get_template_specialization t decl
| None -> Typ.NoTemplate in
Typ.Name.Cpp.from_template_string templ_info name_str
| ObjCInterfaceDecl (_, name_info, _, _, _)
| ObjCImplementationDecl (_, name_info, _, _, _)
| ObjCProtocolDecl (_, name_info, _, _, _)
| ObjCCategoryDecl (_, name_info, _, _, _)
| ObjCCategoryImplDecl (_, name_info, _, _, _) ->
CAst_utils.get_qualified_name name_info |> Typ.Name.Objc.from_string
| _ -> assert false
(** fetches list of superclasses for C++ classes *)
and get_superclass_list_cpp tenv decl =
let base_decls = get_superclass_decls decl in
let get_super_field super_decl = get_record_typename ~tenv super_decl in
List.map ~f:get_super_field base_decls
and get_record_struct_type tenv definition_decl =
let open Clang_ast_t in
match definition_decl with
| ClassTemplateSpecializationDecl (_, _, _, type_ptr, _, _, record_decl_info, _, _)
| CXXRecordDecl (_, _, _, type_ptr, _, _, record_decl_info, _)
| RecordDecl (_, _, _, type_ptr, _, _, record_decl_info) ->
let sil_typename = get_record_typename definition_decl in
let sil_typename = get_record_typename ~tenv definition_decl in
(match Tenv.lookup tenv sil_typename with
| Some _ -> Typ.Tstruct sil_typename (* just reuse what is already in tenv *)
| None ->
let is_complete_definition = record_decl_info.Clang_ast_t.rdi_is_complete_definition in
let extra_fields =
if CTrans_models.is_objc_memory_model_controlled (Typename.name sil_typename) then
if CTrans_models.is_objc_memory_model_controlled (Typ.Name.name sil_typename) then
[Typ.Struct.objc_ref_counter_field]
else [] in
let annots =
if Typename.Cpp.is_class sil_typename then Annot.Class.cpp
if Typ.Name.Cpp.is_class sil_typename then Annot.Class.cpp
else Annot.Item.empty (* No annotations for structs *) in
if is_complete_definition then (
CAst_utils.update_sil_types_map type_ptr (Typ.Tstruct sil_typename);
@ -205,7 +209,7 @@ and get_record_struct_type tenv definition_decl =
let fields = CGeneral_utils.append_no_duplicates_fields non_statics extra_fields in
let statics = [] in (* Note: We treat static field same as global variables *)
let methods = [] in (* C++ methods are not put into tenv (info isn't used) *)
let supers = get_superclass_list_cpp definition_decl in
let supers = get_superclass_list_cpp tenv definition_decl in
let specialization = get_template_specialization tenv definition_decl in
Tenv.mk_struct tenv ~fields ~statics ~methods ~supers ~annots ~specialization
sil_typename |> ignore;

@ -11,9 +11,7 @@ open! IStd
(** Processes types and record declarations by adding them to the tenv *)
val get_record_name : Clang_ast_t.decl -> string
val get_record_typename : Clang_ast_t.decl -> Typename.t
val get_record_typename : ?tenv:Tenv.t -> Clang_ast_t.decl -> Typ.Name.t
val add_types_from_decl_to_tenv : Tenv.t -> Clang_ast_t.decl -> Typ.t
@ -23,7 +21,7 @@ val add_predefined_types : Tenv.t -> unit
val type_ptr_to_sil_type : Tenv.t -> Clang_ast_t.type_ptr -> Typ.t
val class_from_pointer_type : Tenv.t -> Clang_ast_t.type_ptr -> Typename.t
val class_from_pointer_type : Tenv.t -> Clang_ast_t.type_ptr -> Typ.Name.t
val get_class_type_np : Tenv.t -> Clang_ast_t.expr_info ->
Clang_ast_t.obj_c_message_expr_info -> Typ.t

@ -111,7 +111,7 @@ let create_class_qual_type ?(is_const=false) typename =
create_qual_type ~is_const @@ create_class_type typename
let make_objc_class_type class_name =
create_class_type (Typename.Objc.from_string class_name)
create_class_type (Typ.Name.Objc.from_string class_name)
let create_struct_type struct_name = `StructType struct_name

@ -44,10 +44,10 @@ val create_void_unsigned_long_type : type_ptr
val create_void_void_type : type_ptr
val create_class_type : Typename.t -> type_ptr
val create_class_qual_type : ?is_const:bool -> Typename.t -> qual_type
val create_class_type : Typ.Name.t -> type_ptr
val create_class_qual_type : ?is_const:bool -> Typ.Name.t -> qual_type
val create_struct_type : Typename.t -> type_ptr
val create_struct_type : Typ.Name.t -> type_ptr
val create_pointer_type : type_ptr -> type_ptr
val create_pointer_qual_type : is_const:bool -> type_ptr -> qual_type
@ -79,7 +79,7 @@ val make_message_expr : type_ptr -> string -> stmt -> stmt_info -> bool -> stmt
val make_binary_stmt : stmt -> stmt -> stmt_info -> expr_info -> binary_operator_info -> stmt
val make_obj_c_message_expr_info_class : string -> Typename.t -> pointer option ->
val make_obj_c_message_expr_info_class : string -> Typ.Name.t -> pointer option ->
obj_c_message_expr_info
val make_obj_c_message_expr_info_instance : string -> obj_c_message_expr_info

@ -103,9 +103,11 @@ let get_curr_class_name curr_class =
| None -> assert false in
CAst_utils.get_qualified_name name_info
let get_curr_class_typename curr_class =
let get_curr_class_typename context =
let tenv = context.tenv in
let curr_class = get_curr_class context in
match get_curr_class_ptr curr_class |> CAst_utils.get_decl with
| Some decl -> CType_decl.get_record_typename decl
| Some decl -> CType_decl.get_record_typename ~tenv decl
| None -> assert false
let curr_class_to_string curr_class =

@ -47,7 +47,7 @@ val get_curr_class : t -> curr_class
val get_curr_class_name : curr_class -> string
val get_curr_class_typename : curr_class -> Typename.t
val get_curr_class_typename : t -> Typ.Name.t
val get_curr_class_decl_ptr : curr_class -> Clang_ast_t.pointer

@ -16,7 +16,7 @@ module L = Logging
type field_type = Ident.fieldname * Typ.t * (Annot.t * bool) list
let rec get_fields_super_classes tenv super_class =
Logging.out_debug " ... Getting fields of superclass '%s'\n" (Typename.to_string super_class);
Logging.out_debug " ... Getting fields of superclass '%s'\n" (Typ.Name.to_string super_class);
match Tenv.lookup tenv super_class with
| None -> []
| Some { fields; supers = super_class :: _ } ->
@ -29,7 +29,7 @@ let fields_superclass tenv interface_decl_info =
| Some dr ->
(match dr.Clang_ast_t.dr_name with
| Some sc ->
let classname = Typename.Objc.from_string (CAst_utils.get_qualified_name sc) in
let classname = Typ.Name.Objc.from_string (CAst_utils.get_qualified_name sc) in
get_fields_super_classes tenv classname
| _ -> [])
| _ -> []
@ -78,7 +78,7 @@ let rec get_fields type_ptr_to_sil_type tenv decl_list =
(* Add potential extra fields defined only in the implementation of the class *)
(* to the info given in the interface. Update the tenv accordingly. *)
let add_missing_fields tenv class_name missing_fields =
let class_tn_name = Typename.Objc.from_string class_name in
let class_tn_name = Typ.Name.Objc.from_string class_name in
match Tenv.lookup tenv class_tn_name with
| Some ({ fields } as struct_typ) ->
let new_fields = CGeneral_utils.append_no_duplicates_fields fields missing_fields in

@ -204,7 +204,7 @@ struct
| ObjCImplementationDecl(decl_info, _, decl_list, _, _) ->
let curr_class = CContext.ContextClsDeclPtr dec_ptr in
let class_typename = CType_decl.get_record_typename dec in
let class_typename = CType_decl.get_record_typename ~tenv dec in
let type_ptr_to_sil_type = CType_decl.type_ptr_to_sil_type in
ignore (ObjcInterface_decl.interface_impl_declaration type_ptr_to_sil_type tenv dec);
CMethod_trans.add_default_method_for_class trans_unit_ctx class_typename decl_info;

@ -38,7 +38,7 @@ let rec append_no_duplicates eq list1 list2 =
| [] -> list1
let append_no_duplicates_csu list1 list2 =
append_no_duplicates Typename.equal list1 list2
append_no_duplicates Typ.Name.equal list1 list2
let append_no_duplicates_annotations list1 list2 =
let eq (annot1, _) (annot2, _) = String.equal annot1.Annot.class_name annot2.Annot.class_name in

@ -21,7 +21,7 @@ val append_no_duplicates_fields : (Ident.fieldname * Typ.t * Annot.Item.t) list
(Ident.fieldname * Typ.t * Annot.Item.t) list
val append_no_duplicates_csu :
Typename.t list -> Typename.t list -> Typename.t list
Typ.Name.t list -> Typ.Name.t list -> Typ.Name.t list
val sort_fields :
(Ident.fieldname * Typ.t * Annot.Item.t) list ->

@ -250,7 +250,7 @@ let get_superclass_curr_class_objc context =
super_of_decl_ref_opt ocidi.ocidi_class_interface
| _ -> assert false in
match CContext.get_curr_class context with
| CContext.ContextClsDeclPtr ptr -> Typename.Objc.from_string (retreive_super_name ptr)
| CContext.ContextClsDeclPtr ptr -> Typ.Name.Objc.from_string (retreive_super_name ptr)
| CContext.ContextNoCls -> assert false
(* Gets the class name from a method signature found by clang, if search is successful *)

@ -36,10 +36,10 @@ val get_objc_method_data : Clang_ast_t.obj_c_message_expr_info ->
(string * Clang_ast_t.pointer option * method_call_type)
val get_class_name_method_call_from_receiver_kind : CContext.t ->
Clang_ast_t.obj_c_message_expr_info -> (Exp.t * Typ.t) list -> Typename.t
Clang_ast_t.obj_c_message_expr_info -> (Exp.t * Typ.t) list -> Typ.Name.t
val get_class_name_method_call_from_clang : CFrontend_config.translation_unit_context -> Tenv.t ->
Clang_ast_t.obj_c_message_expr_info -> Typename.t option
Clang_ast_t.obj_c_message_expr_info -> Typ.Name.t option
val method_signature_of_decl : CFrontend_config.translation_unit_context -> Tenv.t ->
Clang_ast_t.decl -> CModule_type.block_data option ->
@ -51,10 +51,10 @@ val method_signature_of_pointer : CFrontend_config.translation_unit_context -> T
val get_method_name_from_clang : Tenv.t -> CMethod_signature.method_signature option ->
CMethod_signature.method_signature option
val create_procdesc_with_pointer : CContext.t -> Clang_ast_t.pointer -> Typename.t option ->
val create_procdesc_with_pointer : CContext.t -> Clang_ast_t.pointer -> Typ.Name.t option ->
string -> Typ.Procname.t
val add_default_method_for_class : CFrontend_config.translation_unit_context -> Typename.t ->
val add_default_method_for_class : CFrontend_config.translation_unit_context -> Typ.Name.t ->
Clang_ast_t.decl_info -> unit
val get_procname_from_cpp_lambda : CContext.t -> Clang_ast_t.decl -> Typ.Procname.t

@ -116,7 +116,7 @@ struct
Logging.out_debug "Block %s field:\n" block_name;
List.iter ~f:(fun (fn, _, _) ->
Logging.out_debug "-----> field: '%s'\n" (Ident.fieldname_to_string fn)) fields;
let block_typename = Typename.Objc.from_string block_name in
let block_typename = Typ.Name.Objc.from_string block_name in
ignore (Tenv.mk_struct tenv ~fields block_typename);
let block_type = Typ.Tstruct block_typename in
let trans_res =
@ -566,7 +566,7 @@ struct
type_ptr with
| Some builtin_pname -> builtin_pname
| None ->
let class_typename = Typename.Cpp.from_string
let class_typename = Typ.Name.Cpp.from_string
(CAst_utils.get_class_name_from_member name_info) in
CMethod_trans.create_procdesc_with_pointer context decl_ptr (Some class_typename)
method_name in
@ -656,8 +656,7 @@ struct
init_expr_trans trans_state (var_exp, typ) stmt_info init_expr
else empty_res_trans in
let exps = if Self.is_var_self pvar (CContext.is_objc_method context) then
let curr_class = CContext.get_curr_class context in
let class_typename = CContext.get_curr_class_typename curr_class in
let class_typename = CContext.get_curr_class_typename context in
if (CType.is_class typ) then
raise (Self.SelfClassException class_typename)
else

@ -11,7 +11,7 @@ open! IStd
open Objc_models
let class_equal class_typename class_name = String.equal (Typename.name class_typename) class_name
let class_equal class_typename class_name = String.equal (Typ.Name.name class_typename) class_name
let is_cf_non_null_alloc pname =
String.equal (Typ.Procname.to_string pname) CFrontend_config.cf_non_null_alloc
@ -158,7 +158,7 @@ let get_predefined_ms_retain_release method_name mk_procname lang =
let return_type =
if is_retain_method method_name || is_autorelease_method method_name
then Ast_expressions.create_id_type else Ast_expressions.create_void_type in
let class_typename = Typename.Objc.from_string CFrontend_config.nsobject_cl in
let class_typename = Typ.Name.Objc.from_string CFrontend_config.nsobject_cl in
let class_type = Ast_expressions.create_class_qual_type class_typename in
let args = [(Mangled.from_string CFrontend_config.self, class_type)] in
get_predefined_ms_method condition class_typename method_name Typ.Procname.ObjCInstanceMethod

@ -39,8 +39,8 @@ val is_toll_free_bridging : Typ.Procname.t -> bool
val is_cf_retain_release : Typ.Procname.t -> bool
val get_predefined_model_method_signature : Typename.t -> string ->
(Typename.t -> string -> Typ.Procname.objc_cpp_method_kind -> Typ.Procname.t) ->
val get_predefined_model_method_signature : Typ.Name.t -> string ->
(Typ.Name.t -> string -> Typ.Procname.objc_cpp_method_kind -> Typ.Procname.t) ->
CFrontend_config.clang_lang -> CMethod_signature.method_signature option
val is_dispatch_function_name : string -> (string * int) option

@ -574,14 +574,14 @@ let rec get_type_from_exp_stmt stmt =
module Self =
struct
exception SelfClassException of Typename.t
exception SelfClassException of Typ.Name.t
let add_self_parameter_for_super_instance context procname loc mei =
if is_superinstance mei then
let typ, self_expr, ins =
let t' =
CType.add_pointer_to_typ
(Typ.Tstruct (CContext.get_curr_class_typename context.CContext.curr_class)) in
(Typ.Tstruct (CContext.get_curr_class_typename context)) in
let e = Exp.Lvar (Pvar.mk (Mangled.from_string CFrontend_config.self) procname) in
let id = Ident.create_fresh Ident.knormal in
t', Exp.Var id, [Sil.Load (id, e, t', loc)] in

@ -109,7 +109,7 @@ val alloc_trans :
Typ.Procname.t option -> trans_result
val new_or_alloc_trans : trans_state -> Location.t -> Clang_ast_t.stmt_info ->
Clang_ast_t.type_ptr -> Typename.t option -> string -> trans_result
Clang_ast_t.type_ptr -> Typ.Name.t option -> string -> trans_result
val cpp_new_trans : Location.t -> Typ.t -> Exp.t option -> trans_result
@ -202,7 +202,7 @@ end
module Self :
sig
exception SelfClassException of Typename.t
exception SelfClassException of Typ.Name.t
val add_self_parameter_for_super_instance :
CContext.t -> Typ.Procname.t -> Location.t -> Clang_ast_t.obj_c_message_expr_info ->

@ -11,8 +11,8 @@ open! IStd
let get_builtin_objc_typename builtin_type =
match builtin_type with
| `ObjCId -> Typename.C.from_string CFrontend_config.objc_object
| `ObjCClass -> Typename.C.from_string CFrontend_config.objc_class
| `ObjCId -> Typ.Name.C.from_string CFrontend_config.objc_object
| `ObjCClass -> Typ.Name.C.from_string CFrontend_config.objc_class
let get_builtin_objc_type builtin_type =
let typ = Typ.Tstruct (get_builtin_objc_typename builtin_type) in

@ -9,7 +9,7 @@
open! IStd
val get_builtin_objc_typename : [< `ObjCClass | `ObjCId ] -> Typename.t
val get_builtin_objc_typename : [< `ObjCClass | `ObjCId ] -> Typ.Name.t
val get_builtin_objc_type : [< `ObjCClass | `ObjCId ] -> Typ.t

@ -23,8 +23,8 @@ type t_ptr = [
| `Prebuilt of int
| `PointerOf of t_ptr
| `ReferenceOf of t_ptr
| `ClassType of Typename.t
| `StructType of Typename.t
| `ClassType of Typ.Name.t
| `StructType of Typ.Name.t
| `DeclPtr of int
| `ErrorType
] [@@deriving compare]
@ -40,8 +40,8 @@ let rec type_ptr_to_string type_ptr = match type_ptr with
| `Prebuilt raw -> "prebuilt_" ^ (string_of_int raw)
| `PointerOf typ -> "pointer_of_" ^ type_ptr_to_string typ
| `ReferenceOf typ -> "reference_of_" ^ type_ptr_to_string typ
| `ClassType name -> "class_name_" ^ Typename.name name
| `StructType name -> "struct_name_" ^ Typename.name name
| `ClassType name -> "class_name_" ^ Typ.Name.name name
| `StructType name -> "struct_name_" ^ Typ.Name.name name
| `DeclPtr raw -> "decl_ptr_" ^ (string_of_int raw)
| `ErrorType -> "error_type"

@ -59,7 +59,7 @@ let get_base_class_name_from_category decl =
| Some decl_ref ->
(match CAst_utils.get_decl decl_ref.Clang_ast_t.dr_decl_pointer with
| Some ObjCInterfaceDecl (_, name_info, _, _, _) ->
Some (Typename.Objc.from_string (CAst_utils.get_qualified_name name_info))
Some (Typ.Name.Objc.from_string (CAst_utils.get_qualified_name name_info))
| _ -> None)
| None -> None
@ -67,7 +67,7 @@ let get_base_class_name_from_category decl =
(* to the corresponding class. Update the tenv accordingly.*)
let process_category type_ptr_to_sil_type tenv class_name decl_info decl_list =
let decl_fields = CField_decl.get_fields type_ptr_to_sil_type tenv decl_list in
let class_tn_name = Typename.Objc.from_string class_name in
let class_tn_name = Typ.Name.Objc.from_string class_name in
let decl_key = `DeclPtr decl_info.Clang_ast_t.di_pointer in
CAst_utils.update_sil_types_map decl_key (Typ.Tstruct class_tn_name);
(match Tenv.lookup tenv class_tn_name with

@ -18,4 +18,4 @@ val category_impl_decl : CAst_utils.type_ptr_to_sil_type -> Tenv.t -> Clang_ast_
val noname_category : string -> string
val get_base_class_name_from_category : Clang_ast_t.decl -> Typename.t option
val get_base_class_name_from_category : Clang_ast_t.decl -> Typ.Name.t option

@ -60,8 +60,8 @@ let get_interface_supers super_opt protocols =
let super_class =
match super_opt with
| None -> []
| Some super -> [Typename.Objc.from_string super] in
let protocol_names = List.map ~f:Typename.Objc.protocol_from_string protocols in
| Some super -> [Typ.Name.Objc.from_string super] in
let protocol_names = List.map ~f:Typ.Name.Objc.protocol_from_string protocols in
let super_classes = super_class@protocol_names in
super_classes
@ -77,7 +77,7 @@ let create_supers_fields type_ptr_to_sil_type tenv decl_list
let add_class_to_tenv type_ptr_to_sil_type tenv decl_info name_info decl_list ocidi =
let class_name = CAst_utils.get_qualified_name name_info in
Logging.out_debug "ADDING: ObjCInterfaceDecl for '%s'\n" class_name;
let interface_name = Typename.Objc.from_string class_name in
let interface_name = Typ.Name.Objc.from_string class_name in
let decl_key = `DeclPtr decl_info.Clang_ast_t.di_pointer in
CAst_utils.update_sil_types_map decl_key (Typ.Tstruct interface_name);
let decl_supers, decl_fields =
@ -89,7 +89,7 @@ let add_class_to_tenv type_ptr_to_sil_type tenv decl_info name_info decl_list oc
Logging.out_debug "----->SuperClass field: '%s' " (Ident.fieldname_to_string fn);
Logging.out_debug "type: '%s'\n" (Typ.to_string ft)) fields_sc;
(*In case we found categories, or partial definition of this class earlier and they are already in the tenv *)
let fields, (supers : Typename.t list) =
let fields, (supers : Typ.Name.t list) =
match Tenv.lookup tenv interface_name with
| Some { fields; supers} ->
CGeneral_utils.append_no_duplicates_fields decl_fields fields,
@ -107,7 +107,7 @@ let add_class_to_tenv type_ptr_to_sil_type tenv decl_info name_info decl_list oc
Tenv.mk_struct tenv
~fields: all_fields ~supers ~methods:[] ~annots:Annot.Class.objc interface_name );
Logging.out_debug
" >>>Verifying that Typename '%s' is in tenv\n" (Typename.to_string interface_name);
" >>>Verifying that Typename '%s' is in tenv\n" (Typ.Name.to_string interface_name);
(match Tenv.lookup tenv interface_name with
| Some st ->
Logging.out_debug " >>>OK. Found typ='%a'\n"
@ -140,7 +140,7 @@ let interface_impl_declaration type_ptr_to_sil_type tenv decl =
let _ = add_class_decl type_ptr_to_sil_type tenv idi in
let fields = CField_decl.get_fields type_ptr_to_sil_type tenv decl_list in
CField_decl.add_missing_fields tenv class_name fields;
let class_tn_name = Typename.Objc.from_string class_name in
let class_tn_name = Typ.Name.Objc.from_string class_name in
let decl_key = `DeclPtr decl_info.Clang_ast_t.di_pointer in
let class_typ = Typ.Tstruct class_tn_name in
CAst_utils.update_sil_types_map decl_key class_typ;

@ -25,7 +25,7 @@ let protocol_decl type_ptr_to_sil_type tenv decl =
(* Here we are giving a similar treatment as interfaces (see above)*)
(* It may turn out that we need a more specific treatment for protocols*)
Logging.out_debug "ADDING: ObjCProtocolDecl for '%s'\n" name;
let protocol_name = Typename.Objc.protocol_from_string name in
let protocol_name = Typ.Name.Objc.protocol_from_string name in
let decl_key = `DeclPtr decl_info.Clang_ast_t.di_pointer in
CAst_utils.update_sil_types_map decl_key (Typ.Tstruct protocol_name);
ignore( Tenv.mk_struct tenv ~methods:[] protocol_name );

@ -118,8 +118,8 @@ let check_condition tenv case_zero find_canonical_duplicate curr_pdesc
let loc = Procdesc.Node.get_loc node in
let throwable_found = ref false in
let typ_is_throwable = function
| Typ.Tstruct (TN_csu (Class Java, _) as name) ->
String.equal (Typename.name name) "java.lang.Throwable"
| Typ.Tstruct (TN_csu (Class Java, _, _) as name) ->
String.equal (Typ.Name.name name) "java.lang.Throwable"
| _ -> false in
let do_instr = function
| Sil.Call (_, Exp.Const (Const.Cfun pn), [_; (Exp.Sizeof(t, _, _), _)], _, _) when
@ -289,7 +289,7 @@ let check_constructor_initialization tenv
let should_check_field_initialization =
let in_current_class =
let fld_cname = Ident.java_fieldname_get_class fn in
String.equal (Typename.name name) fld_cname in
String.equal (Typ.Name.name name) fld_cname in
not injector_readonly_annotated &&
PatternMatch.type_is_class ft &&
in_current_class &&

@ -58,7 +58,7 @@ let android_lifecycles =
let is_subtype_package_class tenv tname package classname =
PatternMatch.is_subtype tenv
tname (Typename.Java.from_package_class package classname)
tname (Typ.Name.Java.from_package_class package classname)
let is_context tenv tname =
is_subtype_package_class tenv tname "android.content" "Context"
@ -78,7 +78,7 @@ let is_fragment tenv tname =
(** return true if [class_name] is the name of a class that belong to the Android framework *)
let is_android_lib_class class_name =
let class_str = Typename.name class_name in
let class_str = Typ.Name.name class_name in
String.is_prefix ~prefix:"android" class_str || String.is_prefix ~prefix:"com.android" class_str
(** given an Android framework type mangled string [lifecycle_typ] (e.g., android.app.Activity) and

@ -15,25 +15,25 @@ open! IStd
val get_lifecycles : (string * string * string list) list
(** return true if [typename] <: android.content.Context *)
val is_context : Tenv.t -> Typename.t -> bool
val is_context : Tenv.t -> Typ.Name.t -> bool
(** return true if [typename] <: android.app.Application *)
val is_application : Tenv.t -> Typename.t -> bool
val is_application : Tenv.t -> Typ.Name.t -> bool
(** return true if [typename] <: android.app.Activity *)
val is_activity : Tenv.t -> Typename.t -> bool
val is_activity : Tenv.t -> Typ.Name.t -> bool
(** return true if [typename] <: android.view.View *)
val is_view : Tenv.t -> Typename.t -> bool
val is_view : Tenv.t -> Typ.Name.t -> bool
val is_fragment : Tenv.t -> Typename.t -> bool
val is_fragment : Tenv.t -> Typ.Name.t -> bool
(** return true if [procname] is a special lifecycle cleanup method *)
val is_destroy_method : Typ.Procname.t -> bool
(** given an Android framework type mangled string [lifecycle_typ] (e.g., android.app.Activity)
and a list of method names [lifecycle_procs_strs], get the appropriate typ and procnames *)
val get_lifecycle_for_framework_typ_opt : Tenv.t -> Typename.t -> string list -> Typ.Procname.t list
val get_lifecycle_for_framework_typ_opt : Tenv.t -> Typ.Name.t -> string list -> Typ.Procname.t list
(** return true if [class_name] is the name of a class that belong to the Android framework *)
val is_android_lib_class : Typename.t -> bool
val is_android_lib_class : Typ.Name.t -> bool

@ -18,7 +18,7 @@ module F = Format
constituting a lifecycle trace *)
let try_create_lifecycle_trace name lifecycle_name lifecycle_procs tenv =
match name with
| Typename.TN_csu (Class Java, _) ->
| Typ.TN_csu (Class Java, _, _) ->
if PatternMatch.is_subtype tenv name lifecycle_name &&
not (AndroidFramework.is_android_lib_class name) then
let ptr_to_struct_typ = Some (Typ.Tptr (Tstruct name, Pk_pointer)) in
@ -37,7 +37,7 @@ let try_create_lifecycle_trace name lifecycle_name lifecycle_procs tenv =
(** generate a harness for a lifecycle type in an Android application *)
let create_harness cfg cg tenv =
List.iter ~f:(fun (pkg, clazz, lifecycle_methods) ->
let typname = Typename.Java.from_package_class pkg clazz in
let typname = Typ.Name.Java.from_package_class pkg clazz in
let framework_procs =
AndroidFramework.get_lifecycle_for_framework_typ_opt tenv typname lifecycle_methods in
(* iterate through the type environment and generate a lifecycle harness for each
@ -49,11 +49,11 @@ let create_harness cfg cg tenv =
| [] -> ()
| lifecycle_trace ->
let harness_procname =
let harness_cls_name = Typename.name name in
let harness_cls_name = Typ.Name.name name in
let pname =
Typ.Procname.Java
(Typ.Procname.java
(Typename.Java.from_string harness_cls_name) None
(Typ.Name.Java.from_string harness_cls_name) None
"InferGeneratedHarness" [] Typ.Procname.Static) in
match pname with
| Typ.Procname.Java harness_procname -> harness_procname

@ -98,7 +98,7 @@ let rec inhabit_typ tenv typ cfg env =
match typ with
| Tstruct name -> (
match name, Tenv.lookup tenv name with
| TN_csu (Class _, _), Some { methods } ->
| TN_csu (Class _, _, _), Some { methods } ->
let is_suitable_constructor p =
let try_get_non_receiver_formals p =
get_non_receiver_formals (formals_from_name cfg p) in

@ -58,7 +58,7 @@ let const_type const =
let typename_of_classname cn =
Typename.Java.from_string (JBasics.cn_name cn)
Typ.Name.Java.from_string (JBasics.cn_name cn)
let rec get_named_type vt =
@ -88,8 +88,8 @@ let rec create_array_type typ dim =
let extract_cn_no_obj typ =
match typ with
| Typ.Tptr (Tstruct (TN_csu (Class _, _) as name), Pk_pointer) ->
let class_name = JBasics.make_cn (Typename.name name) in
| Typ.Tptr (Tstruct (TN_csu (Class _, _, _) as name), Pk_pointer) ->
let class_name = JBasics.make_cn (Typ.Name.name name) in
if JBasics.cn_equal class_name JBasics.java_lang_object then None
else
let jbir_class_name = class_name in
@ -193,7 +193,7 @@ let get_method_kind m =
let get_method_procname cn ms method_kind =
let return_type_name, method_name, args_type_name = method_signature_names ms in
let class_name = Typename.Java.from_string (JBasics.cn_name cn) in
let class_name = Typ.Name.Java.from_string (JBasics.cn_name cn) in
let proc_name_java =
Typ.Procname.java class_name return_type_name method_name args_type_name method_kind in
Typ.Procname.Java proc_name_java

@ -17,7 +17,7 @@ open Sawja_pack
val get_named_type : JBasics.value_type -> Typ.t
(** transforms a Java class name into a Sil class name *)
val typename_of_classname : JBasics.class_name -> Typename.t
val typename_of_classname : JBasics.class_name -> Typ.Name.t
(** returns a name for a field based on a class name and a field name *)
val create_fieldname : JBasics.class_name -> JBasics.field_signature -> Ident.fieldname

@ -28,7 +28,7 @@ include
| Typ.Tptr (Tstruct original_typename, _) ->
PatternMatch.supertype_exists
tenv
(fun typename _ -> String.equal (Typename.name typename) class_string)
(fun typename _ -> String.equal (Typ.Name.name typename) class_string)
original_typename
| _ ->
false in

@ -47,7 +47,7 @@ module SourceKind = struct
Some Other
| class_name, method_name ->
let taint_matching_supertype typename _ =
match Typename.name typename, method_name with
match Typ.Name.name typename, method_name with
| "android.app.Activity", "getIntent" ->
Some Intent
| "android.content.Intent", "getStringExtra" ->
@ -60,7 +60,7 @@ module SourceKind = struct
PatternMatch.supertype_find_map_opt
tenv
taint_matching_supertype
(Typename.Java.from_string class_name) in
(Typ.Name.Java.from_string class_name) in
begin
match kind_opt with
| Some _ -> kind_opt
@ -85,7 +85,7 @@ module SourceKind = struct
let taint_formal_with_types ((formal_name, formal_typ) as formal) =
let matches_classname = match formal_typ with
| Typ.Tptr (Tstruct typename, _) ->
List.mem ~equal:String.equal type_strs (Typename.name typename)
List.mem ~equal:String.equal type_strs (Typ.Name.name typename)
| _ ->
false in
if matches_classname
@ -104,7 +104,7 @@ module SourceKind = struct
taint_formals_with_types ["java.lang.Integer"; "java.lang.String"] Other formals
| class_name, method_name ->
let taint_matching_supertype typename _ =
match Typename.name typename, method_name with
match Typ.Name.name typename, method_name with
| "android.app.Activity", ("onActivityResult" | "onNewIntent") ->
Some (taint_formals_with_types ["android.content.Intent"] Intent formals)
| _ ->
@ -114,7 +114,7 @@ module SourceKind = struct
PatternMatch.supertype_find_map_opt
tenv
taint_matching_supertype
(Typename.Java.from_string class_name) with
(Typ.Name.Java.from_string class_name) with
| Some tainted_formals -> tainted_formals
| None -> Source.all_formals_untainted pdesc
end
@ -174,7 +174,7 @@ module SinkKind = struct
[Other, 0, false]
| class_name, method_name ->
let taint_matching_supertype typename _ =
match Typename.name typename, method_name with
match Typ.Name.name typename, method_name with
| "android.app.Activity",
("startActivityFromChild" | "startActivityFromFragment") ->
Some (taint_nth 1 Intent ~report_reachable:true)
@ -240,7 +240,7 @@ module SinkKind = struct
PatternMatch.supertype_find_map_opt
tenv
taint_matching_supertype
(Typename.Java.from_string class_name) with
(Typ.Name.Java.from_string class_name) with
| Some sinks -> sinks
| None -> []
end

Loading…
Cancel
Save