Struct synstructure::VariantInfo

source ·

pub struct VariantInfo<'a> {
    pub prefix: Option<&'a Ident>,
    /* private fields */
}

Expand description

A wrapper around a syn::DeriveInput’s variant which provides utilities for destructuring Variants with match expressions.

Fields§

§prefix: Option<&'a Ident>

Implementations§

source §

impl<'a> VariantInfo<'a>

source

pub fn bindings(&self) -> &[BindingInfo<'a>]

Returns a slice of the bindings in this Variant.

source

pub fn bindings_mut(&mut self) -> &mut [BindingInfo<'a>]

Returns a mut slice of the bindings in this Variant.

source

pub fn ast(&self) -> VariantAst<'a>

Returns a VariantAst object which contains references to the underlying syn AST node which this Variant was created from.

source

pub fn omitted_bindings(&self) -> bool

True if any bindings were omitted due to a filter call.

source

pub fn pat(&self) -> TokenStream

Generates the match-arm pattern which could be used to match against this Variant.

Example

let di: syn::DeriveInput = syn::parse_quote! {
    enum A {
        B(i32, i32),
        C(u32),
    }
};
let s = Structure::new(&di);

assert_eq!(
    s.variants()[0].pat().to_string(),
    quote!{
        A::B(ref __binding_0, ref __binding_1,)
    }.to_string()
);

source

pub fn construct<F, T>(&self, func: F) -> TokenStreamwhere F: FnMut(&Field, usize) -> T, T: ToTokens,

Generates the token stream required to construct the current variant.

The init array initializes each of the fields in the order they are written in variant.ast().fields.

Example

let di: syn::DeriveInput = syn::parse_quote! {
    enum A {
        B(usize, usize),
        C{ v: usize },
    }
};
let s = Structure::new(&di);

assert_eq!(
    s.variants()[0].construct(|_, i| quote!(#i)).to_string(),

    quote!{
        A::B(0usize, 1usize,)
    }.to_string()
);

assert_eq!(
    s.variants()[1].construct(|_, i| quote!(#i)).to_string(),

    quote!{
        A::C{ v: 0usize, }
    }.to_string()
);

source

pub fn each<F, R>(&self, f: F) -> TokenStreamwhere F: FnMut(&BindingInfo<'_>) -> R, R: ToTokens,

Runs the passed-in function once for each bound field, passing in a BindingInfo. and generating a match arm which evaluates the returned tokens.

This method will ignore fields which are ignored through the filter method.

Example

let di: syn::DeriveInput = syn::parse_quote! {
    enum A {
        B(i32, i32),
        C(u32),
    }
};
let s = Structure::new(&di);

assert_eq!(
    s.variants()[0].each(|bi| quote!(println!("{:?}", #bi))).to_string(),

    quote!{
        A::B(ref __binding_0, ref __binding_1,) => {
            { println!("{:?}", __binding_0) }
            { println!("{:?}", __binding_1) }
        }
    }.to_string()
);

source

pub fn fold<F, I, R>(&self, init: I, f: F) -> TokenStreamwhere F: FnMut(TokenStream, &BindingInfo<'_>) -> R, I: ToTokens, R: ToTokens,

Runs the passed-in function once for each bound field, passing in the result of the previous call, and a BindingInfo. generating a match arm which evaluates to the resulting tokens.

This method will ignore fields which are ignored through the filter method.

Example

let di: syn::DeriveInput = syn::parse_quote! {
    enum A {
        B(i32, i32),
        C(u32),
    }
};
let s = Structure::new(&di);

assert_eq!(
    s.variants()[0].fold(quote!(0), |acc, bi| quote!(#acc + #bi)).to_string(),

    quote!{
        A::B(ref __binding_0, ref __binding_1,) => {
            0 + __binding_0 + __binding_1
        }
    }.to_string()
);

source

pub fn filter<F>(&mut self, f: F) -> &mut Selfwhere F: FnMut(&BindingInfo<'_>) -> bool,

Filter the bindings created by this Variant object. This has 2 effects:

The bindings will no longer appear in match arms generated by methods on this Variant or its subobjects.
Impl blocks created with the bound_impl or unsafe_bound_impl method only consider type parameters referenced in the types of non-filtered fields.

Example

let di: syn::DeriveInput = syn::parse_quote! {
    enum A {
        B{ a: i32, b: i32 },
        C{ a: u32 },
    }
};
let mut s = Structure::new(&di);

s.variants_mut()[0].filter(|bi| {
    bi.ast().ident == Some(quote::format_ident!("b"))
});

assert_eq!(
    s.each(|bi| quote!(println!("{:?}", #bi))).to_string(),

    quote!{
        A::B{ b: ref __binding_1, .. } => {
            { println!("{:?}", __binding_1) }
        }
        A::C{ a: ref __binding_0, } => {
            { println!("{:?}", __binding_0) }
        }
    }.to_string()
);

source

pub fn remove_binding(&mut self, idx: usize) -> &mut Self

Remove the binding at the given index.

Panics

Panics if the index is out of range.

source

pub fn bind_with<F>(&mut self, f: F) -> &mut Selfwhere F: FnMut(&BindingInfo<'_>) -> BindStyle,

Updates the BindStyle for each of the passed-in fields by calling the passed-in function for each BindingInfo.

Example

let di: syn::DeriveInput = syn::parse_quote! {
    enum A {
        B(i32, i32),
        C(u32),
    }
};
let mut s = Structure::new(&di);

s.variants_mut()[0].bind_with(|bi| BindStyle::RefMut);

assert_eq!(
    s.each(|bi| quote!(println!("{:?}", #bi))).to_string(),

    quote!{
        A::B(ref mut __binding_0, ref mut __binding_1,) => {
            { println!("{:?}", __binding_0) }
            { println!("{:?}", __binding_1) }
        }
        A::C(ref __binding_0,) => {
            { println!("{:?}", __binding_0) }
        }
    }.to_string()
);

source

pub fn binding_name<F>(&mut self, f: F) -> &mut Selfwhere F: FnMut(&Field, usize) -> Ident,

Updates the binding name for each fo the passed-in fields by calling the passed-in function for each BindingInfo.

The function will be called with the BindingInfo and its index in the enclosing variant.

The default name is __binding_{} where {} is replaced with an increasing number.

Example

let di: syn::DeriveInput = syn::parse_quote! {
    enum A {
        B{ a: i32, b: i32 },
        C{ a: u32 },
    }
};
let mut s = Structure::new(&di);

s.variants_mut()[0].binding_name(|bi, i| bi.ident.clone().unwrap());

assert_eq!(
    s.each(|bi| quote!(println!("{:?}", #bi))).to_string(),

    quote!{
        A::B{ a: ref a, b: ref b, } => {
            { println!("{:?}", a) }
            { println!("{:?}", b) }
        }
        A::C{ a: ref __binding_0, } => {
            { println!("{:?}", __binding_0) }
        }
    }.to_string()
);

source

pub fn referenced_ty_params(&self) -> Vec<&'a Ident>

Returns a list of the type parameters which are referenced in this field’s type.

Caveat

If the field contains any macros in type position, all parameters will be considered bound. This is because we cannot determine which type parameters are bound by type macros.

Example

let di: syn::DeriveInput = syn::parse_quote! {
    struct A<T, U> {
        a: Option<T>,
        b: U,
    }
};
let mut s = Structure::new(&di);

assert_eq!(
    s.variants()[0].bindings()[0].referenced_ty_params(),
    &[&quote::format_ident!("T")]
);