Struct VariantDef

pub struct VariantDef {
    pub def_id: DefId,
    pub ctor: Option<(CtorKind, DefId)>,
    pub name: Symbol,
    pub discr: VariantDiscr,
    pub fields: IndexVec<FieldIdx, FieldDef>,
    tainted: Option<ErrorGuaranteed>,
    flags: VariantFlags,
}

Definition of a variant – a struct’s fields or an enum variant.

Fields

def_id: DefId

DefId that identifies the variant itself. If this variant belongs to a struct or union, then this is a copy of its DefId.

ctor: Option<(CtorKind, DefId)>

DefId that identifies the variant’s constructor. If this variant is a struct variant, then this is None.

name: Symbol

Variant or struct name, maybe empty for anonymous adt (struct or union).

discr: VariantDiscr

Discriminant of this variant.

fields: IndexVec<FieldIdx, FieldDef>

Fields of this variant.

tainted: Option<ErrorGuaranteed>

The error guarantees from parser, if any.

flags: VariantFlags

Flags of the variant (e.g. is field list non-exhaustive)?

Implementations

impl<'tcx> VariantDef

pub fn inhabited_predicate( &self, tcx: TyCtxt<'tcx>, adt: AdtDef<'_>, ) -> InhabitedPredicate<'tcx>

Calculates the forest of DefIds from which this variant is visibly uninhabited.

impl VariantDef

pub fn new( name: Symbol, variant_did: Option<DefId>, ctor: Option<(CtorKind, DefId)>, discr: VariantDiscr, fields: IndexVec<FieldIdx, FieldDef>, adt_kind: AdtKind, parent_did: DefId, recover_tainted: Option<ErrorGuaranteed>, is_field_list_non_exhaustive: bool, ) -> Self

Creates a new VariantDef.

variant_did is the DefId that identifies the enum variant (if this VariantDef represents an enum variant).

ctor_did is the DefId that identifies the constructor of unit or tuple-variants/structs. If this is a struct-variant then this should be None.

parent_did is the DefId of the AdtDef representing the enum or struct that owns this variant. It is used for checking if a struct has #[non_exhaustive] w/out having to go through the redirect of checking the ctor’s attributes - but compiling a small crate requires loading the AdtDefs for all the structs in the universe (e.g., coherence for any built-in trait), and we do not want to load attributes twice.

If someone speeds up attribute loading to not be a performance concern, they can remove this hack and use the constructor DefId everywhere.

pub fn is_field_list_non_exhaustive(&self) -> bool

Is this field list non-exhaustive?

pub fn ident(&self, tcx: TyCtxt<'_>) -> Ident

Computes the Ident of this variant by looking up the Span

pub fn has_errors(&self) -> Result<(), ErrorGuaranteed>

Was this variant obtained as part of recovering from a syntactic error?

pub fn ctor_kind(&self) -> Option<CtorKind>

pub fn ctor_def_id(&self) -> Option<DefId>

pub fn single_field(&self) -> &FieldDef

Returns the one field in this variant.

panic!s if there are no fields or multiple fields.

pub fn tail_opt(&self) -> Option<&FieldDef>

Returns the last field in this variant, if present.

pub fn tail(&self) -> &FieldDef

Returns the last field in this variant.

Panics

Panics, if the variant has no fields.

pub fn has_unsafe_fields(&self) -> bool

Returns whether this variant has unsafe fields.

Trait Implementations

impl Debug for VariantDef

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

Formats the value using the given formatter.

impl<__D: TyDecoder> Decodable<__D> for VariantDef

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

impl<__E: TyEncoder> Encodable<__E> for VariantDef

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

impl Hash for VariantDef

fn hash<H: Hasher>(&self, s: &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<'__ctx> HashStable<StableHashingContext<'__ctx>> for VariantDef

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

impl PartialEq for VariantDef

fn eq(&self, other: &Self) -> 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 Eq for VariantDef

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