1mod derive_enum;2mod derive_struct;34use quote::quote;5use derive_struct::*;6use derive_enum::*;78pub(crate) fn impl_abi_macro(ast: &syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream> {9 let name = &ast.ident;10 match &ast.data {11 syn::Data::Struct(ds) => expand_struct(ds, ast),12 syn::Data::Enum(de) => expand_enum(de, ast),13 syn::Data::Union(_) => Err(syn::Error::new(name.span(), "Unions not supported")),14 }15}1617fn expand_struct(18 ds: &syn::DataStruct,19 ast: &syn::DeriveInput,20) -> syn::Result<proc_macro2::TokenStream> {21 let name = &ast.ident;22 let docs = extract_docs(&ast.attrs, false)?;23 let (is_named_fields, field_names, field_types, field_docs, params_count) = match ds.fields {24 syn::Fields::Named(ref fields) => Ok((25 true,26 fields.named.iter().enumerate().map(map_field_to_name),27 fields.named.iter().map(map_field_to_type),28 fields.named.iter().map(map_field_to_doc),29 fields.named.len(),30 )),31 syn::Fields::Unnamed(ref fields) => Ok((32 false,33 fields.unnamed.iter().enumerate().map(map_field_to_name),34 fields.unnamed.iter().map(map_field_to_type),35 fields.unnamed.iter().map(map_field_to_doc),36 fields.unnamed.len(),37 )),38 syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),39 }?;4041 if params_count == 0 {42 return Err(syn::Error::new(name.span(), "Empty structs not supported"));43 };4445 let tuple_type = tuple_type(field_types.clone());46 let tuple_ref_type = tuple_ref_type(field_types.clone());47 let tuple_data = tuple_data_as_ref(is_named_fields, field_names.clone());48 let tuple_names = tuple_names(is_named_fields, field_names.clone());49 let struct_from_tuple = struct_from_tuple(name, is_named_fields, field_names.clone());5051 let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);52 let abi_type = impl_struct_abi_type(name, tuple_type.clone(), params_count);53 let abi_read = impl_struct_abi_read(name, tuple_type, tuple_names, struct_from_tuple);54 let abi_write = impl_struct_abi_write(name, is_named_fields, tuple_ref_type, tuple_data);55 let solidity_type = impl_struct_solidity_type(name, field_types.clone(), params_count);56 let solidity_type_name =57 impl_struct_solidity_type_name(name, field_types.clone(), params_count);58 let solidity_struct_collect =59 impl_struct_solidity_struct_collect(name, field_names, field_types, field_docs, &docs)?;6061 Ok(quote! {62 #can_be_plcaed_in_vec63 #abi_type64 #abi_read65 #abi_write66 #solidity_type67 #solidity_type_name68 #solidity_struct_collect69 })70}7172fn expand_enum(73 de: &syn::DataEnum,74 ast: &syn::DeriveInput,75) -> syn::Result<proc_macro2::TokenStream> {76 let name = &ast.ident;77 check_repr_u8(name, &ast.attrs)?;78 let docs = extract_docs(&ast.attrs, false)?;79 let option_count = check_and_count_options(de)?;80 let enum_options = de.variants.iter().map(|v| &v.ident);81 let enum_options_docs = de.variants.iter().map(|v| extract_docs(&v.attrs, true));8283 let from = impl_enum_from_u8(name, enum_options.clone());84 let solidity_option = impl_solidity_option(name, enum_options.clone());85 let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);86 let abi_type = impl_enum_abi_type(name, option_count);87 let abi_read = impl_enum_abi_read(name);88 let abi_write = impl_enum_abi_write(name);89 let solidity_type = impl_enum_solidity_type(name);90 let solidity_type_name = impl_enum_solidity_type_name(name);91 let solidity_struct_collect = impl_enum_solidity_struct_collect(92 name,93 enum_options,94 option_count,95 enum_options_docs,96 &docs,97 );9899 Ok(quote! {100 #from101 #solidity_option102 #can_be_plcaed_in_vec103 #abi_type104 #abi_read105 #abi_write106 #solidity_type107 #solidity_type_name108 #solidity_struct_collect109 })110}111112fn extract_docs(113 attrs: &[syn::Attribute],114 is_field_doc: bool,115) -> syn::Result<Vec<proc_macro2::TokenStream>> {116 attrs117 .iter()118 .filter_map(|attr| {119 if let Some(ps) = attr.path.segments.first() {120 if ps.ident == "doc" {121 let meta = match attr.parse_meta() {122 Ok(meta) => meta,123 Err(e) => return Some(Err(e)),124 };125 match meta {126 syn::Meta::NameValue(mnv) => match &mnv.lit {127 syn::Lit::Str(ls) => return Some(Ok(ls.value())),128 _ => unreachable!(),129 },130 _ => unreachable!(),131 }132 }133 }134 None135 })136 .enumerate()137 .map(|(i, doc)| {138 let doc = doc?;139 let doc = doc.trim();140 let dev = if i == 0 { " @dev" } else { "" };141 let tab = if is_field_doc { "\t" } else { "" };142 Ok(quote! {143 writeln!(str, "{}///{} {}", #tab, #dev, #doc).unwrap();144 })145 })146 .collect()147}