1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
use crate::attribute_helpers::contains_skip;
use quote::quote;
use syn::export::{Span, TokenStream2};
use syn::{Fields, Index, ItemStruct};
pub fn struct_ser(input: &ItemStruct) -> syn::Result<TokenStream2> {
let name = &input.ident;
let generics = &input.generics;
let mut body = TokenStream2::new();
let mut serializable_field_types = TokenStream2::new();
match &input.fields {
Fields::Named(fields) => {
for field in &fields.named {
if contains_skip(&field.attrs) {
continue;
}
let field_name = field.ident.as_ref().unwrap();
let delta = quote! {
borsh::BorshSerialize::serialize(&self.#field_name, writer)?;
};
body.extend(delta);
let field_type = &field.ty;
serializable_field_types.extend(quote!{
#field_type: borsh::ser::BorshSerialize,
});
}
}
Fields::Unnamed(fields) => {
for field_idx in 0..fields.unnamed.len() {
let field_idx = Index {
index: field_idx as u32,
span: Span::call_site(),
};
let delta = quote! {
borsh::BorshSerialize::serialize(&self.#field_idx, writer)?;
};
body.extend(delta);
}
}
Fields::Unit => {}
}
Ok(quote! {
impl #generics borsh::ser::BorshSerialize for #name #generics where #serializable_field_types {
fn serialize<W: std::io::Write>(&self, writer: &mut W) -> Result<(), std::io::Error> {
#body
Ok(())
}
}
})
}
#[rustfmt::skip]
#[cfg(test)]
mod tests {
use super::*;
fn assert_eq(expected: TokenStream2, actual: TokenStream2) {
assert_eq!(expected.to_string(), actual.to_string())
}
#[test]
fn simple_struct() {
let item_struct: ItemStruct = syn::parse2(quote!{
struct A {
x: u64,
y: String,
}
}).unwrap();
let actual = struct_ser(&item_struct).unwrap();
let expected = quote!{
impl borsh::ser::BorshSerialize for A
where
u64: borsh::ser::BorshSerialize,
String: borsh::ser::BorshSerialize,
{
fn serialize<W: std::io::Write>(&self, writer: &mut W) -> Result<(), std::io::Error> {
borsh::BorshSerialize::serialize(&self.x, writer)?;
borsh::BorshSerialize::serialize(&self.y, writer)?;
Ok(())
}
}
};
assert_eq(expected, actual);
}
#[test]
fn simple_generics() {
let item_struct: ItemStruct = syn::parse2(quote!{
struct A<K, V> {
x: HashMap<K, V>,
y: String,
}
}).unwrap();
let actual = struct_ser(&item_struct).unwrap();
let expected = quote!{
impl<K, V> borsh::ser::BorshSerialize for A<K, V>
where
HashMap<K, V>: borsh::ser::BorshSerialize,
String: borsh::ser::BorshSerialize,
{
fn serialize<W: std::io::Write>(&self, writer: &mut W) -> Result<(), std::io::Error> {
borsh::BorshSerialize::serialize(&self.x, writer)?;
borsh::BorshSerialize::serialize(&self.y, writer)?;
Ok(())
}
}
};
assert_eq(expected, actual);
}
}