Allow customizing defaults

Author: meithecatte

README.md

@@ -5,10 +5,9 @@
 
 # Enumflags
 
-`enumflags2` defines a `BitFlags<T>` type, which is a `Set<T>`
-for enums without associated data.
-
-This means that the type of a single flag is separate from a set of flags.
+`enumflags2` implements the classic bitflags datastructure. Annotate an enum
+with `#[bitflags]`, and `BitFlags<YourEnum>` will be able to hold arbitrary combinations
+of your enum within the space of a single integer.
 
 ## Usage
 
@@ -28,7 +27,8 @@ enumflags2 = "^0.6"
 - [x] Optional support for serialization with the [`serde`](https://serde.rs/) feature flag.
 
 ## Example
-```
+
+```rust
 use enumflags2::{bitflags, make_bitflags, BitFlags};
 
 #[bitflags]
@@ -91,4 +91,23 @@ want to write a separate implementation for `BitFlags<T, u8>`,
 This strategy is often used by `enumflags2` itself; to avoid clutter, only
 one of the copies is shown in the documentation.
 
+## Customizing `Default`
+
+By default, creating an instance of `BitFlags<T>` with `Default` will result in an empty
+set. If that's undesirable, you may customize this:
+
+```rust
+#[bitflags(default = B | C)]
+#[repr(u8)]
+#[derive(Copy, Clone, Debug, PartialEq)]
+enum Test {
+    A = 0b0001,
+    B = 0b0010,
+    C = 0b0100,
+    D = 0b1000,
+}
+
+assert_eq!(BitFlags::default(), Test::B | Test::C);
+```
+
 [const-trait-rfc]: https://github.com/rust-lang/rfcs/pull/2632

enumflags_derive/src/lib.rs

@@ -4,7 +4,7 @@ extern crate proc_macro;
 extern crate quote;
 
 use std::convert::TryFrom;
-use syn::{Ident, Item, ItemEnum, spanned::Spanned, parse_macro_input};
+use syn::{Token, Ident, Item, ItemEnum, spanned::Spanned, parse_macro_input, parse::{Parse, ParseStream}};
 use proc_macro2::{TokenStream, Span};
 
 struct Flag {
@@ -19,14 +19,41 @@ enum FlagValue {
     Inferred,
 }
 
+struct Parameters {
+    default: Vec<Ident>,
+}
+
+impl Parse for Parameters {
+    fn parse(input: ParseStream) -> syn::parse::Result<Self> {
+        if input.is_empty() {
+            return Ok(Parameters {
+                default: vec![],
+            });
+        }
+
+        input.parse::<Token![default]>()?;
+        input.parse::<Token![=]>()?;
+        let mut default = vec![input.parse()?];
+        while !input.is_empty() {
+            input.parse::<Token![|]>()?;
+            default.push(input.parse()?);
+        }
+
+        Ok(Parameters {
+            default
+        })
+    }
+}
+
 #[proc_macro_attribute]
 pub fn bitflags_internal(
-    _attr: proc_macro::TokenStream,
+    attr: proc_macro::TokenStream,
     input: proc_macro::TokenStream,
 ) -> proc_macro::TokenStream {
+    let Parameters { default } = parse_macro_input!(attr as Parameters);
     let ast = parse_macro_input!(input as Item);
     let output = match ast {
-        Item::Enum(ref item_enum) => gen_enumflags(item_enum),
+        Item::Enum(ref item_enum) => gen_enumflags(item_enum, default),
         _ => Err(syn::Error::new_spanned(&ast,
                 "#[bitflags] requires an enum")),
     };
@@ -190,7 +217,7 @@ fn check_flag(
     }
 }
 
-fn gen_enumflags(ast: &ItemEnum)
+fn gen_enumflags(ast: &ItemEnum, default: Vec<Ident>)
     -> Result<TokenStream, syn::Error>
 {
     let ident = &ast.ident;
@@ -264,6 +291,9 @@ fn gen_enumflags(ast: &ItemEnum)
 
                 const EMPTY: Self::Numeric = 0;
 
+                const DEFAULT: Self::Numeric = 
+                    0 #(| (#repeated_name::#default as #ty))*;
+
                 const ALL_BITS: Self::Numeric =
                     0 #(| (#repeated_name::#variant_names as #ty))*;
 

src/lib.rs

@@ -1,8 +1,7 @@
 //! # Enum Flags
-//! `enumflags2` defines a `BitFlags<T>` type, which is a `Set<T>`
-//! for enums without associated data.
-//!
-//! This means that the type of a single flag is separate from a set of flags.
+//! `enumflags2` implements the classic bitflags datastructure. Annotate an enum
+//! with `#[bitflags]`, and `BitFlags<YourEnum>` will be able to hold arbitrary combinations
+//! of your enum within the space of a single integer.
 //!
 //! ## Example
 //! ```
@@ -68,6 +67,26 @@
 //! This strategy is often used by `enumflags2` itself; to avoid clutter, only
 //! one of the copies is shown in the documentation.
 //!
+//! ## Customizing `Default`
+//!
+//! By default, creating an instance of `BitFlags<T>` with `Default` will result in an empty
+//! set. If that's undesirable, you may customize this:
+//!
+//! ```
+//! # use enumflags2::{BitFlags, bitflags};
+//! #[bitflags(default = B | C)]
+//! #[repr(u8)]
+//! #[derive(Copy, Clone, Debug, PartialEq)]
+//! enum Test {
+//!     A = 0b0001,
+//!     B = 0b0010,
+//!     C = 0b0100,
+//!     D = 0b1000,
+//! }
+//!
+//! assert_eq!(BitFlags::default(), Test::B | Test::C);
+//! ```
+//!
 //! [const-trait-rfc]: https://github.com/rust-lang/rfcs/pull/2632
 #![warn(missing_docs)]
 #![cfg_attr(all(not(test), not(feature = "std")), no_std)]
@@ -174,6 +193,10 @@ pub mod _internal {
         /// A value with no bits set.
         const EMPTY: Self::Numeric;
 
+        /// The value used by the Default implementation. Equivalent to EMPTY, unless
+        /// customized.
+        const DEFAULT: Self::Numeric;
+
         /// A value with all flag bits set.
         const ALL_BITS: Self::Numeric;
 
@@ -357,14 +380,15 @@ macro_rules! make_bitflags {
     }
 }
 
-/// The default value returned is one with all flags unset, i. e. [`empty`][Self::empty].
+/// The default value returned is one with all flags unset, i. e. [`empty`][Self::empty],
+/// unless customized.
 impl<T> Default for BitFlags<T>
 where
     T: BitFlag,
 {
     #[inline(always)]
     fn default() -> Self {
-        Self::empty()
+        BitFlags { val: T::DEFAULT, marker: PhantomData }
     }
 }