diff --git a/website/static/man/next/infer-analyze.1.html b/website/static/man/next/infer-analyze.1.html index a4da3c55d..db2b7f5f7 100644 --- a/website/static/man/next/infer-analyze.1.html +++ b/website/static/man/next/infer-analyze.1.html @@ -520,14 +520,32 @@ modelled as allocs in Pulse

string

Regex of methods that should be -modelled as free in Pulse

+modelled as wrappers to free(3) in Pulse. The pointer +to be freed should be the first argument of the function. +This should only be needed if the code of the wrapper is not +visible to infer or if Pulse somehow doesn't understand it +(e.g. the call is dispatched to global function +pointers).

--pulse-model-malloc-pattern string

Regex of methods that should be -modelled as mallocs in Pulse

+modelled as wrappers to malloc(3) in Pulse. The size +to allocate should be the first argument of the function. +See --pulse-model-free-pattern for more +information.

+ + +

--pulse-model-realloc-pattern +string

+ +

Regex of methods that should be +modelled as wrappers to realloc(3) in Pulse. The +pointer to be reallocated should be the first argument of +the function and the new size the second argument. See +--pulse-model-free-pattern for more information.

--pulse-model-release-pattern diff --git a/website/static/man/next/infer.1.html b/website/static/man/next/infer.1.html index cfaf584b3..45c339d67 100644 --- a/website/static/man/next/infer.1.html +++ b/website/static/man/next/infer.1.html @@ -1706,14 +1706,32 @@ modelled as allocs in Pulse

--pulse-model-free-pattern string

Regex of methods that should be -modelled as free in Pulse

+modelled as wrappers to free(3) in Pulse. The pointer +to be freed should be the first argument of the function. +This should only be needed if the code of the wrapper is not +visible to infer or if Pulse somehow doesn't understand it +(e.g. the call is dispatched to global function +pointers).

See also infer-analyze(1).
--pulse-model-malloc-pattern
string

Regex of methods that should be -modelled as mallocs in Pulse

+modelled as wrappers to malloc(3) in Pulse. The size +to allocate should be the first argument of the function. +See --pulse-model-free-pattern for more +information.

+ +

See also +infer-analyze(1).
+--pulse-model-realloc-pattern
string

+ +

Regex of methods that should be +modelled as wrappers to realloc(3) in Pulse. The +pointer to be reallocated should be the first argument of +the function and the new size the second argument. See +--pulse-model-free-pattern for more information.

See also infer-analyze(1).
diff --git a/website/static/odoc/next/infer/Absint/AbstractDomain/InvertedMap/index.html b/website/static/odoc/next/infer/Absint/AbstractDomain/InvertedMap/index.html index a367f475c..8b63cd78b 100644 --- a/website/static/odoc/next/infer/Absint/AbstractDomain/InvertedMap/index.html +++ b/website/static/odoc/next/infer/Absint/AbstractDomain/InvertedMap/index.html @@ -1,2 +1,2 @@ -InvertedMap (infer.Absint.AbstractDomain.InvertedMap)

Module AbstractDomain.InvertedMap

Map domain ordered by intersection over the set of bindings, so the top element is the empty map. Every element implictly maps to top unless it is explicitly bound to something else

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithTop with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file +InvertedMap (infer.Absint.AbstractDomain.InvertedMap)

Module AbstractDomain.InvertedMap

Map domain ordered by intersection over the set of bindings, so the top element is the empty map. Every element implictly maps to top unless it is explicitly bound to something else

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithTop with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint/AbstractDomain/Map/index.html b/website/static/odoc/next/infer/Absint/AbstractDomain/Map/index.html index 571b63509..509351348 100644 --- a/website/static/odoc/next/infer/Absint/AbstractDomain/Map/index.html +++ b/website/static/odoc/next/infer/Absint/AbstractDomain/Map/index.html @@ -1,2 +1,2 @@ -Map (infer.Absint.AbstractDomain.Map)

Module AbstractDomain.Map

Map domain ordered by union over the set of bindings, so the bottom element is the empty map. Every element implicitly maps to bottom unless it is explicitly bound to something else

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithBottom with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file +Map (infer.Absint.AbstractDomain.Map)

Module AbstractDomain.Map

Map domain ordered by union over the set of bindings, so the bottom element is the empty map. Every element implicitly maps to bottom unless it is explicitly bound to something else

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithBottom with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint/AbstractDomain/MapOfPPMap/index.html b/website/static/odoc/next/infer/Absint/AbstractDomain/MapOfPPMap/index.html index d528870aa..93323bd3d 100644 --- a/website/static/odoc/next/infer/Absint/AbstractDomain/MapOfPPMap/index.html +++ b/website/static/odoc/next/infer/Absint/AbstractDomain/MapOfPPMap/index.html @@ -1,2 +1,2 @@ -MapOfPPMap (infer.Absint.AbstractDomain.MapOfPPMap)

Module AbstractDomain.MapOfPPMap

Map domain ordered by union over the set of bindings, so the bottom element is the empty map. Every element implicitly maps to bottom unless it is explicitly bound to something else. Uses PPMap as the underlying map

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithBottom with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file +MapOfPPMap (infer.Absint.AbstractDomain.MapOfPPMap)

Module AbstractDomain.MapOfPPMap

Map domain ordered by union over the set of bindings, so the bottom element is the empty map. Every element implicitly maps to bottom unless it is explicitly bound to something else. Uses PPMap as the underlying map

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithBottom with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint/AbstractDomain/SafeInvertedMap/index.html b/website/static/odoc/next/infer/Absint/AbstractDomain/SafeInvertedMap/index.html index f7c17ee2c..89228a2b5 100644 --- a/website/static/odoc/next/infer/Absint/AbstractDomain/SafeInvertedMap/index.html +++ b/website/static/odoc/next/infer/Absint/AbstractDomain/SafeInvertedMap/index.html @@ -1,2 +1,2 @@ -SafeInvertedMap (infer.Absint.AbstractDomain.SafeInvertedMap)

Module AbstractDomain.SafeInvertedMap

Similar to InvertedMap but it guarantees that it has a canonical form. For example, both {a -> top_v} and empty represent the same abstract value top in InvertedMap, but in this implementation, top is always implemented as empty by not adding the top_v explicitly.

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithTop with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file +SafeInvertedMap (infer.Absint.AbstractDomain.SafeInvertedMap)

Module AbstractDomain.SafeInvertedMap

Similar to InvertedMap but it guarantees that it has a canonical form. For example, both {a -> top_v} and empty represent the same abstract value top in InvertedMap, but in this implementation, top is always implemented as empty by not adding the top_v explicitly.

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithTop with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint/AbstractDomain/module-type-InvertedMapS/index.html b/website/static/odoc/next/infer/Absint/AbstractDomain/module-type-InvertedMapS/index.html index 1906178ec..44cbb95d9 100644 --- a/website/static/odoc/next/infer/Absint/AbstractDomain/module-type-InvertedMapS/index.html +++ b/website/static/odoc/next/infer/Absint/AbstractDomain/module-type-InvertedMapS/index.html @@ -1,2 +1,2 @@ -InvertedMapS (infer.Absint.AbstractDomain.InvertedMapS)

Module type AbstractDomain.InvertedMapS

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithTop with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file +InvertedMapS (infer.Absint.AbstractDomain.InvertedMapS)

Module type AbstractDomain.InvertedMapS

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithTop with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint/AbstractDomain/module-type-MapS/index.html b/website/static/odoc/next/infer/Absint/AbstractDomain/module-type-MapS/index.html index a93136c0d..e0cfd4636 100644 --- a/website/static/odoc/next/infer/Absint/AbstractDomain/module-type-MapS/index.html +++ b/website/static/odoc/next/infer/Absint/AbstractDomain/module-type-MapS/index.html @@ -1,2 +1,2 @@ -MapS (infer.Absint.AbstractDomain.MapS)

Module type AbstractDomain.MapS

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithBottom with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file +MapS (infer.Absint.AbstractDomain.MapS)

Module type AbstractDomain.MapS

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithBottom with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint/IdAccessPathMapDomain/index.html b/website/static/odoc/next/infer/Absint/IdAccessPathMapDomain/index.html index 4ee323801..705d30814 100644 --- a/website/static/odoc/next/infer/Absint/IdAccessPathMapDomain/index.html +++ b/website/static/odoc/next/infer/Absint/IdAccessPathMapDomain/index.html @@ -1,2 +1,2 @@ -IdAccessPathMapDomain (infer.Absint.IdAccessPathMapDomain)

Module Absint.IdAccessPathMapDomain

include AbstractDomain.MapS with type key = IR.Var.t and type value = HilExp.AccessExpression.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include AbstractDomain.WithBottom with type t := t
include AbstractDomain.S
include AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file +IdAccessPathMapDomain (infer.Absint.IdAccessPathMapDomain)

Module Absint.IdAccessPathMapDomain

include AbstractDomain.MapS with type key = IR.Var.t and type value = HilExp.AccessExpression.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include AbstractDomain.WithBottom with type t := t
include AbstractDomain.S
include AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint/PatternMatch/ObjectiveC/index.html b/website/static/odoc/next/infer/Absint/PatternMatch/ObjectiveC/index.html index ccd6895a4..2dec424d5 100644 --- a/website/static/odoc/next/infer/Absint/PatternMatch/ObjectiveC/index.html +++ b/website/static/odoc/next/infer/Absint/PatternMatch/ObjectiveC/index.html @@ -1,2 +1,2 @@ -ObjectiveC (infer.Absint.PatternMatch.ObjectiveC)

Module PatternMatch.ObjectiveC

val implements : string -> IR.Tenv.t -> string -> bool

Check whether class implements a given ObjC class

val implements_ns_string_variants : IR.Tenv.t -> string -> bool

Check whether class implements NSString or NSAttributedString

val conforms_to : protocol:string -> IR.Tenv.t -> string -> bool

Check whether class conforms to a given ObjC protocol

val implements_collection : IR.Tenv.t -> string -> bool
val is_core_graphics_create_or_copy : IR.Tenv.t -> string -> bool
val is_core_foundation_create_or_copy : IR.Tenv.t -> string -> bool
val is_core_graphics_release : IR.Tenv.t -> string -> bool
val is_modelled_as_alloc : IR.Tenv.t -> string -> bool
val is_modelled_as_release : IR.Tenv.t -> string -> bool
\ No newline at end of file +ObjectiveC (infer.Absint.PatternMatch.ObjectiveC)

Module PatternMatch.ObjectiveC

val implements : string -> IR.Tenv.t -> string -> bool

Check whether class implements a given ObjC class

val implements_ns_string_variants : IR.Tenv.t -> string -> bool

Check whether class implements NSString or NSAttributedString

val conforms_to : protocol:string -> IR.Tenv.t -> string -> bool

Check whether class conforms to a given ObjC protocol

val implements_collection : IR.Tenv.t -> string -> bool
val is_core_graphics_create_or_copy : IR.Tenv.t -> string -> bool
val is_core_foundation_create_or_copy : IR.Tenv.t -> string -> bool
val is_core_graphics_release : IR.Tenv.t -> string -> bool
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint__AbstractDomain/InvertedMap/index.html b/website/static/odoc/next/infer/Absint__AbstractDomain/InvertedMap/index.html index 61407c29c..1bd512eb8 100644 --- a/website/static/odoc/next/infer/Absint__AbstractDomain/InvertedMap/index.html +++ b/website/static/odoc/next/infer/Absint__AbstractDomain/InvertedMap/index.html @@ -1,2 +1,2 @@ -InvertedMap (infer.Absint__AbstractDomain.InvertedMap)

Module Absint__AbstractDomain.InvertedMap

Map domain ordered by intersection over the set of bindings, so the top element is the empty map. Every element implictly maps to top unless it is explicitly bound to something else

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithTop with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file +InvertedMap (infer.Absint__AbstractDomain.InvertedMap)

Module Absint__AbstractDomain.InvertedMap

Map domain ordered by intersection over the set of bindings, so the top element is the empty map. Every element implictly maps to top unless it is explicitly bound to something else

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithTop with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint__AbstractDomain/Map/index.html b/website/static/odoc/next/infer/Absint__AbstractDomain/Map/index.html index 5abbe1347..eaa2dbd75 100644 --- a/website/static/odoc/next/infer/Absint__AbstractDomain/Map/index.html +++ b/website/static/odoc/next/infer/Absint__AbstractDomain/Map/index.html @@ -1,2 +1,2 @@ -Map (infer.Absint__AbstractDomain.Map)

Module Absint__AbstractDomain.Map

Map domain ordered by union over the set of bindings, so the bottom element is the empty map. Every element implicitly maps to bottom unless it is explicitly bound to something else

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithBottom with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file +Map (infer.Absint__AbstractDomain.Map)

Module Absint__AbstractDomain.Map

Map domain ordered by union over the set of bindings, so the bottom element is the empty map. Every element implicitly maps to bottom unless it is explicitly bound to something else

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithBottom with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint__AbstractDomain/MapOfPPMap/index.html b/website/static/odoc/next/infer/Absint__AbstractDomain/MapOfPPMap/index.html index 001139c72..984375693 100644 --- a/website/static/odoc/next/infer/Absint__AbstractDomain/MapOfPPMap/index.html +++ b/website/static/odoc/next/infer/Absint__AbstractDomain/MapOfPPMap/index.html @@ -1,2 +1,2 @@ -MapOfPPMap (infer.Absint__AbstractDomain.MapOfPPMap)

Module Absint__AbstractDomain.MapOfPPMap

Map domain ordered by union over the set of bindings, so the bottom element is the empty map. Every element implicitly maps to bottom unless it is explicitly bound to something else. Uses PPMap as the underlying map

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithBottom with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file +MapOfPPMap (infer.Absint__AbstractDomain.MapOfPPMap)

Module Absint__AbstractDomain.MapOfPPMap

Map domain ordered by union over the set of bindings, so the bottom element is the empty map. Every element implicitly maps to bottom unless it is explicitly bound to something else. Uses PPMap as the underlying map

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithBottom with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint__AbstractDomain/SafeInvertedMap/index.html b/website/static/odoc/next/infer/Absint__AbstractDomain/SafeInvertedMap/index.html index 37c4c3a84..594e21136 100644 --- a/website/static/odoc/next/infer/Absint__AbstractDomain/SafeInvertedMap/index.html +++ b/website/static/odoc/next/infer/Absint__AbstractDomain/SafeInvertedMap/index.html @@ -1,2 +1,2 @@ -SafeInvertedMap (infer.Absint__AbstractDomain.SafeInvertedMap)

Module Absint__AbstractDomain.SafeInvertedMap

Similar to InvertedMap but it guarantees that it has a canonical form. For example, both {a -> top_v} and empty represent the same abstract value top in InvertedMap, but in this implementation, top is always implemented as empty by not adding the top_v explicitly.

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithTop with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file +SafeInvertedMap (infer.Absint__AbstractDomain.SafeInvertedMap)

Module Absint__AbstractDomain.SafeInvertedMap

Similar to InvertedMap but it guarantees that it has a canonical form. For example, both {a -> top_v} and empty represent the same abstract value top in InvertedMap, but in this implementation, top is always implemented as empty by not adding the top_v explicitly.

Parameters

Signature

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithTop with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint__AbstractDomain/module-type-InvertedMapS/index.html b/website/static/odoc/next/infer/Absint__AbstractDomain/module-type-InvertedMapS/index.html index e864994b8..7464566d2 100644 --- a/website/static/odoc/next/infer/Absint__AbstractDomain/module-type-InvertedMapS/index.html +++ b/website/static/odoc/next/infer/Absint__AbstractDomain/module-type-InvertedMapS/index.html @@ -1,2 +1,2 @@ -InvertedMapS (infer.Absint__AbstractDomain.InvertedMapS)

Module type Absint__AbstractDomain.InvertedMapS

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithTop with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file +InvertedMapS (infer.Absint__AbstractDomain.InvertedMapS)

Module type Absint__AbstractDomain.InvertedMapS

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithTop with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint__AbstractDomain/module-type-MapS/index.html b/website/static/odoc/next/infer/Absint__AbstractDomain/module-type-MapS/index.html index a5dd4428d..9111c1274 100644 --- a/website/static/odoc/next/infer/Absint__AbstractDomain/module-type-MapS/index.html +++ b/website/static/odoc/next/infer/Absint__AbstractDomain/module-type-MapS/index.html @@ -1,2 +1,2 @@ -MapS (infer.Absint__AbstractDomain.MapS)

Module type Absint__AbstractDomain.MapS

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithBottom with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file +MapS (infer.Absint__AbstractDomain.MapS)

Module type Absint__AbstractDomain.MapS

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include WithBottom with type t := t
include S
include NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint__IdAccessPathMapDomain/index.html b/website/static/odoc/next/infer/Absint__IdAccessPathMapDomain/index.html index c63303d6a..05b6504e7 100644 --- a/website/static/odoc/next/infer/Absint__IdAccessPathMapDomain/index.html +++ b/website/static/odoc/next/infer/Absint__IdAccessPathMapDomain/index.html @@ -1,2 +1,2 @@ -Absint__IdAccessPathMapDomain (infer.Absint__IdAccessPathMapDomain)

Module Absint__IdAccessPathMapDomain

include Absint.AbstractDomain.MapS with type key = IR.Var.t and type value = Absint.HilExp.AccessExpression.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file +Absint__IdAccessPathMapDomain (infer.Absint__IdAccessPathMapDomain)

Module Absint__IdAccessPathMapDomain

include Absint.AbstractDomain.MapS with type key = IR.Var.t and type value = Absint.HilExp.AccessExpression.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Absint__PatternMatch/ObjectiveC/index.html b/website/static/odoc/next/infer/Absint__PatternMatch/ObjectiveC/index.html index ba497e03d..c41f960da 100644 --- a/website/static/odoc/next/infer/Absint__PatternMatch/ObjectiveC/index.html +++ b/website/static/odoc/next/infer/Absint__PatternMatch/ObjectiveC/index.html @@ -1,2 +1,2 @@ -ObjectiveC (infer.Absint__PatternMatch.ObjectiveC)

Module Absint__PatternMatch.ObjectiveC

val implements : string -> IR.Tenv.t -> string -> bool

Check whether class implements a given ObjC class

val implements_ns_string_variants : IR.Tenv.t -> string -> bool

Check whether class implements NSString or NSAttributedString

val conforms_to : protocol:string -> IR.Tenv.t -> string -> bool

Check whether class conforms to a given ObjC protocol

val implements_collection : IR.Tenv.t -> string -> bool
val is_core_graphics_create_or_copy : IR.Tenv.t -> string -> bool
val is_core_foundation_create_or_copy : IR.Tenv.t -> string -> bool
val is_core_graphics_release : IR.Tenv.t -> string -> bool
val is_modelled_as_alloc : IR.Tenv.t -> string -> bool
val is_modelled_as_release : IR.Tenv.t -> string -> bool
\ No newline at end of file +ObjectiveC (infer.Absint__PatternMatch.ObjectiveC)

Module Absint__PatternMatch.ObjectiveC

val implements : string -> IR.Tenv.t -> string -> bool

Check whether class implements a given ObjC class

val implements_ns_string_variants : IR.Tenv.t -> string -> bool

Check whether class implements NSString or NSAttributedString

val conforms_to : protocol:string -> IR.Tenv.t -> string -> bool

Check whether class conforms to a given ObjC protocol

val implements_collection : IR.Tenv.t -> string -> bool
val is_core_graphics_create_or_copy : IR.Tenv.t -> string -> bool
val is_core_foundation_create_or_copy : IR.Tenv.t -> string -> bool
val is_core_graphics_release : IR.Tenv.t -> string -> bool
\ No newline at end of file diff --git a/website/static/odoc/next/infer/BO/ArrayBlk/index.html b/website/static/odoc/next/infer/BO/ArrayBlk/index.html index 7370f850b..91b418081 100644 --- a/website/static/odoc/next/infer/BO/ArrayBlk/index.html +++ b/website/static/odoc/next/infer/BO/ArrayBlk/index.html @@ -1,2 +1,2 @@ -ArrayBlk (infer.BO.ArrayBlk)

Module BO.ArrayBlk

module ArrInfo : sig ... end
include Absint.AbstractDomain.MapS with type key = AbsLoc.Allocsite.t and type value = ArrInfo.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

val compare : t -> t -> int
val bot : t
val make_c : AbsLoc.Allocsite.t -> offset:Itv.t -> size:Itv.t -> stride:Itv.t -> t

Make an array block for C

val make_java : AbsLoc.Allocsite.t -> length:Itv.t -> t

Make an array block for Java

val unknown : t
val get_pow_loc : t -> AbsLoc.PowLoc.t

Return all allocsites as PowLoc.t

val is_bot : t -> bool
val is_symbolic : t -> bool

Check if there is a symbolic integer value in its offset or size

val lift_cmp_itv : (Itv.t -> Itv.t -> Boolean.t) -> Boolean.EqualOrder.t -> t -> t -> Boolean.t

Lift a comparison of Itv.t and Loc.t to that of t. The comparison for Itv.t is used for integer values such as offset and size, and the comparison for Loc.t is used for allocsites.

val transform_length : f:(Itv.t -> Itv.t) -> t -> t

Apply f to all sizes

val prune_binop : IR.Binop.t -> t -> t -> t

prune_binop bop x y returns a pruned value of x by bop and y.

val prune_eq : t -> t -> t

prune_eq x y returns a pruned value of x by == y.

val prune_ne : t -> t -> t

prune_ne x y returns a pruned value of x by != y.

val prune_offset_le_size : t -> t

Prune offset by offset <= size

val minus_offset : t -> Itv.t -> t
val plus_offset : t -> Itv.t -> t
val diff : t -> t -> Itv.t

Return difference of offsets between given array blocks

val normalize : t -> t

Normalize all interval values such as offset and size in it. Thus, if an interval value is invalid, the interval value is replaced with bottom.

val subst : t -> Bounds.Bound.eval_sym -> AbsLoc.PowLoc.eval_locpath -> AbsLoc.PowLoc.t * t

Substitute symbolic abstract locations and symbolic interval value in the array block. eval_sym is to get substituted interval values and eval_locpath is to get substituted abstract locaion values. It also returns a set of abstract locations containing non-allocsite locations from the substitution results. Since the key of ArrayBlk.t is AbsLoc.Allocsite.t, they cannot be written in this domain.

val set_length : Itv.t -> t -> t
val set_offset : Itv.t -> t -> t
val set_stride : Z.t -> t -> t
val get_symbols : t -> BO.Symb.SymbolSet.t

Return all symbols for integer values in it

val get_offset : ?⁠cost_mode:bool -> t -> Itv.t

Return offset of the array block. If cost_mode is true, it returns a conservative (bigger than correct one), but not correct offset results.

val get_size : ?⁠cost_mode:bool -> t -> Itv.t

Return size of the array block. If cost_mode is true, it returns a conservative (bigger than correct one), but not correct size results.

\ No newline at end of file +ArrayBlk (infer.BO.ArrayBlk)

Module BO.ArrayBlk

module ArrInfo : sig ... end
include Absint.AbstractDomain.MapS with type key = AbsLoc.Allocsite.t and type value = ArrInfo.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

val compare : t -> t -> int
val bot : t
val make_c : AbsLoc.Allocsite.t -> offset:Itv.t -> size:Itv.t -> stride:Itv.t -> t

Make an array block for C

val make_java : AbsLoc.Allocsite.t -> length:Itv.t -> t

Make an array block for Java

val unknown : t
val get_pow_loc : t -> AbsLoc.PowLoc.t

Return all allocsites as PowLoc.t

val is_bot : t -> bool
val is_symbolic : t -> bool

Check if there is a symbolic integer value in its offset or size

val lift_cmp_itv : (Itv.t -> Itv.t -> Boolean.t) -> Boolean.EqualOrder.t -> t -> t -> Boolean.t

Lift a comparison of Itv.t and Loc.t to that of t. The comparison for Itv.t is used for integer values such as offset and size, and the comparison for Loc.t is used for allocsites.

val transform_length : f:(Itv.t -> Itv.t) -> t -> t

Apply f to all sizes

val prune_binop : IR.Binop.t -> t -> t -> t

prune_binop bop x y returns a pruned value of x by bop and y.

val prune_eq : t -> t -> t

prune_eq x y returns a pruned value of x by == y.

val prune_ne : t -> t -> t

prune_ne x y returns a pruned value of x by != y.

val prune_offset_le_size : t -> t

Prune offset by offset <= size

val minus_offset : t -> Itv.t -> t
val plus_offset : t -> Itv.t -> t
val diff : t -> t -> Itv.t

Return difference of offsets between given array blocks

val normalize : t -> t

Normalize all interval values such as offset and size in it. Thus, if an interval value is invalid, the interval value is replaced with bottom.

val subst : t -> Bounds.Bound.eval_sym -> AbsLoc.PowLoc.eval_locpath -> AbsLoc.PowLoc.t * t

Substitute symbolic abstract locations and symbolic interval value in the array block. eval_sym is to get substituted interval values and eval_locpath is to get substituted abstract locaion values. It also returns a set of abstract locations containing non-allocsite locations from the substitution results. Since the key of ArrayBlk.t is AbsLoc.Allocsite.t, they cannot be written in this domain.

val set_length : Itv.t -> t -> t
val set_offset : Itv.t -> t -> t
val set_stride : Z.t -> t -> t
val get_symbols : t -> BO.Symb.SymbolSet.t

Return all symbols for integer values in it

val get_offset : ?⁠cost_mode:bool -> t -> Itv.t

Return offset of the array block. If cost_mode is true, it returns a conservative (bigger than correct one), but not correct offset results.

val get_size : ?⁠cost_mode:bool -> t -> Itv.t

Return size of the array block. If cost_mode is true, it returns a conservative (bigger than correct one), but not correct size results.

\ No newline at end of file diff --git a/website/static/odoc/next/infer/BO/BufferOverrunDomain/AliasTargets/index.html b/website/static/odoc/next/infer/BO/BufferOverrunDomain/AliasTargets/index.html index 36476b816..da491fe89 100644 --- a/website/static/odoc/next/infer/BO/BufferOverrunDomain/AliasTargets/index.html +++ b/website/static/odoc/next/infer/BO/BufferOverrunDomain/AliasTargets/index.html @@ -1,2 +1,2 @@ -AliasTargets (infer.BO.BufferOverrunDomain.AliasTargets)

Module BufferOverrunDomain.AliasTargets

include Absint.AbstractDomain.InvertedMapS with type key = KeyRhs.t and type value = AliasTarget.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val exists2 : (key -> value -> key -> value -> bool) -> t -> t -> bool
val find_simple_alias : t -> key option

Find a simple alias from the set of aliases

val subst : subst_loc:(key -> key option) -> t -> t

Substitute alias target value

\ No newline at end of file +AliasTargets (infer.BO.BufferOverrunDomain.AliasTargets)

Module BufferOverrunDomain.AliasTargets

include Absint.AbstractDomain.InvertedMapS with type key = KeyRhs.t and type value = AliasTarget.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val exists2 : (key -> value -> key -> value -> bool) -> t -> t -> bool
val find_simple_alias : t -> key option

Find a simple alias from the set of aliases

val subst : subst_loc:(key -> key option) -> t -> t

Substitute alias target value

\ No newline at end of file diff --git a/website/static/odoc/next/infer/BO/BufferOverrunDomain/PrunePairs/index.html b/website/static/odoc/next/infer/BO/BufferOverrunDomain/PrunePairs/index.html index 93846ebc5..455564c7e 100644 --- a/website/static/odoc/next/infer/BO/BufferOverrunDomain/PrunePairs/index.html +++ b/website/static/odoc/next/infer/BO/BufferOverrunDomain/PrunePairs/index.html @@ -1,2 +1,2 @@ -PrunePairs (infer.BO.BufferOverrunDomain.PrunePairs)

Module BufferOverrunDomain.PrunePairs

PrunePairs is a map from abstract locations to abstract values that represents pruned results in the latest pruning. It uses InvertedMap because more pruning means smaller abstract states.

include Absint.AbstractDomain.InvertedMapS with type key = AbsLoc.Loc.t and type value = PrunedVal.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val is_reachable : t -> bool

Check if a path is reachable, by using its pruned values

\ No newline at end of file +PrunePairs (infer.BO.BufferOverrunDomain.PrunePairs)

Module BufferOverrunDomain.PrunePairs

PrunePairs is a map from abstract locations to abstract values that represents pruned results in the latest pruning. It uses InvertedMap because more pruning means smaller abstract states.

include Absint.AbstractDomain.InvertedMapS with type key = AbsLoc.Loc.t and type value = PrunedVal.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val is_reachable : t -> bool

Check if a path is reachable, by using its pruned values

\ No newline at end of file diff --git a/website/static/odoc/next/infer/BO__ArrayBlk/index.html b/website/static/odoc/next/infer/BO__ArrayBlk/index.html index de445bff6..3493bf36d 100644 --- a/website/static/odoc/next/infer/BO__ArrayBlk/index.html +++ b/website/static/odoc/next/infer/BO__ArrayBlk/index.html @@ -1,2 +1,2 @@ -BO__ArrayBlk (infer.BO__ArrayBlk)

Module BO__ArrayBlk

module ArrInfo : sig ... end
include Absint.AbstractDomain.MapS with type key = BO.AbsLoc.Allocsite.t and type value = ArrInfo.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

val compare : t -> t -> int
val bot : t
val make_c : BO.AbsLoc.Allocsite.t -> offset:BO.Itv.t -> size:BO.Itv.t -> stride:BO.Itv.t -> t

Make an array block for C

val make_java : BO.AbsLoc.Allocsite.t -> length:BO.Itv.t -> t

Make an array block for Java

val unknown : t
val get_pow_loc : t -> BO.AbsLoc.PowLoc.t

Return all allocsites as PowLoc.t

val is_bot : t -> bool
val is_symbolic : t -> bool

Check if there is a symbolic integer value in its offset or size

val lift_cmp_itv : (BO.Itv.t -> BO.Itv.t -> BO.Boolean.t) -> BO.Boolean.EqualOrder.t -> t -> t -> BO.Boolean.t

Lift a comparison of Itv.t and Loc.t to that of t. The comparison for Itv.t is used for integer values such as offset and size, and the comparison for Loc.t is used for allocsites.

val transform_length : f:(BO.Itv.t -> BO.Itv.t) -> t -> t

Apply f to all sizes

val prune_binop : IR.Binop.t -> t -> t -> t

prune_binop bop x y returns a pruned value of x by bop and y.

val prune_eq : t -> t -> t

prune_eq x y returns a pruned value of x by == y.

val prune_ne : t -> t -> t

prune_ne x y returns a pruned value of x by != y.

val prune_offset_le_size : t -> t

Prune offset by offset <= size

val minus_offset : t -> BO.Itv.t -> t
val plus_offset : t -> BO.Itv.t -> t
val diff : t -> t -> BO.Itv.t

Return difference of offsets between given array blocks

val normalize : t -> t

Normalize all interval values such as offset and size in it. Thus, if an interval value is invalid, the interval value is replaced with bottom.

val subst : t -> BO.Bounds.Bound.eval_sym -> BO.AbsLoc.PowLoc.eval_locpath -> BO.AbsLoc.PowLoc.t * t

Substitute symbolic abstract locations and symbolic interval value in the array block. eval_sym is to get substituted interval values and eval_locpath is to get substituted abstract locaion values. It also returns a set of abstract locations containing non-allocsite locations from the substitution results. Since the key of ArrayBlk.t is AbsLoc.Allocsite.t, they cannot be written in this domain.

val set_length : BO.Itv.t -> t -> t
val set_offset : BO.Itv.t -> t -> t
val set_stride : Z.t -> t -> t
val get_symbols : t -> BO.Symb.SymbolSet.t

