Struct ruast::Variant

pub struct Variant {
    pub vis: Visibility,
    pub ident: String,
    pub data: VariantData,
    pub disr_expr: Option<Expr>,
}

Fields

vis: Visibility

ident: String

data: VariantData

disr_expr: Option<Expr>

Implementations

impl Variant

pub fn new( vis: Visibility, ident: impl Into<String>, data: VariantData, disr_expr: Option<Expr> ) -> Self

pub fn empty(ident: impl Into<String>) -> Self

Examples found in repository

examples/enum.rs (line 6)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use ruast::*;

    let mut krate = Crate::new();
    let def = EnumDef::empty("Foo")
        .with_variant(Variant::empty("Bar"))
        .with_variant(Variant::tuple("Baz", vec![FieldDef::anonymous("u32")]));
    krate.add_item(def);
    let imp = Impl::empty("Foo").with_item(Fn::empty_method("test", Pat::ref_self()));
    krate.add_item(imp);
    println!("{krate}");
    Ok(())
}

pub fn inherited(ident: impl Into<String>, data: VariantData) -> Self

pub fn struct_(ident: impl Into<String>, fields: Vec<FieldDef>) -> Self

pub fn tuple(ident: impl Into<String>, fields: Vec<FieldDef>) -> Self

Examples found in repository

examples/enum.rs (line 7)

fn main() -> Result<(), Box<dyn std::error::Error>> {
    use ruast::*;

    let mut krate = Crate::new();
    let def = EnumDef::empty("Foo")
        .with_variant(Variant::empty("Bar"))
        .with_variant(Variant::tuple("Baz", vec![FieldDef::anonymous("u32")]));
    krate.add_item(def);
    let imp = Impl::empty("Foo").with_item(Fn::empty_method("test", Pat::ref_self()));
    krate.add_item(imp);
    println!("{krate}");
    Ok(())
}

Trait Implementations

impl Clone for Variant

fn clone(&self) -> Variant

Returns a copy 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 Display for Variant

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

Formats the value using the given formatter.

impl EmptyItem for Variant

type Input = String

fn empty(ident: impl Into<Self::Input>) -> Self

impl From<Variant> for TokenStream

fn from(value: Variant) -> Self

Converts to this type from the input type.

impl HasItem<Variant> for EnumDef

fn items(&self) -> &[Variant]

fn items_mut(&mut self) -> &mut Vec<Variant>

fn with_item(self, item: impl Into<Itm>) -> Selfwhere Self: Sized,

fn add_item(&mut self, item: impl Into<Itm>)

fn add_pub_item<K>(&mut self, item: impl Into<K>)where Itm: AddVisibility<K>,

fn with_pub_item<K>(self, item: impl Into<K>) -> Selfwhere Self: Sized, Itm: AddVisibility<K>,

fn remove_item(&mut self, index: usize) -> Option<Itm>

fn remove_item_by_id(&mut self, ident: &str) -> Option<Itm>

fn get_item(&self, index: usize) -> Option<&Itm>

fn get_item_by_id(&self, ident: &str) -> Option<&Itm>

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

fn ident(&self) -> &str

impl PartialEq for Variant

fn eq(&self, other: &Variant) -> bool

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

fn ne(&self, other: &Rhs) -> bool

This method tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for Variant

impl StructuralEq for Variant

impl StructuralPartialEq for Variant