1use proc_macro2::TokenStream;2use quote::quote;34pub(crate) fn impl_abi_macro(ast: &syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream> {5 let name = &ast.ident;6 let docs = extract_docs(&ast.attrs)?;78 let (is_named_fields, field_names, field_types, field_docs, params_count) = match &ast.data {9 syn::Data::Struct(ds) => match ds.fields {10 syn::Fields::Named(ref fields) => Ok((11 true,12 fields.named.iter().enumerate().map(map_field_to_name),13 fields.named.iter().map(map_field_to_type),14 fields.named.iter().map(map_field_to_doc),15 fields.named.len(),16 )),17 syn::Fields::Unnamed(ref fields) => Ok((18 false,19 fields.unnamed.iter().enumerate().map(map_field_to_name),20 fields.unnamed.iter().map(map_field_to_type),21 fields.unnamed.iter().map(map_field_to_doc),22 fields.unnamed.len(),23 )),24 syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),25 },26 syn::Data::Enum(_) => Err(syn::Error::new(name.span(), "Enums not supported")),27 syn::Data::Union(_) => Err(syn::Error::new(name.span(), "Unions not supported")),28 }?;2930 if params_count == 0 {31 return Err(syn::Error::new(name.span(), "Empty structs not supported"));32 };3334 let tuple_type = tuple_type(field_types.clone());35 let tuple_ref_type = tuple_ref_type(field_types.clone());36 let tuple_data = tuple_data_as_ref(is_named_fields, field_names.clone());37 let tuple_names = tuple_names(is_named_fields, field_names.clone());38 let struct_from_tuple = struct_from_tuple(name, is_named_fields, field_names.clone());3940 let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);41 let abi_type = impl_abi_type(name, tuple_type.clone());42 let abi_read = impl_abi_read(name, tuple_type, tuple_names, struct_from_tuple);43 let abi_write = impl_abi_write(name, is_named_fields, tuple_ref_type, tuple_data);44 let solidity_type = impl_solidity_type(name, field_types.clone(), params_count);45 let solidity_type_name = impl_solidity_type_name(name, field_types.clone(), params_count);46 let solidity_struct_collect =47 impl_solidity_struct_collect(name, field_names, field_types, field_docs, &docs)?;4849 Ok(quote! {50 #can_be_plcaed_in_vec51 #abi_type52 #abi_read53 #abi_write54 #solidity_type55 #solidity_type_name56 #solidity_struct_collect57 })58}5960fn tuple_type<'a>(61 field_types: impl Iterator<Item = &'a syn::Type> + Clone,62) -> proc_macro2::TokenStream {63 let field_types = field_types.map(|ty| quote!(#ty,));64 quote! {(#(#field_types)*)}65}6667fn tuple_ref_type<'a>(68 field_types: impl Iterator<Item = &'a syn::Type> + Clone,69) -> proc_macro2::TokenStream {70 let field_types = field_types.map(|ty| quote!(&#ty,));71 quote! {(#(#field_types)*)}72}7374fn tuple_data_as_ref(75 is_named_fields: bool,76 field_names: impl Iterator<Item = syn::Ident> + Clone,77) -> proc_macro2::TokenStream {78 let field_names = field_names.enumerate().map(|(i, field)| {79 if is_named_fields {80 quote!(&self.#field,)81 } else {82 let field = proc_macro2::Literal::usize_unsuffixed(i);83 quote!(&self.#field,)84 }85 });86 quote! {(#(#field_names)*)}87}8889fn tuple_names(90 is_named_fields: bool,91 field_names: impl Iterator<Item = syn::Ident> + Clone,92) -> proc_macro2::TokenStream {93 let field_names = field_names.enumerate().map(|(i, field)| {94 if is_named_fields {95 quote!(#field,)96 } else {97 let field = proc_macro2::Ident::new(98 format!("field{}", i).as_str(),99 proc_macro2::Span::call_site(),100 );101 quote!(#field,)102 }103 });104 quote! {(#(#field_names)*)}105}106107fn struct_from_tuple(108 name: &syn::Ident,109 is_named_fields: bool,110 field_names: impl Iterator<Item = syn::Ident> + Clone,111) -> proc_macro2::TokenStream {112 let field_names = field_names.enumerate().map(|(i, field)| {113 if is_named_fields {114 quote!(#field,)115 } else {116 let field = proc_macro2::Ident::new(117 format!("field{}", i).as_str(),118 proc_macro2::Span::call_site(),119 );120 quote!(#field,)121 }122 });123124 if is_named_fields {125 quote! {#name {#(#field_names)*}}126 } else {127 quote! {#name (#(#field_names)*)}128 }129}130131fn extract_docs(attrs: &Vec<syn::Attribute>) -> syn::Result<Vec<String>> {132 attrs133 .iter()134 .filter_map(|attr| {135 if let Some(ps) = attr.path.segments.first() {136 if ps.ident == "doc" {137 let meta = match attr.parse_meta() {138 Ok(meta) => meta,139 Err(e) => return Some(Err(e)),140 };141 match meta {142 syn::Meta::NameValue(mnv) => match &mnv.lit {143 syn::Lit::Str(ls) => return Some(Ok(ls.value())),144 _ => unreachable!(),145 },146 _ => unreachable!(),147 }148 }149 }150 None151 })152 .collect()153}154155fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {156 match field.1.ident.as_ref() {157 Some(name) => name.clone(),158 None => {159 let mut name = "field".to_string();160 name.push_str(field.0.to_string().as_str());161 syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())162 }163 }164}165166fn map_field_to_type<'a>(field: &'a syn::Field) -> &'a syn::Type {167 &field.ty168}169170fn map_field_to_doc(field: &syn::Field) -> Result<Vec<std::string::String>, syn::Error> {171 extract_docs(&field.attrs)172}173174fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {175 quote! {176 impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}177 }178}179180fn impl_abi_type<'a>(181 name: &syn::Ident,182 tuple_type: proc_macro2::TokenStream,183) -> proc_macro2::TokenStream {184 quote! {185 impl ::evm_coder::abi::AbiType for #name {186 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <#tuple_type as ::evm_coder::abi::AbiType>::SIGNATURE;187 fn is_dynamic() -> bool {188 <#tuple_type as ::evm_coder::abi::AbiType>::is_dynamic()189 }190 fn size() -> usize {191 <#tuple_type as ::evm_coder::abi::AbiType>::size()192 }193 }194 }195}196197fn impl_abi_read<'a>(198 name: &syn::Ident,199 tuple_type: proc_macro2::TokenStream,200 tuple_names: proc_macro2::TokenStream,201 struct_from_tuple: proc_macro2::TokenStream,202) -> proc_macro2::TokenStream {203 quote!(204 impl ::evm_coder::abi::AbiRead for #name {205 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {206 let #tuple_names = <#tuple_type as ::evm_coder::abi::AbiRead>::abi_read(reader)?;207 Ok(#struct_from_tuple)208 }209 }210 )211}212213fn impl_abi_write<'a>(214 name: &syn::Ident,215 is_named_fields: bool,216 tuple_type: proc_macro2::TokenStream,217 tuple_data: proc_macro2::TokenStream,218) -> proc_macro2::TokenStream {219 quote!(220 impl ::evm_coder::abi::AbiWrite for #name {221 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {222 <#tuple_type as ::evm_coder::abi::AbiWrite>::abi_write(&#tuple_data, writer)223 }224 }225 )226}227228fn impl_solidity_type<'a>(229 name: &syn::Ident,230 field_types: impl Iterator<Item = &'a syn::Type> + Clone,231 params_count: usize,232) -> proc_macro2::TokenStream {233 let len = proc_macro2::Literal::usize_suffixed(params_count);234 quote! {235 #[cfg(feature = "stubgen")]236 impl ::evm_coder::solidity::SolidityType for #name {237 fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {238 let mut collected =239 Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());240 #({241 let mut out = String::new();242 <#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)243 .expect("no fmt error");244 collected.push(out);245 })*246 collected247 }248249 fn len() -> usize {250 #len251 }252 }253 }254}255256fn impl_solidity_type_name<'a>(257 name: &syn::Ident,258 field_types: impl Iterator<Item = &'a syn::Type> + Clone,259 params_count: usize,260) -> proc_macro2::TokenStream {261 let arg_dafaults = field_types.enumerate().map(|(i, ty)| {262 let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName263 >::solidity_default(writer, tc)?;);264 let last_item = params_count - 1;265 if i != last_item {266 defult_value.extend(quote! {write!(writer, ",")?;})267 }268 defult_value269 });270271 quote! {272 #[cfg(feature = "stubgen")]273 impl ::evm_coder::solidity::SolidityTypeName for #name {274 fn solidity_name(275 writer: &mut impl ::core::fmt::Write,276 tc: &::evm_coder::solidity::TypeCollector,277 ) -> ::core::fmt::Result {278 write!(writer, "{}", tc.collect_struct::<Self>())279 }280281 fn is_simple() -> bool {282 false283 }284285 fn solidity_default(286 writer: &mut impl ::core::fmt::Write,287 tc: &::evm_coder::solidity::TypeCollector,288 ) -> ::core::fmt::Result {289 write!(writer, "{}(", tc.collect_struct::<Self>())?;290291 #(#arg_dafaults)*292293 write!(writer, ")")294 }295 }296 }297}298299fn impl_solidity_struct_collect<'a>(300 name: &syn::Ident,301 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,302 field_types: impl Iterator<Item = &'a syn::Type> + Clone,303 field_docs: impl Iterator<Item = syn::Result<Vec<String>>> + Clone,304 docs: &Vec<String>,305) -> syn::Result<proc_macro2::TokenStream> {306 let string_name = name.to_string();307 let name_type = field_names308 .into_iter()309 .zip(field_types)310 .zip(field_docs)311 .map(|((name, ty), doc)| {312 let field_docs = match doc {313 Ok(doc) => doc.into_iter().enumerate().map(|(i, doc)| {314 let doc = doc.trim();315 let dev = if i == 0 { " @dev" } else { "" };316 quote! {317 writeln!(str, "\t///{} {}", #dev, #doc).unwrap();318 }319 }),320 Err(e) => unreachable!("{:?}", e),321 };322 let name = format!("{}", name);323 quote!(324 #(#field_docs)*325 write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();326 writeln!(str, "{};", #name).unwrap();327 )328 });329 let docs = docs.iter().enumerate().map(|(i, doc)| {330 let doc = doc.trim();331 let dev = if i == 0 { " @dev" } else { "" };332 quote! {333 writeln!(str, "///{} {}", #dev, #doc).unwrap();334 }335 });336337 Ok(quote! {338 #[cfg(feature = "stubgen")]339 impl ::evm_coder::solidity::StructCollect for #name {340 fn name() -> String {341 #string_name.into()342 }343344 fn declaration() -> String {345 use std::fmt::Write;346347 let mut str = String::new();348 #(#docs)*349 writeln!(str, "struct {} {{", Self::name()).unwrap();350 #(#name_type)*351 writeln!(str, "}}").unwrap();352 str353 }354 }355 })356}