impl TryFrom<T::Type> for BitFlags<T>

enumflags/Cargo.toml

@@ -12,3 +12,6 @@ documentation = "https://docs.rs/enumflags2"
 [dependencies]
 enumflags2_derive = { version = "0.6.0", path = "../enumflags_derive" }
 serde = { version = "^1.0.0", default-features = false, optional = true }
+
+[features]
+std = []

enumflags/src/fallible.rs

@@ -0,0 +1,62 @@
+use core::convert::TryFrom;
+use core::fmt;
+use super::BitFlags;
+use super::_internal::RawBitFlags;
+
+macro_rules! impl_try_from {
+    ($($ty:ty),*) => {
+        $(
+            impl<T> TryFrom<$ty> for BitFlags<T>
+            where
+                T: RawBitFlags<Type=$ty>,
+            {
+                type Error = FromBitsError<T>;
+
+                fn try_from(bits: T::Type) -> Result<Self, Self::Error> {
+                    let flags = Self::from_bits_truncate(bits);
+                    if flags.bits() == bits {
+                        Ok(flags)
+                    } else {
+                        Err(FromBitsError {
+                            flags,
+                            invalid: bits & !flags.bits(),
+                        })
+                    }
+                }
+            }
+        )*
+    };
+}
+
+impl_try_from! {
+    u8, u16, u32, u64, usize
+}
+
+#[derive(Debug, Copy, Clone)]
+pub struct FromBitsError<T: RawBitFlags> {
+    flags: BitFlags<T>,
+    invalid: T::Type,
+}
+
+impl<T: RawBitFlags> FromBitsError<T> {
+    pub fn truncate(self) -> BitFlags<T> {
+        self.flags
+    }
+
+    pub fn invalid_bits(self) -> T::Type {
+        self.invalid
+    }
+}
+
+impl<T: RawBitFlags + fmt::Debug> fmt::Display for FromBitsError<T> {
+    fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+        write!(fmt, "Invalid bits for {:?}: {:#b}", self.flags, self.invalid)
+    }
+}
+
+#[cfg(feature = "std")]
+impl<T: RawBitFlags + fmt::Debug> std::error::Error for FromBitsError<T> {
+    fn description(&self) -> &str {
+        "invalid bitflags representation"
+    }
+}

enumflags/src/formatting.rs

@@ -4,7 +4,6 @@ use crate::{BitFlags, _internal::RawBitFlags};
 impl<T> fmt::Debug for BitFlags<T>
 where
     T: RawBitFlags + fmt::Debug,
-    T::Type: fmt::Binary + fmt::Debug,
 {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         let name = T::bitflags_type_name();

enumflags/src/lib.rs

@@ -44,10 +44,11 @@
 //! ## Optional Feature Flags
 //!
 //! - [`serde`](https://serde.rs/) implements `Serialize` and `Deserialize` for `BitFlags<T>`.
+//! - `std` implements `std::error::Error` for `FromBitsError`.
 #![warn(missing_docs)]
-#![cfg_attr(not(test), no_std)]
+#![cfg_attr(all(not(test), not(feature = "std")), no_std)]
 
-#[cfg(test)]
+#[cfg(any(test, feature = "std"))]
 extern crate core;
 use core::{cmp, ops};
 use core::iter::FromIterator;
@@ -89,6 +90,7 @@ pub mod _internal {
 
     use core::ops::{BitAnd, BitOr, BitXor, Not};
     use core::cmp::PartialOrd;
+    use core::fmt;
 
     pub trait BitFlagNum
         : Default
@@ -97,6 +99,8 @@ pub mod _internal {
         + BitXor<Self, Output = Self>
         + Not<Output = Self>
         + PartialOrd<Self>
+        + fmt::Debug
+        + fmt::Binary
         + Copy
         + Clone {
     }
@@ -116,6 +120,10 @@ pub mod _internal {
 // Internal debug formatting implementations
 mod formatting;
 
+// impl TryFrom<T::Type> for BitFlags<T>
+mod fallible;
+pub use fallible::FromBitsError;
+
 use _internal::RawBitFlags;
 
 /// Represents a set of flags of some type `T`.
@@ -148,7 +156,7 @@ where
 
 impl<T: RawBitFlags> From<T> for BitFlags<T> {
     fn from(t: T) -> BitFlags<T> {
-        BitFlags { val: t.bits() }
+        Self::from_flag(t)
     }
 }
 
@@ -201,6 +209,10 @@ where
         }
     }
 
+    pub fn from_flag(t: T) -> Self {
+        BitFlags { val: t.bits() }
+    }
+
     /// Truncates flags that are illegal
     pub fn from_bits_truncate(bits: T::Type) -> Self {
         unsafe { BitFlags::new(bits & T::all()) }

test_suite/tests/formatting.rs

@@ -72,3 +72,13 @@ fn format() {
         "0x0F"
     );
 }
+
+#[test]
+fn debug_generic() {
+    use enumflags2::{BitFlags, _internal::RawBitFlags};
+
+    #[derive(Debug)]
+    struct Debug<T: RawBitFlags>(BitFlags<T>);
+
+    let _ = format!("{:?}", Debug(BitFlags::<Test>::all()));
+}