Struct rustc_middle::ty::consts::kind::UnevaluatedConst

pub struct UnevaluatedConst<'tcx> {
    pub def: DefId,
    pub args: GenericArgsRef<'tcx>,
}

An unevaluated (potentially generic) constant used in the type-system.

Fields

def: DefId

args: GenericArgsRef<'tcx>

Implementations

impl<'tcx> UnevaluatedConst<'tcx>

pub(crate) fn prepare_for_eval( self, tcx: TyCtxt<'tcx>, param_env: ParamEnv<'tcx> ) -> (ParamEnv<'tcx>, Self)

FIXME(RalfJung): I cannot explain what this does or why it makes sense, but not doing this hurts performance.

impl<'tcx> UnevaluatedConst<'tcx>

pub fn new(def: DefId, args: GenericArgsRef<'tcx>) -> UnevaluatedConst<'tcx>

Trait Implementations

impl<'tcx> Clone for UnevaluatedConst<'tcx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for UnevaluatedConst<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> DebugWithInfcx<TyCtxt<'tcx>> for UnevaluatedConst<'tcx>

fn fmt<Infcx: InferCtxtLike<Interner = TyCtxt<'tcx>>>( this: WithInfcx<'_, Infcx, &Self>, f: &mut Formatter<'_> ) -> Result

impl<'tcx, __D: TyDecoder<I = TyCtxt<'tcx>>> Decodable<__D> for UnevaluatedConst<'tcx>

fn decode(__decoder: &mut __D) -> Self

impl<'tcx, __E: TyEncoder<I = TyCtxt<'tcx>>> Encodable<__E> for UnevaluatedConst<'tcx>

fn encode(&self, __encoder: &mut __E)

impl<'tcx> EraseType for UnevaluatedConst<'tcx>

type Result = [u8; 16]

impl<'tcx> Hash for UnevaluatedConst<'tcx>

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<'tcx, '__ctx> HashStable<StableHashingContext<'__ctx>> for UnevaluatedConst<'tcx>

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

impl IntoDiagArg for UnevaluatedConst<'_>

fn into_diag_arg(self) -> DiagArgValue

impl<'tcx> PartialEq for UnevaluatedConst<'tcx>

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

This method tests for self and other values to be equal, and is used by ==.

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

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

impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for UnevaluatedConst<'tcx>

fn try_fold_with<__F: FallibleTypeFolder<TyCtxt<'tcx>>>( self, __folder: &mut __F ) -> Result<Self, __F::Error>

The entry point for folding. To fold a value t with a folder f call: t.try_fold_with(f).

fn fold_with<F>(self, folder: &mut F) -> Self

where F: TypeFolder<I>,

A convenient alternative to try_fold_with for use with infallible folders. Do not override this method, to ensure coherence with try_fold_with.

impl<'tcx> TypeSuperVisitable<TyCtxt<'tcx>> for UnevaluatedConst<'tcx>

fn super_visit_with<V: TypeVisitor<TyCtxt<'tcx>>>( &self, visitor: &mut V ) -> V::Result

Provides a default visit for a recursive type of interest. This should only be called within TypeVisitor methods, when a non-custom traversal is desired for the value of the type of interest passed to that method. For example, in MyVisitor::visit_ty(ty), it is valid to call ty.super_visit_with(self), but any other visiting should be done with xyz.visit_with(self).

impl<'tcx> TypeVisitable<TyCtxt<'tcx>> for UnevaluatedConst<'tcx>

fn visit_with<__V: TypeVisitor<TyCtxt<'tcx>>>( &self, __visitor: &mut __V ) -> __V::Result

The entry point for visiting. To visit a value t with a visitor v call: t.visit_with(v).

impl<'tcx> Copy for UnevaluatedConst<'tcx>

impl<'tcx> Eq for UnevaluatedConst<'tcx>

impl<'tcx> StructuralPartialEq for UnevaluatedConst<'tcx>

Layout

Note: Most layout information is completely unstable and may even differ between compilations. The only exception is types with certain repr(...) attributes. Please see the Rust Reference's “Type Layout” chapter for details on type layout guarantees.

Size: 16 bytes