Return all symbols for integer values in it

val get_offset : ?⁠cost_mode:bool -> t -> BO.Itv.t

Return offset of the array block. If cost_mode is true, it returns a conservative (bigger than correct one), but not correct offset results.

val get_size : ?⁠cost_mode:bool -> t -> BO.Itv.t

Return size of the array block. If cost_mode is true, it returns a conservative (bigger than correct one), but not correct size results.

\ No newline at end of file +BO__ArrayBlk (infer.BO__ArrayBlk)

Module BO__ArrayBlk

module ArrInfo : sig ... end
include Absint.AbstractDomain.MapS with type key = BO.AbsLoc.Allocsite.t and type value = ArrInfo.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

val compare : t -> t -> int
val bot : t
val make_c : BO.AbsLoc.Allocsite.t -> offset:BO.Itv.t -> size:BO.Itv.t -> stride:BO.Itv.t -> t

Make an array block for C

val make_java : BO.AbsLoc.Allocsite.t -> length:BO.Itv.t -> t

Make an array block for Java

val unknown : t
val get_pow_loc : t -> BO.AbsLoc.PowLoc.t

Return all allocsites as PowLoc.t

val is_bot : t -> bool
val is_symbolic : t -> bool

Check if there is a symbolic integer value in its offset or size

val lift_cmp_itv : (BO.Itv.t -> BO.Itv.t -> BO.Boolean.t) -> BO.Boolean.EqualOrder.t -> t -> t -> BO.Boolean.t

Lift a comparison of Itv.t and Loc.t to that of t. The comparison for Itv.t is used for integer values such as offset and size, and the comparison for Loc.t is used for allocsites.

val transform_length : f:(BO.Itv.t -> BO.Itv.t) -> t -> t

Apply f to all sizes

val prune_binop : IR.Binop.t -> t -> t -> t

prune_binop bop x y returns a pruned value of x by bop and y.

val prune_eq : t -> t -> t

prune_eq x y returns a pruned value of x by == y.

val prune_ne : t -> t -> t

prune_ne x y returns a pruned value of x by != y.

val prune_offset_le_size : t -> t

Prune offset by offset <= size

val minus_offset : t -> BO.Itv.t -> t
val plus_offset : t -> BO.Itv.t -> t
val diff : t -> t -> BO.Itv.t

Return difference of offsets between given array blocks

val normalize : t -> t

Normalize all interval values such as offset and size in it. Thus, if an interval value is invalid, the interval value is replaced with bottom.

val subst : t -> BO.Bounds.Bound.eval_sym -> BO.AbsLoc.PowLoc.eval_locpath -> BO.AbsLoc.PowLoc.t * t

Substitute symbolic abstract locations and symbolic interval value in the array block. eval_sym is to get substituted interval values and eval_locpath is to get substituted abstract locaion values. It also returns a set of abstract locations containing non-allocsite locations from the substitution results. Since the key of ArrayBlk.t is AbsLoc.Allocsite.t, they cannot be written in this domain.

val set_length : BO.Itv.t -> t -> t
val set_offset : BO.Itv.t -> t -> t
val set_stride : Z.t -> t -> t
val get_symbols : t -> BO.Symb.SymbolSet.t

Return all symbols for integer values in it

val get_offset : ?⁠cost_mode:bool -> t -> BO.Itv.t

Return offset of the array block. If cost_mode is true, it returns a conservative (bigger than correct one), but not correct offset results.

val get_size : ?⁠cost_mode:bool -> t -> BO.Itv.t

Return size of the array block. If cost_mode is true, it returns a conservative (bigger than correct one), but not correct size results.

\ No newline at end of file diff --git a/website/static/odoc/next/infer/BO__BufferOverrunDomain/AliasTargets/index.html b/website/static/odoc/next/infer/BO__BufferOverrunDomain/AliasTargets/index.html index 41cae7f23..61eda27a2 100644 --- a/website/static/odoc/next/infer/BO__BufferOverrunDomain/AliasTargets/index.html +++ b/website/static/odoc/next/infer/BO__BufferOverrunDomain/AliasTargets/index.html @@ -1,2 +1,2 @@ -AliasTargets (infer.BO__BufferOverrunDomain.AliasTargets)

Module BO__BufferOverrunDomain.AliasTargets

include Absint.AbstractDomain.InvertedMapS with type key = KeyRhs.t and type value = AliasTarget.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val exists2 : (key -> value -> key -> value -> bool) -> t -> t -> bool
val find_simple_alias : t -> key option

Find a simple alias from the set of aliases

val subst : subst_loc:(key -> key option) -> t -> t

Substitute alias target value

\ No newline at end of file +AliasTargets (infer.BO__BufferOverrunDomain.AliasTargets)

Module BO__BufferOverrunDomain.AliasTargets

include Absint.AbstractDomain.InvertedMapS with type key = KeyRhs.t and type value = AliasTarget.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val exists2 : (key -> value -> key -> value -> bool) -> t -> t -> bool
val find_simple_alias : t -> key option

Find a simple alias from the set of aliases

val subst : subst_loc:(key -> key option) -> t -> t

Substitute alias target value

\ No newline at end of file diff --git a/website/static/odoc/next/infer/BO__BufferOverrunDomain/PrunePairs/index.html b/website/static/odoc/next/infer/BO__BufferOverrunDomain/PrunePairs/index.html index 2187bb4d6..1c3ec04be 100644 --- a/website/static/odoc/next/infer/BO__BufferOverrunDomain/PrunePairs/index.html +++ b/website/static/odoc/next/infer/BO__BufferOverrunDomain/PrunePairs/index.html @@ -1,2 +1,2 @@ -PrunePairs (infer.BO__BufferOverrunDomain.PrunePairs)

Module BO__BufferOverrunDomain.PrunePairs

PrunePairs is a map from abstract locations to abstract values that represents pruned results in the latest pruning. It uses InvertedMap because more pruning means smaller abstract states.

include Absint.AbstractDomain.InvertedMapS with type key = BO.AbsLoc.Loc.t and type value = PrunedVal.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val is_reachable : t -> bool

Check if a path is reachable, by using its pruned values

\ No newline at end of file +PrunePairs (infer.BO__BufferOverrunDomain.PrunePairs)

Module BO__BufferOverrunDomain.PrunePairs

PrunePairs is a map from abstract locations to abstract values that represents pruned results in the latest pruning. It uses InvertedMap because more pruning means smaller abstract states.

include Absint.AbstractDomain.InvertedMapS with type key = BO.AbsLoc.Loc.t and type value = PrunedVal.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val is_reachable : t -> bool

Check if a path is reachable, by using its pruned values

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Backend/ClosuresSubstitution/Domain/index.html b/website/static/odoc/next/infer/Backend/ClosuresSubstitution/Domain/index.html index b390a8fbb..5909a6f22 100644 --- a/website/static/odoc/next/infer/Backend/ClosuresSubstitution/Domain/index.html +++ b/website/static/odoc/next/infer/Backend/ClosuresSubstitution/Domain/index.html @@ -1,2 +1,2 @@ -Domain (infer.Backend.ClosuresSubstitution.Domain)

Module ClosuresSubstitution.Domain

type key = IR.Var.t
type value = VDom.t
type t = Absint__AbstractDomain.SafeInvertedMap(IR.Var)(VDom).t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool
val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file +Domain (infer.Backend.ClosuresSubstitution.Domain)

Module ClosuresSubstitution.Domain

type key = IR.Var.t
type value = VDom.t
type t = Absint__AbstractDomain.SafeInvertedMap(IR.Var)(VDom).t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool
val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Backend__ClosuresSubstitution/Domain/index.html b/website/static/odoc/next/infer/Backend__ClosuresSubstitution/Domain/index.html index 1c57c33bf..e0aa3d124 100644 --- a/website/static/odoc/next/infer/Backend__ClosuresSubstitution/Domain/index.html +++ b/website/static/odoc/next/infer/Backend__ClosuresSubstitution/Domain/index.html @@ -1,2 +1,2 @@ -Domain (infer.Backend__ClosuresSubstitution.Domain)

Module Backend__ClosuresSubstitution.Domain

type key = IR.Var.t
type value = VDom.t
type t = Absint__AbstractDomain.SafeInvertedMap(IR.Var)(VDom).t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool
val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file +Domain (infer.Backend__ClosuresSubstitution.Domain)

Module Backend__ClosuresSubstitution.Domain

type key = IR.Var.t
type value = VDom.t
type t = Absint__AbstractDomain.SafeInvertedMap(IR.Var)(VDom).t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool
val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Checkers/AnnotationReachabilityDomain/SinkMap/index.html b/website/static/odoc/next/infer/Checkers/AnnotationReachabilityDomain/SinkMap/index.html index ea51bd795..4ab05d7d4 100644 --- a/website/static/odoc/next/infer/Checkers/AnnotationReachabilityDomain/SinkMap/index.html +++ b/website/static/odoc/next/infer/Checkers/AnnotationReachabilityDomain/SinkMap/index.html @@ -1,2 +1,2 @@ -SinkMap (infer.Checkers.AnnotationReachabilityDomain.SinkMap)

Module AnnotationReachabilityDomain.SinkMap

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file +SinkMap (infer.Checkers.AnnotationReachabilityDomain.SinkMap)

Module AnnotationReachabilityDomain.SinkMap

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Checkers/AnnotationReachabilityDomain/index.html b/website/static/odoc/next/infer/Checkers/AnnotationReachabilityDomain/index.html index 6c71d8c52..4ce1ff1ee 100644 --- a/website/static/odoc/next/infer/Checkers/AnnotationReachabilityDomain/index.html +++ b/website/static/odoc/next/infer/Checkers/AnnotationReachabilityDomain/index.html @@ -1,2 +1,2 @@ -AnnotationReachabilityDomain (infer.Checkers.AnnotationReachabilityDomain)

Module Checkers.AnnotationReachabilityDomain

include Absint.AbstractDomain.MapS with type key = IR.Annot.t and type value = SinkMap.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

val add_call_site : IR.Annot.t -> IR.Procname.t -> Absint.CallSite.t -> t -> t
\ No newline at end of file +AnnotationReachabilityDomain (infer.Checkers.AnnotationReachabilityDomain)

Module Checkers.AnnotationReachabilityDomain

include Absint.AbstractDomain.MapS with type key = IR.Annot.t and type value = SinkMap.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

val add_call_site : IR.Annot.t -> IR.Procname.t -> Absint.CallSite.t -> t -> t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Checkers/ReachingDefs/ReachingDefsMap/index.html b/website/static/odoc/next/infer/Checkers/ReachingDefs/ReachingDefsMap/index.html index 6c9faa28f..427636020 100644 --- a/website/static/odoc/next/infer/Checkers/ReachingDefs/ReachingDefsMap/index.html +++ b/website/static/odoc/next/infer/Checkers/ReachingDefs/ReachingDefsMap/index.html @@ -1,2 +1,2 @@ -ReachingDefsMap (infer.Checkers.ReachingDefs.ReachingDefsMap)

Module ReachingDefs.ReachingDefsMap

Map var -> its reaching definition

type key = IR.Var.t
type value = Defs.t
type t = Absint__AbstractDomain.Map(IR.Var)(Defs).t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool
val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t
val is_bottom : t -> bool
\ No newline at end of file +ReachingDefsMap (infer.Checkers.ReachingDefs.ReachingDefsMap)

Module ReachingDefs.ReachingDefsMap

Map var -> its reaching definition

type key = IR.Var.t
type value = Defs.t
type t = Absint__AbstractDomain.Map(IR.Var)(Defs).t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool
val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t
val is_bottom : t -> bool
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Checkers__AnnotationReachabilityDomain/SinkMap/index.html b/website/static/odoc/next/infer/Checkers__AnnotationReachabilityDomain/SinkMap/index.html index 707ccb1d5..d1afa5e8f 100644 --- a/website/static/odoc/next/infer/Checkers__AnnotationReachabilityDomain/SinkMap/index.html +++ b/website/static/odoc/next/infer/Checkers__AnnotationReachabilityDomain/SinkMap/index.html @@ -1,2 +1,2 @@ -SinkMap (infer.Checkers__AnnotationReachabilityDomain.SinkMap)

Module Checkers__AnnotationReachabilityDomain.SinkMap

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file +SinkMap (infer.Checkers__AnnotationReachabilityDomain.SinkMap)

Module Checkers__AnnotationReachabilityDomain.SinkMap

include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Checkers__AnnotationReachabilityDomain/index.html b/website/static/odoc/next/infer/Checkers__AnnotationReachabilityDomain/index.html index ccc1c0548..ff40bb139 100644 --- a/website/static/odoc/next/infer/Checkers__AnnotationReachabilityDomain/index.html +++ b/website/static/odoc/next/infer/Checkers__AnnotationReachabilityDomain/index.html @@ -1,2 +1,2 @@ -Checkers__AnnotationReachabilityDomain (infer.Checkers__AnnotationReachabilityDomain)

Module Checkers__AnnotationReachabilityDomain

include Absint.AbstractDomain.MapS with type key = IR.Annot.t and type value = SinkMap.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

val add_call_site : IR.Annot.t -> IR.Procname.t -> Absint.CallSite.t -> t -> t
\ No newline at end of file +Checkers__AnnotationReachabilityDomain (infer.Checkers__AnnotationReachabilityDomain)

Module Checkers__AnnotationReachabilityDomain

include Absint.AbstractDomain.MapS with type key = IR.Annot.t and type value = SinkMap.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

val add_call_site : IR.Annot.t -> IR.Procname.t -> Absint.CallSite.t -> t -> t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Checkers__ReachingDefs/ReachingDefsMap/index.html b/website/static/odoc/next/infer/Checkers__ReachingDefs/ReachingDefsMap/index.html index 044954f0a..fe7fac83c 100644 --- a/website/static/odoc/next/infer/Checkers__ReachingDefs/ReachingDefsMap/index.html +++ b/website/static/odoc/next/infer/Checkers__ReachingDefs/ReachingDefsMap/index.html @@ -1,2 +1,2 @@ -ReachingDefsMap (infer.Checkers__ReachingDefs.ReachingDefsMap)

Module Checkers__ReachingDefs.ReachingDefsMap

Map var -> its reaching definition

type key = IR.Var.t
type value = Defs.t
type t = Absint__AbstractDomain.Map(IR.Var)(Defs).t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool
val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t
val is_bottom : t -> bool
\ No newline at end of file +ReachingDefsMap (infer.Checkers__ReachingDefs.ReachingDefsMap)

Module Checkers__ReachingDefs.ReachingDefsMap

Map var -> its reaching definition

type key = IR.Var.t
type value = Defs.t
type t = Absint__AbstractDomain.Map(IR.Var)(Defs).t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool
val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t
val is_bottom : t -> bool
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Concurrency/RacerDDomain/AttributeMapDomain/index.html b/website/static/odoc/next/infer/Concurrency/RacerDDomain/AttributeMapDomain/index.html index 9a6b538ce..545bc9408 100644 --- a/website/static/odoc/next/infer/Concurrency/RacerDDomain/AttributeMapDomain/index.html +++ b/website/static/odoc/next/infer/Concurrency/RacerDDomain/AttributeMapDomain/index.html @@ -1,2 +1,2 @@ -AttributeMapDomain (infer.Concurrency.RacerDDomain.AttributeMapDomain)

Module RacerDDomain.AttributeMapDomain

include Absint.AbstractDomain.InvertedMapS with type key = AccessExpression.t and type value = Attribute.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val get : AccessExpression.t -> t -> Attribute.t

find the Attribute.t associated with a given access expression or return Attribute.bottom

val is_functional : t -> AccessExpression.t -> bool
val propagate_assignment : AccessExpression.t -> Absint.HilExp.t -> t -> t

propagate attributes from the leaves to the root of an RHS Hil expression

\ No newline at end of file +AttributeMapDomain (infer.Concurrency.RacerDDomain.AttributeMapDomain)

Module RacerDDomain.AttributeMapDomain

include Absint.AbstractDomain.InvertedMapS with type key = AccessExpression.t and type value = Attribute.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val get : AccessExpression.t -> t -> Attribute.t

find the Attribute.t associated with a given access expression or return Attribute.bottom

val is_functional : t -> AccessExpression.t -> bool
val propagate_assignment : AccessExpression.t -> Absint.HilExp.t -> t -> t

propagate attributes from the leaves to the root of an RHS Hil expression

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Concurrency/StarvationDomain/AttributeDomain/index.html b/website/static/odoc/next/infer/Concurrency/StarvationDomain/AttributeDomain/index.html index a3219cd8c..1902d0f5d 100644 --- a/website/static/odoc/next/infer/Concurrency/StarvationDomain/AttributeDomain/index.html +++ b/website/static/odoc/next/infer/Concurrency/StarvationDomain/AttributeDomain/index.html @@ -1,2 +1,2 @@ -AttributeDomain (infer.Concurrency.StarvationDomain.AttributeDomain)

Module StarvationDomain.AttributeDomain

Tracks all expressions assigned values of Attribute

include Absint.AbstractDomain.InvertedMapS with type key = Absint.HilExp.AccessExpression.t and type value = Attribute.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val is_thread_guard : Absint.HilExp.AccessExpression.t -> t -> bool
val is_future_done_guard : Absint.HilExp.AccessExpression.t -> t -> bool

does the given expr has attribute FutureDone x return Some x else None

\ No newline at end of file +AttributeDomain (infer.Concurrency.StarvationDomain.AttributeDomain)

Module StarvationDomain.AttributeDomain

Tracks all expressions assigned values of Attribute

include Absint.AbstractDomain.InvertedMapS with type key = Absint.HilExp.AccessExpression.t and type value = Attribute.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val is_thread_guard : Absint.HilExp.AccessExpression.t -> t -> bool
val is_future_done_guard : Absint.HilExp.AccessExpression.t -> t -> bool

does the given expr has attribute FutureDone x return Some x else None

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Concurrency__RacerDDomain/AttributeMapDomain/index.html b/website/static/odoc/next/infer/Concurrency__RacerDDomain/AttributeMapDomain/index.html index a766cfe4d..5ca3108bf 100644 --- a/website/static/odoc/next/infer/Concurrency__RacerDDomain/AttributeMapDomain/index.html +++ b/website/static/odoc/next/infer/Concurrency__RacerDDomain/AttributeMapDomain/index.html @@ -1,2 +1,2 @@ -AttributeMapDomain (infer.Concurrency__RacerDDomain.AttributeMapDomain)

Module Concurrency__RacerDDomain.AttributeMapDomain

include Absint.AbstractDomain.InvertedMapS with type key = AccessExpression.t and type value = Attribute.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val get : AccessExpression.t -> t -> Attribute.t

find the Attribute.t associated with a given access expression or return Attribute.bottom

val is_functional : t -> AccessExpression.t -> bool
val propagate_assignment : AccessExpression.t -> Absint.HilExp.t -> t -> t

propagate attributes from the leaves to the root of an RHS Hil expression

\ No newline at end of file +AttributeMapDomain (infer.Concurrency__RacerDDomain.AttributeMapDomain)

Module Concurrency__RacerDDomain.AttributeMapDomain

include Absint.AbstractDomain.InvertedMapS with type key = AccessExpression.t and type value = Attribute.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val get : AccessExpression.t -> t -> Attribute.t

find the Attribute.t associated with a given access expression or return Attribute.bottom

val is_functional : t -> AccessExpression.t -> bool
val propagate_assignment : AccessExpression.t -> Absint.HilExp.t -> t -> t

propagate attributes from the leaves to the root of an RHS Hil expression

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Concurrency__StarvationDomain/AttributeDomain/index.html b/website/static/odoc/next/infer/Concurrency__StarvationDomain/AttributeDomain/index.html index c871799dc..ba57b988e 100644 --- a/website/static/odoc/next/infer/Concurrency__StarvationDomain/AttributeDomain/index.html +++ b/website/static/odoc/next/infer/Concurrency__StarvationDomain/AttributeDomain/index.html @@ -1,2 +1,2 @@ -AttributeDomain (infer.Concurrency__StarvationDomain.AttributeDomain)

Module Concurrency__StarvationDomain.AttributeDomain

Tracks all expressions assigned values of Attribute

include Absint.AbstractDomain.InvertedMapS with type key = Absint.HilExp.AccessExpression.t and type value = Attribute.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val is_thread_guard : Absint.HilExp.AccessExpression.t -> t -> bool
val is_future_done_guard : Absint.HilExp.AccessExpression.t -> t -> bool

does the given expr has attribute FutureDone x return Some x else None

\ No newline at end of file +AttributeDomain (infer.Concurrency__StarvationDomain.AttributeDomain)

Module Concurrency__StarvationDomain.AttributeDomain

Tracks all expressions assigned values of Attribute

include Absint.AbstractDomain.InvertedMapS with type key = Absint.HilExp.AccessExpression.t and type value = Attribute.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithTop with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val top : t
val is_top : t -> bool
val is_thread_guard : Absint.HilExp.AccessExpression.t -> t -> bool
val is_future_done_guard : Absint.HilExp.AccessExpression.t -> t -> bool

does the given expr has attribute FutureDone x return Some x else None

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Costlib/CostModels/NSAttributedString/index.html b/website/static/odoc/next/infer/Costlib/CostModels/NSAttributedString/index.html new file mode 100644 index 000000000..39d4fdd3d --- /dev/null +++ b/website/static/odoc/next/infer/Costlib/CostModels/NSAttributedString/index.html @@ -0,0 +1,2 @@ + +NSAttributedString (infer.Costlib.CostModels.NSAttributedString)

Module CostModels.NSAttributedString

val enumerate_using_block : 'a Absint.ProcnameDispatcher.Call.FuncArg.t list -> CostUtils.CostModelEnv.cost_model_env -> ret:'b -> BO.BufferOverrunDomain.Mem.t -> BasicCost.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Costlib__CostModels/NSAttributedString/index.html b/website/static/odoc/next/infer/Costlib__CostModels/NSAttributedString/index.html new file mode 100644 index 000000000..d4dbbaf07 --- /dev/null +++ b/website/static/odoc/next/infer/Costlib__CostModels/NSAttributedString/index.html @@ -0,0 +1,2 @@ + +NSAttributedString (infer.Costlib__CostModels.NSAttributedString)

Module Costlib__CostModels.NSAttributedString

val enumerate_using_block : 'a Absint.ProcnameDispatcher.Call.FuncArg.t list -> Costlib.CostUtils.CostModelEnv.cost_model_env -> ret:'b -> BO.BufferOverrunDomain.Mem.t -> BasicCost.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/ErlangFrontend/.dune-keep b/website/static/odoc/next/infer/ErlangFrontend/.dune-keep new file mode 100644 index 000000000..e69de29bb diff --git a/website/static/odoc/next/infer/ErlangFrontend/ErlangAst/index.html b/website/static/odoc/next/infer/ErlangFrontend/ErlangAst/index.html new file mode 100644 index 000000000..3349d294f --- /dev/null +++ b/website/static/odoc/next/infer/ErlangFrontend/ErlangAst/index.html @@ -0,0 +1,2 @@ + +ErlangAst (infer.ErlangFrontend.ErlangAst)

Module ErlangFrontend.ErlangAst

Basics

type module_reference =
| ModuleName of string
| ModuleMissing
| ModuleVariable of string
type function_reference =
| FunctionName of string
| FunctionVariable of string
type function_ = {
module_ : module_reference;
function_ : function_reference;
arity : int;
}
type line = int
type record_name = string
type binary_operator =
| Add
| And
| AndAlso
| AtLeast
| AtMost
| BAnd
| BOr
| Bsl
| Bsr
| BXor
| Equal
| ExactlyEqual
| ExactlyNotEqual
| FDiv
| Greater
| IDiv
| Less
| ListAdd
| ListSub
| Mul
| NotEqual
| Or
| OrElse
| Rem
| Send
| Sub
| Xor
type unary_operator =
| UBNot
| UMinus
| UNot
type association_kind =
| Arrow
| Exact
type exception_ =
| Atom of string
| Pattern of string
type type_specifier = unit

S8.2: Atomic literals

type literal =
| Atom of string
| Char of string
| Float of float
| Int of string
| String of string

S8.4: Expressions

type body = expression list
and simple_expression =
| BinaryOperator of expression * binary_operator * expression
| BitstringComprehension of {
expression : expression;
qualifiers : qualifier list;
}
| BitstringConstructor of bin_element list
| Block of body
| Call of {
module_ : expression option;
function_ : expression;
args : expression list;
}
| Case of {
expression : expression;
cases : case_clause list;
}
| Catch of expression
| Cons of {
head : expression;
tail : expression;
}
| Fun of function_
| If of case_clause list
| Lambda of {
name : string option;
cases : case_clause list;
}
| ListComprehension of {
expression : expression;
qualifiers : qualifier list;
}
| Literal of literal
| Map of {
map : expression option;
updates : association list;
}
| Match of {
pattern : pattern;
body : expression;
}
| Nil
| Receive of {
cases : case_clause list;
timeout : timeout option;
}
| RecordAccess of {
record : expression;
name : record_name;
field : string;
}
| RecordIndex of {
name : record_name;
field : string;
}
| RecordUpdate of {
record : expression option;
name : record_name;
updates : record_update list;
}
| TryCatch of {
body : body;
ok_cases : case_clause list;
catch_cases : catch_clause list;
after : body;
}
| Tuple of expression list
| UnaryOperator of unary_operator * expression
| Variable of string
and expression = {
line : line;
simple_expression : simple_expression;
}
and qualifier =
| BitsGenerator of {
pattern : pattern;
expression : expression;
}
| Filter of expression
| Generator of {
pattern : pattern;
expression : expression;
}
and timeout = {
time : expression;
handler : body;
}
and bin_element = {
expression : expression;
size : expression option;
types : type_specifier list option;
}
and record_update = {
field : string option;
expression : expression;
}
and association = {
kind : association_kind;
key : expression;
value : expression;
}
and pattern = expression
and guard = expression

S8.5 Clauses

and 'pat clause = {
line : line;
patterns : 'pat list;
guards : guard list;
body : body;
}
and case_clause = pattern clause
and catch_clause = catch_pattern clause
and catch_pattern = {
exception_ : exception_;
pattern : pattern;
variable : string;
}

S8.1: Module declarations and forms

type simple_form =
| Export of function_ list
| Import of {
module_name : string;
functions : function_ list;
}
| Module of string
| File of {
path : string;
}
| Function of {
function_ : function_;
clauses : case_clause list;
}
type form = {
line : line;
simple_form : simple_form;
}
type module_ = form list
\ No newline at end of file diff --git a/website/static/odoc/next/infer/ErlangFrontend/ErlangJsonParser/index.html b/website/static/odoc/next/infer/ErlangFrontend/ErlangJsonParser/index.html new file mode 100644 index 000000000..2f6cf39c5 --- /dev/null +++ b/website/static/odoc/next/infer/ErlangFrontend/ErlangJsonParser/index.html @@ -0,0 +1,2 @@ + +ErlangJsonParser (infer.ErlangFrontend.ErlangJsonParser)

Module ErlangFrontend.ErlangJsonParser

val to_module : Yojson.Safe.t -> ErlangAst.module_ option
\ No newline at end of file diff --git a/website/static/odoc/next/infer/ErlangFrontend/ErlangTranslator/index.html b/website/static/odoc/next/infer/ErlangFrontend/ErlangTranslator/index.html new file mode 100644 index 000000000..246beb4ca --- /dev/null +++ b/website/static/odoc/next/infer/ErlangFrontend/ErlangTranslator/index.html @@ -0,0 +1,2 @@ + +ErlangTranslator (infer.ErlangFrontend.ErlangTranslator)

Module ErlangFrontend.ErlangTranslator

val to_source_and_cfg : ErlangAst.module_ -> IBase.SourceFile.t * IR.Cfg.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/ErlangFrontend/index.html b/website/static/odoc/next/infer/ErlangFrontend/index.html new file mode 100644 index 000000000..5f3b5ced8 --- /dev/null +++ b/website/static/odoc/next/infer/ErlangFrontend/index.html @@ -0,0 +1,2 @@ + +ErlangFrontend (infer.ErlangFrontend)

Module ErlangFrontend

module ErlangAst : sig ... end
module ErlangJsonParser : sig ... end
module ErlangTranslator : sig ... end
\ No newline at end of file diff --git a/website/static/odoc/next/infer/ErlangFrontend__ErlangAst/.dune-keep b/website/static/odoc/next/infer/ErlangFrontend__ErlangAst/.dune-keep new file mode 100644 index 000000000..e69de29bb diff --git a/website/static/odoc/next/infer/ErlangFrontend__ErlangAst/index.html b/website/static/odoc/next/infer/ErlangFrontend__ErlangAst/index.html new file mode 100644 index 000000000..03ab8ca78 --- /dev/null +++ b/website/static/odoc/next/infer/ErlangFrontend__ErlangAst/index.html @@ -0,0 +1,2 @@ + +ErlangFrontend__ErlangAst (infer.ErlangFrontend__ErlangAst)

Module ErlangFrontend__ErlangAst

Erlang abstract forms, following https://erlang.org/doc/apps/erts/absform.html

Basics

type module_reference =
| ModuleName of string
| ModuleMissing
| ModuleVariable of string
type function_reference =
| FunctionName of string
| FunctionVariable of string
type function_ = {
module_ : module_reference;
function_ : function_reference;
arity : int;
}
type line = int
type record_name = string
type binary_operator =
| Add
| And
| AndAlso
| AtLeast
| AtMost
| BAnd
| BOr
| Bsl
| Bsr
| BXor
| Equal
| ExactlyEqual
| ExactlyNotEqual
| FDiv
| Greater
| IDiv
| Less
| ListAdd
| ListSub
| Mul
| NotEqual
| Or
| OrElse
| Rem
| Send
| Sub
| Xor
type unary_operator =
| UBNot
| UMinus
| UNot
type association_kind =
| Arrow
| Exact
type exception_ =
| Atom of string
| Pattern of string
type type_specifier = unit

S8.2: Atomic literals

type literal =
| Atom of string
| Char of string
| Float of float
| Int of string
| String of string

S8.4: Expressions

type body = expression list
and simple_expression =
| BinaryOperator of expression * binary_operator * expression
| BitstringComprehension of {
expression : expression;
qualifiers : qualifier list;
}
| BitstringConstructor of bin_element list
| Block of body
| Call of {
module_ : expression option;
function_ : expression;
args : expression list;
}
| Case of {
expression : expression;
cases : case_clause list;
}
| Catch of expression
| Cons of {
head : expression;
tail : expression;
}
| Fun of function_
| If of case_clause list
| Lambda of {
name : string option;
cases : case_clause list;
}
| ListComprehension of {
expression : expression;
qualifiers : qualifier list;
}
| Literal of literal
| Map of {
map : expression option;
updates : association list;
}
| Match of {
pattern : pattern;
body : expression;
}
| Nil
| Receive of {
cases : case_clause list;
timeout : timeout option;
}
| RecordAccess of {
record : expression;
name : record_name;
field : string;
}
| RecordIndex of {
name : record_name;
field : string;
}
| RecordUpdate of {
record : expression option;
name : record_name;
updates : record_update list;
}
| TryCatch of {
body : body;
ok_cases : case_clause list;
catch_cases : catch_clause list;
after : body;
}
| Tuple of expression list
| UnaryOperator of unary_operator * expression
| Variable of string
and expression = {
line : line;
simple_expression : simple_expression;
}
and qualifier =
| BitsGenerator of {
pattern : pattern;
expression : expression;
}
| Filter of expression
| Generator of {
pattern : pattern;
expression : expression;
}
and timeout = {
time : expression;
handler : body;
}
and bin_element = {
expression : expression;
size : expression option;
types : type_specifier list option;
}
and record_update = {
field : string option;
expression : expression;
}
and association = {
kind : association_kind;
key : expression;
value : expression;
}
and pattern = expression
and guard = expression

