Struct rustc_middle::ty::VariantDef

pub struct VariantDef {
    pub def_id: DefId,
    pub ctor_def_id: Option<DefId>,
    pub ident: Ident,
    pub discr: VariantDiscr,
    pub fields: Vec<FieldDef>,
    pub ctor_kind: CtorKind,
    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_def_id: Option<DefId>

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

ident: Ident

Variant or struct name.

discr: VariantDiscr

Discriminant of this variant.

fields: Vec<FieldDef>

Fields of this variant.

ctor_kind: CtorKind

Type of constructor of variant.

flags: VariantFlags

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

Implementations

impl<'tcx> VariantDef

pub fn uninhabited_from(
    &self,
    tcx: TyCtxt<'tcx>,
    substs: SubstsRef<'tcx>,
    adt_kind: AdtKind,
    param_env: ParamEnv<'tcx>
) -> DefIdForest

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

impl VariantDef

pub fn new(
    ident: Ident,
    variant_did: Option<DefId>,
    ctor_def_id: Option<DefId>,
    discr: VariantDiscr,
    fields: Vec<FieldDef>,
    ctor_kind: CtorKind,
    adt_kind: AdtKind,
    parent_did: DefId,
    recovered: bool,
    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 is_recovered(&self) -> bool

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

Trait Implementations

impl Debug for VariantDef

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

Formats the value using the given formatter.

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

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