Skip to content

Commit d0eb893

Browse files
meithecattemeithecatte
committed
cargo fmt
1 parent 0eb2260 commit d0eb893

File tree

7 files changed

+199
-185
lines changed

7 files changed

+199
-185
lines changed

‎benches/from_iterator.rs‎

Lines changed: 34 additions & 40 deletions
Original file line numberDiff line numberDiff line change
@@ -1,5 +1,5 @@
11
use criterion::{black_box, criterion_group, criterion_main, Criterion};
2-
use enumflags2::{BitFlags, bitflags};
2+
use enumflags2::{bitflags, BitFlags};
33

44
#[bitflags]
55
#[repr(u16)]
@@ -19,45 +19,39 @@ pub enum Test {
1919
}
2020

2121
pub fn iterators(c: &mut Criterion) {
22-
let v = vec![
23-
Test::Flag3,
24-
Test::Flag7,
25-
Test::Flag5,
26-
Test::Flag11,
27-
];
28-
29-
let v2 = vec![
30-
Test::Flag10,
31-
Test::Flag3,
32-
Test::Flag1,
33-
Test::Flag4,
34-
];
35-
36-
c.bench_function("simple iterator collect", |b| b.iter(|| {
37-
black_box(&v).iter().copied().collect::<BitFlags<_>>()
38-
}));
39-
40-
c.bench_function("chained iterator collect", |b| b.iter(|| {
41-
black_box(&v).iter()
42-
.chain(black_box(&v2).iter())
43-
.copied()
44-
.collect::<BitFlags<_>>()
45-
}));
46-
47-
c.bench_function("simple iterator extend", |b| b.iter(|| {
48-
let mut flags = BitFlags::empty();
49-
flags.extend(black_box(&v).iter().copied());
50-
flags
51-
}));
52-
53-
c.bench_function("chained iterator extend", |b| b.iter(|| {
54-
let mut flags = BitFlags::empty();
55-
flags.extend(
56-
black_box(&v).iter()
57-
.chain(black_box(&v2).iter())
58-
.copied());
59-
flags
60-
}));
22+
let v = vec![Test::Flag3, Test::Flag7, Test::Flag5, Test::Flag11];
23+
24+
let v2 = vec![Test::Flag10, Test::Flag3, Test::Flag1, Test::Flag4];
25+
26+
c.bench_function("simple iterator collect", |b| {
27+
b.iter(|| black_box(&v).iter().copied().collect::<BitFlags<_>>())
28+
});
29+
30+
c.bench_function("chained iterator collect", |b| {
31+
b.iter(|| {
32+
black_box(&v)
33+
.iter()
34+
.chain(black_box(&v2).iter())
35+
.copied()
36+
.collect::<BitFlags<_>>()
37+
})
38+
});
39+
40+
c.bench_function("simple iterator extend", |b| {
41+
b.iter(|| {
42+
let mut flags = BitFlags::empty();
43+
flags.extend(black_box(&v).iter().copied());
44+
flags
45+
})
46+
});
47+
48+
c.bench_function("chained iterator extend", |b| {
49+
b.iter(|| {
50+
let mut flags = BitFlags::empty();
51+
flags.extend(black_box(&v).iter().chain(black_box(&v2).iter()).copied());
52+
flags
53+
})
54+
});
6155
}
6256

6357
criterion_group!(benches, iterators);

‎enumflags_derive/src/lib.rs‎

Lines changed: 100 additions & 92 deletions
Original file line numberDiff line numberDiff line change
@@ -3,9 +3,14 @@ extern crate proc_macro;
33
#[macro_use]
44
extern crate quote;
55

6+
use proc_macro2::{Span, TokenStream};
67
use std::convert::TryFrom;
7-
use syn::{Token, Ident, Item, ItemEnum, spanned::Spanned, parse_macro_input, parse::{Parse, ParseStream}};
8-
use proc_macro2::{TokenStream, Span};
8+
use syn::{
9+
parse::{Parse, ParseStream},
10+
parse_macro_input,
11+
spanned::Spanned,
12+
Ident, Item, ItemEnum, Token,
13+
};
914

