Module `Concurrency.RacerDModels`

val is_container_read : IR.Tenv.t -> IR.Procname.t -> bool
val is_container_write : IR.Tenv.t -> IR.Procname.t -> bool: return Some (access) if this procedure accesses the contents of a container (e.g., Map.get)

val has_return_annot : (IR.Annot.Item.t -> bool) -> IR.Procname.t -> bool
val is_functional : IR.Procname.t -> bool
val acquires_ownership : IR.Procname.t -> IR.Tenv.t -> bool
val is_box : IR.Procname.t -> bool: return true if the given procname boxes a primitive type into a reference type

val is_thread_confined_method : IR.Tenv.t -> IR.Procname.t -> bool: Methods in @ThreadConfined classes and methods annotated with @ThreadConfined are assumed to all run on the same thread. For the moment we won't warn on accesses resulting from use of such methods at all. In future we should account for races between these methods and methods from completely different classes that don't necessarily run on the same thread as the confined object.

val should_analyze_proc : IR.Tenv.t -> IR.Procname.t -> bool: return true if we should compute a summary for the procedure. if this returns false, we won't analyze the procedure or report any warnings on it. note: in the future, we will want to analyze the procedures in all of these cases in order to find more bugs. this is just a temporary measure to avoid obvious false positives

val get_current_class_and_threadsafe_superclasses : IR.Tenv.t -> IR.Procname.t -> (IR.Typ.name * IR.Typ.name list) option
val is_thread_safe_method : IR.Procname.t -> IR.Tenv.t -> bool: returns true if method or overriden method in superclass is @ThreadSafe, @ThreadSafe(enableChecks = true), or is defined as an alias of @ThreadSafe in a .inferconfig file.

val is_marked_thread_safe : IR.Procname.t -> IR.Tenv.t -> bool
val is_safe_access : 'a Absint.HilExp.Access.t -> Absint.HilExp.AccessExpression.t -> IR.Tenv.t -> bool: check if an access to a field is thread-confined, or whether the field is volatile

val should_flag_interface_call : IR.Tenv.t -> Absint.HilExp.t list -> IR.CallFlags.t -> IR.Procname.t -> bool: should an interface call be flagged as potentially non-thread safe?

val is_synchronized_container : IR.Procname.t -> Absint.HilExp.AccessExpression.t -> IR.Tenv.t -> bool: is a call on an access expression to a method of a synchronized container?

val is_initializer : IR.Tenv.t -> IR.Procname.t -> bool: should the given procedure be treated as a constructor/initializer?

val is_synchronized_container_constructor : IR.Tenv.t -> IR.Procname.t -> Absint.HilExp.t list -> bool
val is_converter_to_synchronized_container : IR.Tenv.t -> IR.Procname.t -> Absint.HilExp.t list -> bool: is the given procname a method that wraps a container into a thread-safe wrapper?