S8.5 Clauses

and 'pat clause = {
line : line;
patterns : 'pat list;
guards : guard list;
body : body;
}
and case_clause = pattern clause
and catch_clause = catch_pattern clause
and catch_pattern = {
exception_ : exception_;
pattern : pattern;
variable : string;
}

S8.1: Module declarations and forms

type simple_form =
| Export of function_ list
| Import of {
module_name : string;
functions : function_ list;
}
| Module of string
| File of {
path : string;
}
| Function of {
function_ : function_;
clauses : case_clause list;
}
type form = {
line : line;
simple_form : simple_form;
}
type module_ = form list
\ No newline at end of file diff --git a/website/static/odoc/next/infer/ErlangFrontend__ErlangJsonParser/.dune-keep b/website/static/odoc/next/infer/ErlangFrontend__ErlangJsonParser/.dune-keep new file mode 100644 index 000000000..e69de29bb diff --git a/website/static/odoc/next/infer/ErlangFrontend__ErlangJsonParser/index.html b/website/static/odoc/next/infer/ErlangFrontend__ErlangJsonParser/index.html new file mode 100644 index 000000000..4539d6a05 --- /dev/null +++ b/website/static/odoc/next/infer/ErlangFrontend__ErlangJsonParser/index.html @@ -0,0 +1,2 @@ + +ErlangFrontend__ErlangJsonParser (infer.ErlangFrontend__ErlangJsonParser)

Module ErlangFrontend__ErlangJsonParser

val to_module : Yojson.Safe.t -> ErlangFrontend.ErlangAst.module_ option
\ No newline at end of file diff --git a/website/static/odoc/next/infer/ErlangFrontend__ErlangTranslator/.dune-keep b/website/static/odoc/next/infer/ErlangFrontend__ErlangTranslator/.dune-keep new file mode 100644 index 000000000..e69de29bb diff --git a/website/static/odoc/next/infer/ErlangFrontend__ErlangTranslator/index.html b/website/static/odoc/next/infer/ErlangFrontend__ErlangTranslator/index.html new file mode 100644 index 000000000..7b66be463 --- /dev/null +++ b/website/static/odoc/next/infer/ErlangFrontend__ErlangTranslator/index.html @@ -0,0 +1,2 @@ + +ErlangFrontend__ErlangTranslator (infer.ErlangFrontend__ErlangTranslator)

Module ErlangFrontend__ErlangTranslator

val to_source_and_cfg : ErlangFrontend.ErlangAst.module_ -> IBase.SourceFile.t * IR.Cfg.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IBase/Config/index.html b/website/static/odoc/next/infer/IBase/Config/index.html index 313457dab..c560ab421 100644 --- a/website/static/odoc/next/infer/IBase/Config/index.html +++ b/website/static/odoc/next/infer/IBase/Config/index.html @@ -1,2 +1,2 @@ -Config (infer.IBase.Config)

Module IBase.Config

type os_type =
| Unix
| Win32
| Cygwin
type build_system =
| BAnt
| BBuck
| BClang
| BGradle
| BJava
| BJavac
| BMake
| BMvn
| BNdk
| BRebar3
| BXcode
type scheduler =
| File
| Restart
| SyntacticCallGraph
val equal_scheduler : scheduler -> scheduler -> bool
val build_system_of_exe_name : string -> build_system
val string_of_build_system : build_system -> string
val env_inside_maven : IStdlib.IStd.Unix.env

Constant configuration values

val anonymous_block_num_sep : string
val anonymous_block_prefix : string
val assign : string
val biabduction_models_sql : string
val biabduction_models_jar : string
val bin_dir : string
val bound_error_allowed_in_procedure_call : bool
val clang_exe_aliases : string list
val clang_initializer_prefix : string
val clang_inner_destructor_prefix : string
val clang_plugin_path : string
val default_failure_name : string
val dotty_frontend_output : string
val etc_dir : string
val fail_on_issue_exit_code : int
val fcp_dir : string
val idempotent_getters : bool
val initial_analysis_time : float
val ivar_attributes : string
val java_lambda_marker_infix : string

marker to recognize methods generated by javalib to eliminate lambdas

val kotlin_source_extension : string
val lib_dir : string
val max_narrows : int
val max_widens : int
val meet_level : int
val nsnotification_center_checker_backend : bool
val os_type : os_type
val pp_version : Stdlib.Format.formatter -> unit -> unit
val property_attributes : string
val report_nullable_inconsistency : bool
val save_compact_summaries : bool
val smt_output : bool
val source_file_extentions : string list
val unsafe_unret : string
val weak : string
val whitelisted_cpp_classes : string list
val whitelisted_cpp_methods : string list
val wrappers_dir : string

Configuration values specified by command-line options

val annotation_reachability_cxx : Yojson.Basic.t
val annotation_reachability_cxx_sources : Yojson.Basic.t
val annotation_reachability_custom_pairs : Yojson.Basic.t
val append_buck_flavors : string list
val biabduction_abs_struct : int
val biabduction_abs_val : int
val biabduction_allow_leak : bool
val biabduction_array_level : int
val biabduction_models_mode : bool
val biabduction_iterations : int
val biabduction_join_cond : int
val biabduction_memleak_buckets : [ `MLeak_all | `MLeak_arc | `MLeak_cf | `MLeak_cpp | `MLeak_no_arc | `MLeak_unknown ] list
val biabduction_monitor_prop_size : bool
val biabduction_nelseg : bool
val biabduction_only_footprint : bool
val biabduction_seconds_per_iteration : float option
val biabduction_symops_per_iteration : int option
val biabduction_trace_join : bool
val biabduction_trace_rearrange : bool
val biabduction_type_size : bool
val biabduction_unsafe_malloc : bool
val biabduction_worklist_mode : int
val biabduction_write_dotty : bool
val bo_debug : int
val bo_field_depth_limit : int option
val bootclasspath : string option
val buck : bool
val buck_blacklist : string list
val buck_build_args : string list
val buck_build_args_no_inline : string list
val buck_cache_mode : bool
val buck_java_flavor_suppress_config : bool
val buck_java_heap_size_gb : int option
val buck_merge_all_deps : bool
val buck_mode : BuckMode.t option
val buck_out_gen : string
val buck_targets_blacklist : string list
val call_graph_schedule : bool
val capture : bool
val capture_blacklist : string option
val censor_report : ((bool * Str.regexp) * (bool * Str.regexp) * string) list
val cfg_json : string option
val changed_files_index : string option
val check_version : string option
val clang_ast_file : [ `Biniou of string | `Yojson of string ] option
val clang_compound_literal_init_limit : int
val clang_extra_flags : string list
val clang_blacklisted_flags : string list
val clang_blacklisted_flags_with_arg : string list
val clang_frontend_action_string : string
val clang_ignore_regex : string option
val clang_isystem_to_override_regex : Str.regexp option
val clang_idirafter_to_override_regex : Str.regexp option
val clang_libcxx_include_to_override_regex : string option
val classpath : string option
val command : ATDGenerated.InferCommand.t
val config_impact_current : string option
val config_impact_data_file : string option
val config_impact_issues_tests : string option
val config_impact_max_callees_to_print : int
val config_impact_previous : string option
val continue_analysis : bool
val continue_capture : bool
val costs_current : string option
val cost_issues_tests : string option
val cost_scuba_logging : bool
val costs_previous : string option
val cost_suppress_func_ptr : bool
val cost_tests_only_autoreleasepool : bool
val cxx : bool
val cxx_scope_guards : Yojson.Basic.t
val deduplicate : bool
val debug_exceptions : bool
val debug_level_analysis : int
val debug_level_capture : int
val debug_level_linters : int
val debug_level_test_determinator : int
val debug_mode : bool
val default_linters : bool
val dependency_mode : bool
val developer_mode : bool
val differential_filter_files : string option
val differential_filter_set : [ `Introduced | `Fixed | `Preexisting ] list
val dotty_cfg_libs : bool
val dump_duplicate_symbols : bool
val eradicate_condition_redundant : bool
val eradicate_field_over_annotated : bool
val eradicate_return_over_annotated : bool
val eradicate_verbose : bool
val erlang_ast_dir : string option
val erlang_skip_rebar3 : bool
val fail_on_bug : bool
val fcp_apple_clang : string option
val fcp_syntax_only : bool
val file_renamings : string option
val filter_paths : bool
val filtering : bool
val force_delete_results_dir : bool
val force_integration : build_system option
val from_json_report : string
val from_json_config_impact_report : string
val from_json_costs_report : string
val frontend_stats : bool
val frontend_tests : bool
val function_pointer_specialization : bool
val generated_classes : string option
val genrule_mode : bool
val get_linter_doc_url : linter_id:string -> string option
val help_checker : Checker.t list
val help_issue_type : IssueType.t list
val hoisting_report_only_expensive : bool
val html : bool
val global_tenv : bool
val icfg_dotty_outfile : string option
val impurity_report_immutable_modifications : bool
val incremental_analysis : bool
val infer_is_clang : bool
val infer_is_javac : bool
val implicit_sdk_root : string option
val inclusive_cost : bool
val inferconfig_file : string option
val inferconfig_dir : string option
val is_checker_enabled : Checker.t -> bool
val issues_tests : string option
val issues_tests_fields : IssuesTestField.t list
val java_debug_source_file_info : string option
val java_jar_compiler : string option
val java_source_parser_experimental : bool
val java_version : int option
val javac_classes_out : string
val job_id : string option
val jobs : int
val keep_going : bool
val linter : string option
val linters_def_file : string list
val linters_def_folder : string list
val linters_developer_mode : bool
val linters_ignore_clang_failures : bool
val linters_validate_syntax_only : bool
val list_checkers : bool
val list_issue_types : bool
val liveness_dangerous_classes : Yojson.Basic.t
val liveness_ignored_constant : string list
val load_average : float option
val max_nesting : int option
val memtrace_analysis : bool
val memtrace_sampling_rate : float
val merge : bool
val method_decls_info : string option
val modified_lines : string option
val no_translate_libs : bool
val nullable_annotation : string option
val nullsafe_annotation_graph : bool
val nullsafe_disable_field_not_initialized_in_nonstrict_classes : bool
val nullsafe_optimistic_third_party_in_default_mode : bool
val nullsafe_third_party_signatures : string option
val nullsafe_third_party_location_for_messaging_only : string option
val nullsafe_strict_containers : bool
val oom_threshold : int option
val only_cheap_debug : bool
val patterns_modeled_expensive : string * Yojson.Basic.t
val patterns_never_returning_null : string * Yojson.Basic.t
val patterns_skip_implementation : string * Yojson.Basic.t
val patterns_skip_translation : string * Yojson.Basic.t
val pmd_xml : bool
val print_active_checkers : bool
val print_builtins : bool
val print_jbir : bool
val print_logs : bool
val print_types : bool
val print_using_diff : bool
val procedures : bool
val procedures_attributes : bool
val procedures_cfg : bool
val procedures_definedness : bool
val procedures_filter : string option
val procedures_name : bool
val procedures_source_file : bool
val procedures_summary : bool
val procedures_summary_json : bool
val process_clang_ast : bool
val profiler_samples : string option
val progress_bar : [ `MultiLine | `Plain | `Quiet ]
val project_root : string
val pulse_cut_to_one_path_procedures_pattern : Str.regexp option
val pulse_intraprocedural_only : bool
val pulse_isl : bool
val pulse_manifest_emp : bool
val pulse_max_disjuncts : int
val pulse_model_abort : string list
val pulse_model_alloc_pattern : Str.regexp option
val pulse_model_free_pattern : Str.regexp option
val pulse_model_malloc_pattern : Str.regexp option
val pulse_model_release_pattern : Str.regexp option
val pulse_model_return_first_arg : Str.regexp option
val pulse_model_return_nonnull : Str.regexp option
val pulse_model_skip_pattern : Str.regexp option
val pulse_report_ignore_unknown_java_methods_patterns : Str.regexp option
val pulse_model_transfer_ownership_namespace : (string * string) list
val pulse_model_transfer_ownership : string list
val pulse_report_latent_issues : bool
val pulse_recency_limit : int
val pulse_widen_threshold : int
val pulse_nullsafe_report_npe : bool
val pure_by_default : bool
val quandary_endpoints : Yojson.Basic.t
val quandary_sanitizers : Yojson.Basic.t
val quandary_show_passthroughs : bool
val quandary_sinks : Yojson.Basic.t
val quandary_sources : Yojson.Basic.t
val quiet : bool
val racerd_guardedby : bool
val reactive_mode : bool
val reanalyze : bool
val relative_path_backtrack : int
val remodel_class : string option
val report : bool
val report_blacklist_files_containing : string list
val report_console_limit : int option
val report_current : string option
val report_custom_error : bool
val report_force_relative_path : bool
val report_formatter : [ `No_formatter | `Phabricator_formatter ]
val report_path_regex_blacklist : string list
val report_path_regex_whitelist : string list
val report_previous : string option
val report_suppress_errors : string list
val reports_include_ml_loc : bool
val rest : string list
val results_dir : string
val scheduler : scheduler
val scuba_logging : bool
val scuba_normals : string IStdlib.IStd.String.Map.t
val scuba_tags : string list IStdlib.IStd.String.Map.t
val select : [ `All | `Select of int ] option
val show_buckets : bool
val siof_check_iostreams : bool
val siof_safe_methods : string list
val skip_analysis_in_path : string list
val skip_analysis_in_path_skips_compilation : bool
val skip_duplicated_types : bool
val skip_non_capture_clang_commands : bool
val skip_translation_headers : string list
val source_files : bool
val source_files_cfg : bool
val source_files_filter : string option
val source_files_freshly_captured : bool
val source_files_procedure_names : bool
val source_files_type_environment : bool
val source_preview : bool
val sourcepath : string option
val sources : string list
val sqlite_cache_size : int
val sqlite_page_size : int
val sqlite_lock_timeout : int
val sqlite_vfs : string option
val starvation_skip_analysis : Yojson.Basic.t
val starvation_strict_mode : bool
val starvation_whole_program : bool
val subtype_multirange : bool
val summaries_caches_max_size : int
val suppress_lint_ignore_types : bool
val tenv_json : string option
val test_determinator : bool
val export_changed_functions : bool
val test_filtering : bool
val testing_mode : bool
val threadsafe_aliases : Yojson.Basic.t
val topl_max_conjuncts : int
val topl_max_disjuncts : int
val topl_properties : string list
val trace_absarray : bool
val trace_error : bool
val trace_events : bool
val trace_ondemand : bool
val trace_topl : bool
val tv_commit : string option
val tv_limit : int
val tv_limit_filtered : int
val uninit_interproc : bool
val workspace : string option
val write_html : bool
val write_html_whitelist_regex : string list
val write_website : string option
val xcode_developer_dir : string option
val xcode_isysroot_suffix : string option
val xcpretty : bool

Configuration values derived from command-line options

val dynamic_dispatch : bool
val toplevel_results_dir : string

In some integrations, eg Buck, infer subprocesses started by the build system (started by the toplevel infer process) will have their own results directory; this points to the results directory of the toplevel infer process, which can be useful for, eg, storing debug info. In other cases this is equal to results_dir.

val is_in_custom_symbols : string -> string -> bool

Does named symbol match any prefix in the named custom symbol list?

val java_package_is_external : string -> bool

Check if a Java package is external to the repository

val scuba_execution_id : IStdlib.IStd.Int64.t option

a random number to (hopefully) uniquely identify this run

Global variables with initial values specified by command-line options

val clang_compilation_dbs : [ `Escaped of string | `Raw of string ] list
\ No newline at end of file +Config (infer.IBase.Config)

Module IBase.Config

type os_type =
| Unix
| Win32
| Cygwin
type build_system =
| BAnt
| BBuck
| BClang
| BGradle
| BJava
| BJavac
| BMake
| BMvn
| BNdk
| BRebar3
| BXcode
type scheduler =
| File
| Restart
| SyntacticCallGraph
val equal_scheduler : scheduler -> scheduler -> bool
val build_system_of_exe_name : string -> build_system
val string_of_build_system : build_system -> string
val env_inside_maven : IStdlib.IStd.Unix.env

Constant configuration values

val anonymous_block_num_sep : string
val anonymous_block_prefix : string
val assign : string
val biabduction_models_sql : string
val biabduction_models_jar : string
val bin_dir : string
val bound_error_allowed_in_procedure_call : bool
val clang_exe_aliases : string list
val clang_initializer_prefix : string
val clang_inner_destructor_prefix : string
val clang_plugin_path : string
val default_failure_name : string
val dotty_frontend_output : string
val etc_dir : string
val fail_on_issue_exit_code : int
val fcp_dir : string
val idempotent_getters : bool
val initial_analysis_time : float
val ivar_attributes : string
val java_lambda_marker_infix : string

marker to recognize methods generated by javalib to eliminate lambdas

val kotlin_source_extension : string
val lib_dir : string
val max_narrows : int
val max_widens : int
val meet_level : int
val nsnotification_center_checker_backend : bool
val os_type : os_type
val pp_version : Stdlib.Format.formatter -> unit -> unit
val property_attributes : string
val report_nullable_inconsistency : bool
val save_compact_summaries : bool
val smt_output : bool
val source_file_extentions : string list
val unsafe_unret : string
val weak : string
val whitelisted_cpp_classes : string list
val whitelisted_cpp_methods : string list
val wrappers_dir : string

Configuration values specified by command-line options

val annotation_reachability_cxx : Yojson.Basic.t
val annotation_reachability_cxx_sources : Yojson.Basic.t
val annotation_reachability_custom_pairs : Yojson.Basic.t
val append_buck_flavors : string list
val biabduction_abs_struct : int
val biabduction_abs_val : int
val biabduction_allow_leak : bool
val biabduction_array_level : int
val biabduction_models_mode : bool
val biabduction_iterations : int
val biabduction_join_cond : int
val biabduction_memleak_buckets : [ `MLeak_all | `MLeak_arc | `MLeak_cf | `MLeak_cpp | `MLeak_no_arc | `MLeak_unknown ] list
val biabduction_monitor_prop_size : bool
val biabduction_nelseg : bool
val biabduction_only_footprint : bool
val biabduction_seconds_per_iteration : float option
val biabduction_symops_per_iteration : int option
val biabduction_trace_join : bool
val biabduction_trace_rearrange : bool
val biabduction_type_size : bool
val biabduction_unsafe_malloc : bool
val biabduction_worklist_mode : int
val biabduction_write_dotty : bool
val bo_debug : int
val bo_field_depth_limit : int option
val bootclasspath : string option
val buck : bool
val buck_blacklist : string list
val buck_build_args : string list
val buck_build_args_no_inline : string list
val buck_cache_mode : bool
val buck_java_flavor_suppress_config : bool
val buck_java_heap_size_gb : int option
val buck_merge_all_deps : bool
val buck_mode : BuckMode.t option
val buck_out_gen : string
val buck_targets_blacklist : string list
val call_graph_schedule : bool
val capture : bool
val capture_blacklist : string option
val censor_report : ((bool * Str.regexp) * (bool * Str.regexp) * string) list
val cfg_json : string option
val changed_files_index : string option
val check_version : string option
val clang_ast_file : [ `Biniou of string | `Yojson of string ] option
val clang_compound_literal_init_limit : int
val clang_extra_flags : string list
val clang_blacklisted_flags : string list
val clang_blacklisted_flags_with_arg : string list
val clang_frontend_action_string : string
val clang_ignore_regex : string option
val clang_isystem_to_override_regex : Str.regexp option
val clang_idirafter_to_override_regex : Str.regexp option
val clang_libcxx_include_to_override_regex : string option
val classpath : string option
val command : ATDGenerated.InferCommand.t
val config_impact_current : string option
val config_impact_data_file : string option
val config_impact_issues_tests : string option
val config_impact_max_callees_to_print : int
val config_impact_previous : string option
val continue_analysis : bool
val continue_capture : bool
val costs_current : string option
val cost_issues_tests : string option
val cost_scuba_logging : bool
val costs_previous : string option
val cost_suppress_func_ptr : bool
val cost_tests_only_autoreleasepool : bool
val cxx : bool
val cxx_scope_guards : Yojson.Basic.t
val deduplicate : bool
val debug_exceptions : bool
val debug_level_analysis : int
val debug_level_capture : int
val debug_level_linters : int
val debug_level_test_determinator : int
val debug_mode : bool
val default_linters : bool
val dependency_mode : bool
val developer_mode : bool
val differential_filter_files : string option
val differential_filter_set : [ `Introduced | `Fixed | `Preexisting ] list
val dotty_cfg_libs : bool
val dump_duplicate_symbols : bool
val eradicate_condition_redundant : bool
val eradicate_field_over_annotated : bool
val eradicate_return_over_annotated : bool
val eradicate_verbose : bool
val erlang_ast_dir : string option
val erlang_skip_rebar3 : bool
val fail_on_bug : bool
val fcp_apple_clang : string option
val fcp_syntax_only : bool
val file_renamings : string option
val filter_paths : bool
val filtering : bool
val force_delete_results_dir : bool
val force_integration : build_system option
val from_json_report : string
val from_json_config_impact_report : string
val from_json_costs_report : string
val frontend_stats : bool
val frontend_tests : bool
val function_pointer_specialization : bool
val generated_classes : string option
val genrule_mode : bool
val get_linter_doc_url : linter_id:string -> string option
val help_checker : Checker.t list
val help_issue_type : IssueType.t list
val hoisting_report_only_expensive : bool
val html : bool
val global_tenv : bool
val icfg_dotty_outfile : string option
val impurity_report_immutable_modifications : bool
val incremental_analysis : bool
val infer_is_clang : bool
val infer_is_javac : bool
val implicit_sdk_root : string option
val inclusive_cost : bool
val inferconfig_file : string option
val inferconfig_dir : string option
val is_checker_enabled : Checker.t -> bool
val issues_tests : string option
val issues_tests_fields : IssuesTestField.t list
val java_debug_source_file_info : string option
val java_jar_compiler : string option
val java_source_parser_experimental : bool
val java_version : int option
val javac_classes_out : string
val job_id : string option
val jobs : int
val keep_going : bool
val linter : string option
val linters_def_file : string list
val linters_def_folder : string list
val linters_developer_mode : bool
val linters_ignore_clang_failures : bool
val linters_validate_syntax_only : bool
val list_checkers : bool
val list_issue_types : bool
val liveness_dangerous_classes : Yojson.Basic.t
val liveness_ignored_constant : string list
val load_average : float option
val max_nesting : int option
val memtrace_analysis : bool
val memtrace_sampling_rate : float
val merge : bool
val method_decls_info : string option
val modified_lines : string option
val no_translate_libs : bool
val nullable_annotation : string option
val nullsafe_annotation_graph : bool
val nullsafe_disable_field_not_initialized_in_nonstrict_classes : bool
val nullsafe_optimistic_third_party_in_default_mode : bool
val nullsafe_third_party_signatures : string option
val nullsafe_third_party_location_for_messaging_only : string option
val nullsafe_strict_containers : bool
val oom_threshold : int option
val only_cheap_debug : bool
val patterns_modeled_expensive : string * Yojson.Basic.t
val patterns_never_returning_null : string * Yojson.Basic.t
val patterns_skip_implementation : string * Yojson.Basic.t
val patterns_skip_translation : string * Yojson.Basic.t
val pmd_xml : bool
val print_active_checkers : bool
val print_builtins : bool
val print_jbir : bool
val print_logs : bool
val print_types : bool
val print_using_diff : bool
val procedures : bool
val procedures_attributes : bool
val procedures_cfg : bool
val procedures_definedness : bool
val procedures_filter : string option
val procedures_name : bool
val procedures_source_file : bool
val procedures_summary : bool
val procedures_summary_json : bool
val process_clang_ast : bool
val profiler_samples : string option
val progress_bar : [ `MultiLine | `Plain | `Quiet ]
val project_root : string
val pulse_cut_to_one_path_procedures_pattern : Str.regexp option
val pulse_intraprocedural_only : bool
val pulse_isl : bool
val pulse_manifest_emp : bool
val pulse_max_disjuncts : int
val pulse_model_abort : string list
val pulse_model_alloc_pattern : Str.regexp option
val pulse_model_free_pattern : Str.regexp option
val pulse_model_malloc_pattern : Str.regexp option
val pulse_model_realloc_pattern : Str.regexp option
val pulse_model_release_pattern : Str.regexp option
val pulse_model_return_first_arg : Str.regexp option
val pulse_model_return_nonnull : Str.regexp option
val pulse_model_skip_pattern : Str.regexp option
val pulse_report_ignore_unknown_java_methods_patterns : Str.regexp option
val pulse_model_transfer_ownership_namespace : (string * string) list
val pulse_model_transfer_ownership : string list
val pulse_report_latent_issues : bool
val pulse_recency_limit : int
val pulse_widen_threshold : int
val pulse_nullsafe_report_npe : bool
val pure_by_default : bool
val quandary_endpoints : Yojson.Basic.t
val quandary_sanitizers : Yojson.Basic.t
val quandary_show_passthroughs : bool
val quandary_sinks : Yojson.Basic.t
val quandary_sources : Yojson.Basic.t
val quiet : bool
val racerd_guardedby : bool
val reactive_mode : bool
val reanalyze : bool
val relative_path_backtrack : int
val remodel_class : string option
val report : bool
val report_blacklist_files_containing : string list
val report_console_limit : int option
val report_current : string option
val report_custom_error : bool
val report_force_relative_path : bool
val report_formatter : [ `No_formatter | `Phabricator_formatter ]
val report_path_regex_blacklist : string list
val report_path_regex_whitelist : string list
val report_previous : string option
val report_suppress_errors : string list
val reports_include_ml_loc : bool
val rest : string list
val results_dir : string
val scheduler : scheduler
val scuba_logging : bool
val scuba_normals : string IStdlib.IStd.String.Map.t
val scuba_tags : string list IStdlib.IStd.String.Map.t
val select : [ `All | `Select of int ] option
val show_buckets : bool
val siof_check_iostreams : bool
val siof_safe_methods : string list
val skip_analysis_in_path : string list
val skip_analysis_in_path_skips_compilation : bool
val skip_duplicated_types : bool
val skip_non_capture_clang_commands : bool
val skip_translation_headers : string list
val source_files : bool
val source_files_cfg : bool
val source_files_filter : string option
val source_files_freshly_captured : bool
val source_files_procedure_names : bool
val source_files_type_environment : bool
val source_preview : bool
val sourcepath : string option
val sources : string list
val sqlite_cache_size : int
val sqlite_page_size : int
val sqlite_lock_timeout : int
val sqlite_vfs : string option
val starvation_skip_analysis : Yojson.Basic.t
val starvation_strict_mode : bool
val starvation_whole_program : bool
val subtype_multirange : bool
val summaries_caches_max_size : int
val suppress_lint_ignore_types : bool
val tenv_json : string option
val test_determinator : bool
val export_changed_functions : bool
val test_filtering : bool
val testing_mode : bool
val threadsafe_aliases : Yojson.Basic.t
val topl_max_conjuncts : int
val topl_max_disjuncts : int
val topl_properties : string list
val trace_absarray : bool
val trace_error : bool
val trace_events : bool
val trace_ondemand : bool
val trace_topl : bool
val tv_commit : string option
val tv_limit : int
val tv_limit_filtered : int
val uninit_interproc : bool
val workspace : string option
val write_html : bool
val write_html_whitelist_regex : string list
val write_website : string option
val xcode_developer_dir : string option
val xcode_isysroot_suffix : string option
val xcpretty : bool

Configuration values derived from command-line options

val dynamic_dispatch : bool
val toplevel_results_dir : string

In some integrations, eg Buck, infer subprocesses started by the build system (started by the toplevel infer process) will have their own results directory; this points to the results directory of the toplevel infer process, which can be useful for, eg, storing debug info. In other cases this is equal to results_dir.

val is_in_custom_symbols : string -> string -> bool

Does named symbol match any prefix in the named custom symbol list?

val java_package_is_external : string -> bool

Check if a Java package is external to the repository

val scuba_execution_id : IStdlib.IStd.Int64.t option

a random number to (hopefully) uniquely identify this run

Global variables with initial values specified by command-line options

val clang_compilation_dbs : [ `Escaped of string | `Raw of string ] list
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IBase__Config/index.html b/website/static/odoc/next/infer/IBase__Config/index.html index 7f54c3b98..679fe885b 100644 --- a/website/static/odoc/next/infer/IBase__Config/index.html +++ b/website/static/odoc/next/infer/IBase__Config/index.html @@ -1,2 +1,2 @@ -IBase__Config (infer.IBase__Config)

Module IBase__Config

type os_type =
| Unix
| Win32
| Cygwin
type build_system =
| BAnt
| BBuck
| BClang
| BGradle
| BJava
| BJavac
| BMake
| BMvn
| BNdk
| BRebar3
| BXcode
type scheduler =
| File
| Restart
| SyntacticCallGraph
val equal_scheduler : scheduler -> scheduler -> bool
val build_system_of_exe_name : string -> build_system
val string_of_build_system : build_system -> string
val env_inside_maven : IStdlib.IStd.Unix.env

Constant configuration values

val anonymous_block_num_sep : string
val anonymous_block_prefix : string
val assign : string
val biabduction_models_sql : string
val biabduction_models_jar : string
val bin_dir : string
val bound_error_allowed_in_procedure_call : bool
val clang_exe_aliases : string list
val clang_initializer_prefix : string
val clang_inner_destructor_prefix : string
val clang_plugin_path : string
val default_failure_name : string
val dotty_frontend_output : string
val etc_dir : string
val fail_on_issue_exit_code : int
val fcp_dir : string
val idempotent_getters : bool
val initial_analysis_time : float
val ivar_attributes : string
val java_lambda_marker_infix : string

marker to recognize methods generated by javalib to eliminate lambdas

val kotlin_source_extension : string
val lib_dir : string
val max_narrows : int
val max_widens : int
val meet_level : int
val nsnotification_center_checker_backend : bool
val os_type : os_type
val pp_version : Stdlib.Format.formatter -> unit -> unit
val property_attributes : string
val report_nullable_inconsistency : bool
val save_compact_summaries : bool
val smt_output : bool
val source_file_extentions : string list
val unsafe_unret : string
val weak : string
val whitelisted_cpp_classes : string list
val whitelisted_cpp_methods : string list
val wrappers_dir : string

Configuration values specified by command-line options