1015
struct Flag {
1116
name: Ident,
@@ -26,9 +31,7 @@ struct Parameters {
2631
impl Parse for Parameters {
2732
fn parse(input: ParseStream) -> syn::parse::Result<Self> {
2833
if input.is_empty() {
29-
return Ok(Parameters {
30-
default: vec![],
31-
});
34+
return Ok(Parameters { default: vec![] });
3235
}
3336

3437
input.parse::<Token![default]>()?;
@@ -39,9 +42,7 @@ impl Parse for Parameters {
3942
default.push(input.parse()?);
4043
}
4144

42-
Ok(Parameters {
43-
default
44-
})
45+
Ok(Parameters { default })
4546
}
4647
}
4748

@@ -54,54 +55,57 @@ pub fn bitflags_internal(
5455
let ast = parse_macro_input!(input as Item);
5556
let output = match ast {
5657
Item::Enum(ref item_enum) => gen_enumflags(item_enum, default),
57-
_ => Err(syn::Error::new_spanned(&ast,
58-
"#[bitflags] requires an enum")),
58+
_ => Err(syn::Error::new_spanned(
59+
&ast,
60+
"#[bitflags] requires an enum",
61+
)),
5962
};
6063

61-
output.unwrap_or_else(|err| {
62-
let error = err.to_compile_error();
63-
quote! {
64-
#ast
65-
#error
66-
}
67-
}).into()
64+
output
65+
.unwrap_or_else(|err| {
66+
let error = err.to_compile_error();
67+
quote! {
68+
#ast
69+
#error
70+
}
71+
})
72+
.into()
6873
}
6974

7075
/// Try to evaluate the expression given.
7176
fn fold_expr(expr: &syn::Expr) -> Option<u128> {
7277
use syn::Expr;
7378
match expr {
74-
Expr::Lit(ref expr_lit) => {
75-
match expr_lit.lit {
76-
syn::Lit::Int(ref lit_int) => lit_int.base10_parse().ok(),
77-
_ => None,
78-
}
79+
Expr::Lit(ref expr_lit) => match expr_lit.lit {
80+
syn::Lit::Int(ref lit_int) => lit_int.base10_parse().ok(),
81+
_ => None,
7982
},
8083
Expr::Binary(ref expr_binary) => {
8184
let l = fold_expr(&expr_binary.left)?;
8285
let r = fold_expr(&expr_binary.right)?;
8386
match &expr_binary.op {
84-
syn::BinOp::Shl(_) => {
85-
u32::try_from(r).ok()
86-
.and_then(|r| l.checked_shl(r))
87-
}
87+
syn::BinOp::Shl(_) => u32::try_from(r).ok().and_then(|r| l.checked_shl(r)),
8888
_ => None,
8989
}
9090
}
9191
_ => None,
9292
}
9393
}
9494

95-
fn collect_flags<'a>(variants: impl Iterator<Item=&'a syn::Variant>)
96-
-> Result<Vec<Flag>, syn::Error>
97-
{
95+
fn collect_flags<'a>(
96+
variants: impl Iterator<Item = &'a syn::Variant>,
97+
) -> Result<Vec<Flag>, syn::Error> {
9898
variants
9999
.map(|variant| {
100100
// MSRV: Would this be cleaner with `matches!`?
101101
match variant.fields {
102102
syn::Fields::Unit => (),
103-
_ => return Err(syn::Error::new_spanned(&variant.fields,
104-
"Bitflag variants cannot contain additional data")),
103+
_ => {
104+
return Err(syn::Error::new_spanned(
105+
&variant.fields,
106+
"Bitflag variants cannot contain additional data",
107+
))
108+
}
105109
}
106110

107111
let value = if let Some(ref expr) = variant.discriminant {
@@ -125,29 +129,22 @@ fn collect_flags<'a>(variants: impl Iterator<Item=&'a syn::Variant>)
125129

126130
/// Given a list of attributes, find the `repr`, if any, and return the integer
127131
/// type specified.
128-
fn extract_repr(attrs: &[syn::Attribute])
129-
-> Result<Option<Ident>, syn::Error>
130-
{
132+
fn extract_repr(attrs: &[syn::Attribute]) -> Result<Option<Ident>, syn::Error> {
131133
use syn::{Meta, NestedMeta};
132-
attrs.iter()
133-
.find_map(|attr| {
134-
match attr.parse_meta() {
135-
Err(why) => {
136-
Some(Err(syn::Error::new_spanned(attr,
137-
format!("Couldn't parse attribute: {}", why))))
138-
}
139-
Ok(Meta::List(ref meta)) if meta.path.is_ident("repr") => {
140-
meta.nested.iter()
141-
.find_map(|mi| match mi {
142-
NestedMeta::Meta(Meta::Path(path)) => {
143-
path.get_ident().cloned()
144-
.map(Ok)
145-
}
146-
_ => None
147-
})
148-
}
149-
Ok(_) => None
134+
attrs
135+
.iter()
136+
.find_map(|attr| match attr.parse_meta() {
137+
Err(why) => Some(Err(syn::Error::new_spanned(
138+
attr,
139+
format!("Couldn't parse attribute: {}", why),
140+
))),
141+
Ok(Meta::List(ref meta)) if meta.path.is_ident("repr") => {
142+
meta.nested.iter().find_map(|mi| match mi {
143+
NestedMeta::Meta(Meta::Path(path)) => path.get_ident().cloned().map(Ok),
144+
_ => None,
145+
})
150146
}
147+
Ok(_) => None,
151148
})
152149
.transpose()
153150
}
@@ -156,51 +153,64 @@ fn extract_repr(attrs: &[syn::Attribute])
156153
fn type_bits(ty: &Ident) -> Result<u8, syn::Error> {
157154
// This would be so much easier if we could just match on an Ident...
158155
if ty == "usize" {
159-
Err(syn::Error::new_spanned(ty,
160-
"#[repr(usize)] is not supported. Use u32 or u64 instead."))
161-
}
162-
else if ty == "i8" || ty == "i16" || ty == "i32"
163-
|| ty == "i64" || ty == "i128" || ty == "isize" {
164-
Err(syn::Error::new_spanned(ty,
165-
"Signed types in a repr are not supported."))
166-
}
167-
else if ty == "u8" { Ok(8) }
168-
else if ty == "u16" { Ok(16) }
169-
else if ty == "u32" { Ok(32) }
170-
else if ty == "u64" { Ok(64) }
171-
else if ty == "u128" { Ok(128) }
172-
else {
173-
Err(syn::Error::new_spanned(ty,
174-
"repr must be an integer type for #[bitflags]."))
156+
Err(syn::Error::new_spanned(
157+
ty,
158+
"#[repr(usize)] is not supported. Use u32 or u64 instead.",
159+
))
160+
} else if ty == "i8"
161+
|| ty == "i16"
162+
|| ty == "i32"
163+
|| ty == "i64"
164+
|| ty == "i128"
165+
|| ty == "isize"
166+
{
167+
Err(syn::Error::new_spanned(
168+
ty,
169+
"Signed types in a repr are not supported.",
170+
))
171+
} else if ty == "u8" {
172+
Ok(8)
173+
} else if ty == "u16" {
174+
Ok(16)
175+
} else if ty == "u32" {
176+
Ok(32)
177+
} else if ty == "u64" {
178+
Ok(64)
179+
} else if ty == "u128" {
180+
Ok(128)
181+
} else {
182+
Err(syn::Error::new_spanned(
183+
ty,
184+
"repr must be an integer type for #[bitflags].",
185+
))
175186
}
176187
}
177188

178189
/// Returns deferred checks
179-
fn check_flag(
180-
type_name: &Ident,
181-
flag: &Flag,
182-
) -> Result<Option<TokenStream>, syn::Error> {
190+
fn check_flag(type_name: &Ident, flag: &Flag) -> Result<Option<TokenStream>, syn::Error> {
183191
use FlagValue::*;
184192
match flag.value {
185193
Literal(n) => {
186194
if !n.is_power_of_two() {
187-
Err(syn::Error::new(flag.span,
188-
"Flags must have exactly one set bit"))
195+
Err(syn::Error::new(
196+
flag.span,
197+
"Flags must have exactly one set bit",
198+
))
189199
} else {
190200
Ok(None)
191201
}
192202
}
193-
Inferred => {
194-
Err(syn::Error::new(flag.span,
195-
"Please add an explicit discriminant"))
196-
}
203+
Inferred => Err(syn::Error::new(
204+
flag.span,
205+
"Please add an explicit discriminant",
206+
)),
197207
Deferred => {
198208
let variant_name = &flag.name;
199209
// MSRV: Use an unnamed constant (`const _: ...`).
200210
let assertion_name = syn::Ident::new(
201-
&format!("__enumflags_assertion_{}_{}",
202-
type_name, flag.name),
203-
Span::call_site()); // call_site because def_site is unstable
211+
&format!("__enumflags_assertion_{}_{}", type_name, flag.name),
212+
Span::call_site(),
213+
); // call_site because def_site is unstable
204214

205215
Ok(Some(quote_spanned!(flag.span =>
206216
#[doc(hidden)]
@@ -217,21 +227,17 @@ fn check_flag(
217227
}
218228
}
219229

220-
fn gen_enumflags(ast: &ItemEnum, default: Vec<Ident>)
221-
-> Result<TokenStream, syn::Error>
222-
{
230+
fn gen_enumflags(ast: &ItemEnum, default: Vec<Ident>) -> Result<TokenStream, syn::Error> {
223231
let ident = &ast.ident;
224232

225233
let span = Span::call_site();
226234
// for quote! interpolation
227-
let variant_names =
228-
ast.variants.iter()
229-
.map(|v| &v.ident)
230-
.collect::<Vec<_>>();
235+
let variant_names = ast.variants.iter().map(|v| &v.ident).collect::<Vec<_>>();
231236
let repeated_name = vec![&ident; ast.variants.len()];
232237

233238
let variants = collect_flags(ast.variants.iter())?;
234-
let deferred = variants.iter()
239+
let deferred = variants
240+
.iter()
235241
.flat_map(|variant| check_flag(ident, variant).transpose())
236242
.collect::<Result<Vec<_>, _>>()?;
237243

@@ -241,8 +247,10 @@ fn gen_enumflags(ast: &ItemEnum, default: Vec<Ident>)
241247
let bits = type_bits(&ty)?;
242248

243249
if (bits as usize) < variants.len() {
244-
return Err(syn::Error::new_spanned(&ty,
245-
format!("Not enough bits for {} flags", variants.len())));
250+
return Err(syn::Error::new_spanned(
251+
&ty,
252+
format!("Not enough bits for {} flags", variants.len()),
253+
));
246254
}
247255

248256
let std_path = quote_spanned!(span => ::enumflags2::_internal::core);
@@ -291,7 +299,7 @@ fn gen_enumflags(ast: &ItemEnum, default: Vec<Ident>)
291299

292300
const EMPTY: Self::Numeric = 0;
293301

294-
const DEFAULT: Self::Numeric =
302+
const DEFAULT: Self::Numeric =
295303
0 #(| (#repeated_name::#default as #ty))*;
296304

297305
const ALL_BITS: Self::Numeric =

0 commit comments

Comments
 (0)