[−][src]Struct polonius_engine::AllFacts

pub struct AllFacts<R: Atom, L: Atom, P: Atom, V: Atom, M: Atom> {
    pub borrow_region: Vec<(R, L, P)>,
    pub universal_region: Vec<R>,
    pub cfg_edge: Vec<(P, P)>,
    pub killed: Vec<(L, P)>,
    pub outlives: Vec<(R, R, P)>,
    pub invalidates: Vec<(P, L)>,
    pub var_used: Vec<(V, P)>,
    pub var_defined: Vec<(V, P)>,
    pub var_drop_used: Vec<(V, P)>,
    pub var_uses_region: Vec<(V, R)>,
    pub var_drops_region: Vec<(V, R)>,
    pub child: Vec<(M, M)>,
    pub path_belongs_to_var: Vec<(M, V)>,
    pub initialized_at: Vec<(M, P)>,
    pub moved_out_at: Vec<(M, P)>,
    pub path_accessed_at: Vec<(M, P)>,
}

The "facts" which are the basis of the NLL borrow analysis.

Fields

borrow_region: Vec<(R, L, P)>

borrow_region(R, B, P) -- the region R may refer to data from borrow B starting at the point P (this is usually the point after a borrow rvalue)

universal_region: Vec<R>

universal_region(R) -- this is a "free region" within fn body

cfg_edge: Vec<(P, P)>

cfg_edge(P,Q) for each edge P -> Q in the control flow

killed: Vec<(L, P)>

killed(B,P) when some prefix of the path borrowed at B is assigned at point P

outlives: Vec<(R, R, P)>

outlives(R1, R2, P) when we require R1@P: R2@P

invalidates: Vec<(P, L)>

invalidates(P, L) when the loan L is invalidated at point P

var_used: Vec<(V, P)>

var_used(V, P) when the variable V is used for anything but a drop at point P

var_defined: Vec<(V, P)>

var_defined(V, P) when the variable V is overwritten by the point P

var_drop_used: Vec<(V, P)>

var_used(V, P) when the variable V is used in a drop at point P

var_uses_region: Vec<(V, R)>

var_uses_region(V, R) when the type of V includes the region R

var_drops_region: Vec<(V, R)>

var_drops_region(V, R) when the type of V includes the region R and uses it when dropping

child: Vec<(M, M)>

child(M1, M2) when the move path M1is the direct or transitive child ofM2, e.g. child(x.y, x), child(x.y.z, x.y), child(x.y.z, x)would all be true if there was a path likex.y.z`.

path_belongs_to_var: Vec<(M, V)>

path_belongs_to_var(M, V) the root path Mstarting in variableV`.

initialized_at: Vec<(M, P)>

initialized_at(M, P) when the move path Mwas initialized at pointP. This fact is only emitted for a prefix M, and not for the implicit initialization of all of M's children. E.g. a statement like x.y = 3at pointPwould give the factinitialized_at(x.y, P)(but neitherinitialized_at(x.y.z, P)norinitialized_at(x, P)`).

moved_out_at: Vec<(M, P)>

moved_out_at(M, P) when the move path Mwas moved at pointP. The same logic is applied as for initialized_at` above.

path_accessed_at: Vec<(M, P)>

path_accessed_at(M, P) when the move path Mwas accessed at pointP. The same logic as for initialized_atandmoved_out_at` applies.

Trait Implementations

impl<R: Atom, L: Atom, P: Atom, V: Atom, M: Atom> Default for AllFacts<R, L, P, V, M>[src]

impl<R: Clone + Atom, L: Clone + Atom, P: Clone + Atom, V: Clone + Atom, M: Clone + Atom> Clone for AllFacts<R, L, P, V, M>[src]

fn clone_from(&mut self, source: &Self)1.0.0[src]

Performs copy-assignment from source. Read more

impl<R: Debug + Atom, L: Debug + Atom, P: Debug + Atom, V: Debug + Atom, M: Debug + Atom> Debug for AllFacts<R, L, P, V, M>[src]

Auto Trait Implementations

impl<R, L, P, V, M> Send for AllFacts<R, L, P, V, M> where
    L: Send,
    M: Send,
    P: Send,
    R: Send,
    V: Send, 

impl<R, L, P, V, M> Unpin for AllFacts<R, L, P, V, M> where
    L: Unpin,
    M: Unpin,
    P: Unpin,
    R: Unpin,
    V: Unpin, 

impl<R, L, P, V, M> Sync for AllFacts<R, L, P, V, M> where
    L: Sync,
    M: Sync,
    P: Sync,
    R: Sync,
    V: Sync, 

impl<R, L, P, V, M> UnwindSafe for AllFacts<R, L, P, V, M> where
    L: UnwindSafe,
    M: UnwindSafe,
    P: UnwindSafe,
    R: UnwindSafe,
    V: UnwindSafe, 

impl<R, L, P, V, M> RefUnwindSafe for AllFacts<R, L, P, V, M> where
    L: RefUnwindSafe,
    M: RefUnwindSafe,
    P: RefUnwindSafe,
    R: RefUnwindSafe,
    V: RefUnwindSafe, 

Blanket Implementations

impl<T> From<T> for T[src]

impl<T, U> Into<U> for T where
    U: From<T>, [src]

impl<T> ToOwned for T where
    T: Clone, [src]

type Owned = T

The resulting type after obtaining ownership.

impl<T, U> TryFrom<U> for T where
    U: Into<T>, [src]

type Error = Infallible

The type returned in the event of a conversion error.

impl<T, U> TryInto<U> for T where
    U: TryFrom<T>, [src]

type Error = <U as TryFrom<T>>::Error

The type returned in the event of a conversion error.

impl<T> Borrow<T> for T where
    T: ?Sized, [src]

impl<T> BorrowMut<T> for T where
    T: ?Sized, [src]

impl<T> Any for T where
    T: 'static + ?Sized, [src]