val annotation_reachability_cxx : Yojson.Basic.t
val annotation_reachability_cxx_sources : Yojson.Basic.t
val annotation_reachability_custom_pairs : Yojson.Basic.t
val append_buck_flavors : string list
val biabduction_abs_struct : int
val biabduction_abs_val : int
val biabduction_allow_leak : bool
val biabduction_array_level : int
val biabduction_models_mode : bool
val biabduction_iterations : int
val biabduction_join_cond : int
val biabduction_memleak_buckets : [ `MLeak_all | `MLeak_arc | `MLeak_cf | `MLeak_cpp | `MLeak_no_arc | `MLeak_unknown ] list
val biabduction_monitor_prop_size : bool
val biabduction_nelseg : bool
val biabduction_only_footprint : bool
val biabduction_seconds_per_iteration : float option
val biabduction_symops_per_iteration : int option
val biabduction_trace_join : bool
val biabduction_trace_rearrange : bool
val biabduction_type_size : bool
val biabduction_unsafe_malloc : bool
val biabduction_worklist_mode : int
val biabduction_write_dotty : bool
val bo_debug : int
val bo_field_depth_limit : int option
val bootclasspath : string option
val buck : bool
val buck_blacklist : string list
val buck_build_args : string list
val buck_build_args_no_inline : string list
val buck_cache_mode : bool
val buck_java_flavor_suppress_config : bool
val buck_java_heap_size_gb : int option
val buck_merge_all_deps : bool
val buck_mode : IBase.BuckMode.t option
val buck_out_gen : string
val buck_targets_blacklist : string list
val call_graph_schedule : bool
val capture : bool
val capture_blacklist : string option
val censor_report : ((bool * Str.regexp) * (bool * Str.regexp) * string) list
val cfg_json : string option
val changed_files_index : string option
val check_version : string option
val clang_ast_file : [ `Biniou of string | `Yojson of string ] option
val clang_compound_literal_init_limit : int
val clang_extra_flags : string list
val clang_blacklisted_flags : string list
val clang_blacklisted_flags_with_arg : string list
val clang_frontend_action_string : string
val clang_ignore_regex : string option
val clang_isystem_to_override_regex : Str.regexp option
val clang_idirafter_to_override_regex : Str.regexp option
val clang_libcxx_include_to_override_regex : string option
val classpath : string option
val command : ATDGenerated.InferCommand.t
val config_impact_current : string option
val config_impact_data_file : string option
val config_impact_issues_tests : string option
val config_impact_max_callees_to_print : int
val config_impact_previous : string option
val continue_analysis : bool
val continue_capture : bool
val costs_current : string option
val cost_issues_tests : string option
val cost_scuba_logging : bool
val costs_previous : string option
val cost_suppress_func_ptr : bool
val cost_tests_only_autoreleasepool : bool
val cxx : bool
val cxx_scope_guards : Yojson.Basic.t
val deduplicate : bool
val debug_exceptions : bool
val debug_level_analysis : int
val debug_level_capture : int
val debug_level_linters : int
val debug_level_test_determinator : int
val debug_mode : bool
val default_linters : bool
val dependency_mode : bool
val developer_mode : bool
val differential_filter_files : string option
val differential_filter_set : [ `Introduced | `Fixed | `Preexisting ] list
val dotty_cfg_libs : bool
val dump_duplicate_symbols : bool
val eradicate_condition_redundant : bool
val eradicate_field_over_annotated : bool
val eradicate_return_over_annotated : bool
val eradicate_verbose : bool
val erlang_ast_dir : string option
val erlang_skip_rebar3 : bool
val fail_on_bug : bool
val fcp_apple_clang : string option
val fcp_syntax_only : bool
val file_renamings : string option
val filter_paths : bool
val filtering : bool
val force_delete_results_dir : bool
val force_integration : build_system option
val from_json_report : string
val from_json_config_impact_report : string
val from_json_costs_report : string
val frontend_stats : bool
val frontend_tests : bool
val function_pointer_specialization : bool
val generated_classes : string option
val genrule_mode : bool
val get_linter_doc_url : linter_id:string -> string option
val help_checker : IBase.Checker.t list
val help_issue_type : IBase.IssueType.t list
val hoisting_report_only_expensive : bool
val html : bool
val global_tenv : bool
val icfg_dotty_outfile : string option
val impurity_report_immutable_modifications : bool
val incremental_analysis : bool
val infer_is_clang : bool
val infer_is_javac : bool
val implicit_sdk_root : string option
val inclusive_cost : bool
val inferconfig_file : string option
val inferconfig_dir : string option
val is_checker_enabled : IBase.Checker.t -> bool
val issues_tests : string option
val issues_tests_fields : IBase.IssuesTestField.t list
val java_debug_source_file_info : string option
val java_jar_compiler : string option
val java_source_parser_experimental : bool
val java_version : int option
val javac_classes_out : string
val job_id : string option
val jobs : int
val keep_going : bool
val linter : string option
val linters_def_file : string list
val linters_def_folder : string list
val linters_developer_mode : bool
val linters_ignore_clang_failures : bool
val linters_validate_syntax_only : bool
val list_checkers : bool
val list_issue_types : bool
val liveness_dangerous_classes : Yojson.Basic.t
val liveness_ignored_constant : string list
val load_average : float option
val max_nesting : int option
val memtrace_analysis : bool
val memtrace_sampling_rate : float
val merge : bool
val method_decls_info : string option
val modified_lines : string option
val no_translate_libs : bool
val nullable_annotation : string option
val nullsafe_annotation_graph : bool
val nullsafe_disable_field_not_initialized_in_nonstrict_classes : bool
val nullsafe_optimistic_third_party_in_default_mode : bool
val nullsafe_third_party_signatures : string option
val nullsafe_third_party_location_for_messaging_only : string option
val nullsafe_strict_containers : bool
val oom_threshold : int option
val only_cheap_debug : bool
val patterns_modeled_expensive : string * Yojson.Basic.t
val patterns_never_returning_null : string * Yojson.Basic.t
val patterns_skip_implementation : string * Yojson.Basic.t
val patterns_skip_translation : string * Yojson.Basic.t
val pmd_xml : bool
val print_active_checkers : bool
val print_builtins : bool
val print_jbir : bool
val print_logs : bool
val print_types : bool
val print_using_diff : bool
val procedures : bool
val procedures_attributes : bool
val procedures_cfg : bool
val procedures_definedness : bool
val procedures_filter : string option
val procedures_name : bool
val procedures_source_file : bool
val procedures_summary : bool
val procedures_summary_json : bool
val process_clang_ast : bool
val profiler_samples : string option
val progress_bar : [ `MultiLine | `Plain | `Quiet ]
val project_root : string
val pulse_cut_to_one_path_procedures_pattern : Str.regexp option
val pulse_intraprocedural_only : bool
val pulse_isl : bool
val pulse_manifest_emp : bool
val pulse_max_disjuncts : int
val pulse_model_abort : string list
val pulse_model_alloc_pattern : Str.regexp option
val pulse_model_free_pattern : Str.regexp option
val pulse_model_malloc_pattern : Str.regexp option
val pulse_model_release_pattern : Str.regexp option
val pulse_model_return_first_arg : Str.regexp option
val pulse_model_return_nonnull : Str.regexp option
val pulse_model_skip_pattern : Str.regexp option
val pulse_report_ignore_unknown_java_methods_patterns : Str.regexp option
val pulse_model_transfer_ownership_namespace : (string * string) list
val pulse_model_transfer_ownership : string list
val pulse_report_latent_issues : bool
val pulse_recency_limit : int
val pulse_widen_threshold : int
val pulse_nullsafe_report_npe : bool
val pure_by_default : bool
val quandary_endpoints : Yojson.Basic.t
val quandary_sanitizers : Yojson.Basic.t
val quandary_show_passthroughs : bool
val quandary_sinks : Yojson.Basic.t
val quandary_sources : Yojson.Basic.t
val quiet : bool
val racerd_guardedby : bool
val reactive_mode : bool
val reanalyze : bool
val relative_path_backtrack : int
val remodel_class : string option
val report : bool
val report_blacklist_files_containing : string list
val report_console_limit : int option
val report_current : string option
val report_custom_error : bool
val report_force_relative_path : bool
val report_formatter : [ `No_formatter | `Phabricator_formatter ]
val report_path_regex_blacklist : string list
val report_path_regex_whitelist : string list
val report_previous : string option
val report_suppress_errors : string list
val reports_include_ml_loc : bool
val rest : string list
val results_dir : string
val scheduler : scheduler
val scuba_logging : bool
val scuba_normals : string IStdlib.IStd.String.Map.t
val scuba_tags : string list IStdlib.IStd.String.Map.t
val select : [ `All | `Select of int ] option
val show_buckets : bool
val siof_check_iostreams : bool
val siof_safe_methods : string list
val skip_analysis_in_path : string list
val skip_analysis_in_path_skips_compilation : bool
val skip_duplicated_types : bool
val skip_non_capture_clang_commands : bool
val skip_translation_headers : string list
val source_files : bool
val source_files_cfg : bool
val source_files_filter : string option
val source_files_freshly_captured : bool
val source_files_procedure_names : bool
val source_files_type_environment : bool
val source_preview : bool
val sourcepath : string option
val sources : string list
val sqlite_cache_size : int
val sqlite_page_size : int
val sqlite_lock_timeout : int
val sqlite_vfs : string option
val starvation_skip_analysis : Yojson.Basic.t
val starvation_strict_mode : bool
val starvation_whole_program : bool
val subtype_multirange : bool
val summaries_caches_max_size : int
val suppress_lint_ignore_types : bool
val tenv_json : string option
val test_determinator : bool
val export_changed_functions : bool
val test_filtering : bool
val testing_mode : bool
val threadsafe_aliases : Yojson.Basic.t
val topl_max_conjuncts : int
val topl_max_disjuncts : int
val topl_properties : string list
val trace_absarray : bool
val trace_error : bool
val trace_events : bool
val trace_ondemand : bool
val trace_topl : bool
val tv_commit : string option
val tv_limit : int
val tv_limit_filtered : int
val uninit_interproc : bool
val workspace : string option
val write_html : bool
val write_html_whitelist_regex : string list
val write_website : string option
val xcode_developer_dir : string option
val xcode_isysroot_suffix : string option
val xcpretty : bool

Configuration values derived from command-line options

val dynamic_dispatch : bool
val toplevel_results_dir : string

In some integrations, eg Buck, infer subprocesses started by the build system (started by the toplevel infer process) will have their own results directory; this points to the results directory of the toplevel infer process, which can be useful for, eg, storing debug info. In other cases this is equal to results_dir.

val is_in_custom_symbols : string -> string -> bool

Does named symbol match any prefix in the named custom symbol list?

val java_package_is_external : string -> bool

Check if a Java package is external to the repository

val scuba_execution_id : IStdlib.IStd.Int64.t option

a random number to (hopefully) uniquely identify this run

Global variables with initial values specified by command-line options

val clang_compilation_dbs : [ `Escaped of string | `Raw of string ] list
\ No newline at end of file +IBase__Config (infer.IBase__Config)

Module IBase__Config

type os_type =
| Unix
| Win32
| Cygwin
type build_system =
| BAnt
| BBuck
| BClang
| BGradle
| BJava
| BJavac
| BMake
| BMvn
| BNdk
| BRebar3
| BXcode
type scheduler =
| File
| Restart
| SyntacticCallGraph
val equal_scheduler : scheduler -> scheduler -> bool
val build_system_of_exe_name : string -> build_system
val string_of_build_system : build_system -> string
val env_inside_maven : IStdlib.IStd.Unix.env

Constant configuration values

val anonymous_block_num_sep : string
val anonymous_block_prefix : string
val assign : string
val biabduction_models_sql : string
val biabduction_models_jar : string
val bin_dir : string
val bound_error_allowed_in_procedure_call : bool
val clang_exe_aliases : string list
val clang_initializer_prefix : string
val clang_inner_destructor_prefix : string
val clang_plugin_path : string
val default_failure_name : string
val dotty_frontend_output : string
val etc_dir : string
val fail_on_issue_exit_code : int
val fcp_dir : string
val idempotent_getters : bool
val initial_analysis_time : float
val ivar_attributes : string
val java_lambda_marker_infix : string

marker to recognize methods generated by javalib to eliminate lambdas

val kotlin_source_extension : string
val lib_dir : string
val max_narrows : int
val max_widens : int
val meet_level : int
val nsnotification_center_checker_backend : bool
val os_type : os_type
val pp_version : Stdlib.Format.formatter -> unit -> unit
val property_attributes : string
val report_nullable_inconsistency : bool
val save_compact_summaries : bool
val smt_output : bool
val source_file_extentions : string list
val unsafe_unret : string
val weak : string
val whitelisted_cpp_classes : string list
val whitelisted_cpp_methods : string list
val wrappers_dir : string

Configuration values specified by command-line options

val annotation_reachability_cxx : Yojson.Basic.t
val annotation_reachability_cxx_sources : Yojson.Basic.t
val annotation_reachability_custom_pairs : Yojson.Basic.t
val append_buck_flavors : string list
val biabduction_abs_struct : int
val biabduction_abs_val : int
val biabduction_allow_leak : bool
val biabduction_array_level : int
val biabduction_models_mode : bool
val biabduction_iterations : int
val biabduction_join_cond : int
val biabduction_memleak_buckets : [ `MLeak_all | `MLeak_arc | `MLeak_cf | `MLeak_cpp | `MLeak_no_arc | `MLeak_unknown ] list
val biabduction_monitor_prop_size : bool
val biabduction_nelseg : bool
val biabduction_only_footprint : bool
val biabduction_seconds_per_iteration : float option
val biabduction_symops_per_iteration : int option
val biabduction_trace_join : bool
val biabduction_trace_rearrange : bool
val biabduction_type_size : bool
val biabduction_unsafe_malloc : bool
val biabduction_worklist_mode : int
val biabduction_write_dotty : bool
val bo_debug : int
val bo_field_depth_limit : int option
val bootclasspath : string option
val buck : bool
val buck_blacklist : string list
val buck_build_args : string list
val buck_build_args_no_inline : string list
val buck_cache_mode : bool
val buck_java_flavor_suppress_config : bool
val buck_java_heap_size_gb : int option
val buck_merge_all_deps : bool
val buck_mode : IBase.BuckMode.t option
val buck_out_gen : string
val buck_targets_blacklist : string list
val call_graph_schedule : bool
val capture : bool
val capture_blacklist : string option
val censor_report : ((bool * Str.regexp) * (bool * Str.regexp) * string) list
val cfg_json : string option
val changed_files_index : string option
val check_version : string option
val clang_ast_file : [ `Biniou of string | `Yojson of string ] option
val clang_compound_literal_init_limit : int
val clang_extra_flags : string list
val clang_blacklisted_flags : string list
val clang_blacklisted_flags_with_arg : string list
val clang_frontend_action_string : string
val clang_ignore_regex : string option
val clang_isystem_to_override_regex : Str.regexp option
val clang_idirafter_to_override_regex : Str.regexp option
val clang_libcxx_include_to_override_regex : string option
val classpath : string option
val command : ATDGenerated.InferCommand.t
val config_impact_current : string option
val config_impact_data_file : string option
val config_impact_issues_tests : string option
val config_impact_max_callees_to_print : int
val config_impact_previous : string option
val continue_analysis : bool
val continue_capture : bool
val costs_current : string option
val cost_issues_tests : string option
val cost_scuba_logging : bool
val costs_previous : string option
val cost_suppress_func_ptr : bool
val cost_tests_only_autoreleasepool : bool
val cxx : bool
val cxx_scope_guards : Yojson.Basic.t
val deduplicate : bool
val debug_exceptions : bool
val debug_level_analysis : int
val debug_level_capture : int
val debug_level_linters : int
val debug_level_test_determinator : int
val debug_mode : bool
val default_linters : bool
val dependency_mode : bool
val developer_mode : bool
val differential_filter_files : string option
val differential_filter_set : [ `Introduced | `Fixed | `Preexisting ] list
val dotty_cfg_libs : bool
val dump_duplicate_symbols : bool
val eradicate_condition_redundant : bool
val eradicate_field_over_annotated : bool
val eradicate_return_over_annotated : bool
val eradicate_verbose : bool
val erlang_ast_dir : string option
val erlang_skip_rebar3 : bool
val fail_on_bug : bool
val fcp_apple_clang : string option
val fcp_syntax_only : bool
val file_renamings : string option
val filter_paths : bool
val filtering : bool
val force_delete_results_dir : bool
val force_integration : build_system option
val from_json_report : string
val from_json_config_impact_report : string
val from_json_costs_report : string
val frontend_stats : bool
val frontend_tests : bool
val function_pointer_specialization : bool
val generated_classes : string option
val genrule_mode : bool
val get_linter_doc_url : linter_id:string -> string option
val help_checker : IBase.Checker.t list
val help_issue_type : IBase.IssueType.t list
val hoisting_report_only_expensive : bool
val html : bool
val global_tenv : bool
val icfg_dotty_outfile : string option
val impurity_report_immutable_modifications : bool
val incremental_analysis : bool
val infer_is_clang : bool
val infer_is_javac : bool
val implicit_sdk_root : string option
val inclusive_cost : bool
val inferconfig_file : string option
val inferconfig_dir : string option
val is_checker_enabled : IBase.Checker.t -> bool
val issues_tests : string option
val issues_tests_fields : IBase.IssuesTestField.t list
val java_debug_source_file_info : string option
val java_jar_compiler : string option
val java_source_parser_experimental : bool
val java_version : int option
val javac_classes_out : string
val job_id : string option
val jobs : int
val keep_going : bool
val linter : string option
val linters_def_file : string list
val linters_def_folder : string list
val linters_developer_mode : bool
val linters_ignore_clang_failures : bool
val linters_validate_syntax_only : bool
val list_checkers : bool
val list_issue_types : bool
val liveness_dangerous_classes : Yojson.Basic.t
val liveness_ignored_constant : string list
val load_average : float option
val max_nesting : int option
val memtrace_analysis : bool
val memtrace_sampling_rate : float
val merge : bool
val method_decls_info : string option
val modified_lines : string option
val no_translate_libs : bool
val nullable_annotation : string option
val nullsafe_annotation_graph : bool
val nullsafe_disable_field_not_initialized_in_nonstrict_classes : bool
val nullsafe_optimistic_third_party_in_default_mode : bool
val nullsafe_third_party_signatures : string option
val nullsafe_third_party_location_for_messaging_only : string option
val nullsafe_strict_containers : bool
val oom_threshold : int option
val only_cheap_debug : bool
val patterns_modeled_expensive : string * Yojson.Basic.t
val patterns_never_returning_null : string * Yojson.Basic.t
val patterns_skip_implementation : string * Yojson.Basic.t
val patterns_skip_translation : string * Yojson.Basic.t
val pmd_xml : bool
val print_active_checkers : bool
val print_builtins : bool
val print_jbir : bool
val print_logs : bool
val print_types : bool
val print_using_diff : bool
val procedures : bool
val procedures_attributes : bool
val procedures_cfg : bool
val procedures_definedness : bool
val procedures_filter : string option
val procedures_name : bool
val procedures_source_file : bool
val procedures_summary : bool
val procedures_summary_json : bool
val process_clang_ast : bool
val profiler_samples : string option
val progress_bar : [ `MultiLine | `Plain | `Quiet ]
val project_root : string
val pulse_cut_to_one_path_procedures_pattern : Str.regexp option
val pulse_intraprocedural_only : bool
val pulse_isl : bool
val pulse_manifest_emp : bool
val pulse_max_disjuncts : int
val pulse_model_abort : string list
val pulse_model_alloc_pattern : Str.regexp option
val pulse_model_free_pattern : Str.regexp option
val pulse_model_malloc_pattern : Str.regexp option
val pulse_model_realloc_pattern : Str.regexp option
val pulse_model_release_pattern : Str.regexp option
val pulse_model_return_first_arg : Str.regexp option
val pulse_model_return_nonnull : Str.regexp option
val pulse_model_skip_pattern : Str.regexp option
val pulse_report_ignore_unknown_java_methods_patterns : Str.regexp option
val pulse_model_transfer_ownership_namespace : (string * string) list
val pulse_model_transfer_ownership : string list
val pulse_report_latent_issues : bool
val pulse_recency_limit : int
val pulse_widen_threshold : int
val pulse_nullsafe_report_npe : bool
val pure_by_default : bool
val quandary_endpoints : Yojson.Basic.t
val quandary_sanitizers : Yojson.Basic.t
val quandary_show_passthroughs : bool
val quandary_sinks : Yojson.Basic.t
val quandary_sources : Yojson.Basic.t
val quiet : bool
val racerd_guardedby : bool
val reactive_mode : bool
val reanalyze : bool
val relative_path_backtrack : int
val remodel_class : string option
val report : bool
val report_blacklist_files_containing : string list
val report_console_limit : int option
val report_current : string option
val report_custom_error : bool
val report_force_relative_path : bool
val report_formatter : [ `No_formatter | `Phabricator_formatter ]
val report_path_regex_blacklist : string list
val report_path_regex_whitelist : string list
val report_previous : string option
val report_suppress_errors : string list
val reports_include_ml_loc : bool
val rest : string list
val results_dir : string
val scheduler : scheduler
val scuba_logging : bool
val scuba_normals : string IStdlib.IStd.String.Map.t
val scuba_tags : string list IStdlib.IStd.String.Map.t
val select : [ `All | `Select of int ] option
val show_buckets : bool
val siof_check_iostreams : bool
val siof_safe_methods : string list
val skip_analysis_in_path : string list
val skip_analysis_in_path_skips_compilation : bool
val skip_duplicated_types : bool
val skip_non_capture_clang_commands : bool
val skip_translation_headers : string list
val source_files : bool
val source_files_cfg : bool
val source_files_filter : string option
val source_files_freshly_captured : bool
val source_files_procedure_names : bool
val source_files_type_environment : bool
val source_preview : bool
val sourcepath : string option
val sources : string list
val sqlite_cache_size : int
val sqlite_page_size : int
val sqlite_lock_timeout : int
val sqlite_vfs : string option
val starvation_skip_analysis : Yojson.Basic.t
val starvation_strict_mode : bool
val starvation_whole_program : bool
val subtype_multirange : bool
val summaries_caches_max_size : int
val suppress_lint_ignore_types : bool
val tenv_json : string option
val test_determinator : bool
val export_changed_functions : bool
val test_filtering : bool
val testing_mode : bool
val threadsafe_aliases : Yojson.Basic.t
val topl_max_conjuncts : int
val topl_max_disjuncts : int
val topl_properties : string list
val trace_absarray : bool
val trace_error : bool
val trace_events : bool
val trace_ondemand : bool
val trace_topl : bool
val tv_commit : string option
val tv_limit : int
val tv_limit_filtered : int
val uninit_interproc : bool
val workspace : string option
val write_html : bool
val write_html_whitelist_regex : string list
val write_website : string option
val xcode_developer_dir : string option
val xcode_isysroot_suffix : string option
val xcpretty : bool

Configuration values derived from command-line options

val dynamic_dispatch : bool
val toplevel_results_dir : string

In some integrations, eg Buck, infer subprocesses started by the build system (started by the toplevel infer process) will have their own results directory; this points to the results directory of the toplevel infer process, which can be useful for, eg, storing debug info. In other cases this is equal to results_dir.

val is_in_custom_symbols : string -> string -> bool

Does named symbol match any prefix in the named custom symbol list?

val java_package_is_external : string -> bool

Check if a Java package is external to the repository

val scuba_execution_id : IStdlib.IStd.Int64.t option

a random number to (hopefully) uniquely identify this run

Global variables with initial values specified by command-line options

val clang_compilation_dbs : [ `Escaped of string | `Raw of string ] list
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IR/ObjCDispatchModels/index.html b/website/static/odoc/next/infer/IR/ObjCDispatchModels/index.html new file mode 100644 index 000000000..2db3c99a6 --- /dev/null +++ b/website/static/odoc/next/infer/IR/ObjCDispatchModels/index.html @@ -0,0 +1,2 @@ + +ObjCDispatchModels (infer.IR.ObjCDispatchModels)

Module IR.ObjCDispatchModels

val is_model : Procname.t -> bool
val get_dispatch_closure_opt : (Exp.t * Typ.t) list -> (Procname.t * (Exp.t * Typ.t) list) option
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IR/Procname/Erlang/index.html b/website/static/odoc/next/infer/IR/Procname/Erlang/index.html new file mode 100644 index 000000000..798704c3d --- /dev/null +++ b/website/static/odoc/next/infer/IR/Procname/Erlang/index.html @@ -0,0 +1,2 @@ + +Erlang (infer.IR.Procname.Erlang)

Module Procname.Erlang

type t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IR__ObjCDispatchModels/.dune-keep b/website/static/odoc/next/infer/IR__ObjCDispatchModels/.dune-keep new file mode 100644 index 000000000..e69de29bb diff --git a/website/static/odoc/next/infer/IR__ObjCDispatchModels/index.html b/website/static/odoc/next/infer/IR__ObjCDispatchModels/index.html new file mode 100644 index 000000000..924049f5d --- /dev/null +++ b/website/static/odoc/next/infer/IR__ObjCDispatchModels/index.html @@ -0,0 +1,2 @@ + +IR__ObjCDispatchModels (infer.IR__ObjCDispatchModels)

Module IR__ObjCDispatchModels

val is_model : IR.Procname.t -> bool
val get_dispatch_closure_opt : (IR.Exp.t * IR.Typ.t) list -> (IR.Procname.t * (IR.Exp.t * IR.Typ.t) list) option
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IR__Procname/Erlang/index.html b/website/static/odoc/next/infer/IR__Procname/Erlang/index.html new file mode 100644 index 000000000..146cb7280 --- /dev/null +++ b/website/static/odoc/next/infer/IR__Procname/Erlang/index.html @@ -0,0 +1,2 @@ + +Erlang (infer.IR__Procname.Erlang)

Module IR__Procname.Erlang

type t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IStdlib/ISys/index.html b/website/static/odoc/next/infer/IStdlib/ISys/index.html new file mode 100644 index 000000000..9d29b2acc --- /dev/null +++ b/website/static/odoc/next/infer/IStdlib/ISys/index.html @@ -0,0 +1,2 @@ + +ISys (infer.IStdlib.ISys)

Module IStdlib.ISys

val file_exists : ?⁠follow_symlinks:bool -> string -> bool

Similar to Sys.file_exists_exn, but it returns false when the result is unknown, instead of raising an exception. follow_symlinks is true by default.

\ No newline at end of file diff --git a/website/static/odoc/next/infer/IStdlib/PrettyPrintable/MakePPMonoMap/index.html b/website/static/odoc/next/infer/IStdlib/PrettyPrintable/MakePPMonoMap/index.html index 25a8f5b46..f795d6f61 100644 --- a/website/static/odoc/next/infer/IStdlib/PrettyPrintable/MakePPMonoMap/index.html +++ b/website/static/odoc/next/infer/IStdlib/PrettyPrintable/MakePPMonoMap/index.html @@ -1,2 +1,2 @@ -MakePPMonoMap (infer.IStdlib.PrettyPrintable.MakePPMonoMap)

Module PrettyPrintable.MakePPMonoMap

Parameters

Signature

include MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include PrintableType with type t := t
type t
val pp : F.formatter -> t -> unit
val pp_key : F.formatter -> key -> unit
\ No newline at end of file +MakePPMonoMap (infer.IStdlib.PrettyPrintable.MakePPMonoMap)

Module PrettyPrintable.MakePPMonoMap

Parameters

Signature

include MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include PrintableType with type t := t
type t
val pp : F.formatter -> t -> unit
val pp_key : F.formatter -> key -> unit
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IStdlib/PrettyPrintable/PPMonoMapOfPPMap/index.html b/website/static/odoc/next/infer/IStdlib/PrettyPrintable/PPMonoMapOfPPMap/index.html index fcac501af..8ee043982 100644 --- a/website/static/odoc/next/infer/IStdlib/PrettyPrintable/PPMonoMapOfPPMap/index.html +++ b/website/static/odoc/next/infer/IStdlib/PrettyPrintable/PPMonoMapOfPPMap/index.html @@ -1,2 +1,2 @@ -PPMonoMapOfPPMap (infer.IStdlib.PrettyPrintable.PPMonoMapOfPPMap)

Module PrettyPrintable.PPMonoMapOfPPMap

Parameters

Signature

include MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include PrintableType with type t := t
type t
val pp : F.formatter -> t -> unit
val pp_key : F.formatter -> key -> unit
\ No newline at end of file +PPMonoMapOfPPMap (infer.IStdlib.PrettyPrintable.PPMonoMapOfPPMap)

Module PrettyPrintable.PPMonoMapOfPPMap

Parameters

Signature

include MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include PrintableType with type t := t
type t
val pp : F.formatter -> t -> unit
val pp_key : F.formatter -> key -> unit
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IStdlib/PrettyPrintable/module-type-MonoMap/index.html b/website/static/odoc/next/infer/IStdlib/PrettyPrintable/module-type-MonoMap/index.html index a7ce67aab..feabf45a2 100644 --- a/website/static/odoc/next/infer/IStdlib/PrettyPrintable/module-type-MonoMap/index.html +++ b/website/static/odoc/next/infer/IStdlib/PrettyPrintable/module-type-MonoMap/index.html @@ -1,2 +1,2 @@ -MonoMap (infer.IStdlib.PrettyPrintable.MonoMap)

Module type PrettyPrintable.MonoMap

type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
\ No newline at end of file +MonoMap (infer.IStdlib.PrettyPrintable.MonoMap)

Module type PrettyPrintable.MonoMap

type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IStdlib/PrettyPrintable/module-type-PPMonoMap/index.html b/website/static/odoc/next/infer/IStdlib/PrettyPrintable/module-type-PPMonoMap/index.html index 459ca699c..e809d1919 100644 --- a/website/static/odoc/next/infer/IStdlib/PrettyPrintable/module-type-PPMonoMap/index.html +++ b/website/static/odoc/next/infer/IStdlib/PrettyPrintable/module-type-PPMonoMap/index.html @@ -1,2 +1,2 @@ -PPMonoMap (infer.IStdlib.PrettyPrintable.PPMonoMap)

Module type PrettyPrintable.PPMonoMap

include MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include PrintableType with type t := t
type t
val pp : F.formatter -> t -> unit
val pp_key : F.formatter -> key -> unit
\ No newline at end of file +PPMonoMap (infer.IStdlib.PrettyPrintable.PPMonoMap)

Module type PrettyPrintable.PPMonoMap

include MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include PrintableType with type t := t
type t
val pp : F.formatter -> t -> unit
val pp_key : F.formatter -> key -> unit
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IStdlib/RecencyMap/Make/index.html b/website/static/odoc/next/infer/IStdlib/RecencyMap/Make/index.html index a343b778c..c5191ad75 100644 --- a/website/static/odoc/next/infer/IStdlib/RecencyMap/Make/index.html +++ b/website/static/odoc/next/infer/IStdlib/RecencyMap/Make/index.html @@ -1,2 +1,2 @@ -Make (infer.IStdlib.RecencyMap.Make)

Module RecencyMap.Make

Parameters

Signature

type t

Note that the derived compare and equal functions are sensitive to the underlying implementation and in particular won't equate some objects that denote the same map.

val compare : t -> t -> int
val equal : t -> t -> bool
type key = Key.t
type value = Value.t
val pp : F.formatter -> t -> unit
val empty : t
val add : key -> value -> t -> t
val bindings : t -> (key * value) list
val exists : t -> f:((key * value) -> bool) -> bool
val filter : t -> f:((key * value) -> bool) -> t
val find_opt : key -> t -> value option
val fold : t -> init:'acc -> f:('acc -> (key * value) -> 'acc) -> 'acc
val fold_map : t -> init:'acc -> f:('acc -> value -> 'acc * value) -> 'acc * t
val is_empty : t -> bool
val map : t -> f:(value -> value) -> t
val mem : t -> key -> bool
val union_left_biased : t -> t -> t
\ No newline at end of file +Make (infer.IStdlib.RecencyMap.Make)

Module RecencyMap.Make

Parameters

Signature

type t

Note that the derived compare and equal functions are sensitive to the underlying implementation and in particular won't equate some objects that denote the same map.

val compare : t -> t -> int
val equal : t -> t -> bool
type key = Key.t
type value = Value.t
val pp : F.formatter -> t -> unit
val empty : t
val add : key -> value -> t -> t
val bindings : t -> (key * value) list
val exists : t -> f:((key * value) -> bool) -> bool
val filter : t -> f:((key * value) -> bool) -> t
val find_opt : key -> t -> value option
val fold : t -> init:'acc -> f:('acc -> (key * value) -> 'acc) -> 'acc
val fold_map : t -> init:'acc -> f:('acc -> value -> 'acc * value) -> 'acc * t
val is_empty : t -> bool
val map : t -> f:(value -> value) -> t
val mem : t -> key -> bool
val union_left_biased : t -> t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IStdlib/RecencyMap/module-type-S/index.html b/website/static/odoc/next/infer/IStdlib/RecencyMap/module-type-S/index.html index 2328b7b1b..cf06fd47b 100644 --- a/website/static/odoc/next/infer/IStdlib/RecencyMap/module-type-S/index.html +++ b/website/static/odoc/next/infer/IStdlib/RecencyMap/module-type-S/index.html @@ -1,2 +1,2 @@ -S (infer.IStdlib.RecencyMap.S)

