Struct Variant 

pub struct Variant {
    pub span: SourceSpan,
    pub docs: Option<DocString>,
    pub name: Ident,
    pub discriminant: ConstantExpr,
}

A variant of an EnumType.

See the EnumType docs for more information.

Fields

span: SourceSpan

docs: Option<DocString>

The documentation string attached to the constant derived from this variant.

name: Ident

The name of this enum variant

discriminant: ConstantExpr

The discriminant value associated with this variant

Implementations

impl Variant

pub fn new(name: Ident, discriminant: ConstantExpr) -> Self

Construct a new variant of an EnumType, with the given name and discriminant value.

pub fn with_span(self, span: SourceSpan) -> Self

Override the span for this variant

pub fn with_docs(self, docs: Option<Span<String>>) -> Self

Adds documentation to this variant

pub fn assert_instance_of(&self, ty: &Type) -> Result<(), SemanticAnalysisError>

Used to validate that this variant’s discriminant value is an instance of ty, which must be a type valid for use as the underlying representation for an enum, i.e. an integer type up to 64 bits in size.

It is expected that the discriminant expression has been folded to an integer value by the time this is called. If the discriminant has not been fully folded, then an error will be returned.

Trait Implementations

impl Clone for Variant

fn clone(&self) -> Variant

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Variant

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

Formats the value using the given formatter.

impl Hash for Variant

fn hash<H: Hasher>(&self, state: &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 PartialEq for Variant

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 PrettyPrint for Variant

fn render(&self) -> Document

The core of the PrettyPrint functionality.

fn to_pretty_string(&self) -> String

Produce a String containing the results of pretty-printing this object.

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

Pretty-print this object to the given core::fmt::Formatter.

impl Spanned for Variant

fn span(&self) -> SourceSpan

impl Eq for Variant