Enum rustc_middle::ty::inhabitedness::DefIdForest

pub enum DefIdForest {
    Empty,
    Single(DefId),
    Multiple(Arc<[DefId]>),
}

Represents a forest of DefIds closed under the ancestor relation. That is, if a DefId representing a module is contained in the forest then all DefIds defined in that module or submodules are also implicitly contained in the forest.

This is used to represent a set of modules in which a type is visibly uninhabited.

We store the minimal set of DefIds required to represent the whole set. If A and B are DefIds in the DefIdForest, and A is a parent of B, then only A will be stored. When this is used with type_uninhabited_from, there will very rarely be more than one DefId stored.

Variants

Empty

Single(DefId)

Tuple Fields of Single

0: DefId

Multiple(Arc<[DefId]>)

This variant is very rare. Invariant: >1 elements We use Arc because this is used in the output of a query.

Tuple Fields of Multiple

0: Arc<[DefId]>

Implementations

impl<'tcx> DefIdForest

pub fn empty() -> DefIdForest

Creates an empty forest.

pub fn full(tcx: TyCtxt<'tcx>) -> DefIdForest

Creates a forest consisting of a single tree representing the entire crate.

pub fn from_id(id: DefId) -> DefIdForest

Creates a forest containing a DefId and all its descendants.

fn as_slice(&self) -> &[DefId]

fn from_slice(root_ids: &[DefId]) -> DefIdForest

pub fn is_empty(&self) -> bool

Tests whether the forest is empty.

fn iter(&self) -> impl Iterator<Item = DefId> + '_

Iterate over the set of roots.

pub fn contains(&self, tcx: TyCtxt<'tcx>, id: DefId) -> bool

Tests whether the forest contains a given DefId.

pub fn intersection<I>(tcx: TyCtxt<'tcx>, iter: I) -> DefIdForest where
    I: IntoIterator<Item = DefIdForest>, 

Calculate the intersection of a collection of forests.

pub fn union<I>(tcx: TyCtxt<'tcx>, iter: I) -> DefIdForest where
    I: IntoIterator<Item = DefIdForest>, 

Calculate the union of a collection of forests.

Trait Implementations

impl Clone for DefIdForest

fn clone(&self) -> DefIdForest

Returns a copy of the value.

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

Performs copy-assignment from source.

impl Debug for DefIdForest

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

Formats the value using the given formatter.

impl<'__ctx> HashStable<StableHashingContext<'__ctx>> for DefIdForest

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

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: 24 bytes

Size for each variant:

• Empty: 0 bytes
• Single: 8 bytes
• Multiple: 20 bytes