Module type RecencyMap.S

A functional map interface where only the N most recently-accessed elements are guaranteed to be persisted, similarly to an LRU cache. The map stores at most 2*N elements.

type t

Note that the derived compare and equal functions are sensitive to the underlying implementation and in particular won't equate some objects that denote the same map.

val compare : t -> t -> int
val equal : t -> t -> bool
type key
type value
val pp : F.formatter -> t -> unit
val empty : t
val add : key -> value -> t -> t
val bindings : t -> (key * value) list
val exists : t -> f:((key * value) -> bool) -> bool
val filter : t -> f:((key * value) -> bool) -> t
val find_opt : key -> t -> value option
val fold : t -> init:'acc -> f:('acc -> (key * value) -> 'acc) -> 'acc
val fold_map : t -> init:'acc -> f:('acc -> value -> 'acc * value) -> 'acc * t
val is_empty : t -> bool
val map : t -> f:(value -> value) -> t
val mem : t -> key -> bool
val union_left_biased : t -> t -> t
\ No newline at end of file +S (infer.IStdlib.RecencyMap.S)

Module type RecencyMap.S

A functional map interface where only the N most recently-accessed elements are guaranteed to be persisted, similarly to an LRU cache. The map stores at most 2*N elements.

type t

Note that the derived compare and equal functions are sensitive to the underlying implementation and in particular won't equate some objects that denote the same map.

val compare : t -> t -> int
val equal : t -> t -> bool
type key
type value
val pp : F.formatter -> t -> unit
val empty : t
val add : key -> value -> t -> t
val bindings : t -> (key * value) list
val exists : t -> f:((key * value) -> bool) -> bool
val filter : t -> f:((key * value) -> bool) -> t
val find_opt : key -> t -> value option
val fold : t -> init:'acc -> f:('acc -> (key * value) -> 'acc) -> 'acc
val fold_map : t -> init:'acc -> f:('acc -> value -> 'acc * value) -> 'acc * t
val is_empty : t -> bool
val map : t -> f:(value -> value) -> t
val mem : t -> key -> bool
val union_left_biased : t -> t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IStdlib__ISys/.dune-keep b/website/static/odoc/next/infer/IStdlib__ISys/.dune-keep new file mode 100644 index 000000000..e69de29bb diff --git a/website/static/odoc/next/infer/IStdlib__ISys/index.html b/website/static/odoc/next/infer/IStdlib__ISys/index.html new file mode 100644 index 000000000..38218e696 --- /dev/null +++ b/website/static/odoc/next/infer/IStdlib__ISys/index.html @@ -0,0 +1,2 @@ + +IStdlib__ISys (infer.IStdlib__ISys)

Module IStdlib__ISys

val file_exists : ?⁠follow_symlinks:bool -> string -> bool

Similar to Sys.file_exists_exn, but it returns false when the result is unknown, instead of raising an exception. follow_symlinks is true by default.

\ No newline at end of file diff --git a/website/static/odoc/next/infer/IStdlib__PrettyPrintable/MakePPMonoMap/index.html b/website/static/odoc/next/infer/IStdlib__PrettyPrintable/MakePPMonoMap/index.html index 9a4a3cbe3..7d90426cb 100644 --- a/website/static/odoc/next/infer/IStdlib__PrettyPrintable/MakePPMonoMap/index.html +++ b/website/static/odoc/next/infer/IStdlib__PrettyPrintable/MakePPMonoMap/index.html @@ -1,2 +1,2 @@ -MakePPMonoMap (infer.IStdlib__PrettyPrintable.MakePPMonoMap)

Module IStdlib__PrettyPrintable.MakePPMonoMap

Parameters

Signature

include MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include PrintableType with type t := t
type t
val pp : F.formatter -> t -> unit
val pp_key : F.formatter -> key -> unit
\ No newline at end of file +MakePPMonoMap (infer.IStdlib__PrettyPrintable.MakePPMonoMap)

Module IStdlib__PrettyPrintable.MakePPMonoMap

Parameters

Signature

include MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include PrintableType with type t := t
type t
val pp : F.formatter -> t -> unit
val pp_key : F.formatter -> key -> unit
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IStdlib__PrettyPrintable/PPMonoMapOfPPMap/index.html b/website/static/odoc/next/infer/IStdlib__PrettyPrintable/PPMonoMapOfPPMap/index.html index 901b1bace..ddb58986a 100644 --- a/website/static/odoc/next/infer/IStdlib__PrettyPrintable/PPMonoMapOfPPMap/index.html +++ b/website/static/odoc/next/infer/IStdlib__PrettyPrintable/PPMonoMapOfPPMap/index.html @@ -1,2 +1,2 @@ -PPMonoMapOfPPMap (infer.IStdlib__PrettyPrintable.PPMonoMapOfPPMap)

Module IStdlib__PrettyPrintable.PPMonoMapOfPPMap

Parameters

Signature

include MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include PrintableType with type t := t
type t
val pp : F.formatter -> t -> unit
val pp_key : F.formatter -> key -> unit
\ No newline at end of file +PPMonoMapOfPPMap (infer.IStdlib__PrettyPrintable.PPMonoMapOfPPMap)

Module IStdlib__PrettyPrintable.PPMonoMapOfPPMap

Parameters

Signature

include MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include PrintableType with type t := t
type t
val pp : F.formatter -> t -> unit
val pp_key : F.formatter -> key -> unit
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IStdlib__PrettyPrintable/module-type-MonoMap/index.html b/website/static/odoc/next/infer/IStdlib__PrettyPrintable/module-type-MonoMap/index.html index 94502f014..54886b6f2 100644 --- a/website/static/odoc/next/infer/IStdlib__PrettyPrintable/module-type-MonoMap/index.html +++ b/website/static/odoc/next/infer/IStdlib__PrettyPrintable/module-type-MonoMap/index.html @@ -1,2 +1,2 @@ -MonoMap (infer.IStdlib__PrettyPrintable.MonoMap)

Module type IStdlib__PrettyPrintable.MonoMap

type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
\ No newline at end of file +MonoMap (infer.IStdlib__PrettyPrintable.MonoMap)

Module type IStdlib__PrettyPrintable.MonoMap

type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IStdlib__PrettyPrintable/module-type-PPMonoMap/index.html b/website/static/odoc/next/infer/IStdlib__PrettyPrintable/module-type-PPMonoMap/index.html index 118073938..585d3b3a2 100644 --- a/website/static/odoc/next/infer/IStdlib__PrettyPrintable/module-type-PPMonoMap/index.html +++ b/website/static/odoc/next/infer/IStdlib__PrettyPrintable/module-type-PPMonoMap/index.html @@ -1,2 +1,2 @@ -PPMonoMap (infer.IStdlib__PrettyPrintable.PPMonoMap)

Module type IStdlib__PrettyPrintable.PPMonoMap

include MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include PrintableType with type t := t
type t
val pp : F.formatter -> t -> unit
val pp_key : F.formatter -> key -> unit
\ No newline at end of file +PPMonoMap (infer.IStdlib__PrettyPrintable.PPMonoMap)

Module type IStdlib__PrettyPrintable.PPMonoMap

include MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include PrintableType with type t := t
type t
val pp : F.formatter -> t -> unit
val pp_key : F.formatter -> key -> unit
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IStdlib__RecencyMap/Make/index.html b/website/static/odoc/next/infer/IStdlib__RecencyMap/Make/index.html index fddda1ce8..4ffd57b7c 100644 --- a/website/static/odoc/next/infer/IStdlib__RecencyMap/Make/index.html +++ b/website/static/odoc/next/infer/IStdlib__RecencyMap/Make/index.html @@ -1,2 +1,2 @@ -Make (infer.IStdlib__RecencyMap.Make)

Module IStdlib__RecencyMap.Make

Parameters

Signature

type t

Note that the derived compare and equal functions are sensitive to the underlying implementation and in particular won't equate some objects that denote the same map.

val compare : t -> t -> int
val equal : t -> t -> bool
type key = Key.t
type value = Value.t
val pp : F.formatter -> t -> unit
val empty : t
val add : key -> value -> t -> t
val bindings : t -> (key * value) list
val exists : t -> f:((key * value) -> bool) -> bool
val filter : t -> f:((key * value) -> bool) -> t
val find_opt : key -> t -> value option
val fold : t -> init:'acc -> f:('acc -> (key * value) -> 'acc) -> 'acc
val fold_map : t -> init:'acc -> f:('acc -> value -> 'acc * value) -> 'acc * t
val is_empty : t -> bool
val map : t -> f:(value -> value) -> t
val mem : t -> key -> bool
val union_left_biased : t -> t -> t
\ No newline at end of file +Make (infer.IStdlib__RecencyMap.Make)

Module IStdlib__RecencyMap.Make

Parameters

Signature

type t

Note that the derived compare and equal functions are sensitive to the underlying implementation and in particular won't equate some objects that denote the same map.

val compare : t -> t -> int
val equal : t -> t -> bool
type key = Key.t
type value = Value.t
val pp : F.formatter -> t -> unit
val empty : t
val add : key -> value -> t -> t
val bindings : t -> (key * value) list
val exists : t -> f:((key * value) -> bool) -> bool
val filter : t -> f:((key * value) -> bool) -> t
val find_opt : key -> t -> value option
val fold : t -> init:'acc -> f:('acc -> (key * value) -> 'acc) -> 'acc
val fold_map : t -> init:'acc -> f:('acc -> value -> 'acc * value) -> 'acc * t
val is_empty : t -> bool
val map : t -> f:(value -> value) -> t
val mem : t -> key -> bool
val union_left_biased : t -> t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/IStdlib__RecencyMap/module-type-S/index.html b/website/static/odoc/next/infer/IStdlib__RecencyMap/module-type-S/index.html index 1f195844f..732d353f4 100644 --- a/website/static/odoc/next/infer/IStdlib__RecencyMap/module-type-S/index.html +++ b/website/static/odoc/next/infer/IStdlib__RecencyMap/module-type-S/index.html @@ -1,2 +1,2 @@ -S (infer.IStdlib__RecencyMap.S)

Module type IStdlib__RecencyMap.S

A functional map interface where only the N most recently-accessed elements are guaranteed to be persisted, similarly to an LRU cache. The map stores at most 2*N elements.

type t

Note that the derived compare and equal functions are sensitive to the underlying implementation and in particular won't equate some objects that denote the same map.

val compare : t -> t -> int
val equal : t -> t -> bool
type key
type value
val pp : F.formatter -> t -> unit
val empty : t
val add : key -> value -> t -> t
val bindings : t -> (key * value) list
val exists : t -> f:((key * value) -> bool) -> bool
val filter : t -> f:((key * value) -> bool) -> t
val find_opt : key -> t -> value option
val fold : t -> init:'acc -> f:('acc -> (key * value) -> 'acc) -> 'acc
val fold_map : t -> init:'acc -> f:('acc -> value -> 'acc * value) -> 'acc * t
val is_empty : t -> bool
val map : t -> f:(value -> value) -> t
val mem : t -> key -> bool
val union_left_biased : t -> t -> t
\ No newline at end of file +S (infer.IStdlib__RecencyMap.S)

Module type IStdlib__RecencyMap.S

A functional map interface where only the N most recently-accessed elements are guaranteed to be persisted, similarly to an LRU cache. The map stores at most 2*N elements.

type t

Note that the derived compare and equal functions are sensitive to the underlying implementation and in particular won't equate some objects that denote the same map.

val compare : t -> t -> int
val equal : t -> t -> bool
type key
type value
val pp : F.formatter -> t -> unit
val empty : t
val add : key -> value -> t -> t
val bindings : t -> (key * value) list
val exists : t -> f:((key * value) -> bool) -> bool
val filter : t -> f:((key * value) -> bool) -> t
val find_opt : key -> t -> value option
val fold : t -> init:'acc -> f:('acc -> (key * value) -> 'acc) -> 'acc
val fold_map : t -> init:'acc -> f:('acc -> value -> 'acc * value) -> 'acc * t
val is_empty : t -> bool
val map : t -> f:(value -> value) -> t
val mem : t -> key -> bool
val union_left_biased : t -> t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Integration/Rebar3/index.html b/website/static/odoc/next/infer/Integration/Rebar3/index.html new file mode 100644 index 000000000..9d80eb751 --- /dev/null +++ b/website/static/odoc/next/infer/Integration/Rebar3/index.html @@ -0,0 +1,2 @@ + +Rebar3 (infer.Integration.Rebar3)

Module Integration.Rebar3

val capture : args:string list -> unit
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Integration__Rebar3/.dune-keep b/website/static/odoc/next/infer/Integration__Rebar3/.dune-keep new file mode 100644 index 000000000..e69de29bb diff --git a/website/static/odoc/next/infer/Integration__Rebar3/index.html b/website/static/odoc/next/infer/Integration__Rebar3/index.html new file mode 100644 index 000000000..428bca11f --- /dev/null +++ b/website/static/odoc/next/infer/Integration__Rebar3/index.html @@ -0,0 +1,2 @@ + +Integration__Rebar3 (infer.Integration__Rebar3)

Module Integration__Rebar3

val capture : args:string list -> unit
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib/PulseAbductiveDomain/AddressAttributes/index.html b/website/static/odoc/next/infer/Pulselib/PulseAbductiveDomain/AddressAttributes/index.html index 4bfc8aaaa..02b811741 100644 --- a/website/static/odoc/next/infer/Pulselib/PulseAbductiveDomain/AddressAttributes/index.html +++ b/website/static/odoc/next/infer/Pulselib/PulseAbductiveDomain/AddressAttributes/index.html @@ -1,2 +1,2 @@ -AddressAttributes (infer.Pulselib.PulseAbductiveDomain.AddressAttributes)

Module PulseAbductiveDomain.AddressAttributes

attribute operations like BaseAddressAttributes but that also take care of propagating facts to the precondition

val abduce_and_add : PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attributes.t -> t -> t

add the attributes to both the current state and, if meaningful, the pre

val add_one : PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attribute.t -> t -> t

add the attribute only to the post

val add_attrs : PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attributes.t -> t -> t
val check_valid : ?⁠must_be_valid_reason:PulseBasicInterface.Invalidation.must_be_valid_reason -> PulseBasicInterface.Trace.t -> PulseBasicInterface.AbstractValue.t -> t -> (tPulseBasicInterface.Invalidation.t * PulseBasicInterface.Trace.t) IStdlib.IStd.result
val check_initialized : PulseBasicInterface.Trace.t -> PulseBasicInterface.AbstractValue.t -> t -> (t, unit) IStdlib.IStd.result
val invalidate : (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.ValueHistory.t) -> PulseBasicInterface.Invalidation.t -> IBase.Location.t -> t -> t
val replace_must_be_valid_reason : PulseBasicInterface.Invalidation.must_be_valid_reason -> PulseBasicInterface.AbstractValue.t -> t -> t
val allocate : IR.Procname.t -> (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.ValueHistory.t) -> IBase.Location.t -> t -> t
val add_dynamic_type : IR.Typ.t -> PulseBasicInterface.AbstractValue.t -> t -> t
val remove_allocation_attr : PulseBasicInterface.AbstractValue.t -> t -> t
val get_closure_proc_name : PulseBasicInterface.AbstractValue.t -> t -> IR.Procname.t option
val is_end_of_collection : PulseBasicInterface.AbstractValue.t -> t -> bool
val mark_as_end_of_collection : PulseBasicInterface.AbstractValue.t -> t -> t
val is_std_vector_reserved : PulseBasicInterface.AbstractValue.t -> t -> bool
val std_vector_reserve : PulseBasicInterface.AbstractValue.t -> t -> t
val find_opt : PulseBasicInterface.AbstractValue.t -> t -> PulseBasicInterface.Attributes.t option
val check_valid_isl : PulseBasicInterface.Trace.t -> PulseBasicInterface.AbstractValue.t -> ?⁠null_noop:bool -> t -> (t[> `ISLError of t | `InvalidAccess of PulseBasicInterface.Invalidation.t * PulseBasicInterface.Trace.t * t ]) IStdlib.IStd.result list
\ No newline at end of file +AddressAttributes (infer.Pulselib.PulseAbductiveDomain.AddressAttributes)

Module PulseAbductiveDomain.AddressAttributes

attribute operations like BaseAddressAttributes but that also take care of propagating facts to the precondition

val abduce_and_add : PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attributes.t -> t -> t

add the attributes to both the current state and, if meaningful, the pre

val add_one : PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attribute.t -> t -> t

add the attribute only to the post

val add_attrs : PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attributes.t -> t -> t
val check_valid : ?⁠must_be_valid_reason:PulseBasicInterface.Invalidation.must_be_valid_reason -> PulseBasicInterface.Trace.t -> PulseBasicInterface.AbstractValue.t -> t -> (tPulseBasicInterface.Invalidation.t * PulseBasicInterface.Trace.t) IStdlib.IStd.result
val check_initialized : PulseBasicInterface.Trace.t -> PulseBasicInterface.AbstractValue.t -> t -> (t, unit) IStdlib.IStd.result
val invalidate : (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.ValueHistory.t) -> PulseBasicInterface.Invalidation.t -> IBase.Location.t -> t -> t
val replace_must_be_valid_reason : PulseBasicInterface.Invalidation.must_be_valid_reason -> PulseBasicInterface.AbstractValue.t -> t -> t
val allocate : IR.Procname.t -> (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.ValueHistory.t) -> IBase.Location.t -> t -> t
val add_dynamic_type : IR.Typ.t -> PulseBasicInterface.AbstractValue.t -> t -> t
val remove_allocation_attr : PulseBasicInterface.AbstractValue.t -> t -> t
val get_allocation : PulseBasicInterface.AbstractValue.t -> t -> (IR.Procname.t * PulseBasicInterface.Trace.t) option
val get_closure_proc_name : PulseBasicInterface.AbstractValue.t -> t -> IR.Procname.t option
val is_end_of_collection : PulseBasicInterface.AbstractValue.t -> t -> bool
val mark_as_end_of_collection : PulseBasicInterface.AbstractValue.t -> t -> t
val is_std_vector_reserved : PulseBasicInterface.AbstractValue.t -> t -> bool
val std_vector_reserve : PulseBasicInterface.AbstractValue.t -> t -> t
val add_unreachable_at : PulseBasicInterface.AbstractValue.t -> IBase.Location.t -> t -> t
val find_opt : PulseBasicInterface.AbstractValue.t -> t -> PulseBasicInterface.Attributes.t option
val check_valid_isl : PulseBasicInterface.Trace.t -> PulseBasicInterface.AbstractValue.t -> ?⁠null_noop:bool -> t -> (t[> `ISLError of t | `InvalidAccess of PulseBasicInterface.Invalidation.t * PulseBasicInterface.Trace.t * t ]) IStdlib.IStd.result list
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib/PulseAbductiveDomain/index.html b/website/static/odoc/next/infer/Pulselib/PulseAbductiveDomain/index.html index 7de85e00c..856937bd2 100644 --- a/website/static/odoc/next/infer/Pulselib/PulseAbductiveDomain/index.html +++ b/website/static/odoc/next/infer/Pulselib/PulseAbductiveDomain/index.html @@ -1,2 +1,2 @@ -PulseAbductiveDomain (infer.Pulselib.PulseAbductiveDomain)

Module Pulselib.PulseAbductiveDomain

module BaseDomain = PulseBaseDomain
module BaseMemory = PulseBaseMemory
module BaseStack = PulseBaseStack
module type BaseDomainSig = sig ... end

signature common to the "normal" Domain, representing the post at the current program point, and the inverted PreDomain, representing the inferred pre-condition

module PostDomain : BaseDomainSig

The post abstract state at each program point, or current state.

module PreDomain : BaseDomainSig

The inferred pre-condition at each program point, biabduction style.

type t = private {
post : PostDomain.t;

state at the current program point

pre : PreDomain.t;

inferred procedure pre-condition leading to the current program point

path_condition : PulseBasicInterface.PathCondition.t;

arithmetic facts true along the path (holding for both pre and post since abstract values are immutable)

topl : PulseTopl.state;

state at of the Topl monitor at the current program point, when Topl is enabled

skipped_calls : PulseBasicInterface.SkippedCalls.t;

metadata: procedure calls for which no summary was found

}

pre/post on a single program path

val equal : t -> t -> bool
val leq : lhs:t -> rhs:t -> bool
val pp : Stdlib.Format.formatter -> t -> unit
val mk_initial : IR.Tenv.t -> IR.Procdesc.t -> t
val get_pre : t -> BaseDomain.t
val get_post : t -> BaseDomain.t
module Stack : sig ... end

stack operations like BaseStack but that also take care of propagating facts to the precondition

module Memory : sig ... end

memory operations like BaseMemory but that also take care of propagating facts to the precondition

module AddressAttributes : sig ... end

attribute operations like BaseAddressAttributes but that also take care of propagating facts to the precondition

val is_local : IR.Var.t -> t -> bool
val find_post_cell_opt : PulseBasicInterface.AbstractValue.t -> t -> BaseDomain.cell option
val discard_unreachable : t -> t

garbage collect unreachable addresses in the state to make it smaller and return the new state

val get_unreachable_attributes : t -> PulseBasicInterface.AbstractValue.t list

collect the addresses that have attributes but are unreachable in the current post-condition

val add_skipped_call : IR.Procname.t -> PulseBasicInterface.Trace.t -> t -> t
val add_skipped_calls : PulseBasicInterface.SkippedCalls.t -> t -> t
val set_path_condition : PulseBasicInterface.PathCondition.t -> t -> t
val is_isl_without_allocation : t -> bool
val is_pre_without_isl_abduced : t -> bool
type summary = private t

private type to make sure summary_of_post is always called when creating summaries

val compare_summary : summary -> summary -> int
val equal_summary : summary -> summary -> bool
val yojson_of_summary : summary -> Ppx_yojson_conv_lib.Yojson.Safe.t
val skipped_calls_match_pattern : summary -> bool
val summary_of_post : IR.Tenv.t -> IR.Procdesc.t -> IBase.Location.t -> t -> (summary[> `MemoryLeak of summary * IR.Procname.t * PulseBasicInterface.Trace.t * IBase.Location.t | `PotentialInvalidAccessSummary of summary * PulseBasicInterface.AbstractValue.t * (PulseBasicInterface.Trace.t * PulseBasicInterface.Invalidation.must_be_valid_reason option) ]) IStdlib.IStd.result PulseBasicInterface.SatUnsat.t

Trim the state down to just the procedure's interface (formals and globals), and simplify and normalize the state.

val set_post_edges : PulseBasicInterface.AbstractValue.t -> BaseMemory.Edges.t -> t -> t

directly set the edges for the given address, bypassing abduction altogether

val set_post_cell : (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.ValueHistory.t) -> BaseDomain.cell -> IBase.Location.t -> t -> t

directly set the edges and attributes for the given address, bypassing abduction altogether

val incorporate_new_eqs : PulseBasicInterface.PathCondition.new_eqs -> t -> (t[> `PotentialInvalidAccess of t * PulseBasicInterface.AbstractValue.t * (PulseBasicInterface.Trace.t * PulseBasicInterface.Invalidation.must_be_valid_reason option) ]) IStdlib.IStd.result

Check that the new equalities discovered are compatible with the current pre and post heaps, e.g. x = 0 is not compatible with x being allocated, and x = y is not compatible with x and y being allocated separately. In those cases, the resulting path condition is PathCondition.false_.

val initialize : PulseBasicInterface.AbstractValue.t -> t -> t

Remove "Uninitialized" attribute of the given address

val set_uninitialized : IR.Tenv.t -> [ `LocalDecl of IR.Pvar.t * PulseBasicInterface.AbstractValue.t option | `Malloc of PulseBasicInterface.AbstractValue.t ] -> IR.Typ.t -> IBase.Location.t -> t -> t

Add "Uninitialized" attributes when a variable is declared or a memory is allocated by malloc.

module Topl : sig ... end
\ No newline at end of file +PulseAbductiveDomain (infer.Pulselib.PulseAbductiveDomain)

Module Pulselib.PulseAbductiveDomain

module BaseDomain = PulseBaseDomain
module BaseMemory = PulseBaseMemory
module BaseStack = PulseBaseStack
module type BaseDomainSig = sig ... end

signature common to the "normal" Domain, representing the post at the current program point, and the inverted PreDomain, representing the inferred pre-condition

module PostDomain : BaseDomainSig

The post abstract state at each program point, or current state.

module PreDomain : BaseDomainSig

The inferred pre-condition at each program point, biabduction style.

type t = private {
post : PostDomain.t;

state at the current program point

pre : PreDomain.t;

inferred procedure pre-condition leading to the current program point

path_condition : PulseBasicInterface.PathCondition.t;

arithmetic facts true along the path (holding for both pre and post since abstract values are immutable)

topl : PulseTopl.state;

state at of the Topl monitor at the current program point, when Topl is enabled

skipped_calls : PulseBasicInterface.SkippedCalls.t;

metadata: procedure calls for which no summary was found

}

pre/post on a single program path

val equal : t -> t -> bool
val leq : lhs:t -> rhs:t -> bool
val pp : Stdlib.Format.formatter -> t -> unit
val mk_initial : IR.Tenv.t -> IR.Procdesc.t -> t
val get_pre : t -> BaseDomain.t
val get_post : t -> BaseDomain.t
module Stack : sig ... end

stack operations like BaseStack but that also take care of propagating facts to the precondition

module Memory : sig ... end

memory operations like BaseMemory but that also take care of propagating facts to the precondition

module AddressAttributes : sig ... end

attribute operations like BaseAddressAttributes but that also take care of propagating facts to the precondition

val is_local : IR.Var.t -> t -> bool
val find_post_cell_opt : PulseBasicInterface.AbstractValue.t -> t -> BaseDomain.cell option
val get_unreachable_attributes : t -> PulseBasicInterface.AbstractValue.t list

collect the addresses that have attributes but are unreachable in the current post-condition

val add_skipped_call : IR.Procname.t -> PulseBasicInterface.Trace.t -> t -> t
val add_skipped_calls : PulseBasicInterface.SkippedCalls.t -> t -> t
val set_path_condition : PulseBasicInterface.PathCondition.t -> t -> t
val is_isl_without_allocation : t -> bool
val is_pre_without_isl_abduced : t -> bool
type summary = private t

private type to make sure summary_of_post is always called when creating summaries

val compare_summary : summary -> summary -> int
val equal_summary : summary -> summary -> bool
val yojson_of_summary : summary -> Ppx_yojson_conv_lib.Yojson.Safe.t
val skipped_calls_match_pattern : summary -> bool
val summary_of_post : IR.Tenv.t -> IR.Procdesc.t -> IBase.Location.t -> t -> (summary[> `MemoryLeak of summary * IR.Procname.t * PulseBasicInterface.Trace.t * IBase.Location.t | `PotentialInvalidAccessSummary of summary * PulseBasicInterface.AbstractValue.t * (PulseBasicInterface.Trace.t * PulseBasicInterface.Invalidation.must_be_valid_reason option) ]) IStdlib.IStd.result PulseBasicInterface.SatUnsat.t

Trim the state down to just the procedure's interface (formals and globals), and simplify and normalize the state.

val set_post_edges : PulseBasicInterface.AbstractValue.t -> BaseMemory.Edges.t -> t -> t

directly set the edges for the given address, bypassing abduction altogether

val set_post_cell : (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.ValueHistory.t) -> BaseDomain.cell -> IBase.Location.t -> t -> t

directly set the edges and attributes for the given address, bypassing abduction altogether

val incorporate_new_eqs : PulseBasicInterface.PathCondition.new_eqs -> t -> (t[> `PotentialInvalidAccess of t * PulseBasicInterface.AbstractValue.t * (PulseBasicInterface.Trace.t * PulseBasicInterface.Invalidation.must_be_valid_reason option) ]) IStdlib.IStd.result

Check that the new equalities discovered are compatible with the current pre and post heaps, e.g. x = 0 is not compatible with x being allocated, and x = y is not compatible with x and y being allocated separately. In those cases, the resulting path condition is PathCondition.false_.

val initialize : PulseBasicInterface.AbstractValue.t -> t -> t

Remove "Uninitialized" attribute of the given address

val set_uninitialized : IR.Tenv.t -> [ `LocalDecl of IR.Pvar.t * PulseBasicInterface.AbstractValue.t option | `Malloc of PulseBasicInterface.AbstractValue.t ] -> IR.Typ.t -> IBase.Location.t -> t -> t

Add "Uninitialized" attributes when a variable is declared or a memory is allocated by malloc.

module Topl : sig ... end
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib/PulseAttribute/Attributes/index.html b/website/static/odoc/next/infer/Pulselib/PulseAttribute/Attributes/index.html index 7272c8019..0fac4d254 100644 --- a/website/static/odoc/next/infer/Pulselib/PulseAttribute/Attributes/index.html +++ b/website/static/odoc/next/infer/Pulselib/PulseAttribute/Attributes/index.html @@ -1,2 +1,2 @@ -Attributes (infer.Pulselib.PulseAttribute.Attributes)

Module PulseAttribute.Attributes

include IStdlib.PrettyPrintable.PPUniqRankSet with type elt = t
type t
val compare : t -> t -> int
val equal : t -> t -> bool
type rank
type elt = t
val add : t -> elt -> t
val empty : t
val find_rank : t -> rank -> elt option
val fold : t -> init:'accum -> f:('accum -> elt -> 'accum) -> 'accum
val fold_map : t -> init:'accum -> f:('accum -> elt -> 'accum * elt) -> 'accum * t
val for_all : f:(elt -> bool) -> t -> bool
val is_empty : t -> bool
val is_singleton : t -> bool
val is_subset : t -> of_:t -> bool
val map : t -> f:(elt -> elt) -> t
val singleton : elt -> t
val elements : t -> elt list
val remove : elt -> t -> t
val mem : elt -> t -> bool
val union_prefer_left : t -> t -> t

in case an element with the same rank is present both in lhs and rhs, keep the one from lhs in union_prefer_left lhs rhs

val pp : ?⁠print_rank:bool -> IStdlib.PrettyPrintable.F.formatter -> t -> unit
val get_address_of_stack_variable : t -> (IR.Var.t * IBase.Location.t * ValueHistory.t) option
val get_closure_proc_name : t -> IR.Procname.t option
val get_allocation : t -> (IR.Procname.t * Trace.t) option
val get_dynamic_type : t -> IR.Typ.t option
val is_end_of_collection : t -> bool
val get_invalid : t -> (Invalidation.t * Trace.t) option
val get_isl_abduced : t -> Trace.t option
val get_must_be_valid : t -> (Trace.t * Invalidation.must_be_valid_reason option) option
val get_written_to : t -> Trace.t option
val is_modified : t -> bool
val is_std_vector_reserved : t -> bool
val is_uninitialized : t -> bool
val get_must_be_initialized : t -> Trace.t option
val isl_subset : t -> t -> bool

check whether for each attr in the second list, there exists a corresponding attr in the first according to Attributes.isl_equiv.

val replace_isl_abduced : t -> t -> t

While applying a spec, replacing ISLAbduced by Allocated and Invalidation.Cfree by Invalidation.delete, if applicable

val add_call : IR.Procname.t -> IBase.Location.t -> ValueHistory.t -> t -> t
\ No newline at end of file +Attributes (infer.Pulselib.PulseAttribute.Attributes)

Module PulseAttribute.Attributes

