Struct rustc_middle::mir::interpret::ConstAllocation

source ·

pub struct ConstAllocation<'tcx>(pub Interned<'tcx, Allocation>);

Expand description

Interned types generally have an Outer type and an Inner type, where Outer is a newtype around Interned<Inner>, and all the operations are done on Outer, because all occurrences are interned. E.g. Ty is an outer type and TyKind is its inner type.

Here things are different because only const allocations are interned. This means that both the inner type (Allocation) and the outer type (ConstAllocation) are used quite a bit.

Tuple Fields§

§0: Interned<'tcx, Allocation>

Struct rustc_middle::mir::interpret::ConstAllocation

Tuple Fields§

Implementations§

impl<'tcx> ConstAllocation<'tcx>

pub fn inner(self) -> &'tcx Allocation

Trait Implementations§

impl<'tcx> Clone for ConstAllocation<'tcx>

fn clone(&self) -> ConstAllocation<'tcx>

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

impl<'tcx> Debug for ConstAllocation<'tcx>

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

impl<'tcx, D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<D> for ConstAllocation<'tcx>

fn decode(decoder: &mut D) -> Self

impl<'tcx, E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<E> for ConstAllocation<'tcx>

fn encode(&self, e: &mut E)

impl<'tcx> Hash for ConstAllocation<'tcx>

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

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

impl<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for ConstAllocation<'tcx>

fn hash_stable( &self, __hcx: &mut StableHashingContext<'__ctx>, __hasher: &mut StableHasher )

impl<'a, 'tcx> Lift<'tcx> for ConstAllocation<'a>

type Lifted = ConstAllocation<'tcx>

fn lift_to_tcx(self, tcx: TyCtxt<'tcx>) -> Option<Self::Lifted>

impl<'tcx> PartialEq<ConstAllocation<'tcx>> for ConstAllocation<'tcx>

fn eq(&self, other: &ConstAllocation<'tcx>) -> bool

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

impl<'tcx> Copy for ConstAllocation<'tcx>

impl<'tcx> Eq for ConstAllocation<'tcx>

impl<'tcx> StructuralEq for ConstAllocation<'tcx>

impl<'tcx> StructuralPartialEq for ConstAllocation<'tcx>

Auto Trait Implementations§

impl<'tcx> RefUnwindSafe for ConstAllocation<'tcx>

impl<'tcx> Send for ConstAllocation<'tcx>

impl<'tcx> Sync for ConstAllocation<'tcx>

impl<'tcx> Unpin for ConstAllocation<'tcx>

impl<'tcx> UnwindSafe for ConstAllocation<'tcx>

Blanket Implementations§

impl<T> Aligned for T

const ALIGN: Alignment = _

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

fn type_id(&self) -> TypeId

impl<'tcx, T> ArenaAllocatable<'tcx, IsCopy> for Twhere T: Copy,

fn allocate_on<'a>(self, arena: &'a Arena<'tcx>) -> &'a mut T

fn allocate_from_iter<'a>( arena: &'a Arena<'tcx>, iter: impl IntoIterator<Item = T> ) -> &'a mut [T]

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<Tcx, T> DepNodeParams<Tcx> for Twhere Tcx: DepContext, T: for<'a> HashStable<StableHashingContext<'a>> + Debug,

default fn fingerprint_style() -> FingerprintStyle

default fn to_fingerprint(&self, tcx: Tcx) -> Fingerprint

default fn to_debug_str(&self, _: Tcx) -> String

default fn recover(_: Tcx, _: &DepNode) -> Option<T>

impl<T> From<T> for T

fn from(t: T) -> T

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

fn into(self) -> U

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> ToOwned for Twhere T: Clone,

type Owned = T

fn to_owned(&self) -> T

fn clone_into(&self, target: &mut T)

impl<'tcx, T> ToPredicate<'tcx, T> for T

fn to_predicate(self, _tcx: TyCtxt<'tcx>) -> 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<Tcx, T> Value<Tcx> for Twhere Tcx: DepContext,

default fn from_cycle_error( tcx: Tcx, cycle: &[QueryInfo], _guar: ErrorGuaranteed ) -> T

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

impl<'tcx, 'ctx> HashStable<StableHashingContext<'ctx>> for ConstAllocation<'tcx>

fn hash_stable( &self, hcx: &mut StableHashingContext<'ctx>, __hasher: &mut StableHasher )