`83d2fa047b91`

1 file changed

modifiedcrates/evm-coder/procedural/src/abi_derive.rsdiff before after both
14	ast: &syn::DeriveInput,14	ast: &syn::DeriveInput,
15) -> syn::Result<proc_macro2::TokenStream> {15) -> syn::Result<proc_macro2::TokenStream> {
16	let name = &ast.ident;16	let name = &ast.ident;
17	let docs = extract_docs(&ast.attrs, true)?;17	let docs = extract_docs(&ast.attrs, false)?;
18	let (is_named_fields, field_names, field_types, field_docs, params_count) = match ds.fields {18	let (is_named_fields, field_names, field_types, field_docs, params_count) = match ds.fields {
19		syn::Fields::Named(ref fields) => Ok((19		syn::Fields::Named(ref fields) => Ok((
20			true,20			true,
70) -> syn::Result<proc_macro2::TokenStream> {70) -> syn::Result<proc_macro2::TokenStream> {
71	let name = &ast.ident;71	let name = &ast.ident;
72	check_repr_u8(name, &ast.attrs)?;72	check_repr_u8(name, &ast.attrs)?;
73	let docs = extract_docs(&ast.attrs, true)?;73	let docs = extract_docs(&ast.attrs, false)?;
74	let option_count = check_and_count_option(de)?;74	let option_count = check_and_count_options(de)?;
75	let enum_options = de.variants.iter().map(|v| &v.ident);75	let enum_options = de.variants.iter().map(|v| &v.ident);
76	let enum_options_docs = de.variants.iter().map(|v| extract_docs(&v.attrs, false));76	let enum_options_docs = de.variants.iter().map(|v| extract_docs(&v.attrs, true));
7777
78	let from = impl_enum_from_u8(name, enum_options.clone());78	let from = impl_enum_from_u8(name, enum_options.clone());
79	let solidity_option = impl_solidity_option(name, enum_options.clone());79	let solidity_option = impl_solidity_option(name, enum_options.clone());
115		#[cfg(feature = "stubgen")]115		#[cfg(feature = "stubgen")]
116		impl ::evm_coder::solidity::SolidityEnum for #name {116		impl ::evm_coder::solidity::SolidityEnum for #name {
117			fn solidity_option(&self) -> &str {117			fn solidity_option(&self) -> &str {
118				match <#name>::default() {118				match Self::default() {
119					#(#enum_options)*119					#(#enum_options)*
120				}120				}
121			}121			}
254	)254	)
255}255}
256256
257fn check_and_count_option(de: &syn::DataEnum) -> syn::Result<usize> {257fn check_and_count_options(de: &syn::DataEnum) -> syn::Result<usize> {
258	let mut count = 0;258	let mut count = 0;
259	for error in de.variants.iter().filter_map(|v| {259	for error in de.variants.iter().filter_map(|v| {
260		if !v.fields.is_empty() {260		if !v.fields.is_empty() {
280280
281fn check_repr_u8(name: &syn::Ident, attrs: &Vec<syn::Attribute>) -> syn::Result<()> {281fn check_repr_u8(name: &syn::Ident, attrs: &Vec<syn::Attribute>) -> syn::Result<()> {
282	let mut has_repr = false;282	let mut has_repr = false;
283	for error in attrs.iter().filter_map(|attr| {283	for attr in attrs.iter() {
284		if let Some(ps) = attr.path.segments.first() {284		if attr.path.is_ident("repr") {
285			if ps.ident == "repr" {
286				has_repr = true;285			has_repr = true;
287				let meta = match attr.parse_meta() {
288					Ok(meta) => meta,
289					Err(e) => return Some(Err(e)),
290				};
291				match meta {286			match attr.parse_meta()? {
292					syn::Meta::List(p) => {287				syn::Meta::List(p) => {
293						for error in p.nested.iter().filter_map(|nm| match nm {288					for nm in p.nested.iter() {
289						match nm {
294							syn::NestedMeta::Meta(m) => match m {290							syn::NestedMeta::Meta(m) => match m {
295								syn::Meta::Path(p) => {291								syn::Meta::Path(p) => {
296									for i in p.segments.iter().filter_map(|ps| {
297										if ps.ident != "u8" {292									if !p.is_ident("u8") {
298											Some(Err(syn::Error::new(293										return Err(syn::Error::new(
299												ps.ident.span(),294											p.segments
295												.first()
296												.expect("repr segments are empty")
297												.ident
298												.span(),
300												"Enum is not \"repr(u8)\"",299											"Enum is not \"repr(u8)\"",
301											)))300										));
302										} else {301									}
303											None
304										}
305									}) {
306										return Some(i);
307									}
308									None
309								}302								}
310								_ => None,303								_ => {}
311							},304							},
312							_ => None,305							_ => {}
313						}) {306						}
314							return Some(error);307					}
315						}
316						None::<syn::Result<()>>
317					}308				}
318					_ => None,309				_ => {}
319				};310			};
320			}
321		}311		}
322		None
323	}) {312	}
324		return error;
325	}
326313
327	if !has_repr {314	if !has_repr {
328		return Err(syn::Error::new(name.span(), "Enum is not \"repr(u8)\""));315		return Err(syn::Error::new(name.span(), "Enum is not \"repr(u8)\""));
404391
405fn extract_docs(392fn extract_docs(
406	attrs: &[syn::Attribute],393	attrs: &[syn::Attribute],
407	is_general: bool,394	is_field_doc: bool,
408) -> syn::Result<Vec<proc_macro2::TokenStream>> {395) -> syn::Result<Vec<proc_macro2::TokenStream>> {
409	attrs396	attrs
410		.iter()397		.iter()
431			let doc = doc?;418			let doc = doc?;
432			let doc = doc.trim();419			let doc = doc.trim();
433			let dev = if i == 0 { " @dev" } else { "" };420			let dev = if i == 0 { " @dev" } else { "" };
434			let tab = if is_general { "" } else { "\t" };421			let tab = if is_field_doc { "\t" } else { "" };
435			Ok(quote! {422			Ok(quote! {
436				writeln!(str, "{}///{} {}", #tab, #dev, #doc).unwrap();423				writeln!(str, "{}///{} {}", #tab, #dev, #doc).unwrap();
437			})424			})
455}442}
456443
457fn map_field_to_doc(field: &syn::Field) -> syn::Result<Vec<proc_macro2::TokenStream>> {444fn map_field_to_doc(field: &syn::Field) -> syn::Result<Vec<proc_macro2::TokenStream>> {
458	extract_docs(&field.attrs, false)445	extract_docs(&field.attrs, true)
459}446}
460447
461fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {448fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {