Add derive support for tuple structs

derive/Cargo.toml

@@ -8,6 +8,7 @@ proc-macro = true
 
 [dependencies]
 quote = "1.0.9"
+proc-macro2 = "1.0"
 
 [dependencies.syn]
 version = "1.0.74"

derive/src/derive_struct.rs

@@ -1,12 +1,13 @@
 use crate::Result;
 use proc_macro::TokenStream;
-use quote::{quote, quote_spanned};
+use proc_macro2::TokenStream as TokenStream2;
-use syn::{spanned::Spanned, Generics, Ident};
+use quote::{quote, quote_spanned, ToTokens};
+use syn::{spanned::Spanned, Generics, Ident, Index};
 
 pub struct DeriveStruct {
     name: Ident,
     generics: Generics,
-    fields: Vec<Ident>,
+    fields: Vec<TokenStream2>,
 }
 
 impl DeriveStruct {
@@ -15,13 +16,13 @@ impl DeriveStruct {
             syn::Fields::Named(fields) => fields
                 .named
                 .iter()
-                .map(|f| f.ident.clone().unwrap())
+                .map(|f| f.ident.clone().unwrap().to_token_stream())
                 .collect(),
             syn::Fields::Unnamed(fields) => fields
                 .unnamed
                 .iter()
                 .enumerate()
-                .map(|(i, field)| Ident::new(&i.to_string(), field.ty.span()))
+                .map(|(i, _)| Index::from(i).to_token_stream())
                 .collect(),
             syn::Fields::Unit => Vec::new(),
         };

tests/derive.rs

@@ -14,6 +14,9 @@ pub struct Test2<T: Decodable> {
     c: u32,
 }
 
+#[derive(bincode::Encodable, bincode::Decodable, PartialEq, Debug, Eq)]
+pub struct TestTupleStruct(u32, u32, u32);
+
 #[test]
 fn test_encodable() {
     let start = Test {
@@ -38,3 +41,20 @@ fn test_decodable() {
     let result: Test2<u32> = bincode::decode(&mut slice).unwrap();
     assert_eq!(result, start);
 }
+
+#[test]
+fn test_encodable_tuple() {
+    let start = TestTupleStruct(5, 10, 1024);
+    let mut slice = [0u8; 1024];
+    let bytes_written = bincode::encode_into_slice(start, &mut slice).unwrap();
+    assert_eq!(bytes_written, 5);
+    assert_eq!(&slice[..bytes_written], &[5, 10, 251, 0, 4]);
+}
+
+#[test]
+fn test_decodable_tuple() {
+    let start = TestTupleStruct(5, 10, 1024);
+    let mut slice = [5, 10, 251, 0, 4];
+    let result: TestTupleStruct = bincode::decode(&mut slice).unwrap();
+    assert_eq!(result, start);
+}