support reading Unit structs

bitstream_reader_derive/src/lib.rs

@@ -183,8 +183,9 @@ fn derive_bitread_trait(
             .push(parse_quote!(_E: ::bitstream_reader::Endianness));
     }
     let (impl_generics, _, _) = trait_generics.split_for_impl();
+    let span = input.span();
 
-    let parse = parse(&input.data, &name, &input.attrs);
+    let parse = parse(input.data, &name, &input.attrs);
 
     let endianness_placeholder = endianness.unwrap_or("_E".to_owned());
     let trait_def_str = format!(
@@ -193,7 +194,7 @@ fn derive_bitread_trait(
     );
     let trait_def = parse_str::<Path>(&trait_def_str).unwrap();
 
-    let endianness_ident = Ident::new(&endianness_placeholder, input.span());
+    let endianness_ident = Ident::new(&endianness_placeholder, span);
 
     let expanded = quote! {
         impl #impl_generics #trait_def for #name #ty_generics #where_clause {
@@ -208,11 +209,14 @@ fn derive_bitread_trait(
     proc_macro::TokenStream::from(expanded)
 }
 
-fn parse(data: &Data, struct_name: &Ident, attrs: &Vec<Attribute>) -> TokenStream {
-    match *data {
-        Data::Struct(ref data) => {
-            match data.fields {
-                Fields::Named(ref fields) => {
+fn parse(data: Data, struct_name: &Ident, attrs: &Vec<Attribute>) -> TokenStream {
+    let span = struct_name.span();
+
+    match data {
+        Data::Struct(DataStruct {
+            fields: Fields::Named(fields),
+            ..
+        }) => {
             let definitions = fields.named.iter().map(|f| {
                 let name = &f.ident;
                 // Get attributes `#[..]` on each field
@@ -241,7 +245,6 @@ fn parse(data: &Data, struct_name: &Ident, attrs: &Vec<Attribute>) -> TokenStrea
                     #name,
                 }
             });
-                    let span = data.struct_token.span();
             quote_spanned! {span=>
                 #(#definitions)*
 
@@ -250,10 +253,15 @@ fn parse(data: &Data, struct_name: &Ident, attrs: &Vec<Attribute>) -> TokenStrea
                 })
             }
         }
-                _ => unimplemented!(),
+        Data::Struct(DataStruct {
+            fields: Fields::Unit,
+            ..
+        }) => {
+            quote_spanned! {span=>
+                Ok(#struct_name)
             }
         }
-        Data::Enum(ref data) => {
+        Data::Enum(data) => {
             let discriminant_bits: u64 = get_attribute_value(attrs, &["discriminant_bits"]).expect(
                 "'discriminant_bits' attribute is required when deriving `BinRead` for enums",
             );

bitstream_reader_derive/tests/test.rs

@@ -265,6 +265,18 @@ fn test_read_rest_enum() {
     assert_eq!(TestEnumRest::Asd, stream.read().unwrap());
 }
 
+#[derive(BitRead, BitSize, PartialEq, Debug)]
+struct EmptyStruct;
+
+fn test_empty_struct() {
+    let bytes = vec![0, 0, 0, 0];
+    let buffer = BitBuffer::new(bytes, BigEndian);
+    let mut stream = BitStream::from(buffer);
+    assert_eq!(EmptyStruct, stream.read().unwrap());
+    assert_eq!(0, stream.pos());
+    assert_eq!(0, bit_size_of::<EmptyStruct>());
+}
+
 #[derive(BitSize)]
 struct SizeStruct {
     foo: u8,