Struct Results

Source

pub struct Results<'tcx, A>where
    A: Analysis<'tcx>,{
    pub analysis: A,
    pub entry_states: EntryStates<A::Domain>,
}

Expand description

The results of a dataflow analysis that has converged to fixpoint. It holds the domain values (states) at the entry of each basic block. Domain values in other parts of the block are recomputed on the fly by visitors (i.e. ResultsCursor, or ResultsVisitor impls). The analysis is also present because it’s often needed alongside the entry states.

Fields§

§analysis: A§entry_states: EntryStates<A::Domain>

Results

Struct Results Copy item path

Fields§

Implementations§

impl<'tcx, A> Results<'tcx, A>where A: Analysis<'tcx>,

pub fn into_results_cursor<'mir>( self, body: &'mir Body<'tcx>, ) -> ResultsCursor<'mir, 'tcx, A>

Auto Trait Implementations§

impl<'tcx, A> DynSend for Results<'tcx, A>where A: DynSend, <A as Analysis<'tcx>>::Domain: DynSend,

impl<'tcx, A> DynSync for Results<'tcx, A>where A: DynSync, <A as Analysis<'tcx>>::Domain: DynSync,

impl<'tcx, A> Freeze for Results<'tcx, A>where A: Freeze,

impl<'tcx, A> RefUnwindSafe for Results<'tcx, A>where A: RefUnwindSafe, <A as Analysis<'tcx>>::Domain: RefUnwindSafe,

impl<'tcx, A> Send for Results<'tcx, A>where A: Send, <A as Analysis<'tcx>>::Domain: Send,

impl<'tcx, A> Sync for Results<'tcx, A>where A: Sync, <A as Analysis<'tcx>>::Domain: Sync,

impl<'tcx, A> Unpin for Results<'tcx, A>where A: Unpin, <A as Analysis<'tcx>>::Domain: Unpin,

impl<'tcx, A> UnwindSafe for Results<'tcx, A>where A: UnwindSafe, <A as Analysis<'tcx>>::Domain: UnwindSafe,

Blanket Implementations§

impl<T> Aligned for T

const ALIGN: Alignment

impl<T> Any for Twhere T: 'static + ?Sized,

fn type_id(&self) -> TypeId

impl<T> Borrow<T> for Twhere T: ?Sized,

fn borrow(&self) -> &T

impl<T> BorrowMut<T> for Twhere T: ?Sized,

fn borrow_mut(&mut self) -> &mut T

impl<T, R> CollectAndApply<T, R> for T

fn collect_and_apply<I, F>(iter: I, f: F) -> Rwhere I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

type Output = R

impl<T> From<T> for T

fn from(t: T) -> T

impl<T> Instrument for T

fn instrument(self, span: Span) -> Instrumented<Self>

fn in_current_span(self) -> Instrumented<Self>

impl<T, U> Into<U> for Twhere U: From<T>,

fn into(self) -> U

impl<T> IntoEither for T

fn into_either(self, into_left: bool) -> Either<Self, Self>

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>where F: FnOnce(&Self) -> bool,

impl<P> IntoQueryParam<P> for P

fn into_query_param(self) -> P

impl<T> MaybeResult<T> for T

type Error = !

fn from(_: Result<T, <T as MaybeResult<T>>::Error>) -> T

fn to_result(self) -> Result<T, <T as MaybeResult<T>>::Error>

impl<T> Pointable for T

const ALIGN: usize

type Init = T

unsafe fn init(init: <T as Pointable>::Init) -> usize

unsafe fn deref<'a>(ptr: usize) -> &'a T

unsafe fn deref_mut<'a>(ptr: usize) -> &'a mut T

unsafe fn drop(ptr: usize)

impl<T> Same for T

type Output = T

impl<T, U> TryFrom<U> for Twhere U: Into<T>,

type Error = Infallible

fn try_from(value: U) -> Result<T, <T as TryFrom<U>>::Error>

impl<T, U> TryInto<U> for Twhere U: TryFrom<T>,

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

fn try_into(self) -> Result<U, <U as TryFrom<T>>::Error>

impl<I, T, U> Upcast<I, U> for Twhere U: UpcastFrom<I, T>,

fn upcast(self, interner: I) -> U

impl<I, T> UpcastFrom<I, T> for T

fn upcast_from(from: T, _tcx: I) -> T

impl<V, T> VZip<V> for Twhere V: MultiLane<T>,

fn vzip(self) -> V

impl<Tcx, T> Value<Tcx> for Twhere Tcx: DepContext,

default fn from_cycle_error( tcx: Tcx, cycle_error: &CycleError, _guar: ErrorGuaranteed, ) -> T

impl<T> WithSubscriber for T

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>where S: Into<Dispatch>,

fn with_current_subscriber(self) -> WithDispatch<Self>

impl<T> ErasedDestructor for Twhere T: 'static,

Layout§

Struct Results

impl<'tcx, A> Results<'tcx, A>
where A: Analysis<'tcx>,

impl<'tcx, A> DynSend for Results<'tcx, A>
where A: DynSend, <A as Analysis<'tcx>>::Domain: DynSend,

impl<'tcx, A> DynSync for Results<'tcx, A>
where A: DynSync, <A as Analysis<'tcx>>::Domain: DynSync,

impl<'tcx, A> Freeze for Results<'tcx, A>
where A: Freeze,

impl<'tcx, A> RefUnwindSafe for Results<'tcx, A>
where A: RefUnwindSafe, <A as Analysis<'tcx>>::Domain: RefUnwindSafe,

impl<'tcx, A> Send for Results<'tcx, A>
where A: Send, <A as Analysis<'tcx>>::Domain: Send,

impl<'tcx, A> Sync for Results<'tcx, A>
where A: Sync, <A as Analysis<'tcx>>::Domain: Sync,

impl<'tcx, A> Unpin for Results<'tcx, A>
where A: Unpin, <A as Analysis<'tcx>>::Domain: Unpin,

impl<'tcx, A> UnwindSafe for Results<'tcx, A>
where A: UnwindSafe, <A as Analysis<'tcx>>::Domain: UnwindSafe,

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

impl<T> Borrow<T> for T
where T: ?Sized,

impl<T> BorrowMut<T> for T
where T: ?Sized,

fn collect_and_apply<I, F>(iter: I, f: F) -> R
where I: Iterator<Item = T>, F: FnOnce(&[T]) -> R,

impl<T, U> Into<U> for T
where U: From<T>,

fn into_either_with<F>(self, into_left: F) -> Either<Self, Self>
where F: FnOnce(&Self) -> bool,

impl<T, U> TryFrom<U> for T
where U: Into<T>,

impl<T, U> TryInto<U> for T
where U: TryFrom<T>,

impl<I, T, U> Upcast<I, U> for T
where U: UpcastFrom<I, T>,

impl<V, T> VZip<V> for T
where V: MultiLane<T>,

impl<Tcx, T> Value<Tcx> for T
where Tcx: DepContext,

fn with_subscriber<S>(self, subscriber: S) -> WithDispatch<Self>
where S: Into<Dispatch>,

impl<T> ErasedDestructor for T
where T: 'static,