include IStdlib.PrettyPrintable.PPUniqRankSet with type elt = t
type t
val compare : t -> t -> int
val equal : t -> t -> bool
type rank
type elt = t
val add : t -> elt -> t
val empty : t
val find_rank : t -> rank -> elt option
val fold : t -> init:'accum -> f:('accum -> elt -> 'accum) -> 'accum
val fold_map : t -> init:'accum -> f:('accum -> elt -> 'accum * elt) -> 'accum * t
val for_all : f:(elt -> bool) -> t -> bool
val is_empty : t -> bool
val is_singleton : t -> bool
val is_subset : t -> of_:t -> bool
val map : t -> f:(elt -> elt) -> t
val singleton : elt -> t
val elements : t -> elt list
val remove : elt -> t -> t
val mem : elt -> t -> bool
val union_prefer_left : t -> t -> t

in case an element with the same rank is present both in lhs and rhs, keep the one from lhs in union_prefer_left lhs rhs

val pp : ?⁠print_rank:bool -> IStdlib.PrettyPrintable.F.formatter -> t -> unit
val get_address_of_stack_variable : t -> (IR.Var.t * IBase.Location.t * ValueHistory.t) option
val get_closure_proc_name : t -> IR.Procname.t option
val get_allocation : t -> (IR.Procname.t * Trace.t) option
val get_dynamic_type : t -> IR.Typ.t option
val is_end_of_collection : t -> bool
val get_invalid : t -> (Invalidation.t * Trace.t) option
val get_isl_abduced : t -> Trace.t option
val get_must_be_valid : t -> (Trace.t * Invalidation.must_be_valid_reason option) option
val get_written_to : t -> Trace.t option
val is_modified : t -> bool
val is_std_vector_reserved : t -> bool
val is_uninitialized : t -> bool
val get_must_be_initialized : t -> Trace.t option
val get_unreachable_at : t -> IBase.Location.t option
val isl_subset : t -> t -> bool

check whether for each attr in the second list, there exists a corresponding attr in the first according to Attributes.isl_equiv.

val replace_isl_abduced : t -> t -> t

While applying a spec, replacing ISLAbduced by Allocated and Invalidation.Cfree by Invalidation.delete, if applicable

val add_call : IR.Procname.t -> IBase.Location.t -> ValueHistory.t -> t -> t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib/PulseAttribute/index.html b/website/static/odoc/next/infer/Pulselib/PulseAttribute/index.html index 63fb83759..ccf889e7e 100644 --- a/website/static/odoc/next/infer/Pulselib/PulseAttribute/index.html +++ b/website/static/odoc/next/infer/Pulselib/PulseAttribute/index.html @@ -1,2 +1,2 @@ -PulseAttribute (infer.Pulselib.PulseAttribute)

Module Pulselib.PulseAttribute

module F = Stdlib.Format
module Invalidation = PulseInvalidation
module Trace = PulseTrace
module ValueHistory = PulseValueHistory
type t =
| AddressOfCppTemporary of IR.Var.t * ValueHistory.t
| AddressOfStackVariable of IR.Var.t * IBase.Location.t * ValueHistory.t
| Allocated of IR.Procname.t * Trace.t

the Procname.t is the function causing the allocation, eg malloc

| Closure of IR.Procname.t
| DynamicType of IR.Typ.t
| EndOfCollection
| Invalid of Invalidation.t * Trace.t
| ISLAbduced of Trace.t

The allocation is abduced so as the analysis could run normally

| MustBeInitialized of Trace.t
| MustBeValid of Trace.t * Invalidation.must_be_valid_reason option
| StdVectorReserve
| Uninitialized
| WrittenTo of Trace.t
val compare : t -> t -> int
val pp : F.formatter -> t -> unit
val is_suitable_for_pre : t -> bool
val is_suitable_for_post : t -> bool
module Attributes : sig ... end
\ No newline at end of file +PulseAttribute (infer.Pulselib.PulseAttribute)

Module Pulselib.PulseAttribute

module F = Stdlib.Format
module Invalidation = PulseInvalidation
module Trace = PulseTrace
module ValueHistory = PulseValueHistory
type t =
| AddressOfCppTemporary of IR.Var.t * ValueHistory.t
| AddressOfStackVariable of IR.Var.t * IBase.Location.t * ValueHistory.t
| Allocated of IR.Procname.t * Trace.t

the Procname.t is the function causing the allocation, eg malloc

| Closure of IR.Procname.t
| DynamicType of IR.Typ.t
| EndOfCollection
| Invalid of Invalidation.t * Trace.t
| ISLAbduced of Trace.t

The allocation is abduced so as the analysis could run normally

| MustBeInitialized of Trace.t
| MustBeValid of Trace.t * Invalidation.must_be_valid_reason option
| StdVectorReserve
| Uninitialized
| UnreachableAt of IBase.Location.t

temporary marker to remember where a variable became unreachable; helps with accurately reporting leaks

| WrittenTo of Trace.t
val compare : t -> t -> int
val pp : F.formatter -> t -> unit
val is_suitable_for_pre : t -> bool
val is_suitable_for_post : t -> bool
module Attributes : sig ... end
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib/PulseBaseAddressAttributes/index.html b/website/static/odoc/next/infer/Pulselib/PulseBaseAddressAttributes/index.html index 6745b3414..0983b41db 100644 --- a/website/static/odoc/next/infer/Pulselib/PulseBaseAddressAttributes/index.html +++ b/website/static/odoc/next/infer/Pulselib/PulseBaseAddressAttributes/index.html @@ -1,2 +1,2 @@ -PulseBaseAddressAttributes (infer.Pulselib.PulseBaseAddressAttributes)

Module Pulselib.PulseBaseAddressAttributes

module F = Stdlib.Format
type t
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
val empty : t
val filter : (PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attributes.t -> bool) -> t -> t
val for_all : (PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attributes.t -> bool) -> t -> bool
val filter_with_discarded_addrs : (PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attributes.t -> bool) -> t -> t * PulseBasicInterface.AbstractValue.t list
val find_opt : PulseBasicInterface.AbstractValue.t -> t -> PulseBasicInterface.Attributes.t option
val add_one : PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attribute.t -> t -> t
val add : PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attributes.t -> t -> t
val allocate : IR.Procname.t -> (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.ValueHistory.t) -> IBase.Location.t -> t -> t
val fold : (PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attributes.t -> 'a -> 'a) -> t -> 'a -> 'a
val check_valid : PulseBasicInterface.AbstractValue.t -> t -> (unit, PulseBasicInterface.Invalidation.t * PulseBasicInterface.Trace.t) IStdlib.IStd.result
val check_initialized : PulseBasicInterface.AbstractValue.t -> t -> (unit, unit) IStdlib.IStd.result
val invalidate : (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.ValueHistory.t) -> PulseBasicInterface.Invalidation.t -> IBase.Location.t -> t -> t
val get_closure_proc_name : PulseBasicInterface.AbstractValue.t -> t -> IR.Procname.t option
val get_invalid : PulseBasicInterface.AbstractValue.t -> t -> (PulseBasicInterface.Invalidation.t * PulseBasicInterface.Trace.t) option
val get_must_be_valid : PulseBasicInterface.AbstractValue.t -> t -> (PulseBasicInterface.Trace.t * PulseBasicInterface.Invalidation.must_be_valid_reason option) option
val is_must_be_valid_or_allocated_isl : PulseBasicInterface.AbstractValue.t -> t -> bool
val get_must_be_initialized : PulseBasicInterface.AbstractValue.t -> t -> PulseBasicInterface.Trace.t option
val add_dynamic_type : IR.Typ.t -> PulseBasicInterface.AbstractValue.t -> t -> t
val get_dynamic_type : t -> PulseBasicInterface.AbstractValue.t -> IR.Typ.t option
val std_vector_reserve : PulseBasicInterface.AbstractValue.t -> t -> t
val is_std_vector_reserved : PulseBasicInterface.AbstractValue.t -> t -> bool
val mark_as_end_of_collection : PulseBasicInterface.AbstractValue.t -> t -> t
val is_end_of_collection : PulseBasicInterface.AbstractValue.t -> t -> bool
val pp : F.formatter -> t -> unit
val remove_allocation_attr : PulseBasicInterface.AbstractValue.t -> t -> t
val remove_must_be_valid_attr : PulseBasicInterface.AbstractValue.t -> t -> t
val remove_isl_abduced_attr : PulseBasicInterface.AbstractValue.t -> t -> t
val initialize : PulseBasicInterface.AbstractValue.t -> t -> t
val canonicalize : get_var_repr:(PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.AbstractValue.t) -> t -> t

merge the attributes of all the variables that are equal according to get_var_repr and remove non-canonical variables in favor of their rerpresentative

val subst_var : (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.AbstractValue.t) -> t -> t
\ No newline at end of file +PulseBaseAddressAttributes (infer.Pulselib.PulseBaseAddressAttributes)

Module Pulselib.PulseBaseAddressAttributes

module F = Stdlib.Format
type t
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
val empty : t
val filter : (PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attributes.t -> bool) -> t -> t
val for_all : (PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attributes.t -> bool) -> t -> bool
val filter_with_discarded_addrs : (PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attributes.t -> bool) -> t -> t * PulseBasicInterface.AbstractValue.t list
val find_opt : PulseBasicInterface.AbstractValue.t -> t -> PulseBasicInterface.Attributes.t option
val add_one : PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attribute.t -> t -> t
val add : PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attributes.t -> t -> t
val allocate : IR.Procname.t -> (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.ValueHistory.t) -> IBase.Location.t -> t -> t
val fold : (PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.Attributes.t -> 'a -> 'a) -> t -> 'a -> 'a
val check_valid : PulseBasicInterface.AbstractValue.t -> t -> (unit, PulseBasicInterface.Invalidation.t * PulseBasicInterface.Trace.t) IStdlib.IStd.result
val check_initialized : PulseBasicInterface.AbstractValue.t -> t -> (unit, unit) IStdlib.IStd.result
val invalidate : (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.ValueHistory.t) -> PulseBasicInterface.Invalidation.t -> IBase.Location.t -> t -> t
val get_allocation : PulseBasicInterface.AbstractValue.t -> t -> (IR.Procname.t * PulseBasicInterface.Trace.t) option
val get_closure_proc_name : PulseBasicInterface.AbstractValue.t -> t -> IR.Procname.t option
val get_invalid : PulseBasicInterface.AbstractValue.t -> t -> (PulseBasicInterface.Invalidation.t * PulseBasicInterface.Trace.t) option
val get_must_be_valid : PulseBasicInterface.AbstractValue.t -> t -> (PulseBasicInterface.Trace.t * PulseBasicInterface.Invalidation.must_be_valid_reason option) option
val is_must_be_valid_or_allocated_isl : PulseBasicInterface.AbstractValue.t -> t -> bool
val get_must_be_initialized : PulseBasicInterface.AbstractValue.t -> t -> PulseBasicInterface.Trace.t option
val add_dynamic_type : IR.Typ.t -> PulseBasicInterface.AbstractValue.t -> t -> t
val get_dynamic_type : t -> PulseBasicInterface.AbstractValue.t -> IR.Typ.t option
val std_vector_reserve : PulseBasicInterface.AbstractValue.t -> t -> t
val is_std_vector_reserved : PulseBasicInterface.AbstractValue.t -> t -> bool
val mark_as_end_of_collection : PulseBasicInterface.AbstractValue.t -> t -> t
val is_end_of_collection : PulseBasicInterface.AbstractValue.t -> t -> bool
val add_unreachable_at : PulseBasicInterface.AbstractValue.t -> IBase.Location.t -> t -> t
val pp : F.formatter -> t -> unit
val remove_allocation_attr : PulseBasicInterface.AbstractValue.t -> t -> t
val remove_must_be_valid_attr : PulseBasicInterface.AbstractValue.t -> t -> t
val remove_isl_abduced_attr : PulseBasicInterface.AbstractValue.t -> t -> t
val initialize : PulseBasicInterface.AbstractValue.t -> t -> t
val canonicalize : get_var_repr:(PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.AbstractValue.t) -> t -> t

merge the attributes of all the variables that are equal according to get_var_repr and remove non-canonical variables in favor of their rerpresentative

val subst_var : (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.AbstractValue.t) -> t -> t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib/PulseBaseDomain/GraphVisit/index.html b/website/static/odoc/next/infer/Pulselib/PulseBaseDomain/GraphVisit/index.html new file mode 100644 index 000000000..81f5d7bb3 --- /dev/null +++ b/website/static/odoc/next/infer/Pulselib/PulseBaseDomain/GraphVisit/index.html @@ -0,0 +1,2 @@ + +GraphVisit (infer.Pulselib.PulseBaseDomain.GraphVisit)

Module PulseBaseDomain.GraphVisit

val fold : var_filter:(IR.Var.t -> bool) -> t -> init:'accum -> f:(IR.Var.t -> 'accum -> PulseBasicInterface.AbstractValue.t -> Memory.Access.t list -> ('accum'final) Base.Continue_or_stop.t) -> finish:('accum -> 'final) -> Pulselib.PulseBasicInterface.AbstractValue.Set.t * 'final

Generic graph traversal of the memory starting from each variable in the stack that pass var_filter, in order. Returns the result of folding over every address in the graph and the set of addresses that have been visited before f returned Stop or all reachable addresses were seen. f is passed each address together with the variable from which the address was reached and the access path from that variable to the address.

val fold_from_addresses : PulseBasicInterface.AbstractValue.t Stdlib.Seq.t -> t -> init:'accum -> f:('accum -> PulseBasicInterface.AbstractValue.t -> Memory.Access.t list -> ('accum'final) Base.Continue_or_stop.t) -> finish:('accum -> 'final) -> Pulselib.PulseBasicInterface.AbstractValue.Set.t * 'final

Similar to fold, but start from given addresses, instead of stack variables.

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib/PulseBaseDomain/index.html b/website/static/odoc/next/infer/Pulselib/PulseBaseDomain/index.html index d6bb9f23b..2ee5afc86 100644 --- a/website/static/odoc/next/infer/Pulselib/PulseBaseDomain/index.html +++ b/website/static/odoc/next/infer/Pulselib/PulseBaseDomain/index.html @@ -1,2 +1,2 @@ -PulseBaseDomain (infer.Pulselib.PulseBaseDomain)

Module Pulselib.PulseBaseDomain

module F = Stdlib.Format
type t = {
heap : PulseBaseMemory.t;
stack : PulseBaseStack.t;
attrs : PulseBaseAddressAttributes.t;
}
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
type cell = PulseBaseMemory.Edges.t * PulseBasicInterface.Attributes.t
val empty : t
val reachable_addresses : t -> Pulselib.PulseBasicInterface.AbstractValue.Set.t

compute the set of abstract addresses that are "used" in the abstract state, i.e. reachable from the stack variables

val reachable_addresses_from : PulseBasicInterface.AbstractValue.t list -> t -> Pulselib.PulseBasicInterface.AbstractValue.Set.t

compute the set of abstract addresses that are reachable from given abstract addresses

type mapping
val empty_mapping : mapping
type isograph_relation =
| NotIsomorphic

no mapping was found that can make LHS the same as the RHS

| IsomorphicUpTo of mapping

mapping(lhs) is isomorphic to rhs

val isograph_map : lhs:t -> rhs:t -> mapping -> isograph_relation
val is_isograph : lhs:t -> rhs:t -> mapping -> bool
val find_cell_opt : PulseBasicInterface.AbstractValue.t -> t -> cell option
val pp : F.formatter -> t -> unit
val subst_var : (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.AbstractValue.t) -> t -> t PulseBasicInterface.SatUnsat.t
\ No newline at end of file +PulseBaseDomain (infer.Pulselib.PulseBaseDomain)

Module Pulselib.PulseBaseDomain

module Memory = PulseBaseMemory
module F = Stdlib.Format
type t = {
heap : PulseBaseMemory.t;
stack : PulseBaseStack.t;
attrs : PulseBaseAddressAttributes.t;
}
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
type cell = PulseBaseMemory.Edges.t * PulseBasicInterface.Attributes.t
val empty : t
val reachable_addresses : ?⁠var_filter:(IR.Var.t -> bool) -> t -> Pulselib.PulseBasicInterface.AbstractValue.Set.t

compute the set of abstract addresses that are "used" in the abstract state, i.e. reachable from the stack variables

val reachable_addresses_from : PulseBasicInterface.AbstractValue.t Stdlib.Seq.t -> t -> Pulselib.PulseBasicInterface.AbstractValue.Set.t

compute the set of abstract addresses that are reachable from given abstract addresses

type mapping
val empty_mapping : mapping
type isograph_relation =
| NotIsomorphic

no mapping was found that can make LHS the same as the RHS

| IsomorphicUpTo of mapping

mapping(lhs) is isomorphic to rhs

val isograph_map : lhs:t -> rhs:t -> mapping -> isograph_relation
val is_isograph : lhs:t -> rhs:t -> mapping -> bool
val find_cell_opt : PulseBasicInterface.AbstractValue.t -> t -> cell option
val pp : F.formatter -> t -> unit
val subst_var : (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.AbstractValue.t) -> t -> t PulseBasicInterface.SatUnsat.t
module GraphVisit : sig ... end
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib/PulseBaseMemory/Edges/index.html b/website/static/odoc/next/infer/Pulselib/PulseBaseMemory/Edges/index.html index ca722b39a..3ca9ecd9c 100644 --- a/website/static/odoc/next/infer/Pulselib/PulseBaseMemory/Edges/index.html +++ b/website/static/odoc/next/infer/Pulselib/PulseBaseMemory/Edges/index.html @@ -1,2 +1,2 @@ -Edges (infer.Pulselib.PulseBaseMemory.Edges)

Module PulseBaseMemory.Edges

type t

Note that the derived compare and equal functions are sensitive to the underlying implementation and in particular won't equate some objects that denote the same map.

val compare : t -> t -> int
val equal : t -> t -> bool
type key = Access.t
type value = AddrTrace.t
val pp : IStdlib.RecencyMap.F.formatter -> t -> unit
val empty : t
val add : key -> value -> t -> t
val bindings : t -> (key * value) list
val exists : t -> f:((key * value) -> bool) -> bool
val filter : t -> f:((key * value) -> bool) -> t
val find_opt : key -> t -> value option
val fold : t -> init:'acc -> f:('acc -> (key * value) -> 'acc) -> 'acc
val fold_map : t -> init:'acc -> f:('acc -> value -> 'acc * value) -> 'acc * t
val is_empty : t -> bool
val map : t -> f:(value -> value) -> t
val mem : t -> key -> bool
val union_left_biased : t -> t -> t
\ No newline at end of file +Edges (infer.Pulselib.PulseBaseMemory.Edges)

Module PulseBaseMemory.Edges

type t

Note that the derived compare and equal functions are sensitive to the underlying implementation and in particular won't equate some objects that denote the same map.

val compare : t -> t -> int
val equal : t -> t -> bool
type key = Access.t
type value = AddrTrace.t
val pp : IStdlib.RecencyMap.F.formatter -> t -> unit
val empty : t
val add : key -> value -> t -> t
val bindings : t -> (key * value) list
val exists : t -> f:((key * value) -> bool) -> bool
val filter : t -> f:((key * value) -> bool) -> t
val find_opt : key -> t -> value option
val fold : t -> init:'acc -> f:('acc -> (key * value) -> 'acc) -> 'acc
val fold_map : t -> init:'acc -> f:('acc -> value -> 'acc * value) -> 'acc * t
val is_empty : t -> bool
val map : t -> f:(value -> value) -> t
val mem : t -> key -> bool
val union_left_biased : t -> t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib/PulseBaseMemory/index.html b/website/static/odoc/next/infer/Pulselib/PulseBaseMemory/index.html index f29d65ba6..bb982e73c 100644 --- a/website/static/odoc/next/infer/Pulselib/PulseBaseMemory/index.html +++ b/website/static/odoc/next/infer/Pulselib/PulseBaseMemory/index.html @@ -1,2 +1,2 @@ -PulseBaseMemory (infer.Pulselib.PulseBaseMemory)

Module Pulselib.PulseBaseMemory

module Access : sig ... end
module AccessSet : IStdlib.IStd.Caml.Set.S with type AccessSet.elt = Access.t
module AddrTrace : sig ... end
module Edges : IStdlib.RecencyMap.S with type key = Access.t and type value = AddrTrace.t
include IStdlib.PrettyPrintable.PPMonoMap with type key = PulseBasicInterface.AbstractValue.t and type value = Edges.t
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
val compare : t -> t -> int
val equal : t -> t -> bool
val register_address : PulseBasicInterface.AbstractValue.t -> t -> t
val add_edge : PulseBasicInterface.AbstractValue.t -> Access.t -> AddrTrace.t -> t -> t
val find_edge_opt : PulseBasicInterface.AbstractValue.t -> Access.t -> t -> AddrTrace.t option
val has_edge : PulseBasicInterface.AbstractValue.t -> Access.t -> t -> bool
val yojson_of_t : t -> Yojson.Safe.t
val is_allocated : t -> PulseBasicInterface.AbstractValue.t -> bool

whether the address has a non-empty set of edges

val canonicalize : get_var_repr:(PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.AbstractValue.t) -> t -> t PulseBasicInterface.SatUnsat.t

replace each address in the heap by its canonical representative according to the current equality relation, represented by get_var_repr; also remove addresses that point to empty edges

val subst_var : (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.AbstractValue.t) -> t -> t PulseBasicInterface.SatUnsat.t
\ No newline at end of file +PulseBaseMemory (infer.Pulselib.PulseBaseMemory)

Module Pulselib.PulseBaseMemory

module Access : sig ... end
module AccessSet : IStdlib.IStd.Caml.Set.S with type AccessSet.elt = Access.t
module AddrTrace : sig ... end
module Edges : IStdlib.RecencyMap.S with type key = Access.t and type value = AddrTrace.t
include IStdlib.PrettyPrintable.PPMonoMap with type key = PulseBasicInterface.AbstractValue.t and type value = Edges.t
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
val compare : t -> t -> int
val equal : t -> t -> bool
val register_address : PulseBasicInterface.AbstractValue.t -> t -> t
val add_edge : PulseBasicInterface.AbstractValue.t -> Access.t -> AddrTrace.t -> t -> t
val find_edge_opt : PulseBasicInterface.AbstractValue.t -> Access.t -> t -> AddrTrace.t option
val has_edge : PulseBasicInterface.AbstractValue.t -> Access.t -> t -> bool
val yojson_of_t : t -> Yojson.Safe.t
val is_allocated : t -> PulseBasicInterface.AbstractValue.t -> bool

whether the address has a non-empty set of edges

val canonicalize : get_var_repr:(PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.AbstractValue.t) -> t -> t PulseBasicInterface.SatUnsat.t

replace each address in the heap by its canonical representative according to the current equality relation, represented by get_var_repr; also remove addresses that point to empty edges

val subst_var : (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.AbstractValue.t) -> t -> t PulseBasicInterface.SatUnsat.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib/PulseBaseStack/index.html b/website/static/odoc/next/infer/Pulselib/PulseBaseStack/index.html index 2412d2507..32b406054 100644 --- a/website/static/odoc/next/infer/Pulselib/PulseBaseStack/index.html +++ b/website/static/odoc/next/infer/Pulselib/PulseBaseStack/index.html @@ -1,2 +1,2 @@ -PulseBaseStack (infer.Pulselib.PulseBaseStack)

Module Pulselib.PulseBaseStack

module F = Stdlib.Format
include IStdlib.PrettyPrintable.MonoMap with type key = IR.Var.t and type value = PulseBasicInterface.AbstractValue.t * PulseBasicInterface.ValueHistory.t
type key = IR.Var.t
type value = PulseBasicInterface.AbstractValue.t * PulseBasicInterface.ValueHistory.t
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val pp : F.formatter -> t -> unit
val yojson_of_t : t -> Yojson.Safe.t
val canonicalize : get_var_repr:(PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.AbstractValue.t) -> t -> t PulseBasicInterface.SatUnsat.t

replace each address in the stack by its canonical representative according to the current equality relation, represented by get_var_repr

val subst_var : (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.AbstractValue.t) -> t -> t PulseBasicInterface.SatUnsat.t
\ No newline at end of file +PulseBaseStack (infer.Pulselib.PulseBaseStack)

Module Pulselib.PulseBaseStack

module F = Stdlib.Format
include IStdlib.PrettyPrintable.MonoMap with type key = IR.Var.t and type value = PulseBasicInterface.AbstractValue.t * PulseBasicInterface.ValueHistory.t
type key = IR.Var.t
type value = PulseBasicInterface.AbstractValue.t * PulseBasicInterface.ValueHistory.t
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
val compare : t -> t -> int
val equal : t -> t -> bool
val pp : F.formatter -> t -> unit
val yojson_of_t : t -> Yojson.Safe.t
val canonicalize : get_var_repr:(PulseBasicInterface.AbstractValue.t -> PulseBasicInterface.AbstractValue.t) -> t -> t PulseBasicInterface.SatUnsat.t

replace each address in the stack by its canonical representative according to the current equality relation, represented by get_var_repr

val subst_var : (PulseBasicInterface.AbstractValue.t * PulseBasicInterface.AbstractValue.t) -> t -> t PulseBasicInterface.SatUnsat.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib/PulseFormula/index.html b/website/static/odoc/next/infer/Pulselib/PulseFormula/index.html index 61f61fe26..d9799c915 100644 --- a/website/static/odoc/next/infer/Pulselib/PulseFormula/index.html +++ b/website/static/odoc/next/infer/Pulselib/PulseFormula/index.html @@ -1,2 +1,2 @@ -PulseFormula (infer.Pulselib.PulseFormula)

Module Pulselib.PulseFormula

module F = Stdlib.Format
module SatUnsat = PulseSatUnsat
module Var = PulseAbstractValue

Arithmetic solver

Build formulas from SIL and tries to decide if they are (mostly un-)satisfiable.

type t
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
val pp : F.formatter -> t -> unit
val pp_with_pp_var : (F.formatter -> Var.t -> unit) -> F.formatter -> t -> unit

only used for unit tests

type operand =
| LiteralOperand of IR.IntLit.t
| AbstractValueOperand of Var.t

Build formulas

type new_eq =
| EqZero of Var.t
| Equal of Var.t * Var.t

some operations will return a set of new facts discovered that are relevant to communicate to the memory domain

type new_eqs = new_eq list
val ttrue : t
val and_equal : operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_equal_instanceof : Var.t -> Var.t -> IR.Typ.t -> t -> (t * new_eqs) SatUnsat.t
val and_less_equal : operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_less_than : operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_equal_unop : Var.t -> IR.Unop.t -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_equal_binop : Var.t -> IR.Binop.t -> operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val prune_binop : negated:bool -> IR.Binop.t -> operand -> operand -> t -> (t * new_eqs) SatUnsat.t

Operations

val normalize : IR.Tenv.t -> get_dynamic_type:(Var.t -> IR.Typ.t option) -> t -> (t * new_eqs) SatUnsat.t

think a bit harder about the formula

val simplify : IR.Tenv.t -> get_dynamic_type:(Var.t -> IR.Typ.t option) -> can_be_pruned:Var.Set.t -> keep:Var.Set.t -> t -> (t * new_eqs) SatUnsat.t
val and_fold_subst_variables : t -> up_to_f:t -> init:'acc -> f:('acc -> Var.t -> 'acc * Var.t) -> ('acc * t * new_eqs) SatUnsat.t
val is_known_zero : t -> Var.t -> bool
val has_no_assumptions : t -> bool
val get_var_repr : t -> Var.t -> Var.t

get the canonical representative for the variable according to the equality relation

\ No newline at end of file +PulseFormula (infer.Pulselib.PulseFormula)

Module Pulselib.PulseFormula

module F = Stdlib.Format
module SatUnsat = PulseSatUnsat
module Var = PulseAbstractValue

Arithmetic solver

Build formulas from SIL and tries to decide if they are (mostly un-)satisfiable.

type t
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
val pp : F.formatter -> t -> unit
val pp_with_pp_var : (F.formatter -> Var.t -> unit) -> F.formatter -> t -> unit

only used for unit tests

type operand =
| LiteralOperand of IR.IntLit.t
| AbstractValueOperand of Var.t

Build formulas

type new_eq =
| EqZero of Var.t
| Equal of Var.t * Var.t

some operations will return a set of new facts discovered that are relevant to communicate to the memory domain

type new_eqs = new_eq list
val ttrue : t
val and_equal : operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_equal_instanceof : Var.t -> Var.t -> IR.Typ.t -> t -> (t * new_eqs) SatUnsat.t
val and_less_equal : operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_less_than : operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_equal_unop : Var.t -> IR.Unop.t -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_equal_binop : Var.t -> IR.Binop.t -> operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val prune_binop : negated:bool -> IR.Binop.t -> operand -> operand -> t -> (t * new_eqs) SatUnsat.t

Operations

val normalize : IR.Tenv.t -> get_dynamic_type:(Var.t -> IR.Typ.t option) -> t -> (t * new_eqs) SatUnsat.t

think a bit harder about the formula

val simplify : IR.Tenv.t -> get_dynamic_type:(Var.t -> IR.Typ.t option) -> can_be_pruned:Var.Set.t -> keep:Var.Set.t -> t -> (t * Var.Set.t * new_eqs) SatUnsat.t
val and_fold_subst_variables : t -> up_to_f:t -> init:'acc -> f:('acc -> Var.t -> 'acc * Var.t) -> ('acc * t * new_eqs) SatUnsat.t
val is_known_zero : t -> Var.t -> bool
val has_no_assumptions : t -> bool
val get_known_var_repr : t -> Var.t -> Var.t

get the canonical representative for the variable according to the known/post equality relation

val get_both_var_repr : t -> Var.t -> Var.t

get the canonical representative for the variable according to the both/pre+post equality relation

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib/PulsePathCondition/index.html b/website/static/odoc/next/infer/Pulselib/PulsePathCondition/index.html index 9a1bfcbdc..e5e05e6b3 100644 --- a/website/static/odoc/next/infer/Pulselib/PulsePathCondition/index.html +++ b/website/static/odoc/next/infer/Pulselib/PulsePathCondition/index.html @@ -1,2 +1,2 @@ -PulsePathCondition (infer.Pulselib.PulsePathCondition)

Module Pulselib.PulsePathCondition

module F = Stdlib.Format
module AbstractValue = PulseAbstractValue
module SatUnsat = PulseSatUnsat
module ValueHistory = PulseValueHistory
type t
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
val true_ : t
val false_ : t
val pp : F.formatter -> t -> unit
type new_eqs = PulseFormula.new_eqs

Building arithmetic constraints

val and_nonnegative : AbstractValue.t -> t -> t * new_eqs

and_nonnegative v phi is phi ∧ v≥0

val and_positive : AbstractValue.t -> t -> t * new_eqs

and_positive v phi is phi ∧ v>0

val and_eq_int : AbstractValue.t -> IR.IntLit.t -> t -> t * new_eqs

and_eq_int v i phi is phi ∧ v=i

val and_eq_vars : AbstractValue.t -> AbstractValue.t -> t -> t * new_eqs
val simplify : IR.Tenv.t -> can_be_pruned:AbstractValue.Set.t -> keep:AbstractValue.Set.t -> get_dynamic_type:(AbstractValue.t -> IR.Typ.t option) -> t -> (t * new_eqs) SatUnsat.t

simplify ~can_be_pruned ~keep phi attempts to get rid of as many variables in fv phi but not in keep as possible, and tries to eliminate variables not in can_be_pruned from the "pruned" part of the formula

val and_callee : (AbstractValue.t * ValueHistory.t) AbstractValue.Map.t -> t -> callee:t -> (AbstractValue.t * ValueHistory.t) AbstractValue.Map.t * t * new_eqs

Operations

