a04c5b180a
* WIP * Replace Rlp with UntrustedRlp in views, explicity unwrap with expect First pass to get it to compile. Need to figure out whether to do this or to propogate Errors upstream, which would require many more changes to dependent code. If we do this way we are assuming that the views are always used in a context where the rlp is trusted to be valid e.g. when reading from our own DB. So need to fid out whether views are used with data received from an untrusted (e.g. extrernal peer). * Remove original Rlp impl, rename UntrustedRlp -> Rlp * Create rlp views with view! macro to record debug info Views are assumed to be over valid rlp, so if there is a decoding error we record where the view was created in the first place and report it in the expect * Use $crate in view! macro to avoid import, fix tests * Expect valid rlp in decode functions for now * Replace spaces with tabs in new file * Add doc tests for creating views with macro * Update rlp docs to reflect removing of UntrustedRlp * Replace UntrustedRlp usages in private-tx merge
136 lines
3.1 KiB
Rust
136 lines
3.1 KiB
Rust
use {syn, quote};
|
|
|
|
struct ParseQuotes {
|
|
single: quote::Tokens,
|
|
list: quote::Tokens,
|
|
takes_index: bool,
|
|
}
|
|
|
|
fn decodable_parse_quotes() -> ParseQuotes {
|
|
ParseQuotes {
|
|
single: quote! { rlp.val_at },
|
|
list: quote! { rlp.list_at },
|
|
takes_index: true,
|
|
}
|
|
}
|
|
|
|
fn decodable_wrapper_parse_quotes() -> ParseQuotes {
|
|
ParseQuotes {
|
|
single: quote! { rlp.as_val },
|
|
list: quote! { rlp.as_list },
|
|
takes_index: false,
|
|
}
|
|
}
|
|
|
|
pub fn impl_decodable(ast: &syn::DeriveInput) -> quote::Tokens {
|
|
let body = match ast.data {
|
|
syn::Data::Struct(ref s) => s,
|
|
_ => panic!("#[derive(RlpDecodable)] is only defined for structs."),
|
|
};
|
|
|
|
|
|
let stmts: Vec<_> = body.fields.iter().enumerate().map(decodable_field_map).collect();
|
|
let name = &ast.ident;
|
|
|
|
let dummy_const: syn::Ident = format!("_IMPL_RLP_DECODABLE_FOR_{}", name).into();
|
|
let impl_block = quote! {
|
|
impl rlp::Decodable for #name {
|
|
fn decode(rlp: &rlp::Rlp) -> Result<Self, rlp::DecoderError> {
|
|
let result = #name {
|
|
#(#stmts)*
|
|
};
|
|
|
|
Ok(result)
|
|
}
|
|
}
|
|
};
|
|
|
|
quote! {
|
|
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
|
const #dummy_const: () = {
|
|
extern crate rlp;
|
|
#impl_block
|
|
};
|
|
}
|
|
}
|
|
|
|
pub fn impl_decodable_wrapper(ast: &syn::DeriveInput) -> quote::Tokens {
|
|
let body = match ast.data {
|
|
syn::Data::Struct(ref s) => s,
|
|
_ => panic!("#[derive(RlpDecodableWrapper)] is only defined for structs."),
|
|
};
|
|
|
|
let stmt = {
|
|
let fields: Vec<_> = body.fields.iter().collect();
|
|
if fields.len() == 1 {
|
|
let field = fields.first().expect("fields.len() == 1; qed");
|
|
decodable_field(0, field, decodable_wrapper_parse_quotes())
|
|
} else {
|
|
panic!("#[derive(RlpEncodableWrapper)] is only defined for structs with one field.")
|
|
}
|
|
};
|
|
|
|
let name = &ast.ident;
|
|
|
|
let dummy_const: syn::Ident = format!("_IMPL_RLP_DECODABLE_FOR_{}", name).into();
|
|
let impl_block = quote! {
|
|
impl rlp::Decodable for #name {
|
|
fn decode(rlp: &rlp::Rlp) -> Result<Self, rlp::DecoderError> {
|
|
let result = #name {
|
|
#stmt
|
|
};
|
|
|
|
Ok(result)
|
|
}
|
|
}
|
|
};
|
|
|
|
quote! {
|
|
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
|
const #dummy_const: () = {
|
|
extern crate rlp;
|
|
#impl_block
|
|
};
|
|
}
|
|
}
|
|
|
|
fn decodable_field_map(tuple: (usize, &syn::Field)) -> quote::Tokens {
|
|
decodable_field(tuple.0, tuple.1, decodable_parse_quotes())
|
|
}
|
|
|
|
fn decodable_field(index: usize, field: &syn::Field, quotes: ParseQuotes) -> quote::Tokens {
|
|
let id = match field.ident {
|
|
Some(ref ident) => quote! { #ident },
|
|
None => {
|
|
let index: syn::Index = index.into();
|
|
quote! { #index }
|
|
}
|
|
};
|
|
|
|
let index = quote! { #index };
|
|
|
|
let single = quotes.single;
|
|
let list = quotes.list;
|
|
|
|
match field.ty {
|
|
syn::Type::Path(ref path) => {
|
|
let ident = &path.path.segments.first().expect("there must be at least 1 segment").value().ident;
|
|
if &ident.to_string() == "Vec" {
|
|
if quotes.takes_index {
|
|
quote! { #id: #list(#index)?, }
|
|
} else {
|
|
quote! { #id: #list()?, }
|
|
}
|
|
} else {
|
|
if quotes.takes_index {
|
|
quote! { #id: #single(#index)?, }
|
|
} else {
|
|
quote! { #id: #single()?, }
|
|
}
|
|
}
|
|
},
|
|
_ => panic!("rlp_derive not supported"),
|
|
}
|
|
}
|
|
|