Enum syntax::ast::VariantData

pub enum VariantData {
    Struct(Vec<StructField>, NodeId),
    Tuple(Vec<StructField>, NodeId),
    Unit(NodeId),
}

Fields and Ids of enum variants and structs

For enum variants: NodeId represents both an Id of the variant itself (relevant for all variant kinds) and an Id of the variant's constructor (not relevant for Struct-variants). One shared Id can be successfully used for these two purposes. Id of the whole enum lives in Item.

For structs: NodeId represents an Id of the structure's constructor, so it is not actually used for Struct-structs (but still presents). Structures don't have an analogue of "Id of the variant itself" from enum variants. Id of the whole struct lives in Item.

Variants

Struct(Vec<StructField>, NodeId)

Struct variant.

E.g. Bar { .. } as in enum Foo { Bar { .. } }

Tuple(Vec<StructField>, NodeId)

Tuple variant.

E.g. Bar(..) as in enum Foo { Bar(..) }

Unit(NodeId)

Unit variant.

E.g. Bar = .. as in enum Foo { Bar = .. }

Methods

impl VariantData

Important traits for &'a mut [u8]

impl<'a> Write for &'a mut [u8]impl<'a> Read for &'a [u8]

pub fn fields(&self) -> &[StructField]

pub fn id(&self) -> NodeId

pub fn is_struct(&self) -> bool

pub fn is_tuple(&self) -> bool

pub fn is_unit(&self) -> bool

Trait Implementations

impl Clone for VariantData

fn clone(&self) -> VariantData

Returns a copy of the value.

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

Performs copy-assignment from source.

impl PartialEq for VariantData

fn eq(&self, __arg_0: &VariantData) -> bool

This method tests for self and other values to be equal, and is used by ==.

fn ne(&self, __arg_0: &VariantData) -> bool

This method tests for !=.

impl Eq for VariantData

impl Encodable for VariantData

fn encode<__S: Encoder>(&self, __arg_0: &mut __S) -> Result<(), __S::Error>

impl Decodable for VariantData

fn decode<__D: Decoder>(__arg_0: &mut __D) -> Result<VariantData, __D::Error>

impl Hash for VariantData

fn hash<__H: Hasher>(&self, __arg_0: &mut __H)

Feeds this value into the given [Hasher].

fn hash_slice<H>(data: &[Self], state: &mut H) where
    H: Hasher, 

Feeds a slice of this type into the given [Hasher].

impl Debug for VariantData

fn fmt(&self, __arg_0: &mut Formatter) -> Result

Formats the value using the given formatter.