type operand =
| LiteralOperand of IR.IntLit.t
| AbstractValueOperand of AbstractValue.t
val compare_operand : operand -> operand -> int
val pp_operand : IStdlib.IStd.Formatter.t -> operand -> unit
val eval_binop : AbstractValue.t -> IR.Binop.t -> operand -> operand -> t -> t * new_eqs
val eval_unop : AbstractValue.t -> IR.Unop.t -> AbstractValue.t -> t -> t * new_eqs
val prune_binop : negated:bool -> IR.Binop.t -> operand -> operand -> t -> t * new_eqs
val and_eq_instanceof : AbstractValue.t -> AbstractValue.t -> IR.Typ.t -> t -> t * new_eqs

Queries

val is_known_zero : t -> AbstractValue.t -> bool

is_known_zero phi t returns true if phi |- t = 0, false if we don't know for sure

val is_known_not_equal_zero : t -> AbstractValue.t -> bool

is_known_not_equal_zero phi t returns true if phi |- t != 0, false if we don't know for sure

val is_unsat_cheap : t -> bool

whether the state contains a contradiction, call this as often as you want

val is_unsat_expensive : IR.Tenv.t -> get_dynamic_type:(AbstractValue.t -> IR.Typ.t option) -> t -> t * bool * new_eqs

whether the state contains a contradiction, only call this when you absolutely have to

val has_no_assumptions : t -> bool

whether the current path is independent of any calling context

val get_var_repr : t -> AbstractValue.t -> AbstractValue.t

get the canonical representative for the variable according to the equality relation

\ No newline at end of file +PulsePathCondition (infer.Pulselib.PulsePathCondition)

Module Pulselib.PulsePathCondition

module F = Stdlib.Format
module AbstractValue = PulseAbstractValue
module SatUnsat = PulseSatUnsat
module ValueHistory = PulseValueHistory
type t
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
val true_ : t
val false_ : t
val pp : F.formatter -> t -> unit
type new_eqs = PulseFormula.new_eqs

Building arithmetic constraints

val and_nonnegative : AbstractValue.t -> t -> t * new_eqs

and_nonnegative v phi is phi ∧ v≥0

val and_positive : AbstractValue.t -> t -> t * new_eqs

and_positive v phi is phi ∧ v>0

val and_eq_int : AbstractValue.t -> IR.IntLit.t -> t -> t * new_eqs

and_eq_int v i phi is phi ∧ v=i

val and_eq_vars : AbstractValue.t -> AbstractValue.t -> t -> t * new_eqs
val simplify : IR.Tenv.t -> can_be_pruned:AbstractValue.Set.t -> keep:AbstractValue.Set.t -> get_dynamic_type:(AbstractValue.t -> IR.Typ.t option) -> t -> (t * AbstractValue.Set.t * new_eqs) SatUnsat.t

simplify ~can_be_pruned ~keep phi attempts to get rid of as many variables in fv phi but not in keep as possible, and tries to eliminate variables not in can_be_pruned from the "pruned" part of the formula

val and_callee : (AbstractValue.t * ValueHistory.t) AbstractValue.Map.t -> t -> callee:t -> (AbstractValue.t * ValueHistory.t) AbstractValue.Map.t * t * new_eqs

Operations

type operand =
| LiteralOperand of IR.IntLit.t
| AbstractValueOperand of AbstractValue.t
val compare_operand : operand -> operand -> int
val pp_operand : IStdlib.IStd.Formatter.t -> operand -> unit
val eval_binop : AbstractValue.t -> IR.Binop.t -> operand -> operand -> t -> t * new_eqs
val eval_unop : AbstractValue.t -> IR.Unop.t -> AbstractValue.t -> t -> t * new_eqs
val prune_binop : negated:bool -> IR.Binop.t -> operand -> operand -> t -> t * new_eqs
val and_eq_instanceof : AbstractValue.t -> AbstractValue.t -> IR.Typ.t -> t -> t * new_eqs

Queries

val is_known_zero : t -> AbstractValue.t -> bool

is_known_zero phi t returns true if phi |- t = 0, false if we don't know for sure

val is_known_not_equal_zero : t -> AbstractValue.t -> bool

is_known_not_equal_zero phi t returns true if phi |- t != 0, false if we don't know for sure

val is_unsat_cheap : t -> bool

whether the state contains a contradiction, call this as often as you want

val is_unsat_expensive : IR.Tenv.t -> get_dynamic_type:(AbstractValue.t -> IR.Typ.t option) -> t -> t * bool * new_eqs

whether the state contains a contradiction, only call this when you absolutely have to

val has_no_assumptions : t -> bool

whether the current path is independent of any calling context

val get_known_var_repr : t -> AbstractValue.t -> AbstractValue.t

get the canonical representative for the variable according to the equality relation in the "known" part of the formula

val get_both_var_repr : t -> AbstractValue.t -> AbstractValue.t

get the canonical representative for the variable according to the equality relation in the "both" (known + pruned) part of the formula

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib/PulseSkippedCalls/index.html b/website/static/odoc/next/infer/Pulselib/PulseSkippedCalls/index.html index ea3378fb1..3d4074805 100644 --- a/website/static/odoc/next/infer/Pulselib/PulseSkippedCalls/index.html +++ b/website/static/odoc/next/infer/Pulselib/PulseSkippedCalls/index.html @@ -1,2 +1,2 @@ -PulseSkippedCalls (infer.Pulselib.PulseSkippedCalls)

Module Pulselib.PulseSkippedCalls

include Absint.AbstractDomain.MapS with type key = IR.Procname.t and type value = PulseTrace.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Yojson.Safe.t
\ No newline at end of file +PulseSkippedCalls (infer.Pulselib.PulseSkippedCalls)

Module Pulselib.PulseSkippedCalls

include Absint.AbstractDomain.MapS with type key = IR.Procname.t and type value = PulseTrace.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Yojson.Safe.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib__PulseAbductiveDomain/AddressAttributes/index.html b/website/static/odoc/next/infer/Pulselib__PulseAbductiveDomain/AddressAttributes/index.html index d672b6776..a0325728e 100644 --- a/website/static/odoc/next/infer/Pulselib__PulseAbductiveDomain/AddressAttributes/index.html +++ b/website/static/odoc/next/infer/Pulselib__PulseAbductiveDomain/AddressAttributes/index.html @@ -1,2 +1,2 @@ -AddressAttributes (infer.Pulselib__PulseAbductiveDomain.AddressAttributes)

Module Pulselib__PulseAbductiveDomain.AddressAttributes

attribute operations like BaseAddressAttributes but that also take care of propagating facts to the precondition

val abduce_and_add : Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attributes.t -> t -> t

add the attributes to both the current state and, if meaningful, the pre

val add_one : Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attribute.t -> t -> t

add the attribute only to the post

val add_attrs : Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attributes.t -> t -> t
val check_valid : ?⁠must_be_valid_reason:Pulselib.PulseBasicInterface.Invalidation.must_be_valid_reason -> Pulselib.PulseBasicInterface.Trace.t -> Pulselib.PulseBasicInterface.AbstractValue.t -> t -> (tPulselib.PulseBasicInterface.Invalidation.t * Pulselib.PulseBasicInterface.Trace.t) IStdlib.IStd.result
val check_initialized : Pulselib.PulseBasicInterface.Trace.t -> Pulselib.PulseBasicInterface.AbstractValue.t -> t -> (t, unit) IStdlib.IStd.result
val invalidate : (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.ValueHistory.t) -> Pulselib.PulseBasicInterface.Invalidation.t -> IBase.Location.t -> t -> t
val replace_must_be_valid_reason : Pulselib.PulseBasicInterface.Invalidation.must_be_valid_reason -> Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val allocate : IR.Procname.t -> (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.ValueHistory.t) -> IBase.Location.t -> t -> t
val add_dynamic_type : IR.Typ.t -> Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val remove_allocation_attr : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val get_closure_proc_name : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> IR.Procname.t option
val is_end_of_collection : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> bool
val mark_as_end_of_collection : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val is_std_vector_reserved : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> bool
val std_vector_reserve : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val find_opt : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> Pulselib.PulseBasicInterface.Attributes.t option
val check_valid_isl : Pulselib.PulseBasicInterface.Trace.t -> Pulselib.PulseBasicInterface.AbstractValue.t -> ?⁠null_noop:bool -> t -> (t[> `ISLError of t | `InvalidAccess of Pulselib.PulseBasicInterface.Invalidation.t * Pulselib.PulseBasicInterface.Trace.t * t ]) IStdlib.IStd.result list
\ No newline at end of file +AddressAttributes (infer.Pulselib__PulseAbductiveDomain.AddressAttributes)

Module Pulselib__PulseAbductiveDomain.AddressAttributes

attribute operations like BaseAddressAttributes but that also take care of propagating facts to the precondition

val abduce_and_add : Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attributes.t -> t -> t

add the attributes to both the current state and, if meaningful, the pre

val add_one : Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attribute.t -> t -> t

add the attribute only to the post

val add_attrs : Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attributes.t -> t -> t
val check_valid : ?⁠must_be_valid_reason:Pulselib.PulseBasicInterface.Invalidation.must_be_valid_reason -> Pulselib.PulseBasicInterface.Trace.t -> Pulselib.PulseBasicInterface.AbstractValue.t -> t -> (tPulselib.PulseBasicInterface.Invalidation.t * Pulselib.PulseBasicInterface.Trace.t) IStdlib.IStd.result
val check_initialized : Pulselib.PulseBasicInterface.Trace.t -> Pulselib.PulseBasicInterface.AbstractValue.t -> t -> (t, unit) IStdlib.IStd.result
val invalidate : (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.ValueHistory.t) -> Pulselib.PulseBasicInterface.Invalidation.t -> IBase.Location.t -> t -> t
val replace_must_be_valid_reason : Pulselib.PulseBasicInterface.Invalidation.must_be_valid_reason -> Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val allocate : IR.Procname.t -> (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.ValueHistory.t) -> IBase.Location.t -> t -> t
val add_dynamic_type : IR.Typ.t -> Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val remove_allocation_attr : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val get_allocation : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> (IR.Procname.t * Pulselib.PulseBasicInterface.Trace.t) option
val get_closure_proc_name : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> IR.Procname.t option
val is_end_of_collection : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> bool
val mark_as_end_of_collection : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val is_std_vector_reserved : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> bool
val std_vector_reserve : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val add_unreachable_at : Pulselib.PulseBasicInterface.AbstractValue.t -> IBase.Location.t -> t -> t
val find_opt : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> Pulselib.PulseBasicInterface.Attributes.t option
val check_valid_isl : Pulselib.PulseBasicInterface.Trace.t -> Pulselib.PulseBasicInterface.AbstractValue.t -> ?⁠null_noop:bool -> t -> (t[> `ISLError of t | `InvalidAccess of Pulselib.PulseBasicInterface.Invalidation.t * Pulselib.PulseBasicInterface.Trace.t * t ]) IStdlib.IStd.result list
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib__PulseAbductiveDomain/index.html b/website/static/odoc/next/infer/Pulselib__PulseAbductiveDomain/index.html index d27102a84..286245c91 100644 --- a/website/static/odoc/next/infer/Pulselib__PulseAbductiveDomain/index.html +++ b/website/static/odoc/next/infer/Pulselib__PulseAbductiveDomain/index.html @@ -1,2 +1,2 @@ -Pulselib__PulseAbductiveDomain (infer.Pulselib__PulseAbductiveDomain)

Module Pulselib__PulseAbductiveDomain

module BaseDomain = Pulselib.PulseBaseDomain
module BaseMemory = Pulselib.PulseBaseMemory
module BaseStack = Pulselib.PulseBaseStack
module type BaseDomainSig = sig ... end

signature common to the "normal" Domain, representing the post at the current program point, and the inverted PreDomain, representing the inferred pre-condition

module PostDomain : BaseDomainSig

The post abstract state at each program point, or current state.

module PreDomain : BaseDomainSig

The inferred pre-condition at each program point, biabduction style.

type t = private {
post : PostDomain.t;

state at the current program point

pre : PreDomain.t;

inferred procedure pre-condition leading to the current program point

path_condition : Pulselib.PulseBasicInterface.PathCondition.t;

arithmetic facts true along the path (holding for both pre and post since abstract values are immutable)

topl : Pulselib.PulseTopl.state;

state at of the Topl monitor at the current program point, when Topl is enabled

skipped_calls : Pulselib.PulseBasicInterface.SkippedCalls.t;

metadata: procedure calls for which no summary was found

}

pre/post on a single program path

val equal : t -> t -> bool
val leq : lhs:t -> rhs:t -> bool
val pp : Stdlib.Format.formatter -> t -> unit
val mk_initial : IR.Tenv.t -> IR.Procdesc.t -> t
val get_pre : t -> BaseDomain.t
val get_post : t -> BaseDomain.t
module Stack : sig ... end

stack operations like BaseStack but that also take care of propagating facts to the precondition

module Memory : sig ... end

memory operations like BaseMemory but that also take care of propagating facts to the precondition

module AddressAttributes : sig ... end

attribute operations like BaseAddressAttributes but that also take care of propagating facts to the precondition

val is_local : IR.Var.t -> t -> bool
val find_post_cell_opt : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> BaseDomain.cell option
val discard_unreachable : t -> t

garbage collect unreachable addresses in the state to make it smaller and return the new state

val get_unreachable_attributes : t -> Pulselib.PulseBasicInterface.AbstractValue.t list

collect the addresses that have attributes but are unreachable in the current post-condition

val add_skipped_call : IR.Procname.t -> Pulselib.PulseBasicInterface.Trace.t -> t -> t
val add_skipped_calls : Pulselib.PulseBasicInterface.SkippedCalls.t -> t -> t
val set_path_condition : Pulselib.PulseBasicInterface.PathCondition.t -> t -> t
val is_isl_without_allocation : t -> bool
val is_pre_without_isl_abduced : t -> bool
type summary = private t

private type to make sure summary_of_post is always called when creating summaries

val compare_summary : summary -> summary -> int
val equal_summary : summary -> summary -> bool
val yojson_of_summary : summary -> Ppx_yojson_conv_lib.Yojson.Safe.t
val skipped_calls_match_pattern : summary -> bool
val summary_of_post : IR.Tenv.t -> IR.Procdesc.t -> IBase.Location.t -> t -> (summary[> `MemoryLeak of summary * IR.Procname.t * Pulselib.PulseBasicInterface.Trace.t * IBase.Location.t | `PotentialInvalidAccessSummary of summary * Pulselib.PulseBasicInterface.AbstractValue.t * (Pulselib.PulseBasicInterface.Trace.t * Pulselib.PulseBasicInterface.Invalidation.must_be_valid_reason option) ]) IStdlib.IStd.result Pulselib.PulseBasicInterface.SatUnsat.t

Trim the state down to just the procedure's interface (formals and globals), and simplify and normalize the state.

val set_post_edges : Pulselib.PulseBasicInterface.AbstractValue.t -> BaseMemory.Edges.t -> t -> t

directly set the edges for the given address, bypassing abduction altogether

val set_post_cell : (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.ValueHistory.t) -> BaseDomain.cell -> IBase.Location.t -> t -> t

directly set the edges and attributes for the given address, bypassing abduction altogether

val incorporate_new_eqs : Pulselib.PulseBasicInterface.PathCondition.new_eqs -> t -> (t[> `PotentialInvalidAccess of t * Pulselib.PulseBasicInterface.AbstractValue.t * (Pulselib.PulseBasicInterface.Trace.t * Pulselib.PulseBasicInterface.Invalidation.must_be_valid_reason option) ]) IStdlib.IStd.result

Check that the new equalities discovered are compatible with the current pre and post heaps, e.g. x = 0 is not compatible with x being allocated, and x = y is not compatible with x and y being allocated separately. In those cases, the resulting path condition is PathCondition.false_.

val initialize : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t

Remove "Uninitialized" attribute of the given address

val set_uninitialized : IR.Tenv.t -> [ `LocalDecl of IR.Pvar.t * Pulselib.PulseBasicInterface.AbstractValue.t option | `Malloc of Pulselib.PulseBasicInterface.AbstractValue.t ] -> IR.Typ.t -> IBase.Location.t -> t -> t

Add "Uninitialized" attributes when a variable is declared or a memory is allocated by malloc.

module Topl : sig ... end
\ No newline at end of file +Pulselib__PulseAbductiveDomain (infer.Pulselib__PulseAbductiveDomain)

Module Pulselib__PulseAbductiveDomain

module BaseDomain = Pulselib.PulseBaseDomain
module BaseMemory = Pulselib.PulseBaseMemory
module BaseStack = Pulselib.PulseBaseStack
module type BaseDomainSig = sig ... end

signature common to the "normal" Domain, representing the post at the current program point, and the inverted PreDomain, representing the inferred pre-condition

module PostDomain : BaseDomainSig

The post abstract state at each program point, or current state.

module PreDomain : BaseDomainSig

The inferred pre-condition at each program point, biabduction style.

type t = private {
post : PostDomain.t;

state at the current program point

pre : PreDomain.t;

inferred procedure pre-condition leading to the current program point

path_condition : Pulselib.PulseBasicInterface.PathCondition.t;

arithmetic facts true along the path (holding for both pre and post since abstract values are immutable)

topl : Pulselib.PulseTopl.state;

state at of the Topl monitor at the current program point, when Topl is enabled

skipped_calls : Pulselib.PulseBasicInterface.SkippedCalls.t;

metadata: procedure calls for which no summary was found

}

pre/post on a single program path

val equal : t -> t -> bool
val leq : lhs:t -> rhs:t -> bool
val pp : Stdlib.Format.formatter -> t -> unit
val mk_initial : IR.Tenv.t -> IR.Procdesc.t -> t
val get_pre : t -> BaseDomain.t
val get_post : t -> BaseDomain.t
module Stack : sig ... end

stack operations like BaseStack but that also take care of propagating facts to the precondition

module Memory : sig ... end

memory operations like BaseMemory but that also take care of propagating facts to the precondition

module AddressAttributes : sig ... end

attribute operations like BaseAddressAttributes but that also take care of propagating facts to the precondition

val is_local : IR.Var.t -> t -> bool
val find_post_cell_opt : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> BaseDomain.cell option
val get_unreachable_attributes : t -> Pulselib.PulseBasicInterface.AbstractValue.t list

collect the addresses that have attributes but are unreachable in the current post-condition

val add_skipped_call : IR.Procname.t -> Pulselib.PulseBasicInterface.Trace.t -> t -> t
val add_skipped_calls : Pulselib.PulseBasicInterface.SkippedCalls.t -> t -> t
val set_path_condition : Pulselib.PulseBasicInterface.PathCondition.t -> t -> t
val is_isl_without_allocation : t -> bool
val is_pre_without_isl_abduced : t -> bool
type summary = private t

private type to make sure summary_of_post is always called when creating summaries

val compare_summary : summary -> summary -> int
val equal_summary : summary -> summary -> bool
val yojson_of_summary : summary -> Ppx_yojson_conv_lib.Yojson.Safe.t
val skipped_calls_match_pattern : summary -> bool
val summary_of_post : IR.Tenv.t -> IR.Procdesc.t -> IBase.Location.t -> t -> (summary[> `MemoryLeak of summary * IR.Procname.t * Pulselib.PulseBasicInterface.Trace.t * IBase.Location.t | `PotentialInvalidAccessSummary of summary * Pulselib.PulseBasicInterface.AbstractValue.t * (Pulselib.PulseBasicInterface.Trace.t * Pulselib.PulseBasicInterface.Invalidation.must_be_valid_reason option) ]) IStdlib.IStd.result Pulselib.PulseBasicInterface.SatUnsat.t

Trim the state down to just the procedure's interface (formals and globals), and simplify and normalize the state.

val set_post_edges : Pulselib.PulseBasicInterface.AbstractValue.t -> BaseMemory.Edges.t -> t -> t

directly set the edges for the given address, bypassing abduction altogether

val set_post_cell : (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.ValueHistory.t) -> BaseDomain.cell -> IBase.Location.t -> t -> t

directly set the edges and attributes for the given address, bypassing abduction altogether

val incorporate_new_eqs : Pulselib.PulseBasicInterface.PathCondition.new_eqs -> t -> (t[> `PotentialInvalidAccess of t * Pulselib.PulseBasicInterface.AbstractValue.t * (Pulselib.PulseBasicInterface.Trace.t * Pulselib.PulseBasicInterface.Invalidation.must_be_valid_reason option) ]) IStdlib.IStd.result

Check that the new equalities discovered are compatible with the current pre and post heaps, e.g. x = 0 is not compatible with x being allocated, and x = y is not compatible with x and y being allocated separately. In those cases, the resulting path condition is PathCondition.false_.

val initialize : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t

Remove "Uninitialized" attribute of the given address

val set_uninitialized : IR.Tenv.t -> [ `LocalDecl of IR.Pvar.t * Pulselib.PulseBasicInterface.AbstractValue.t option | `Malloc of Pulselib.PulseBasicInterface.AbstractValue.t ] -> IR.Typ.t -> IBase.Location.t -> t -> t

Add "Uninitialized" attributes when a variable is declared or a memory is allocated by malloc.

module Topl : sig ... end
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib__PulseAttribute/Attributes/index.html b/website/static/odoc/next/infer/Pulselib__PulseAttribute/Attributes/index.html index a78e70a1f..e537a6cee 100644 --- a/website/static/odoc/next/infer/Pulselib__PulseAttribute/Attributes/index.html +++ b/website/static/odoc/next/infer/Pulselib__PulseAttribute/Attributes/index.html @@ -1,2 +1,2 @@ -Attributes (infer.Pulselib__PulseAttribute.Attributes)

Module Pulselib__PulseAttribute.Attributes

include IStdlib.PrettyPrintable.PPUniqRankSet with type elt = t
type t
val compare : t -> t -> int
val equal : t -> t -> bool
type rank
type elt = t
val add : t -> elt -> t
val empty : t
val find_rank : t -> rank -> elt option
val fold : t -> init:'accum -> f:('accum -> elt -> 'accum) -> 'accum
val fold_map : t -> init:'accum -> f:('accum -> elt -> 'accum * elt) -> 'accum * t
val for_all : f:(elt -> bool) -> t -> bool
val is_empty : t -> bool
val is_singleton : t -> bool
val is_subset : t -> of_:t -> bool
val map : t -> f:(elt -> elt) -> t
val singleton : elt -> t
val elements : t -> elt list
val remove : elt -> t -> t
val mem : elt -> t -> bool
val union_prefer_left : t -> t -> t

in case an element with the same rank is present both in lhs and rhs, keep the one from lhs in union_prefer_left lhs rhs

val pp : ?⁠print_rank:bool -> IStdlib.PrettyPrintable.F.formatter -> t -> unit
val get_address_of_stack_variable : t -> (IR.Var.t * IBase.Location.t * ValueHistory.t) option
val get_closure_proc_name : t -> IR.Procname.t option
val get_allocation : t -> (IR.Procname.t * Trace.t) option
val get_dynamic_type : t -> IR.Typ.t option
val is_end_of_collection : t -> bool
val get_invalid : t -> (Invalidation.t * Trace.t) option
val get_isl_abduced : t -> Trace.t option
val get_must_be_valid : t -> (Trace.t * Invalidation.must_be_valid_reason option) option
val get_written_to : t -> Trace.t option
val is_modified : t -> bool
val is_std_vector_reserved : t -> bool
val is_uninitialized : t -> bool
val get_must_be_initialized : t -> Trace.t option
val isl_subset : t -> t -> bool

check whether for each attr in the second list, there exists a corresponding attr in the first according to Attributes.isl_equiv.

val replace_isl_abduced : t -> t -> t

While applying a spec, replacing ISLAbduced by Allocated and Invalidation.Cfree by Invalidation.delete, if applicable

val add_call : IR.Procname.t -> IBase.Location.t -> ValueHistory.t -> t -> t
\ No newline at end of file +Attributes (infer.Pulselib__PulseAttribute.Attributes)

Module Pulselib__PulseAttribute.Attributes

include IStdlib.PrettyPrintable.PPUniqRankSet with type elt = t
type t
val compare : t -> t -> int
val equal : t -> t -> bool
type rank
type elt = t
val add : t -> elt -> t
val empty : t
val find_rank : t -> rank -> elt option
val fold : t -> init:'accum -> f:('accum -> elt -> 'accum) -> 'accum
val fold_map : t -> init:'accum -> f:('accum -> elt -> 'accum * elt) -> 'accum * t
val for_all : f:(elt -> bool) -> t -> bool
val is_empty : t -> bool
val is_singleton : t -> bool
val is_subset : t -> of_:t -> bool
val map : t -> f:(elt -> elt) -> t
val singleton : elt -> t
val elements : t -> elt list
val remove : elt -> t -> t
val mem : elt -> t -> bool
val union_prefer_left : t -> t -> t

in case an element with the same rank is present both in lhs and rhs, keep the one from lhs in union_prefer_left lhs rhs

val pp : ?⁠print_rank:bool -> IStdlib.PrettyPrintable.F.formatter -> t -> unit
val get_address_of_stack_variable : t -> (IR.Var.t * IBase.Location.t * ValueHistory.t) option
val get_closure_proc_name : t -> IR.Procname.t option
val get_allocation : t -> (IR.Procname.t * Trace.t) option
val get_dynamic_type : t -> IR.Typ.t option
val is_end_of_collection : t -> bool
val get_invalid : t -> (Invalidation.t * Trace.t) option
val get_isl_abduced : t -> Trace.t option
val get_must_be_valid : t -> (Trace.t * Invalidation.must_be_valid_reason option) option
val get_written_to : t -> Trace.t option
val is_modified : t -> bool
val is_std_vector_reserved : t -> bool
val is_uninitialized : t -> bool
val get_must_be_initialized : t -> Trace.t option
val get_unreachable_at : t -> IBase.Location.t option
val isl_subset : t -> t -> bool

check whether for each attr in the second list, there exists a corresponding attr in the first according to Attributes.isl_equiv.

val replace_isl_abduced : t -> t -> t

While applying a spec, replacing ISLAbduced by Allocated and Invalidation.Cfree by Invalidation.delete, if applicable

val add_call : IR.Procname.t -> IBase.Location.t -> ValueHistory.t -> t -> t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib__PulseAttribute/index.html b/website/static/odoc/next/infer/Pulselib__PulseAttribute/index.html index d5ef0c427..cfd531d31 100644 --- a/website/static/odoc/next/infer/Pulselib__PulseAttribute/index.html +++ b/website/static/odoc/next/infer/Pulselib__PulseAttribute/index.html @@ -1,2 +1,2 @@ -Pulselib__PulseAttribute (infer.Pulselib__PulseAttribute)

Module Pulselib__PulseAttribute

module F = Stdlib.Format
module Invalidation = Pulselib.PulseInvalidation
module Trace = Pulselib.PulseTrace
module ValueHistory = Pulselib.PulseValueHistory
type t =
| AddressOfCppTemporary of IR.Var.t * ValueHistory.t
| AddressOfStackVariable of IR.Var.t * IBase.Location.t * ValueHistory.t
| Allocated of IR.Procname.t * Trace.t

the Procname.t is the function causing the allocation, eg malloc

| Closure of IR.Procname.t
| DynamicType of IR.Typ.t
| EndOfCollection
| Invalid of Invalidation.t * Trace.t
| ISLAbduced of Trace.t

The allocation is abduced so as the analysis could run normally

| MustBeInitialized of Trace.t
| MustBeValid of Trace.t * Invalidation.must_be_valid_reason option
| StdVectorReserve
| Uninitialized
| WrittenTo of Trace.t
val compare : t -> t -> int
val pp : F.formatter -> t -> unit
val is_suitable_for_pre : t -> bool
val is_suitable_for_post : t -> bool
module Attributes : sig ... end
\ No newline at end of file +Pulselib__PulseAttribute (infer.Pulselib__PulseAttribute)

Module Pulselib__PulseAttribute

module F = Stdlib.Format
module Invalidation = Pulselib.PulseInvalidation
module Trace = Pulselib.PulseTrace
module ValueHistory = Pulselib.PulseValueHistory
type t =
| AddressOfCppTemporary of IR.Var.t * ValueHistory.t
| AddressOfStackVariable of IR.Var.t * IBase.Location.t * ValueHistory.t
| Allocated of IR.Procname.t * Trace.t

the Procname.t is the function causing the allocation, eg malloc

| Closure of IR.Procname.t
| DynamicType of IR.Typ.t
| EndOfCollection
| Invalid of Invalidation.t * Trace.t
| ISLAbduced of Trace.t

The allocation is abduced so as the analysis could run normally

| MustBeInitialized of Trace.t
| MustBeValid of Trace.t * Invalidation.must_be_valid_reason option
| StdVectorReserve
| Uninitialized
| UnreachableAt of IBase.Location.t

temporary marker to remember where a variable became unreachable; helps with accurately reporting leaks

| WrittenTo of Trace.t
val compare : t -> t -> int
val pp : F.formatter -> t -> unit
val is_suitable_for_pre : t -> bool
val is_suitable_for_post : t -> bool
module Attributes : sig ... end
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib__PulseBaseAddressAttributes/index.html b/website/static/odoc/next/infer/Pulselib__PulseBaseAddressAttributes/index.html index 0cf78bbbd..aaf859a98 100644 --- a/website/static/odoc/next/infer/Pulselib__PulseBaseAddressAttributes/index.html +++ b/website/static/odoc/next/infer/Pulselib__PulseBaseAddressAttributes/index.html @@ -1,2 +1,2 @@ -Pulselib__PulseBaseAddressAttributes (infer.Pulselib__PulseBaseAddressAttributes)

Module Pulselib__PulseBaseAddressAttributes

module F = Stdlib.Format
type t
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
val empty : t
val filter : (Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attributes.t -> bool) -> t -> t
val for_all : (Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attributes.t -> bool) -> t -> bool
val filter_with_discarded_addrs : (Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attributes.t -> bool) -> t -> t * Pulselib.PulseBasicInterface.AbstractValue.t list
val find_opt : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> Pulselib.PulseBasicInterface.Attributes.t option
val add_one : Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attribute.t -> t -> t
val add : Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attributes.t -> t -> t
val allocate : IR.Procname.t -> (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.ValueHistory.t) -> IBase.Location.t -> t -> t
val fold : (Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attributes.t -> 'a -> 'a) -> t -> 'a -> 'a
val check_valid : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> (unit, Pulselib.PulseBasicInterface.Invalidation.t * Pulselib.PulseBasicInterface.Trace.t) IStdlib.IStd.result
val check_initialized : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> (unit, unit) IStdlib.IStd.result
val invalidate : (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.ValueHistory.t) -> Pulselib.PulseBasicInterface.Invalidation.t -> IBase.Location.t -> t -> t
val get_closure_proc_name : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> IR.Procname.t option
val get_invalid : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> (Pulselib.PulseBasicInterface.Invalidation.t * Pulselib.PulseBasicInterface.Trace.t) option
val get_must_be_valid : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> (Pulselib.PulseBasicInterface.Trace.t * Pulselib.PulseBasicInterface.Invalidation.must_be_valid_reason option) option
val is_must_be_valid_or_allocated_isl : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> bool
val get_must_be_initialized : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> Pulselib.PulseBasicInterface.Trace.t option
val add_dynamic_type : IR.Typ.t -> Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val get_dynamic_type : t -> Pulselib.PulseBasicInterface.AbstractValue.t -> IR.Typ.t option
val std_vector_reserve : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val is_std_vector_reserved : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> bool
val mark_as_end_of_collection : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val is_end_of_collection : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> bool
val pp : F.formatter -> t -> unit
val remove_allocation_attr : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val remove_must_be_valid_attr : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val remove_isl_abduced_attr : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val initialize : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val canonicalize : get_var_repr:(Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.AbstractValue.t) -> t -> t

merge the attributes of all the variables that are equal according to get_var_repr and remove non-canonical variables in favor of their rerpresentative

val subst_var : (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.AbstractValue.t) -> t -> t
\ No newline at end of file +Pulselib__PulseBaseAddressAttributes (infer.Pulselib__PulseBaseAddressAttributes)

