+use super::generate_fields;
use proc_macro2::{Ident, Literal, TokenStream};
use quote::quote;
use syn::{DataEnum, Variant};
-use super::generate_fields;
fn variant_weight(variant: &Variant) -> Literal {
for attr in variant.attrs.iter() {
if attr.path.is_ident("weight") {
- return attr.parse_args::<Literal>().expect("expected literal for `#[weight(...)]`")
+ return attr
+ .parse_args::<Literal>()
+ .expect("expected literal for `#[weight(...)]`");
}
}
Literal::u64_suffixed(1)
}
pub fn generate(name: &Ident, ty: DataEnum) -> TokenStream {
- let mut variant_weights = ty.variants.into_iter()
+ let mut variant_weights = ty
+ .variants
+ .into_iter()
.map(|variant| (variant_weight(&variant), variant));
let mut arms = TokenStream::new();
+use super::generate_fields;
use proc_macro2::{Ident, TokenStream};
use quote::quote;
use syn::DataStruct;
-use super::generate_fields;
pub fn generate(name: &Ident, ty: DataStruct) -> TokenStream {
let fields = generate_fields(ty.fields);
//! that implements the trait of the same name from the `generate-random` crate.
//! Refer to the documentation of that crate for more information.
-use syn::{DeriveInput, Data, Fields};
+use syn::{Data, DeriveInput, Fields};
-mod handle_struct;
mod handle_enum;
+mod handle_struct;
#[proc_macro_derive(GenerateRandom, attributes(weight))]
pub fn derive_generate_random(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
Data::Struct(ty) => handle_struct::generate(&input.ident, ty),
Data::Enum(ty) => handle_enum::generate(&input.ident, ty),
Data::Union(_) => panic!("Unions are not supported"),
- }.into()
+ }
+ .into()
}
fn generate_fields(fields: Fields) -> proc_macro2::TokenStream {
use quote::quote;
match fields {
Fields::Named(fields) => {
- let fields = fields.named.into_iter()
+ let fields = fields
+ .named
+ .into_iter()
.map(|field| {
let field = field.ident.unwrap();
quote! {
quote! { { #fields } }
}
Fields::Unnamed(fields) => {
- let fields = fields.unnamed.into_iter()
+ let fields = fields
+ .unnamed
+ .into_iter()
.map(|_field| {
quote! {
generate_random::GenerateRandom::generate_random(rng),
}
macro_rules! impl_generate_random {
- ( $( $t:ty, )+ ) => {
- $(
- impl GenerateRandom for $t {
- fn generate_random<R: rand::Rng + ?Sized>(rng: &mut R) -> Self {
- rng.gen()
- }
- }
- )+
- }
+ ( $( $t:ty, )+ ) => {
+ $(
+ impl GenerateRandom for $t {
+ fn generate_random<R: rand::Rng + ?Sized>(rng: &mut R) -> Self {
+ rng.gen()
+ }
+ }
+ )+
+ }
}
impl_generate_random! {
}
macro_rules! impl_generate_random_tuple {
- ( $t0:ident $( $t:ident )* ) => {
- impl< $t0, $( $t, )* > GenerateRandom for ( $t0, $( $t, )* )
- where
- $t0: GenerateRandom,
- $(
- $t: GenerateRandom,
- )*
- {
- fn generate_random<R: rand::Rng + ?Sized>(rng: &mut R) -> Self {
- (
- $t0::generate_random(rng),
- $(
- $t::generate_random(rng),
- )*
- )
- }
- }
- impl_generate_random_tuple!( $( $t )* );
- };
- () => {
- impl GenerateRandom for () {
- fn generate_random<R: rand::Rng + ?Sized>(_rng: &mut R) -> Self {
- ()
- }
- }
- }
+ ( $t0:ident $( $t:ident )* ) => {
+ impl< $t0, $( $t, )* > GenerateRandom for ( $t0, $( $t, )* )
+ where
+ $t0: GenerateRandom,
+ $(
+ $t: GenerateRandom,
+ )*
+ {
+ fn generate_random<R: rand::Rng + ?Sized>(rng: &mut R) -> Self {
+ (
+ $t0::generate_random(rng),
+ $(
+ $t::generate_random(rng),
+ )*
+ )
+ }
+ }
+ impl_generate_random_tuple!( $( $t )* );
+ };
+ () => {
+ impl GenerateRandom for () {
+ fn generate_random<R: rand::Rng + ?Sized>(_rng: &mut R) -> Self {
+ ()
+ }
+ }
+ }
}
impl_generate_random_tuple!(A B C D E F G H I J K L);
#[derive(GenerateRandom, PartialEq, Eq, Debug)]
enum TestEnumNamed {
- Left { x: u8 },
+ Left {
+ x: u8,
+ },
#[weight(2)]
- Right { y: bool },
+ Right {
+ y: bool,
+ },
}
#[derive(GenerateRandom, PartialEq, Eq, Debug)]
fn test_enum_unit() {
let mut rng = rng();
assert_eq!(
- repeat(
- 6,
- || TestEnumUnit::generate_random(&mut rng),
- ),
+ repeat(6, || TestEnumUnit::generate_random(&mut rng),),
vec![
TestEnumUnit::Right,
TestEnumUnit::Right,
TestEnumUnit::Right,
TestEnumUnit::Right,
TestEnumUnit::Right,
- ]);
+ ]
+ );
}
#[test]
fn test_enum_unnamed() {
let mut rng = rng();
assert_eq!(
- repeat(
- 6,
- || TestEnumUnnamed::generate_random(&mut rng),
- ),
+ repeat(6, || TestEnumUnnamed::generate_random(&mut rng),),
vec![
TestEnumUnnamed::Right(false),
TestEnumUnnamed::Left(142),
TestEnumUnnamed::Right(true),
TestEnumUnnamed::Right(false),
TestEnumUnnamed::Left(19),
- ]);
+ ]
+ );
}
#[test]
fn test_enum_named() {
let mut rng = rng();
assert_eq!(
- repeat(
- 6,
- || TestEnumNamed::generate_random(&mut rng),
- ),
+ repeat(6, || TestEnumNamed::generate_random(&mut rng),),
vec![
TestEnumNamed::Right { y: false },
TestEnumNamed::Left { x: 142 },
TestEnumNamed::Right { y: true },
TestEnumNamed::Right { y: false },
TestEnumNamed::Left { x: 19 },
- ]);
+ ]
+ );
}
#[test]
fn test_struct_unit() {
let mut rng = rng();
- assert_eq!(
- TestStructUnit::generate_random(&mut rng),
- TestStructUnit
- );
+ assert_eq!(TestStructUnit::generate_random(&mut rng), TestStructUnit);
}
#[test]