You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
375 lines
11 KiB
375 lines
11 KiB
(*
|
|
* Copyright (c) 2013 - present Facebook, Inc.
|
|
* All rights reserved.
|
|
*
|
|
* This source code is licensed under the BSD style license found in the
|
|
* LICENSE file in the root directory of this source tree. An additional grant
|
|
* of patent rights can be found in the PATENTS file in the same directory.
|
|
*)
|
|
|
|
open! Utils
|
|
|
|
module F = Format
|
|
module L = Logging
|
|
|
|
(** Annotations. *)
|
|
|
|
(** Method signature with annotations. *)
|
|
type annotated_signature = {
|
|
ret : Typ.item_annotation * Typ.t; (** Annotated return type. *)
|
|
params: (Mangled.t * Typ.item_annotation * Typ.t) list (** Annotated parameters. *)
|
|
}
|
|
|
|
let param_equal (s1, ia1, t1) (s2, ia2, t2) =
|
|
Mangled.equal s1 s2 &&
|
|
Typ.item_annotation_compare ia1 ia2 = 0 &&
|
|
Typ.equal t1 t2
|
|
|
|
let equal as1 as2 =
|
|
let ia1, t1 = as1.ret
|
|
and ia2, t2 = as2.ret in
|
|
Typ.item_annotation_compare ia1 ia2 = 0 &&
|
|
Typ.equal t1 t2 &&
|
|
IList.for_all2 param_equal as1.params as2.params
|
|
|
|
let visibleForTesting = "com.google.common.annotations.VisibleForTesting"
|
|
let suppressLint = "android.annotation.SuppressLint"
|
|
|
|
|
|
let get_field_type_and_annotation fn = function
|
|
| Typ.Tptr (Typ.Tstruct struct_typ, _)
|
|
| Typ.Tstruct struct_typ ->
|
|
(try
|
|
let (_, t, a) = IList.find (fun (f, _, _) ->
|
|
Ident.fieldname_equal f fn)
|
|
(struct_typ.Typ.instance_fields @ struct_typ.Typ.static_fields) in
|
|
Some (t, a)
|
|
with Not_found -> None)
|
|
| _ -> None
|
|
|
|
(** Return the annotations on the declaring class of [pname]. Only works for Java *)
|
|
let get_declaring_class_annotations pname tenv =
|
|
match Tenv.proc_extract_declaring_class_typ tenv pname with
|
|
| Some { Typ.struct_annotations } -> Some struct_annotations
|
|
| None -> None
|
|
|
|
let ia_iter f =
|
|
let ann_iter (a, _) = f a in
|
|
IList.iter ann_iter
|
|
|
|
let ma_iter f ((ia, ial) : Typ.method_annotation) =
|
|
IList.iter (ia_iter f) (ia:: ial)
|
|
|
|
let ma_has_annotation_with
|
|
(ma: Typ.method_annotation)
|
|
(predicate: Typ.annotation -> bool): bool =
|
|
let found = ref false in
|
|
ma_iter
|
|
(fun a -> if predicate a then found := true)
|
|
ma;
|
|
!found
|
|
|
|
let ia_has_annotation_with
|
|
(ia: Typ.item_annotation)
|
|
(predicate: Typ.annotation -> bool): bool =
|
|
let found = ref false in
|
|
ia_iter
|
|
(fun a -> if predicate a then found := true)
|
|
ia;
|
|
!found
|
|
|
|
(** Return true if [annot] ends with [ann_name] *)
|
|
let annot_ends_with annot ann_name =
|
|
let filter s =
|
|
let sl = String.length s in
|
|
let al = String.length ann_name in
|
|
sl >= al && String.sub s (sl - al) al = ann_name in
|
|
filter annot.Typ.class_name
|
|
|
|
(** Check if there is an annotation in [ia] which ends with the given name *)
|
|
let ia_ends_with ia ann_name =
|
|
let found = ref false in
|
|
ia_iter (fun a -> if annot_ends_with a ann_name then found := true) ia;
|
|
!found
|
|
|
|
let ia_contains ia ann_name =
|
|
let found = ref false in
|
|
ia_iter (fun a -> if ann_name = a.Typ.class_name then found := true) ia;
|
|
!found
|
|
|
|
let ia_get ia ann_name =
|
|
let found = ref None in
|
|
ia_iter (fun a -> if ann_name = a.Typ.class_name then found := Some a) ia;
|
|
!found
|
|
|
|
let ma_contains ma ann_names =
|
|
let found = ref false in
|
|
ma_iter (fun a ->
|
|
if IList.exists (string_equal a.Typ.class_name) ann_names then found := true
|
|
) ma;
|
|
!found
|
|
|
|
let pdesc_has_annot pdesc annot =
|
|
ma_contains (Cfg.Procdesc.get_attributes pdesc).ProcAttributes.method_annotation [annot]
|
|
|
|
let initializer_ = "Initializer"
|
|
let inject = "Inject"
|
|
let inject_view = "InjectView"
|
|
let bind = "Bind"
|
|
let bind_view = "BindView"
|
|
let bind_array = "BindArray"
|
|
let bind_bitmap = "BindBitmap"
|
|
let bind_drawable = "BindDrawable"
|
|
let bind_string = "BindString"
|
|
let suppress_view_nullability = "SuppressViewNullability"
|
|
let false_on_null = "FalseOnNull"
|
|
let mutable_ = "Mutable"
|
|
let nullable = "Nullable"
|
|
let nonnull = "Nonnull"
|
|
let camel_nonnull = "NonNull"
|
|
let notnull = "NotNull"
|
|
let present = "Present"
|
|
let strict = "com.facebook.infer.annotation.Strict"
|
|
let true_on_null = "TrueOnNull"
|
|
let verify_annotation = "com.facebook.infer.annotation.Verify"
|
|
let expensive = "Expensive"
|
|
let performance_critical = "PerformanceCritical"
|
|
let no_allocation = "NoAllocation"
|
|
let ignore_allocations = "IgnoreAllocations"
|
|
|
|
|
|
let suppress_warnings = "SuppressWarnings"
|
|
let privacy_source = "PrivacySource"
|
|
let privacy_sink = "PrivacySink"
|
|
let integrity_source = "IntegritySource"
|
|
let integrity_sink = "IntegritySink"
|
|
let guarded_by = "GuardedBy"
|
|
|
|
let ia_is_nullable ia =
|
|
ia_ends_with ia nullable
|
|
|
|
let ia_is_present ia =
|
|
ia_ends_with ia present
|
|
|
|
let ia_is_nonnull ia =
|
|
IList.exists
|
|
(ia_ends_with ia)
|
|
[nonnull; notnull; camel_nonnull]
|
|
|
|
let ia_is_false_on_null ia =
|
|
ia_ends_with ia false_on_null
|
|
|
|
let ia_is_true_on_null ia =
|
|
ia_ends_with ia true_on_null
|
|
|
|
let ia_is_initializer ia =
|
|
ia_ends_with ia initializer_
|
|
|
|
let field_injector_readwrite_list =
|
|
[
|
|
inject_view;
|
|
bind;
|
|
bind_view;
|
|
bind_array;
|
|
bind_bitmap;
|
|
bind_drawable;
|
|
bind_string;
|
|
suppress_view_nullability;
|
|
]
|
|
|
|
let field_injector_readonly_list =
|
|
inject
|
|
::
|
|
field_injector_readwrite_list
|
|
|
|
(** Annotations for readonly injectors.
|
|
The injector framework initializes the field but does not write null into it. *)
|
|
let ia_is_field_injector_readonly ia =
|
|
IList.exists
|
|
(ia_ends_with ia)
|
|
field_injector_readonly_list
|
|
|
|
(** Annotations for read-write injectors.
|
|
The injector framework initializes the field and can write null into it. *)
|
|
let ia_is_field_injector_readwrite ia =
|
|
IList.exists
|
|
(ia_ends_with ia)
|
|
field_injector_readwrite_list
|
|
|
|
let ia_is_mutable ia =
|
|
ia_ends_with ia mutable_
|
|
|
|
let ia_get_strict ia =
|
|
ia_get ia strict
|
|
|
|
let ia_is_verify ia =
|
|
ia_contains ia verify_annotation
|
|
|
|
let ia_is_expensive ia =
|
|
ia_ends_with ia expensive
|
|
|
|
let ia_is_performance_critical ia =
|
|
ia_ends_with ia performance_critical
|
|
|
|
let ia_is_no_allocation ia =
|
|
ia_ends_with ia no_allocation
|
|
|
|
let ia_is_ignore_allocations ia =
|
|
ia_ends_with ia ignore_allocations
|
|
|
|
let ia_is_suppress_warnings ia =
|
|
ia_ends_with ia suppress_warnings
|
|
|
|
let ia_is_privacy_source ia =
|
|
ia_ends_with ia privacy_source
|
|
|
|
let ia_is_privacy_sink ia =
|
|
ia_ends_with ia privacy_sink
|
|
|
|
let ia_is_integrity_source ia =
|
|
ia_ends_with ia integrity_source
|
|
|
|
let ia_is_integrity_sink ia =
|
|
ia_ends_with ia integrity_sink
|
|
|
|
let ia_is_guarded_by ia =
|
|
ia_ends_with ia guarded_by
|
|
|
|
type annotation =
|
|
| Nullable
|
|
| Present
|
|
|
|
let ia_is ann ia = match ann with
|
|
| Nullable -> ia_is_nullable ia
|
|
| Present -> ia_is_present ia
|
|
|
|
(** Get a method signature with annotations from a proc_attributes. *)
|
|
let get_annotated_signature proc_attributes : annotated_signature =
|
|
let method_annotation = proc_attributes.ProcAttributes.method_annotation in
|
|
let formals = proc_attributes.ProcAttributes.formals in
|
|
let ret_type = proc_attributes.ProcAttributes.ret_type in
|
|
let (ia, ial0) = method_annotation in
|
|
let natl =
|
|
let rec extract ial parl = match ial, parl with
|
|
| ia :: ial', (name, typ) :: parl' ->
|
|
(name, ia, typ) :: extract ial' parl'
|
|
| [], (name, typ) :: parl' ->
|
|
(name, Typ.item_annotation_empty, typ) :: extract [] parl'
|
|
| [], [] ->
|
|
[]
|
|
| _ :: _, [] ->
|
|
assert false in
|
|
IList.rev (extract (IList.rev ial0) (IList.rev formals)) in
|
|
let annotated_signature = { ret = (ia, ret_type); params = natl } in
|
|
annotated_signature
|
|
|
|
|
|
(** Check if the annotated signature is for a wrapper of an anonymous inner class method.
|
|
These wrappers have the same name as the original method, every type is Object, and the parameters
|
|
are called x0, x1, x2. *)
|
|
let annotated_signature_is_anonymous_inner_class_wrapper ann_sig proc_name =
|
|
let check_ret (ia, t) =
|
|
Typ.item_annotation_is_empty ia && PatternMatch.type_is_object t in
|
|
let x_param_found = ref false in
|
|
let name_is_x_number name =
|
|
let name_str = Mangled.to_string name in
|
|
let len = String.length name_str in
|
|
len >= 2 &&
|
|
String.sub name_str 0 1 = "x" &&
|
|
let s = String.sub name_str 1 (len - 1) in
|
|
let is_int =
|
|
try
|
|
ignore (int_of_string s);
|
|
x_param_found := true;
|
|
true
|
|
with Failure _ -> false in
|
|
is_int in
|
|
let check_param (name, ia, t) =
|
|
if Mangled.to_string name = "this" then true
|
|
else
|
|
name_is_x_number name &&
|
|
Typ.item_annotation_is_empty ia &&
|
|
PatternMatch.type_is_object t in
|
|
Procname.java_is_anonymous_inner_class proc_name
|
|
&& check_ret ann_sig.ret
|
|
&& IList.for_all check_param ann_sig.params
|
|
&& !x_param_found
|
|
|
|
(** Check if the given parameter has a Nullable annotation in the given signature *)
|
|
let param_is_nullable pvar ann_sig =
|
|
IList.exists
|
|
(fun (param, annot, _) ->
|
|
Mangled.equal param (Pvar.get_name pvar) && ia_is_nullable annot)
|
|
ann_sig.params
|
|
|
|
(** Pretty print a method signature with annotations. *)
|
|
let pp_annotated_signature proc_name fmt annotated_signature =
|
|
let pp_ia fmt ia = if ia <> [] then F.fprintf fmt "%a " Typ.pp_item_annotation ia in
|
|
let pp_annotated_param fmt (p, ia, t) =
|
|
F.fprintf fmt " %a%a %a" pp_ia ia (Typ.pp_full pe_text) t Mangled.pp p in
|
|
let ia, ret_type = annotated_signature.ret in
|
|
F.fprintf fmt "%a%a %s (%a )"
|
|
pp_ia ia
|
|
(Typ.pp_full pe_text) ret_type
|
|
(Procname.to_simplified_string proc_name)
|
|
(pp_comma_seq pp_annotated_param) annotated_signature.params
|
|
|
|
let mk_ann_str s = { Typ.class_name = s; Typ.parameters = [] }
|
|
let mk_ann = function
|
|
| Nullable -> mk_ann_str nullable
|
|
| Present -> mk_ann_str present
|
|
let mk_ia ann ia =
|
|
if ia_is ann ia then ia
|
|
else (mk_ann ann, true) :: ia
|
|
let mark_ia ann ia x =
|
|
if x then mk_ia ann ia else ia
|
|
|
|
let mk_ia_strict ia =
|
|
if ia_get_strict ia <> None then ia
|
|
else (mk_ann_str strict, true) :: ia
|
|
let mark_ia_strict ia x =
|
|
if x then mk_ia_strict ia else ia
|
|
|
|
(** Mark the annotated signature with the given annotation map. *)
|
|
let annotated_signature_mark proc_name ann asig (b, bs) =
|
|
let ia, t = asig.ret in
|
|
let ret' = mark_ia ann ia b, t in
|
|
let mark_param (s, ia, t) x =
|
|
let ia' = if x then mk_ia ann ia else ia in
|
|
(s, ia', t) in
|
|
let params' =
|
|
let fail () =
|
|
L.stdout
|
|
"INTERNAL ERROR: annotation for procedure %s has wrong number of arguments@."
|
|
(Procname.to_unique_id proc_name);
|
|
L.stdout " ANNOTATED SIGNATURE: %a@." (pp_annotated_signature proc_name) asig;
|
|
assert false in
|
|
let rec combine l1 l2 = match l1, l2 with
|
|
| (p, ia, t):: l1', l2' when Mangled.to_string p = "this" ->
|
|
(p, ia, t) :: combine l1' l2'
|
|
| (s, ia, t):: l1', x:: l2' ->
|
|
mark_param (s, ia, t) x :: combine l1' l2'
|
|
| [], _:: _ -> fail ()
|
|
| _:: _, [] -> fail ()
|
|
| [], [] -> [] in
|
|
combine asig.params bs in
|
|
{ ret = ret'; params = params'}
|
|
|
|
(** Mark the return of the annotated signature with the given annotation. *)
|
|
let annotated_signature_mark_return ann asig =
|
|
let ia, t = asig.ret in
|
|
let ret' = mark_ia ann ia true, t in
|
|
{ asig with ret = ret'}
|
|
|
|
(** Mark the return of the annotated signature @Strict. *)
|
|
let annotated_signature_mark_return_strict asig =
|
|
let ia, t = asig.ret in
|
|
let ret' = mark_ia_strict ia true, t in
|
|
{ asig with ret = ret'}
|
|
|
|
(** Mark the return of the method_annotation with the given annotation. *)
|
|
let method_annotation_mark_return ann method_annotation =
|
|
let ia_ret, params = method_annotation in
|
|
let ia_ret' = mark_ia ann ia_ret true in
|
|
ia_ret', params
|