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
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
#![cfg_attr(not(feature = "std"), no_std)]
#![cfg_attr(not(feature = "std"), feature(core_intrinsics))]
#![cfg_attr(not(feature = "std"), feature(alloc))]
#[cfg(not(feature = "std"))]
extern crate alloc;
extern crate proc_macro;
extern crate proc_macro2;
#[macro_use]
extern crate syn;
#[macro_use]
extern crate quote;
use proc_macro::TokenStream;
use proc_macro2::Span;
use syn::{DeriveInput, Generics, GenericParam, Ident};
#[cfg(not(feature = "std"))]
use alloc::string::ToString;
mod decode;
mod encode;
const ENCODE_ERR: &str = "derive(Encode) failed";
#[proc_macro_derive(Encode, attributes(codec))]
pub fn encode_derive(input: TokenStream) -> TokenStream {
let input: DeriveInput = syn::parse(input).expect(ENCODE_ERR);
let name = &input.ident;
let generics = add_trait_bounds(input.generics, parse_quote!(_parity_codec::Encode));
let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
let self_ = quote!(self);
let dest_ = quote!(dest);
let encoding = encode::quote(&input.data, name, &self_, &dest_);
let impl_block = quote! {
impl #impl_generics _parity_codec::Encode for #name #ty_generics #where_clause {
fn encode_to<EncOut: _parity_codec::Output>(&#self_, #dest_: &mut EncOut) {
#encoding
}
}
};
let mut new_name = "_IMPL_ENCODE_FOR_".to_string();
new_name.push_str(name.to_string().trim_left_matches("r#"));
let dummy_const = Ident::new(&new_name, Span::call_site());
let generated = quote! {
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const #dummy_const: () = {
#[allow(unknown_lints)]
#[cfg_attr(feature = "cargo-clippy", allow(useless_attribute))]
#[allow(rust_2018_idioms)]
extern crate parity_codec as _parity_codec;
#impl_block
};
};
generated.into()
}
#[proc_macro_derive(Decode, attributes(codec))]
pub fn decode_derive(input: TokenStream) -> TokenStream {
let input: DeriveInput = syn::parse(input).expect(ENCODE_ERR);
let name = &input.ident;
let generics = add_trait_bounds(input.generics, parse_quote!(_parity_codec::Decode));
let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
let input_ = quote!(input);
let decoding = decode::quote(&input.data, name, &input_);
let impl_block = quote! {
impl #impl_generics _parity_codec::Decode for #name #ty_generics #where_clause {
fn decode<DecIn: _parity_codec::Input>(#input_: &mut DecIn) -> Option<Self> {
#decoding
}
}
};
let mut new_name = "_IMPL_DECODE_FOR_".to_string();
new_name.push_str(name.to_string().trim_left_matches("r#"));
let dummy_const = Ident::new(&new_name, Span::call_site());
let generated = quote! {
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const #dummy_const: () = {
#[allow(unknown_lints)]
#[cfg_attr(feature = "cargo-clippy", allow(useless_attribute))]
#[allow(rust_2018_idioms)]
extern crate parity_codec as _parity_codec;
#impl_block
};
};
generated.into()
}
fn add_trait_bounds(mut generics: Generics, bounds: syn::TypeParamBound) -> Generics {
for param in &mut generics.params {
if let GenericParam::Type(ref mut type_param) = *param {
type_param.bounds.push(bounds.clone());
}
}
generics
}
fn index(v: &syn::Variant, i: usize) -> proc_macro2::TokenStream {
let index = v.attrs.iter().filter_map(|attr| {
let pair = attr.path.segments.first()?;
let seg = pair.value();
if seg.ident == Ident::new("codec", seg.ident.span()) {
assert_eq!(attr.path.segments.len(), 1);
let meta = attr.interpret_meta();
if let Some(syn::Meta::List(ref l)) = meta {
if let syn::NestedMeta::Meta(syn::Meta::NameValue(ref nv)) = l.nested.last().unwrap().value() {
assert_eq!(nv.ident, Ident::new("index", nv.ident.span()));
if let syn::Lit::Str(ref s) = nv.lit {
let byte: u8 = s.value().parse().expect("Numeric index expected.");
return Some(byte)
}
panic!("Invalid syntax for `codec` attribute: Expected string literal.")
}
}
panic!("Invalid syntax for `codec` attribute: Expected `name = value` pair.")
} else {
None
}
}).next();
index.map(|i| quote! { #i })
.unwrap_or_else(|| v.discriminant
.as_ref()
.map(|&(_, ref expr)| quote! { #expr })
.unwrap_or_else(|| quote! { #i })
)
}