Enum InhabitedPredicate

pub enum InhabitedPredicate<'tcx> {
    True,
    False,
    ConstIsZero(Const<'tcx>),
    NotInModule(DefId),
    GenericType(Ty<'tcx>),
    OpaqueType(OpaqueTypeKey<'tcx>),
    And(&'tcx [InhabitedPredicate<'tcx>; 2]),
    Or(&'tcx [InhabitedPredicate<'tcx>; 2]),
}

Represents whether some type is inhabited in a given context. Examples of uninhabited types are !, enum Void {}, or a struct containing either of those types. A type’s inhabitedness may depend on the ParamEnv as well as what types are visible in the current module.

Variants

True

Inhabited

False

Uninhabited

ConstIsZero(Const<'tcx>)

Uninhabited when a const value is non-zero. This occurs when there is an array of uninhabited items, but the array is inhabited if it is empty.

NotInModule(DefId)

Uninhabited if within a certain module. This occurs when an uninhabited type has restricted visibility.

GenericType(Ty<'tcx>)

Inhabited if some generic type is inhabited. These are replaced by calling Self::instantiate.

OpaqueType(OpaqueTypeKey<'tcx>)

Inhabited if either we don’t know the hidden type or we know it and it is inhabited.

And(&'tcx [InhabitedPredicate<'tcx>; 2])

A AND B

Or(&'tcx [InhabitedPredicate<'tcx>; 2])

A OR B

Implementations

impl<'tcx> InhabitedPredicate<'tcx>

pub fn apply( self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>, module_def_id: DefId, ) -> bool

Returns true if the corresponding type is inhabited in the given ParamEnv and module.

pub fn apply_revealing_opaque( self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>, module_def_id: DefId, reveal_opaque: &impl Fn(OpaqueTypeKey<'tcx>) -> Option<Ty<'tcx>>, ) -> bool

Returns true if the corresponding type is inhabited in the given ParamEnv and module, revealing opaques when possible.

pub fn apply_any_module( self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>, ) -> Option<bool>

Same as apply, but returns None if self contains a module predicate

pub fn apply_ignore_module( self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>, ) -> bool

Same as apply, but NotInModule(_) predicates yield false. That is, privately uninhabited types are considered always uninhabited.

fn apply_inner<E: Debug>( self, tcx: TyCtxt<'tcx>, typing_env: TypingEnv<'tcx>, eval_stack: &mut SmallVec<[Ty<'tcx>; 1]>, in_module: &impl Fn(DefId) -> Result<bool, E>, reveal_opaque: &impl Fn(OpaqueTypeKey<'tcx>) -> Option<Ty<'tcx>>, ) -> Result<bool, E>

pub fn and(self, tcx: TyCtxt<'tcx>, other: Self) -> Self

pub fn or(self, tcx: TyCtxt<'tcx>, other: Self) -> Self

pub fn all(tcx: TyCtxt<'tcx>, iter: impl IntoIterator<Item = Self>) -> Self

pub fn any(tcx: TyCtxt<'tcx>, iter: impl IntoIterator<Item = Self>) -> Self

fn reduce_and(self, tcx: TyCtxt<'tcx>, other: Self) -> Option<Self>

fn reduce_or(self, tcx: TyCtxt<'tcx>, other: Self) -> Option<Self>

pub fn instantiate(self, tcx: TyCtxt<'tcx>, args: GenericArgsRef<'tcx>) -> Self

Replaces generic types with its corresponding predicate

fn instantiate_opt( self, tcx: TyCtxt<'tcx>, args: GenericArgsRef<'tcx>, ) -> Option<Self>

Trait Implementations

impl<'tcx> Clone for InhabitedPredicate<'tcx>

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

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'tcx> Debug for InhabitedPredicate<'tcx>

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

Formats the value using the given formatter.

impl<'tcx> EraseType for InhabitedPredicate<'tcx>

type Result = [u8; 16]

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

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

impl<'tcx> PartialEq for InhabitedPredicate<'tcx>

fn eq(&self, other: &InhabitedPredicate<'tcx>) -> 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<'tcx> Copy for InhabitedPredicate<'tcx>

impl<'tcx> StructuralPartialEq for InhabitedPredicate<'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

Size for each variant:

• True: 0 bytes
• False: 0 bytes
• ConstIsZero: 8 bytes
• NotInModule: 8 bytes
• GenericType: 8 bytes
• OpaqueType: 16 bytes
• And: 8 bytes
• Or: 8 bytes