Switch to an attribute macro

Author: meithecatte

enumflags_derive/src/lib.rs

@@ -7,35 +7,31 @@ use syn::{Data, Ident, DeriveInput, DataEnum, spanned::Spanned};
 use proc_macro2::TokenStream;
 use proc_macro2::Span;
 
-/// Shorthand for a quoted `compile_error!`.
-macro_rules! error {
-    ($span:expr => $($x:tt)*) => {
-        quote_spanned!($span => compile_error!($($x)*);)
-    };
-    ($($x:tt)*) => {
-        quote!(compile_error!($($x)*);)
-    };
-}
-
-#[proc_macro_derive(BitFlags_internal)]
-pub fn derive_enum_flags(input: proc_macro::TokenStream)
-    -> proc_macro::TokenStream
-{
+#[proc_macro_attribute]
+pub fn bitflags_internal(
+    _attr: proc_macro::TokenStream,
+    input: proc_macro::TokenStream,
+) -> proc_macro::TokenStream {
     let ast: DeriveInput = syn::parse(input).unwrap();
 
-    match ast.data {
+    let impls = match ast.data {
         Data::Enum(ref data) => {
             gen_enumflags(&ast.ident, &ast, data)
-                .unwrap_or_else(|err| err.to_compile_error())
-                .into()
         }
         Data::Struct(ref data) => {
-            error!(data.struct_token.span => "BitFlags can only be derived on enums").into()
+            Err(syn::Error::new_spanned(data.struct_token, "#[bitflags] requires an enum"))
         }
         Data::Union(ref data) => {
-            error!(data.union_token.span => "BitFlags can only be derived on enums").into()
+            Err(syn::Error::new_spanned(data.union_token, "#[bitflags] requires an enum"))
         }
-    }
+    };
+
+    let impls = TokenStream::from(impls.unwrap_or_else(|err| err.to_compile_error()));
+    let combined = quote! {
+        #ast
+        #impls
+    };
+    combined.into()
 }
 
 /// Try to evaluate the expression given.
@@ -232,6 +228,6 @@ fn gen_enumflags(ident: &Ident, item: &DeriveInput, data: &DataEnum)
                 }
             }
 
-            impl ::enumflags2::RawBitFlags for #ident {}
+            impl ::enumflags2::BitFlag for #ident {}
     })
 }

src/fallible.rs

@@ -1,7 +1,7 @@
 use core::convert::TryFrom;
 use core::fmt;
 use super::BitFlags;
-use super::RawBitFlags;
+use super::BitFlag;
 
 // Coherence doesn't let us use a generic type here. Work around by implementing
 // for each integer type manually.
@@ -10,7 +10,7 @@ macro_rules! impl_try_from {
         $(
             impl<T> TryFrom<$ty> for BitFlags<T>
             where
-                T: RawBitFlags<Type=$ty>,
+                T: BitFlag<Type=$ty>,
             {
                 type Error = FromBitsError<T>;
 
@@ -32,8 +32,9 @@ impl_try_from! {
 ///
 /// ```
 /// # use std::convert::TryInto;
-/// # use enumflags2::BitFlags;
-/// #[derive(Clone, Copy, Debug, BitFlags)]
+/// # use enumflags2::{bitflags, BitFlags};
+/// #[bitflags]
+/// #[derive(Clone, Copy, Debug)]
 /// #[repr(u8)]
 /// enum MyFlags {
 ///     A = 0b0001,
@@ -49,12 +50,12 @@ impl_try_from! {
 /// assert_eq!(error.invalid_bits(), 0b10000);
 /// ```
 #[derive(Debug, Copy, Clone)]
-pub struct FromBitsError<T: RawBitFlags> {
+pub struct FromBitsError<T: BitFlag> {
     pub(crate) flags: BitFlags<T>,
     pub(crate) invalid: T::Type,
 }
 
-impl<T: RawBitFlags> FromBitsError<T> {
+impl<T: BitFlag> FromBitsError<T> {
     /// Return the truncated result of the conversion.
     pub fn truncate(self) -> BitFlags<T> {
         self.flags
@@ -66,14 +67,14 @@ impl<T: RawBitFlags> FromBitsError<T> {
     }
 }
 
-impl<T: RawBitFlags + fmt::Debug> fmt::Display for FromBitsError<T> {
+impl<T: BitFlag + 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> {
+impl<T: BitFlag + fmt::Debug> std::error::Error for FromBitsError<T> {
     fn description(&self) -> &str {
         "invalid bitflags representation"
     }

src/formatting.rs

@@ -1,9 +1,9 @@
 use core::fmt::{self, Debug, Binary};
-use crate::{BitFlags, RawBitFlags};
+use crate::{BitFlags, BitFlag};
 
 impl<T> fmt::Debug for BitFlags<T>
 where
-    T: RawBitFlags + fmt::Debug,
+    T: BitFlag + fmt::Debug,
 {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
         let name = T::bitflags_type_name();
@@ -37,7 +37,7 @@ where
 
 impl<T> fmt::Binary for BitFlags<T>
 where
-    T: RawBitFlags,
+    T: BitFlag,
     T::Type: fmt::Binary,
 {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -47,7 +47,7 @@ where
 
 impl<T> fmt::Octal for BitFlags<T>
 where
-    T: RawBitFlags,
+    T: BitFlag,
     T::Type: fmt::Octal,
 {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -57,7 +57,7 @@ where
 
 impl<T> fmt::LowerHex for BitFlags<T>
 where
-    T: RawBitFlags,
+    T: BitFlag,
     T::Type: fmt::LowerHex,
 {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -67,7 +67,7 @@ where
 
 impl<T> fmt::UpperHex for BitFlags<T>
 where
-    T: RawBitFlags,
+    T: BitFlag,
     T::Type: fmt::UpperHex,
 {
     fn fmt(&self, fmt: &mut fmt::Formatter<'_>) -> fmt::Result {