Module Pulselib__PulseBaseAddressAttributes

module F = Stdlib.Format
type t
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
val empty : t
val filter : (Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attributes.t -> bool) -> t -> t
val for_all : (Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attributes.t -> bool) -> t -> bool
val filter_with_discarded_addrs : (Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attributes.t -> bool) -> t -> t * Pulselib.PulseBasicInterface.AbstractValue.t list
val find_opt : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> Pulselib.PulseBasicInterface.Attributes.t option
val add_one : Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attribute.t -> t -> t
val add : Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attributes.t -> t -> t
val allocate : IR.Procname.t -> (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.ValueHistory.t) -> IBase.Location.t -> t -> t
val fold : (Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.Attributes.t -> 'a -> 'a) -> t -> 'a -> 'a
val check_valid : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> (unit, Pulselib.PulseBasicInterface.Invalidation.t * Pulselib.PulseBasicInterface.Trace.t) IStdlib.IStd.result
val check_initialized : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> (unit, unit) IStdlib.IStd.result
val invalidate : (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.ValueHistory.t) -> Pulselib.PulseBasicInterface.Invalidation.t -> IBase.Location.t -> t -> t
val get_allocation : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> (IR.Procname.t * Pulselib.PulseBasicInterface.Trace.t) option
val get_closure_proc_name : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> IR.Procname.t option
val get_invalid : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> (Pulselib.PulseBasicInterface.Invalidation.t * Pulselib.PulseBasicInterface.Trace.t) option
val get_must_be_valid : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> (Pulselib.PulseBasicInterface.Trace.t * Pulselib.PulseBasicInterface.Invalidation.must_be_valid_reason option) option
val is_must_be_valid_or_allocated_isl : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> bool
val get_must_be_initialized : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> Pulselib.PulseBasicInterface.Trace.t option
val add_dynamic_type : IR.Typ.t -> Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val get_dynamic_type : t -> Pulselib.PulseBasicInterface.AbstractValue.t -> IR.Typ.t option
val std_vector_reserve : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val is_std_vector_reserved : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> bool
val mark_as_end_of_collection : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val is_end_of_collection : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> bool
val add_unreachable_at : Pulselib.PulseBasicInterface.AbstractValue.t -> IBase.Location.t -> t -> t
val pp : F.formatter -> t -> unit
val remove_allocation_attr : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val remove_must_be_valid_attr : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val remove_isl_abduced_attr : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val initialize : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val canonicalize : get_var_repr:(Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.AbstractValue.t) -> t -> t

merge the attributes of all the variables that are equal according to get_var_repr and remove non-canonical variables in favor of their rerpresentative

val subst_var : (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.AbstractValue.t) -> t -> t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib__PulseBaseDomain/GraphVisit/index.html b/website/static/odoc/next/infer/Pulselib__PulseBaseDomain/GraphVisit/index.html new file mode 100644 index 000000000..20b3de478 --- /dev/null +++ b/website/static/odoc/next/infer/Pulselib__PulseBaseDomain/GraphVisit/index.html @@ -0,0 +1,2 @@ + +GraphVisit (infer.Pulselib__PulseBaseDomain.GraphVisit)

Module Pulselib__PulseBaseDomain.GraphVisit

val fold : var_filter:(IR.Var.t -> bool) -> t -> init:'accum -> f:(IR.Var.t -> 'accum -> Pulselib.PulseBasicInterface.AbstractValue.t -> Memory.Access.t list -> ('accum'final) Base.Continue_or_stop.t) -> finish:('accum -> 'final) -> Pulselib.PulseBasicInterface.AbstractValue.Set.t * 'final

Generic graph traversal of the memory starting from each variable in the stack that pass var_filter, in order. Returns the result of folding over every address in the graph and the set of addresses that have been visited before f returned Stop or all reachable addresses were seen. f is passed each address together with the variable from which the address was reached and the access path from that variable to the address.

val fold_from_addresses : Pulselib.PulseBasicInterface.AbstractValue.t Stdlib.Seq.t -> t -> init:'accum -> f:('accum -> Pulselib.PulseBasicInterface.AbstractValue.t -> Memory.Access.t list -> ('accum'final) Base.Continue_or_stop.t) -> finish:('accum -> 'final) -> Pulselib.PulseBasicInterface.AbstractValue.Set.t * 'final

Similar to fold, but start from given addresses, instead of stack variables.

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib__PulseBaseDomain/index.html b/website/static/odoc/next/infer/Pulselib__PulseBaseDomain/index.html index d2d584cfc..b2aa5228d 100644 --- a/website/static/odoc/next/infer/Pulselib__PulseBaseDomain/index.html +++ b/website/static/odoc/next/infer/Pulselib__PulseBaseDomain/index.html @@ -1,2 +1,2 @@ -Pulselib__PulseBaseDomain (infer.Pulselib__PulseBaseDomain)

Module Pulselib__PulseBaseDomain

module F = Stdlib.Format
type t = {
heap : Pulselib.PulseBaseMemory.t;
stack : Pulselib.PulseBaseStack.t;
attrs : Pulselib.PulseBaseAddressAttributes.t;
}
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
type cell = Pulselib.PulseBaseMemory.Edges.t * Pulselib.PulseBasicInterface.Attributes.t
val empty : t
val reachable_addresses : t -> Pulselib.PulseBasicInterface.AbstractValue.Set.t

compute the set of abstract addresses that are "used" in the abstract state, i.e. reachable from the stack variables

val reachable_addresses_from : Pulselib.PulseBasicInterface.AbstractValue.t list -> t -> Pulselib.PulseBasicInterface.AbstractValue.Set.t

compute the set of abstract addresses that are reachable from given abstract addresses

type mapping
val empty_mapping : mapping
type isograph_relation =
| NotIsomorphic

no mapping was found that can make LHS the same as the RHS

| IsomorphicUpTo of mapping

mapping(lhs) is isomorphic to rhs

val isograph_map : lhs:t -> rhs:t -> mapping -> isograph_relation
val is_isograph : lhs:t -> rhs:t -> mapping -> bool
val find_cell_opt : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> cell option
val pp : F.formatter -> t -> unit
val subst_var : (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.AbstractValue.t) -> t -> t Pulselib.PulseBasicInterface.SatUnsat.t
\ No newline at end of file +Pulselib__PulseBaseDomain (infer.Pulselib__PulseBaseDomain)

Module Pulselib__PulseBaseDomain

module Memory = Pulselib.PulseBaseMemory
module F = Stdlib.Format
type t = {
heap : Pulselib.PulseBaseMemory.t;
stack : Pulselib.PulseBaseStack.t;
attrs : Pulselib.PulseBaseAddressAttributes.t;
}
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
type cell = Pulselib.PulseBaseMemory.Edges.t * Pulselib.PulseBasicInterface.Attributes.t
val empty : t
val reachable_addresses : ?⁠var_filter:(IR.Var.t -> bool) -> t -> Pulselib.PulseBasicInterface.AbstractValue.Set.t

compute the set of abstract addresses that are "used" in the abstract state, i.e. reachable from the stack variables

val reachable_addresses_from : Pulselib.PulseBasicInterface.AbstractValue.t Stdlib.Seq.t -> t -> Pulselib.PulseBasicInterface.AbstractValue.Set.t

compute the set of abstract addresses that are reachable from given abstract addresses

type mapping
val empty_mapping : mapping
type isograph_relation =
| NotIsomorphic

no mapping was found that can make LHS the same as the RHS

| IsomorphicUpTo of mapping

mapping(lhs) is isomorphic to rhs

val isograph_map : lhs:t -> rhs:t -> mapping -> isograph_relation
val is_isograph : lhs:t -> rhs:t -> mapping -> bool
val find_cell_opt : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> cell option
val pp : F.formatter -> t -> unit
val subst_var : (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.AbstractValue.t) -> t -> t Pulselib.PulseBasicInterface.SatUnsat.t
module GraphVisit : sig ... end
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib__PulseBaseMemory/Edges/index.html b/website/static/odoc/next/infer/Pulselib__PulseBaseMemory/Edges/index.html index 7f820793c..af6cb87c6 100644 --- a/website/static/odoc/next/infer/Pulselib__PulseBaseMemory/Edges/index.html +++ b/website/static/odoc/next/infer/Pulselib__PulseBaseMemory/Edges/index.html @@ -1,2 +1,2 @@ -Edges (infer.Pulselib__PulseBaseMemory.Edges)

Module Pulselib__PulseBaseMemory.Edges

type t

Note that the derived compare and equal functions are sensitive to the underlying implementation and in particular won't equate some objects that denote the same map.

val compare : t -> t -> int
val equal : t -> t -> bool
type key = Access.t
type value = AddrTrace.t
val pp : IStdlib.RecencyMap.F.formatter -> t -> unit
val empty : t
val add : key -> value -> t -> t
val bindings : t -> (key * value) list
val exists : t -> f:((key * value) -> bool) -> bool
val filter : t -> f:((key * value) -> bool) -> t
val find_opt : key -> t -> value option
val fold : t -> init:'acc -> f:('acc -> (key * value) -> 'acc) -> 'acc
val fold_map : t -> init:'acc -> f:('acc -> value -> 'acc * value) -> 'acc * t
val is_empty : t -> bool
val map : t -> f:(value -> value) -> t
val mem : t -> key -> bool
val union_left_biased : t -> t -> t
\ No newline at end of file +Edges (infer.Pulselib__PulseBaseMemory.Edges)

Module Pulselib__PulseBaseMemory.Edges

type t

Note that the derived compare and equal functions are sensitive to the underlying implementation and in particular won't equate some objects that denote the same map.

val compare : t -> t -> int
val equal : t -> t -> bool
type key = Access.t
type value = AddrTrace.t
val pp : IStdlib.RecencyMap.F.formatter -> t -> unit
val empty : t
val add : key -> value -> t -> t
val bindings : t -> (key * value) list
val exists : t -> f:((key * value) -> bool) -> bool
val filter : t -> f:((key * value) -> bool) -> t
val find_opt : key -> t -> value option
val fold : t -> init:'acc -> f:('acc -> (key * value) -> 'acc) -> 'acc
val fold_map : t -> init:'acc -> f:('acc -> value -> 'acc * value) -> 'acc * t
val is_empty : t -> bool
val map : t -> f:(value -> value) -> t
val mem : t -> key -> bool
val union_left_biased : t -> t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib__PulseBaseMemory/index.html b/website/static/odoc/next/infer/Pulselib__PulseBaseMemory/index.html index ae82b4f17..6a8f99ce9 100644 --- a/website/static/odoc/next/infer/Pulselib__PulseBaseMemory/index.html +++ b/website/static/odoc/next/infer/Pulselib__PulseBaseMemory/index.html @@ -1,2 +1,2 @@ -Pulselib__PulseBaseMemory (infer.Pulselib__PulseBaseMemory)

Module Pulselib__PulseBaseMemory

module Access : sig ... end
module AccessSet : IStdlib.IStd.Caml.Set.S with type AccessSet.elt = Access.t
module AddrTrace : sig ... end
module Edges : IStdlib.RecencyMap.S with type key = Access.t and type value = AddrTrace.t
include IStdlib.PrettyPrintable.PPMonoMap with type key = Pulselib.PulseBasicInterface.AbstractValue.t and type value = Edges.t
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
val compare : t -> t -> int
val equal : t -> t -> bool
val register_address : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val add_edge : Pulselib.PulseBasicInterface.AbstractValue.t -> Access.t -> AddrTrace.t -> t -> t
val find_edge_opt : Pulselib.PulseBasicInterface.AbstractValue.t -> Access.t -> t -> AddrTrace.t option
val has_edge : Pulselib.PulseBasicInterface.AbstractValue.t -> Access.t -> t -> bool
val yojson_of_t : t -> Yojson.Safe.t
val is_allocated : t -> Pulselib.PulseBasicInterface.AbstractValue.t -> bool

whether the address has a non-empty set of edges

val canonicalize : get_var_repr:(Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.AbstractValue.t) -> t -> t Pulselib.PulseBasicInterface.SatUnsat.t

replace each address in the heap by its canonical representative according to the current equality relation, represented by get_var_repr; also remove addresses that point to empty edges

val subst_var : (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.AbstractValue.t) -> t -> t Pulselib.PulseBasicInterface.SatUnsat.t
\ No newline at end of file +Pulselib__PulseBaseMemory (infer.Pulselib__PulseBaseMemory)

Module Pulselib__PulseBaseMemory

module Access : sig ... end
module AccessSet : IStdlib.IStd.Caml.Set.S with type AccessSet.elt = Access.t
module AddrTrace : sig ... end
module Edges : IStdlib.RecencyMap.S with type key = Access.t and type value = AddrTrace.t
include IStdlib.PrettyPrintable.PPMonoMap with type key = Pulselib.PulseBasicInterface.AbstractValue.t and type value = Edges.t
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
val compare : t -> t -> int
val equal : t -> t -> bool
val register_address : Pulselib.PulseBasicInterface.AbstractValue.t -> t -> t
val add_edge : Pulselib.PulseBasicInterface.AbstractValue.t -> Access.t -> AddrTrace.t -> t -> t
val find_edge_opt : Pulselib.PulseBasicInterface.AbstractValue.t -> Access.t -> t -> AddrTrace.t option
val has_edge : Pulselib.PulseBasicInterface.AbstractValue.t -> Access.t -> t -> bool
val yojson_of_t : t -> Yojson.Safe.t
val is_allocated : t -> Pulselib.PulseBasicInterface.AbstractValue.t -> bool

whether the address has a non-empty set of edges

val canonicalize : get_var_repr:(Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.AbstractValue.t) -> t -> t Pulselib.PulseBasicInterface.SatUnsat.t

replace each address in the heap by its canonical representative according to the current equality relation, represented by get_var_repr; also remove addresses that point to empty edges

val subst_var : (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.AbstractValue.t) -> t -> t Pulselib.PulseBasicInterface.SatUnsat.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib__PulseBaseStack/index.html b/website/static/odoc/next/infer/Pulselib__PulseBaseStack/index.html index f9e01fa69..4cc568119 100644 --- a/website/static/odoc/next/infer/Pulselib__PulseBaseStack/index.html +++ b/website/static/odoc/next/infer/Pulselib__PulseBaseStack/index.html @@ -1,2 +1,2 @@ -Pulselib__PulseBaseStack (infer.Pulselib__PulseBaseStack)

Module Pulselib__PulseBaseStack

module F = Stdlib.Format
include IStdlib.PrettyPrintable.MonoMap with type key = IR.Var.t and type value = Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.ValueHistory.t
type key = IR.Var.t
type value = Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.ValueHistory.t
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val compare : t -> t -> int
val equal : t -> t -> bool
val pp : F.formatter -> t -> unit
val yojson_of_t : t -> Yojson.Safe.t
val canonicalize : get_var_repr:(Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.AbstractValue.t) -> t -> t Pulselib.PulseBasicInterface.SatUnsat.t

replace each address in the stack by its canonical representative according to the current equality relation, represented by get_var_repr

val subst_var : (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.AbstractValue.t) -> t -> t Pulselib.PulseBasicInterface.SatUnsat.t
\ No newline at end of file +Pulselib__PulseBaseStack (infer.Pulselib__PulseBaseStack)

Module Pulselib__PulseBaseStack

module F = Stdlib.Format
include IStdlib.PrettyPrintable.MonoMap with type key = IR.Var.t and type value = Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.ValueHistory.t
type key = IR.Var.t
type value = Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.ValueHistory.t
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
val compare : t -> t -> int
val equal : t -> t -> bool
val pp : F.formatter -> t -> unit
val yojson_of_t : t -> Yojson.Safe.t
val canonicalize : get_var_repr:(Pulselib.PulseBasicInterface.AbstractValue.t -> Pulselib.PulseBasicInterface.AbstractValue.t) -> t -> t Pulselib.PulseBasicInterface.SatUnsat.t

replace each address in the stack by its canonical representative according to the current equality relation, represented by get_var_repr

val subst_var : (Pulselib.PulseBasicInterface.AbstractValue.t * Pulselib.PulseBasicInterface.AbstractValue.t) -> t -> t Pulselib.PulseBasicInterface.SatUnsat.t
\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib__PulseFormula/index.html b/website/static/odoc/next/infer/Pulselib__PulseFormula/index.html index f6f6f9063..4df7d3bef 100644 --- a/website/static/odoc/next/infer/Pulselib__PulseFormula/index.html +++ b/website/static/odoc/next/infer/Pulselib__PulseFormula/index.html @@ -1,2 +1,2 @@ -Pulselib__PulseFormula (infer.Pulselib__PulseFormula)

Module Pulselib__PulseFormula

module F = Stdlib.Format
module SatUnsat = Pulselib.PulseSatUnsat

Arithmetic solver

Build formulas from SIL and tries to decide if they are (mostly un-)satisfiable.

type t
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
val pp : F.formatter -> t -> unit
val pp_with_pp_var : (F.formatter -> Var.t -> unit) -> F.formatter -> t -> unit

only used for unit tests

type operand =
| LiteralOperand of IR.IntLit.t
| AbstractValueOperand of Var.t

Build formulas

type new_eq =
| EqZero of Var.t
| Equal of Var.t * Var.t

some operations will return a set of new facts discovered that are relevant to communicate to the memory domain

type new_eqs = new_eq list
val ttrue : t
val and_equal : operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_equal_instanceof : Var.t -> Var.t -> IR.Typ.t -> t -> (t * new_eqs) SatUnsat.t
val and_less_equal : operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_less_than : operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_equal_unop : Var.t -> IR.Unop.t -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_equal_binop : Var.t -> IR.Binop.t -> operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val prune_binop : negated:bool -> IR.Binop.t -> operand -> operand -> t -> (t * new_eqs) SatUnsat.t

Operations

val normalize : IR.Tenv.t -> get_dynamic_type:(Var.t -> IR.Typ.t option) -> t -> (t * new_eqs) SatUnsat.t

think a bit harder about the formula

val simplify : IR.Tenv.t -> get_dynamic_type:(Var.t -> IR.Typ.t option) -> can_be_pruned:Var.Set.t -> keep:Var.Set.t -> t -> (t * new_eqs) SatUnsat.t
val and_fold_subst_variables : t -> up_to_f:t -> init:'acc -> f:('acc -> Var.t -> 'acc * Var.t) -> ('acc * t * new_eqs) SatUnsat.t
val is_known_zero : t -> Var.t -> bool
val has_no_assumptions : t -> bool
val get_var_repr : t -> Var.t -> Var.t

get the canonical representative for the variable according to the equality relation

\ No newline at end of file +Pulselib__PulseFormula (infer.Pulselib__PulseFormula)

Module Pulselib__PulseFormula

module F = Stdlib.Format
module SatUnsat = Pulselib.PulseSatUnsat

Arithmetic solver

Build formulas from SIL and tries to decide if they are (mostly un-)satisfiable.

type t
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
val pp : F.formatter -> t -> unit
val pp_with_pp_var : (F.formatter -> Var.t -> unit) -> F.formatter -> t -> unit

only used for unit tests

type operand =
| LiteralOperand of IR.IntLit.t
| AbstractValueOperand of Var.t

Build formulas

type new_eq =
| EqZero of Var.t
| Equal of Var.t * Var.t

some operations will return a set of new facts discovered that are relevant to communicate to the memory domain

type new_eqs = new_eq list
val ttrue : t
val and_equal : operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_equal_instanceof : Var.t -> Var.t -> IR.Typ.t -> t -> (t * new_eqs) SatUnsat.t
val and_less_equal : operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_less_than : operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_equal_unop : Var.t -> IR.Unop.t -> operand -> t -> (t * new_eqs) SatUnsat.t
val and_equal_binop : Var.t -> IR.Binop.t -> operand -> operand -> t -> (t * new_eqs) SatUnsat.t
val prune_binop : negated:bool -> IR.Binop.t -> operand -> operand -> t -> (t * new_eqs) SatUnsat.t

Operations

val normalize : IR.Tenv.t -> get_dynamic_type:(Var.t -> IR.Typ.t option) -> t -> (t * new_eqs) SatUnsat.t

think a bit harder about the formula

val simplify : IR.Tenv.t -> get_dynamic_type:(Var.t -> IR.Typ.t option) -> can_be_pruned:Var.Set.t -> keep:Var.Set.t -> t -> (t * Var.Set.t * new_eqs) SatUnsat.t
val and_fold_subst_variables : t -> up_to_f:t -> init:'acc -> f:('acc -> Var.t -> 'acc * Var.t) -> ('acc * t * new_eqs) SatUnsat.t
val is_known_zero : t -> Var.t -> bool
val has_no_assumptions : t -> bool
val get_known_var_repr : t -> Var.t -> Var.t

get the canonical representative for the variable according to the known/post equality relation

val get_both_var_repr : t -> Var.t -> Var.t

get the canonical representative for the variable according to the both/pre+post equality relation

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib__PulsePathCondition/index.html b/website/static/odoc/next/infer/Pulselib__PulsePathCondition/index.html index de50d70c5..53eb6c47b 100644 --- a/website/static/odoc/next/infer/Pulselib__PulsePathCondition/index.html +++ b/website/static/odoc/next/infer/Pulselib__PulsePathCondition/index.html @@ -1,2 +1,2 @@ -Pulselib__PulsePathCondition (infer.Pulselib__PulsePathCondition)

Module Pulselib__PulsePathCondition

module F = Stdlib.Format
module AbstractValue = Pulselib.PulseAbstractValue
module SatUnsat = Pulselib.PulseSatUnsat
module ValueHistory = Pulselib.PulseValueHistory
type t
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
val true_ : t
val false_ : t
val pp : F.formatter -> t -> unit
type new_eqs = Pulselib.PulseFormula.new_eqs

Building arithmetic constraints

val and_nonnegative : AbstractValue.t -> t -> t * new_eqs

and_nonnegative v phi is phi ∧ v≥0

val and_positive : AbstractValue.t -> t -> t * new_eqs

and_positive v phi is phi ∧ v>0

val and_eq_int : AbstractValue.t -> IR.IntLit.t -> t -> t * new_eqs

and_eq_int v i phi is phi ∧ v=i

val and_eq_vars : AbstractValue.t -> AbstractValue.t -> t -> t * new_eqs
val simplify : IR.Tenv.t -> can_be_pruned:AbstractValue.Set.t -> keep:AbstractValue.Set.t -> get_dynamic_type:(AbstractValue.t -> IR.Typ.t option) -> t -> (t * new_eqs) SatUnsat.t

simplify ~can_be_pruned ~keep phi attempts to get rid of as many variables in fv phi but not in keep as possible, and tries to eliminate variables not in can_be_pruned from the "pruned" part of the formula

val and_callee : (AbstractValue.t * ValueHistory.t) AbstractValue.Map.t -> t -> callee:t -> (AbstractValue.t * ValueHistory.t) AbstractValue.Map.t * t * new_eqs

Operations

type operand =
| LiteralOperand of IR.IntLit.t
| AbstractValueOperand of AbstractValue.t
val compare_operand : operand -> operand -> int
val pp_operand : IStdlib.IStd.Formatter.t -> operand -> unit
val eval_binop : AbstractValue.t -> IR.Binop.t -> operand -> operand -> t -> t * new_eqs
val eval_unop : AbstractValue.t -> IR.Unop.t -> AbstractValue.t -> t -> t * new_eqs
val prune_binop : negated:bool -> IR.Binop.t -> operand -> operand -> t -> t * new_eqs
val and_eq_instanceof : AbstractValue.t -> AbstractValue.t -> IR.Typ.t -> t -> t * new_eqs

Queries

val is_known_zero : t -> AbstractValue.t -> bool

is_known_zero phi t returns true if phi |- t = 0, false if we don't know for sure

val is_known_not_equal_zero : t -> AbstractValue.t -> bool

is_known_not_equal_zero phi t returns true if phi |- t != 0, false if we don't know for sure

val is_unsat_cheap : t -> bool

whether the state contains a contradiction, call this as often as you want

val is_unsat_expensive : IR.Tenv.t -> get_dynamic_type:(AbstractValue.t -> IR.Typ.t option) -> t -> t * bool * new_eqs

whether the state contains a contradiction, only call this when you absolutely have to

val has_no_assumptions : t -> bool

whether the current path is independent of any calling context

val get_var_repr : t -> AbstractValue.t -> AbstractValue.t

get the canonical representative for the variable according to the equality relation

\ No newline at end of file +Pulselib__PulsePathCondition (infer.Pulselib__PulsePathCondition)

Module Pulselib__PulsePathCondition

module F = Stdlib.Format
module AbstractValue = Pulselib.PulseAbstractValue
module SatUnsat = Pulselib.PulseSatUnsat
module ValueHistory = Pulselib.PulseValueHistory
type t
val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Ppx_yojson_conv_lib.Yojson.Safe.t
val true_ : t
val false_ : t
val pp : F.formatter -> t -> unit
type new_eqs = Pulselib.PulseFormula.new_eqs

Building arithmetic constraints

val and_nonnegative : AbstractValue.t -> t -> t * new_eqs

and_nonnegative v phi is phi ∧ v≥0

val and_positive : AbstractValue.t -> t -> t * new_eqs

and_positive v phi is phi ∧ v>0

val and_eq_int : AbstractValue.t -> IR.IntLit.t -> t -> t * new_eqs

and_eq_int v i phi is phi ∧ v=i

val and_eq_vars : AbstractValue.t -> AbstractValue.t -> t -> t * new_eqs
val simplify : IR.Tenv.t -> can_be_pruned:AbstractValue.Set.t -> keep:AbstractValue.Set.t -> get_dynamic_type:(AbstractValue.t -> IR.Typ.t option) -> t -> (t * AbstractValue.Set.t * new_eqs) SatUnsat.t

simplify ~can_be_pruned ~keep phi attempts to get rid of as many variables in fv phi but not in keep as possible, and tries to eliminate variables not in can_be_pruned from the "pruned" part of the formula

val and_callee : (AbstractValue.t * ValueHistory.t) AbstractValue.Map.t -> t -> callee:t -> (AbstractValue.t * ValueHistory.t) AbstractValue.Map.t * t * new_eqs

Operations

type operand =
| LiteralOperand of IR.IntLit.t
| AbstractValueOperand of AbstractValue.t
val compare_operand : operand -> operand -> int
val pp_operand : IStdlib.IStd.Formatter.t -> operand -> unit
val eval_binop : AbstractValue.t -> IR.Binop.t -> operand -> operand -> t -> t * new_eqs
val eval_unop : AbstractValue.t -> IR.Unop.t -> AbstractValue.t -> t -> t * new_eqs
val prune_binop : negated:bool -> IR.Binop.t -> operand -> operand -> t -> t * new_eqs
val and_eq_instanceof : AbstractValue.t -> AbstractValue.t -> IR.Typ.t -> t -> t * new_eqs

Queries

val is_known_zero : t -> AbstractValue.t -> bool

is_known_zero phi t returns true if phi |- t = 0, false if we don't know for sure

val is_known_not_equal_zero : t -> AbstractValue.t -> bool

is_known_not_equal_zero phi t returns true if phi |- t != 0, false if we don't know for sure

val is_unsat_cheap : t -> bool

whether the state contains a contradiction, call this as often as you want

val is_unsat_expensive : IR.Tenv.t -> get_dynamic_type:(AbstractValue.t -> IR.Typ.t option) -> t -> t * bool * new_eqs

whether the state contains a contradiction, only call this when you absolutely have to

val has_no_assumptions : t -> bool

whether the current path is independent of any calling context

val get_known_var_repr : t -> AbstractValue.t -> AbstractValue.t

get the canonical representative for the variable according to the equality relation in the "known" part of the formula

val get_both_var_repr : t -> AbstractValue.t -> AbstractValue.t

get the canonical representative for the variable according to the equality relation in the "both" (known + pruned) part of the formula

\ No newline at end of file diff --git a/website/static/odoc/next/infer/Pulselib__PulseSkippedCalls/index.html b/website/static/odoc/next/infer/Pulselib__PulseSkippedCalls/index.html index a4f273f21..c58361e25 100644 --- a/website/static/odoc/next/infer/Pulselib__PulseSkippedCalls/index.html +++ b/website/static/odoc/next/infer/Pulselib__PulseSkippedCalls/index.html @@ -1,2 +1,2 @@ -Pulselib__PulseSkippedCalls (infer.Pulselib__PulseSkippedCalls)

Module Pulselib__PulseSkippedCalls

include Absint.AbstractDomain.MapS with type key = IR.Procname.t and type value = Pulselib.PulseTrace.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Yojson.Safe.t
\ No newline at end of file +Pulselib__PulseSkippedCalls (infer.Pulselib__PulseSkippedCalls)

Module Pulselib__PulseSkippedCalls

include Absint.AbstractDomain.MapS with type key = IR.Procname.t and type value = Pulselib.PulseTrace.t
include IStdlib.PrettyPrintable.PPMonoMap
include IStdlib.PrettyPrintable.MonoMap
type key
type value
type t
val empty : t
val is_empty : t -> bool
val mem : key -> t -> bool
val add : key -> value -> t -> t
val update : key -> (value option -> value option) -> t -> t
val singleton : key -> value -> t
val remove : key -> t -> t
val merge : (key -> value option -> value option -> value option) -> t -> t -> t
val union : (key -> value -> value -> value option) -> t -> t -> t
val compare : (value -> value -> int) -> t -> t -> int
val equal : (value -> value -> bool) -> t -> t -> bool
val iter : (key -> value -> unit) -> t -> unit
val fold : (key -> value -> 'a -> 'a) -> t -> 'a -> 'a
val for_all : (key -> value -> bool) -> t -> bool
val exists : (key -> value -> bool) -> t -> bool
val filter : (key -> value -> bool) -> t -> t
val filter_map : (key -> value -> value option) -> t -> t
val partition : (key -> value -> bool) -> t -> t * t
val cardinal : t -> int
val bindings : t -> (key * value) list
val min_binding : t -> key * value
val min_binding_opt : t -> (key * value) option
val max_binding : t -> key * value
val max_binding_opt : t -> (key * value) option
val choose : t -> key * value
val choose_opt : t -> (key * value) option
val split : key -> t -> t * value option * t
val find : key -> t -> value
val find_opt : key -> t -> value option
val find_first : (key -> bool) -> t -> key * value
val find_first_opt : (key -> bool) -> t -> (key * value) option
val find_last : (key -> bool) -> t -> key * value
val find_last_opt : (key -> bool) -> t -> (key * value) option
val map : (value -> value) -> t -> t
val mapi : (key -> value -> value) -> t -> t
val is_singleton_or_more : t -> (key * value) IStdlib.IContainer.singleton_or_more
val fold_map : t -> init:'a -> f:('a -> value -> 'a * value) -> 'a * t
val fold_mapi : t -> init:'a -> f:(key -> 'a -> value -> 'a * value) -> 'a * t
val of_seq : (key * value) Stdlib.Seq.t -> t
val to_seq : t -> (key * value) Stdlib.Seq.t
include IStdlib.PrettyPrintable.PrintableType with type t := t
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val pp_key : IStdlib.PrettyPrintable.F.formatter -> key -> unit
include Absint.AbstractDomain.WithBottom with type t := t
include Absint.AbstractDomain.S
include Absint.AbstractDomain.NoJoin
include IStdlib.PrettyPrintable.PrintableType
type t
val pp : IStdlib.PrettyPrintable.F.formatter -> t -> unit
val leq : lhs:t -> rhs:t -> bool

the implication relation: lhs <= rhs means lhs |- rhs

val join : t -> t -> t
val widen : prev:t -> next:t -> num_iters:int -> t
val bottom : t

The bottom value of the domain.

val is_bottom : t -> bool

Return true if this is the bottom value

val compare : t -> t -> int
val equal : t -> t -> bool
val yojson_of_t : t -> Yojson.Safe.t
\ No newline at end of file