Add BitVec support

.github/workflows/rust.yml

@@ -39,6 +39,7 @@ jobs:
 
     - name: check-features
       run: |
+        cargo check --no-default-features --features bit-vec
         cargo check --no-default-features --features serde
         cargo check --no-default-features --features serde,decode
 
@@ -50,7 +51,7 @@ jobs:
 
     - name: test
       run: |
-        cargo test --all
+        cargo test --all --all-features
 
     - name: test no-std
       run: |

Cargo.toml

@@ -14,6 +14,7 @@ categories = ["no-std", "encoding"]
 include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE"]
 
 [dependencies]
+bitvec = { version = "0.20.1", default-features = false, features = ["alloc"], optional = true }
 cfg-if = "1.0"
 scale-info-derive = { version = "0.4.0", path = "derive", default-features = false, optional = true }
 serde = { version = "1", default-features = false, optional = true, features = ["derive", "alloc"] }
@@ -23,6 +24,7 @@ scale = { package = "parity-scale-codec", version = "2.1", default-features = fa
 [features]
 default = ["std"]
 std = [
+    "bitvec/std",
     "scale/std",
 ]
 derive = [
@@ -32,6 +34,10 @@ derive = [
 decode = [
     "scale/full"
 ]
+# enables type information for bitvec types, matching the name of the parity-scale-codec feature
+bit-vec = [
+    "bitvec"
+]
 
 [workspace]
 members = [

src/impls.rs

@@ -286,3 +286,38 @@ where
         TypeDefCompact::new(MetaType::new::<T>()).into()
     }
 }
+
+#[cfg(feature = "bit-vec")]
+impl<O, T> TypeInfo for bitvec::vec::BitVec<O, T>
+where
+    O: bitvec::order::BitOrder + TypeInfo + 'static,
+    T: bitvec::store::BitStore + TypeInfo + 'static,
+{
+    type Identity = Self;
+
+    fn type_info() -> Type {
+        crate::TypeDefBitVec::new::<O, T>().into()
+    }
+}
+
+#[cfg(feature = "bit-vec")]
+impl TypeInfo for bitvec::order::Lsb0 {
+    type Identity = Self;
+
+    fn type_info() -> Type {
+        Type::builder()
+            .path(Path::new("Lsb0", "bitvec::order"))
+            .composite(Fields::unit())
+    }
+}
+
+#[cfg(feature = "bit-vec")]
+impl TypeInfo for bitvec::order::Msb0 {
+    type Identity = Self;
+
+    fn type_info() -> Type {
+        Type::builder()
+            .path(Path::new("Msb0", "bitvec::order"))
+            .composite(Fields::unit())
+    }
+}

src/tests.rs

@@ -111,6 +111,33 @@ fn collections() {
     );
 }
 
+#[cfg(feature = "bit-vec")]
+#[test]
+fn bitvec() {
+    use bitvec::{
+        order::{
+            Lsb0,
+            Msb0,
+        },
+        vec::BitVec,
+    };
+
+    assert_type!(
+        BitVec<Lsb0, u8>,
+        TypeDefBitVec::new::<Lsb0, u8>()
+    );
+
+    assert_type!(
+        BitVec<Msb0, u16>,
+        TypeDefBitVec::new::<Msb0, u16>()
+    );
+
+    assert_type!(
+        BitVec<Msb0, u32>,
+        TypeDefBitVec::new::<Msb0, u32>()
+    );
+}
+
 #[test]
 fn scale_compact_types() {
     assert_type!(Compact<i32>, TypeDefCompact::new(meta_type::<i32>()))

src/ty/mod.rs

@@ -118,6 +118,13 @@ impl_from_type_def_for_type!(
     TypeDefPhantom,
 );
 
+#[cfg(feature = "bit-vec")]
+impl From<crate::TypeDefBitVec> for Type {
+    fn from(item: crate::TypeDefBitVec) -> Self {
+        Self::new(Path::voldemort(), Vec::new(), item, Vec::new())
+    }
+}
+
 impl Type {
     /// Create a [`TypeBuilder`](`crate::build::TypeBuilder`) the public API for constructing a [`Type`]
     pub fn builder() -> TypeBuilder {
@@ -197,6 +204,9 @@ pub enum TypeDef<T: Form = MetaForm> {
     Compact(TypeDefCompact<T>),
     /// A PhantomData type.
     Phantom(TypeDefPhantom<T>),
+    #[cfg(feature = "bit-vec")]
+    /// A BitVec type.
+    BitVec(TypeDefBitVec<T>),
 }
 
 impl IntoPortable for TypeDef {
@@ -212,6 +222,8 @@ impl IntoPortable for TypeDef {
             TypeDef::Primitive(primitive) => primitive.into(),
             TypeDef::Compact(compact) => compact.into_portable(registry).into(),
             TypeDef::Phantom(phantom) => phantom.into_portable(registry).into(),
+            #[cfg(feature = "bit-vec")]
+            TypeDef::BitVec(bitvec) => bitvec.into_portable(registry).into(),
         }
     }
 }
@@ -485,3 +497,58 @@ where
         &self.type_param
     }
 }
+
+/// Type describing a [`bitvec::vec::BitVec`].
+#[cfg(feature = "bit-vec")]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#[cfg_attr(any(feature = "std", feature = "decode"), derive(scale::Decode))]
+#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Encode, Debug)]
+pub struct TypeDefBitVec<T: Form = MetaForm> {
+    /// The type implementing [`::bitvec::store::BitStore`].
+    bit_store_type: T::Type,
+    /// The type implementing [`::bitvec::order::BitOrder`].
+    bit_order_type: T::Type,
+}
+
+#[cfg(feature = "bit-vec")]
+impl IntoPortable for crate::TypeDefBitVec {
+    type Output = crate::TypeDefBitVec<PortableForm>;
+
+    fn into_portable(self, registry: &mut Registry) -> Self::Output {
+        TypeDefBitVec {
+            bit_store_type: registry.register_type(&self.bit_store_type),
+            bit_order_type: registry.register_type(&self.bit_order_type),
+        }
+    }
+}
+
+#[cfg(feature = "bit-vec")]
+impl TypeDefBitVec {
+    /// Creates a new phantom type definition.
+    pub fn new<O, T>() -> Self
+    where
+        O: bitvec::order::BitOrder + TypeInfo + 'static,
+        T: bitvec::store::BitStore + TypeInfo + 'static,
+    {
+        Self {
+            bit_order_type: MetaType::new::<O>(),
+            bit_store_type: MetaType::new::<T>(),
+        }
+    }
+}
+
+#[cfg(feature = "bit-vec")]
+impl<T> TypeDefBitVec<T>
+where
+    T: Form,
+{
+    /// Returns the type of the bit ordering of the [`::bitvec::vec::BitVec`].
+    pub fn bit_order_type(&self) -> &T::Type {
+        &self.bit_order_type
+    }
+
+    /// Returns underlying type used to store the [`::bitvec::vec::BitVec`].
+    pub fn bit_store_type(&self) -> &T::Type {
+        &self.bit_store_type
+    }
+}