impl Debug for BitFlags

The internal `BitFlagsFmt` trait has been removed and replaced with a
`bitflags_type_name()` method.

Author: arcnmx

enumflags/src/lib.rs

@@ -52,6 +52,7 @@ use core::iter::FromIterator;
 mod details {
     use core::ops::{BitAnd, BitOr, BitXor, Not};
     use core::cmp::PartialOrd;
+    use core::fmt::{self, Debug};
 
     pub trait BitFlagNum
         : Default
@@ -69,21 +70,56 @@ mod details {
     impl BitFlagNum for u32 {}
     impl BitFlagNum for u64 {}
     impl BitFlagNum for usize {}
-}
 
-use details::BitFlagNum;
+    // Format an iterator of flags into "A | B | etc"
+    pub(crate) struct FlagFormatter<I>(pub I);
+
+    impl<T: Debug, I: Clone + Iterator<Item=T>> Debug for FlagFormatter<I> {
+        fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+            let mut iter = self.0.clone();
+            if let Some(val) = iter.next() {
+                write!(fmt, "{:?}", val)?
+            }
+            for val in iter {
+                write!(fmt, " | {:?}", val)?
+            }
+            Ok(())
+        }
+    }
 
-/// A trait automatically implemented by `derive(EnumFlags)` on `T` to enable debug printing of
-/// `BitFlags<T>`. This is necessary because the names of the variants are needed.
-#[doc(hidden)]
-pub trait BitFlagsFmt
-where
-    Self: RawBitFlags,
-{
-    /// The implementation of Debug redirects here.
-    fn fmt(flags: BitFlags<Self>, f: &mut fmt::Formatter) -> fmt::Result;
+    // A formatter that obeys format arguments but falls back to binary when
+    // no explicit format is requested. Supports {:08?}, {:08x?}, etc.
+    pub(crate) struct DebugBinaryFormatter<'a, F>(pub &'a F);
+
+    impl<'a, F: fmt::Debug + fmt::Binary + 'a> fmt::Debug for DebugBinaryFormatter<'a, F> {
+        fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+            // Check if {:x?} or {:X?} was used; this is determined via the
+            // discriminator of core::fmt::FlagV1::{DebugLowerHex, DebugUpperHex},
+            // which is not an accessible type: https://github.com/rust-lang/rust/blob/d65e272a9fe3e61aa5f229c5358e35a909435575/src/libcore/fmt/mod.rs#L306
+            // See also: https://github.com/rust-lang/rfcs/pull/2226
+            #[allow(deprecated)]
+            let format_hex = fmt.flags() & (3 << 4) != 0;
+
+            if format_hex {
+                // fmt::Debug machinery handles everything properly
+                if !fmt.alternate() {
+                    write!(fmt, "0x")?
+                }
+                fmt::Debug::fmt(self.0, fmt)
+            } else {
+                // Fall back to binary otheriwse but retain all other arguments
+                // such as padding, alignment, etc.
+                if !fmt.alternate() {
+                    write!(fmt, "0b")?
+                }
+                fmt::Binary::fmt(self.0, fmt)
+            }
+        }
+    }
 }
 
+use details::BitFlagNum;
+
 /// A trait automatically implemented by `derive(EnumFlags)` to make the enum a valid type parameter
 /// for BitFlags.
 #[doc(hidden)]
@@ -99,6 +135,13 @@ pub trait RawBitFlags: Copy + Clone + 'static {
 
     /// Return a slice that contains each variant exactly one.
     fn flag_list() -> &'static [Self];
+
+    /// Return the name of the type for debug formatting purposes.
+    ///
+    /// This is typically `BitFlags<EnumName>`
+    fn bitflags_type_name() -> &'static str {
+        "BitFlags"
+    }
 }
 
 /// Represents a set of flags of some type `T`.
@@ -111,10 +154,17 @@ pub struct BitFlags<T: RawBitFlags> {
 
 impl<T> fmt::Debug for BitFlags<T>
 where
-    T: RawBitFlags + BitFlagsFmt,
+    T: RawBitFlags + fmt::Debug,
+    T::Type: fmt::Binary + fmt::Debug,
 {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
-        T::fmt(self.clone(), fmt)
+        let mut debug = fmt.debug_tuple(T::bitflags_type_name());
+        debug.field(&details::DebugBinaryFormatter(&self.bits()));
+        if !self.is_empty() {
+            let iter = T::flag_list().iter().filter(|&&flag| self.contains(flag));
+            debug.field(&details::FlagFormatter(iter));
+        }
+        debug.finish()
     }
 }
 

enumflags_derive/src/lib.rs

@@ -79,7 +79,6 @@ fn extract_repr(attrs: &[syn::Attribute]) -> Option<syn::Ident> {
 fn gen_enumflags(ident: &Ident, item: &DeriveInput, data: &DataEnum) -> TokenStream {
     let span  = Span::call_site();
     let variants = data.variants.iter().map(|v| &v.ident);
-    let variants_names = variants.clone().map(ToString::to_string);
     let flag_values: Vec<_> = data.variants.iter()
         .map(|v| v.discriminant.as_ref().map(|d| fold_expr(&d.1)).expect("No discriminant")).collect();
     let variants_len = flag_values.len();
@@ -158,30 +157,6 @@ fn gen_enumflags(ident: &Ident, item: &DeriveInput, data: &DataEnum) -> TokenStr
                 }
             }
 
-            impl ::enumflags2::BitFlagsFmt for #ident {
-                fn fmt(flags: ::enumflags2::BitFlags<#ident>,
-                       fmt: &mut #std_path::fmt::Formatter)
-                       -> #std_path::fmt::Result {
-                    use ::enumflags2::RawBitFlags;
-                    use #std_path::iter::Iterator;
-                    const VARIANT_NAMES: [&'static str; #variants_len] = [#(#variants_names, )*];
-                    let mut vals =
-                        VARIANTS.iter().zip(VARIANT_NAMES.iter())
-                        .filter(|&(&val, _)| val as #ty & flags.bits() != 0)
-                        .map(|(_, name)| name);
-                    write!(fmt, "BitFlags<{}>(0b{:b}",
-                           stringify!(#ident),
-                           flags.bits())?;
-                    if let #std_path::option::Option::Some(val) = vals.next() {
-                        write!(fmt, ", {}", val)?;
-                        for val in vals {
-                            write!(fmt, " | {}", val)?;
-                        }
-                    }
-                    write!(fmt, ")")
-                }
-            }
-
             impl ::enumflags2::RawBitFlags for #ident {
                 type Type = #ty;
 
@@ -196,6 +171,10 @@ fn gen_enumflags(ident: &Ident, item: &DeriveInput, data: &DataEnum) -> TokenStr
                 fn flag_list() -> &'static [Self] {
                     &VARIANTS
                 }
+
+                fn bitflags_type_name() -> &'static str {
+                    concat!("BitFlags<", stringify!(#ident), ">")
+                }
             }
         }
     }

example/src/main.rs

@@ -2,7 +2,7 @@ extern crate enumflags2;
 #[macro_use]
 extern crate enumflags2_derive;
 use enumflags2::*;
-#[derive(EnumFlags, Copy, Clone)]
+#[derive(EnumFlags, Copy, Clone, Debug)]
 #[repr(u8)]
 pub enum Test {
     A = 0b0001,