Touch up macros

rossmacarthur · rossmacarthur · commit 92c9b34647f9 · 2020-08-28T11:04:46.000+02:00
diff --git a/src/field/_macros.rs b/src/field/_macros.rs
@@ -1,45 +1,45 @@
 macro_rules! impl_kind {
     (
         $(#[$outer:meta])*
-        pub enum $name:ident {
+        pub enum $Kind:ident {
             $(
                 $(#[$inner:ident $($args:tt)*])*
-                $variant:ident { bit: $bit:expr, align: $align:expr, size: $size:expr },
+                $Variant:ident { bit: $BIT:expr, align: $ALIGN:expr, size: $SIZE:expr },
             )+
         }
     ) => {
         $(#[$outer])*
-        pub enum $name {
+        pub enum $Kind {
             $(
                 $(#[$inner $($args)*])*
-                $variant,
+                $Variant,
             )+
         }
 
-        impl $name {
+        impl $Kind {
             /// Construct a new type from a bit. `None` if unknown.
             pub fn from_bit(bit: u32) -> Option<Self> {
                 match bit {
-                    $( $bit => Some(Self::$variant), )+
+                    $( $BIT => Some(Self::$Variant), )+
                     _ => None
                 }
             }
 
             /// Returns the present bit for the type.
             pub fn bit(&self) -> u32 {
-                match self { $( Self::$variant => $bit, )+ }
+                match self { $( Self::$Variant => $BIT, )+ }
             }
         }
 
-        impl crate::Kind for $name {
+        impl crate::Kind for $Kind {
             /// Returns the alignment of the field.
             fn align(&self) -> usize {
-                match self { $( Self::$variant => $align, )+ }
+                match self { $( Self::$Variant => $ALIGN, )+ }
             }
 
             /// Returns the size of the field.
             fn size(&self) -> usize {
-                match self { $( Self::$variant => $size, )+ }
+                match self { $( Self::$Variant => $SIZE, )+ }
             }
         }
 
@@ -49,38 +49,37 @@ macro_rules! impl_kind {
 macro_rules! impl_enum {
     (
         $(#[$outer:meta])*
-        pub enum $name:ident: $ty:ty{
+        pub enum $Field:ident: $ty:ty {
             $(
                 $(#[$inner:ident $($args:tt)*])*
-                $variant:ident = $value:expr,
+                $Variant:ident = $VALUE:expr,
             )+
         }
     ) => {
         $(#[$outer])*
-        #[derive(Debug, Clone, PartialEq)]
-        pub enum $name {
+        #[derive(Debug, Clone, Copy, PartialEq)]
+        pub enum $Field {
             $(
                 $(#[$inner $($args)*])*
-                $variant = $value,
+                $Variant = $VALUE,
             )+
         }
 
         #[allow(dead_code)]
-        impl $name {
+        impl $Field {
             pub(crate) fn from_bits(bits: $ty) -> Option<Self> {
                 match bits {
                     $(
-                        $value => Some(Self::$variant),
+                        $VALUE => Some(Self::$Variant),
                     )+
                     _ => None
                 }
             }
 
-            /// Consumes this field and returns the underlying value.
             pub(crate) fn into_inner(self) -> $ty {
                 match self {
                     $(
-                        Self::$variant => $value,
+                        Self::$Variant => $VALUE,
                     )+
                 }
             }
@@ -91,21 +90,21 @@ macro_rules! impl_enum {
 macro_rules! impl_newtype {
     (
         $(#[$outer:meta])*
-        pub struct $name:ident($ty:ty);
+        pub struct $Field:ident($ty:ty);
     ) => {
         $(#[$outer])*
-        #[derive(Debug, Clone, PartialEq)]
-        pub struct $name(pub(crate) $ty);
+        #[derive(Debug, Clone, Copy, PartialEq)]
+        pub struct $Field($ty);
 
-        impl FromBytes for $name {
+        impl frombytes::FromBytes for $Field {
             type Error = frombytes::Error;
 
             fn from_bytes(bytes: &mut frombytes::Bytes) -> frombytes::Result<Self> {
                 bytes.read().map(Self)
             }
         }
 
-        impl $name {
+        impl $Field {
             /// Consumes this field and returns the underlying value.
             #[inline]
             pub const fn into_inner(self) -> $ty {
@@ -118,32 +117,32 @@ macro_rules! impl_newtype {
 macro_rules! impl_bitflags {
     (
         $(#[$outer:meta])*
-        pub struct $name:ident: $ty:ty {
+        pub struct $Field:ident: $ty:ty {
             $(
                 $(#[$inner:ident $($args:tt)*])*
-                const $flag:ident = $value:expr;
+                const $FLAG:ident = $VALUE:expr;
             )+
         }
     ) => {
         bitflags::bitflags! {
             $(#[$outer])*
-            pub struct $name: $ty {
+            pub struct $Field: $ty {
                 $(
                     $(#[$inner $($args)*])*
-                    const $flag = $value;
+                    const $FLAG = $VALUE;
                 )+
             }
         }
 
-        impl frombytes::FromBytes for $name {
+        impl frombytes::FromBytes for $Field {
             type Error = frombytes::Error;
 
             fn from_bytes(bytes: &mut frombytes::Bytes) -> frombytes::Result<Self> {
                 bytes.read().map(Self::from_bits_truncate)
             }
         }
 
-        impl $name {
+        impl $Field {
             /// Consumes this field and returns the underlying value.
             #[inline]
             pub const fn into_inner(self) -> $ty {
diff --git a/src/field/mod.rs b/src/field/mod.rs
@@ -125,7 +125,6 @@ impl VendorNamespace {
 
 impl_enum! {
     /// The guard interval.
-    #[derive(Copy)]
     #[non_exhaustive]
     pub enum GuardInterval: u8 {
         /// 800 ns.
@@ -145,7 +144,6 @@ impl From<bool> for GuardInterval {
 }
 
 impl_enum! {
-    #[derive(Copy)]
     /// Forward error correction type.
     pub enum Fec: u8 {
         /// Binary convolutional coding.
