Enum rustc_middle::ty::inhabitedness::DefIdForest

pub enum DefIdForest<'a> {
    Empty,
    Single(DefId),
    Multiple(&'a [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)

Multiple(&'a [DefId])

This variant is very rare. Invariant: >1 elements

Implementations

impl<'tcx> DefIdForest<'tcx>

pub fn empty() -> DefIdForest<'tcx>

Creates an empty forest.

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

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

pub fn from_id(id: DefId) -> DefIdForest<'tcx>

Creates a forest containing a DefId and all its descendants.

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

fn from_vec(
    tcx: TyCtxt<'tcx>,
    root_ids: SmallVec<[DefId; 1]>
) -> DefIdForest<'tcx>

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<'tcx>where
    I: IntoIterator<Item = DefIdForest<'tcx>>,

Calculate the intersection of a collection of forests.

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

Calculate the union of a collection of forests.

Trait Implementations

impl<'a> Clone for DefIdForest<'a>

fn clone(&self) -> DefIdForest<'a>

Returns a copy of the value.

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

Performs copy-assignment from source.

impl<'a> Debug for DefIdForest<'a>

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

Formats the value using the given formatter.

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

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

impl<'a> Copy for DefIdForest<'a>

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