Use internal macro for per-uint-type impls

NOTE: we remove usize, as usize is no longer supported
(as checked by the #[bitflags] macro, see test_suite/ui/invalid_repr.rs).

Also, u128 is added, even though #[repr(u128)] on enums is currently
unstable.

Author: meithecatte

src/fallible.rs

@@ -5,25 +5,17 @@ use super::BitFlag;
 
 // Coherence doesn't let us use a generic type here. Work around by implementing
 // for each integer type manually.
-macro_rules! impl_try_from {
-    ($($ty:ty),*) => {
-        $(
-            impl<T> TryFrom<$ty> for BitFlags<T>
-            where
-                T: BitFlag<Numeric=$ty>,
-            {
-                type Error = FromBitsError<T>;
+for_each_uint! { ty =>
+    impl<T> TryFrom<$ty> for BitFlags<T>
+    where
+        T: BitFlag<Numeric=$ty>,
+    {
+        type Error = FromBitsError<T>;
 
-                fn try_from(bits: T::Numeric) -> Result<Self, Self::Error> {
-                    Self::from_bits(bits)
-                }
-            }
-        )*
-    };
-}
-
-impl_try_from! {
-    u8, u16, u32, u64, usize
+        fn try_from(bits: T::Numeric) -> Result<Self, Self::Error> {
+            Self::from_bits(bits)
+        }
+    }
 }
 
 /// The error struct used by [`BitFlags::from_bits`]

src/lib.rs

@@ -93,6 +93,30 @@ extern crate enumflags2_derive;
 #[doc(hidden)]
 pub use enumflags2_derive::bitflags_internal as bitflags;
 
+// Internal macro: expand into a separate copy for each supported numeric type.
+macro_rules! for_each_uint {
+    ( $tyvar:ident => $($input:tt)* ) => {
+        // This wrapper macro is necessary to create a $ escape sequence
+        // for use in macro repetitions in implement!
+        // cf. https://github.com/rust-lang/rust/issues/35853
+        macro_rules! with_dollar {
+            ( $d:tt ) => {
+                macro_rules! implement {
+                    ( $d($d $tyvar:ty),* ) => {
+                        $d(
+                            $($input)*
+                        )*
+                    }
+                }
+            }
+        }
+
+        with_dollar!($);
+
+        implement! { u8, u16, u32, u64, u128 }
+    }
+}
+
 /// A trait automatically implemented by `#[bitflags]` to make the enum
 /// a valid type parameter for `BitFlags<T>`.
 pub trait BitFlag: Copy + Clone + 'static + _internal::RawBitFlags {
@@ -203,11 +227,9 @@ pub mod _internal {
         + Clone {
     }
 
-    impl BitFlagNum for u8 {}
-    impl BitFlagNum for u16 {}
-    impl BitFlagNum for u32 {}
-    impl BitFlagNum for u64 {}
-    impl BitFlagNum for usize {}
+    for_each_uint! { ty =>
+        impl BitFlagNum for $ty {}
+    }
 
     // Re-export libcore so the macro doesn't inject "extern crate" downstream.
     pub mod core {