Enum AbsLoc 

pub enum AbsLoc {
    Top,
    Alloc(BodyId, u32),
    Param(BodyId, usize),
    SelfParam(BodyId),
    Field {
        parent: LocId,
        field: FieldId,
    },
}

Abstract heap location in the points-to lattice.

A pointer-targets-this kind of fact. Cyclic field chains (e.g. a.next.next.…) are bounded by MAX_FIELD_DEPTH; once the cap is exceeded the chain folds to AbsLoc::Top.

Variants

Top

“Anywhere”, the over-approximation used when precision is unrecoverable (e.g. a value sourced from outside the analysed body, or a points-to set that exceeded the cap).

Alloc(BodyId, u32)

Allocation site within a body, identified by the SSA value of the defining instruction. SSA guarantees a single definition per value, so the SSA value uniquely names the allocation site.

body disambiguates allocations across bodies in the same file. The interned u32 is the SsaValue.0 of the call / constructor instruction.

Param(BodyId, usize)

Function parameter, the abstract identity of the value supplied by the caller for parameter index. The receiver (self / this) uses AbsLoc::SelfParam instead.

SelfParam(BodyId)

Implicit method receiver (self / this). Distinct from Param(_, _) so callers don’t have to encode an “is the receiver” sentinel index.

Field

Heap field of a parent location: parent.f. parent is itself a LocId, chains of field accesses produce nested Field locations. Depth is bounded by MAX_FIELD_DEPTH.

Fields

parent: LocId

field: FieldId

Trait Implementations

impl Clone for AbsLoc

fn clone(&self) -> AbsLoc

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for AbsLoc

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Hash for AbsLoc

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for AbsLoc

fn eq(&self, other: &AbsLoc) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for AbsLoc

impl StructuralPartialEq for AbsLoc