Move EnumSetType fields into a private trait.

diff --git a/enumset/src/lib.rs b/enumset/src/lib.rs
index 44322b014499f148493bafaab5b0267b53e9ca7c..8001b4bf939a66b438ce34b0bc95a3dbc596b137 100644 (file)
--- a/enumset/src/lib.rs
+++ b/enumset/src/lib.rs
@@ -80,7 +80,6 @@ use core::fmt;
 use core::fmt::{Debug, Formatter};
 use core::hash::{Hash, Hasher};
 use core::ops::*;
-use serde2 as serde;
 
 use num_traits::*;
 
@@ -100,7 +99,23 @@ pub mod internal {
 
     /// A reexport of serde so there is no requirement to depend on serde.
     #[cfg(feature = "serde")] pub use serde2 as serde;
+
+    /// The actual members of EnumSetType. Put here to avoid polluting global namespaces.
+    pub unsafe trait EnumSetTypePrivate {
+        type Repr: EnumSetTypeRepr;
+        const ALL_BITS: Self::Repr;
+        fn enum_into_u8(self) -> u8;
+        unsafe fn enum_from_u8(val: u8) -> Self;
+
+        #[cfg(feature = "serde")]
+        fn serialize<S: serde::Serializer>(set: EnumSet<Self>, ser: S) -> Result<S::Ok, S::Error>
+            where Self: EnumSetType;
+        #[cfg(feature = "serde")]
+        fn deserialize<'de, D: serde::Deserializer<'de>>(de: D) -> Result<EnumSet<Self>, D::Error>
+            where Self: EnumSetType;
+    }
 }
+use internal::EnumSetTypePrivate;
 
 mod private {
     use super::*;
@@ -172,17 +187,7 @@ use private::EnumSetTypeRepr;
 ///    A, B, C, D, E, F, G,
 /// }
 /// ```
-pub unsafe trait EnumSetType: Copy + Eq {
-    #[doc(hidden)] type Repr: EnumSetTypeRepr;
-    #[doc(hidden)] const ALL_BITS: Self::Repr;
-    #[doc(hidden)] fn enum_into_u8(self) -> u8;
-    #[doc(hidden)] unsafe fn enum_from_u8(val: u8) -> Self;
-
-    #[cfg(feature = "serde")] #[doc(hidden)]
-    fn serialize<S: serde::Serializer>(set: EnumSet<Self>, ser: S) -> Result<S::Ok, S::Error>;
-    #[cfg(feature = "serde")] #[doc(hidden)]
-    fn deserialize<'de, D: serde::Deserializer<'de>>(de: D) -> Result<EnumSet<Self>, D::Error>;
-}
+pub unsafe trait EnumSetType: Copy + Eq + EnumSetTypePrivate { }
 
 /// An efficient set type for enums.
 ///

diff --git a/enumset/tests/ops.rs b/enumset/tests/ops.rs
index 8a7579d49593ab16e6b6b7e029138135747d792f..014891d87203ac6d28058602609d5343a18be00e 100644 (file)
--- a/enumset/tests/ops.rs
+++ b/enumset/tests/ops.rs
@@ -72,8 +72,8 @@ test_variants! { SparseEnum sparse_enum_all_empty
 }
 
 macro_rules! test_enum {
-    ($e:ident, $mem_size:expr, $ser_size:expr) => {
-        const CONST_SET: EnumSet<$e> = enum_set!($e, $e::A | $e::C);
+    ($e:ident, $mem_size:expr) => {
+        const CONST_SET: EnumSet<$e> = enum_set!($e::A | $e::C);
         const EMPTY_SET: EnumSet<$e> = enum_set!();
         #[test]
         fn const_set() {
@@ -191,8 +191,8 @@ macro_rules! tests {
     ($m:ident, $($tt:tt)*) => { mod $m { use super::*; $($tt)*; } }
 }
 
-tests!(small_enum, test_enum!(SmallEnum, 4, 4));
-tests!(large_enum, test_enum!(LargeEnum, 16, 16));
-tests!(enum8, test_enum!(Enum8, 1, 1));
-tests!(enum128, test_enum!(Enum128, 16, 16));
-tests!(sparse_enum, test_enum!(SparseEnum, 16, 16));
\ No newline at end of file
+tests!(small_enum, test_enum!(SmallEnum, 4));
+tests!(large_enum, test_enum!(LargeEnum, 16));
+tests!(enum8, test_enum!(Enum8, 1));
+tests!(enum128, test_enum!(Enum128, 16));
+tests!(sparse_enum, test_enum!(SparseEnum, 16));
\ No newline at end of file

diff --git a/enumset_derive/src/lib.rs b/enumset_derive/src/lib.rs
index 7fc210895fe33080644759195b1c2989d89c0093..d18523a9a4708b75ed73157311c6bf106b9d738c 100644 (file)
--- a/enumset_derive/src/lib.rs
+++ b/enumset_derive/src/lib.rs
@@ -154,7 +154,7 @@ fn enum_set_type_impl(
     let serde_ops = quote! { };
 
     quote! {
-        unsafe impl ::enumset::EnumSetType for #name {
+        unsafe impl ::enumset::internal::EnumSetTypePrivate for #name {
             type Repr = #repr;
             const ALL_BITS: Self::Repr = #all_variants;
 
@@ -168,6 +168,8 @@ fn enum_set_type_impl(
             #serde_ops
         }
 
+        unsafe impl ::enumset::EnumSetType for #name { }
+
         impl #core::cmp::PartialEq for #name {
             fn eq(&self, other: &Self) -> bool {
                 (*self as u8) == (*other as u8)