1use quote::quote;23pub(crate) fn impl_abi_macro(ast: &syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream> {4 let name = &ast.ident;56 match &ast.data {7 syn::Data::Struct(ds) => {8 let docs = extract_docs(&ast.attrs)?;9 let (is_named_fields, field_names, field_types, field_docs, params_count) =10 match ds.fields {11 syn::Fields::Named(ref fields) => Ok((12 true,13 fields.named.iter().enumerate().map(map_field_to_name),14 fields.named.iter().map(map_field_to_type),15 fields.named.iter().map(map_field_to_doc),16 fields.named.len(),17 )),18 syn::Fields::Unnamed(ref fields) => Ok((19 false,20 fields.unnamed.iter().enumerate().map(map_field_to_name),21 fields.unnamed.iter().map(map_field_to_type),22 fields.unnamed.iter().map(map_field_to_doc),23 fields.unnamed.len(),24 )),25 syn::Fields::Unit => {26 Err(syn::Error::new(name.span(), "Unit structs not supported"))27 }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 =46 impl_solidity_type_name(name, field_types.clone(), params_count);47 let solidity_struct_collect =48 impl_solidity_struct_collect(name, field_names, field_types, field_docs, &docs)?;4950 Ok(quote! {51 #can_be_plcaed_in_vec52 #abi_type53 #abi_read54 #abi_write55 #solidity_type56 #solidity_type_name57 #solidity_struct_collect58 })59 }60 syn::Data::Enum(de) => {61 let _ = check_repr_u8(name, &ast.attrs)?;6263 64 Ok(quote!())65 }66 syn::Data::Union(_) => Err(syn::Error::new(name.span(), "Unions not supported")),67 }68}6970fn check_repr_u8(name: &syn::Ident, attrs: &Vec<syn::Attribute>) -> syn::Result<()> {71 let repr_u8 = attrs72 .iter()73 .filter_map(|attr| {74 if let Some(ps) = attr.path.segments.first() {75 if ps.ident == "repr" {76 let meta = match attr.parse_meta() {77 Ok(meta) => meta,78 Err(e) => return Some(Err(e)),79 };80 let is_repr_u8 = match meta {81 syn::Meta::List(p) => {82 p.nested83 .iter()84 .filter(|nm| match nm {85 syn::NestedMeta::Meta(m) => match m {86 syn::Meta::Path(p) => {87 p.segments.iter().filter(|ps| ps.ident == "u8").count()88 == 189 }90 _ => false,91 },92 _ => false,93 })94 .count() == 195 }96 _ => false,97 };9899 if is_repr_u8 {100 return Some(Ok(()));101 };102 }103 }104 None::<syn::Result<()>>105 })106 .collect::<syn::Result<Vec<_>>>()?;107108 if repr_u8.len() != 1 {109 return Err(syn::Error::new(name.span(), "Enum is not \"repr(u8)\""));110 };111112 Ok(())113}114115fn tuple_type<'a>(116 field_types: impl Iterator<Item = &'a syn::Type> + Clone,117) -> proc_macro2::TokenStream {118 let field_types = field_types.map(|ty| quote!(#ty,));119 quote! {(#(#field_types)*)}120}121122fn tuple_ref_type<'a>(123 field_types: impl Iterator<Item = &'a syn::Type> + Clone,124) -> proc_macro2::TokenStream {125 let field_types = field_types.map(|ty| quote!(&#ty,));126 quote! {(#(#field_types)*)}127}128129fn tuple_data_as_ref(130 is_named_fields: bool,131 field_names: impl Iterator<Item = syn::Ident> + Clone,132) -> proc_macro2::TokenStream {133 let field_names = field_names.enumerate().map(|(i, field)| {134 if is_named_fields {135 quote!(&self.#field,)136 } else {137 let field = proc_macro2::Literal::usize_unsuffixed(i);138 quote!(&self.#field,)139 }140 });141 quote! {(#(#field_names)*)}142}143144fn tuple_names(145 is_named_fields: bool,146 field_names: impl Iterator<Item = syn::Ident> + Clone,147) -> proc_macro2::TokenStream {148 let field_names = field_names.enumerate().map(|(i, field)| {149 if is_named_fields {150 quote!(#field,)151 } else {152 let field = proc_macro2::Ident::new(153 format!("field{}", i).as_str(),154 proc_macro2::Span::call_site(),155 );156 quote!(#field,)157 }158 });159 quote! {(#(#field_names)*)}160}161162fn struct_from_tuple(163 name: &syn::Ident,164 is_named_fields: bool,165 field_names: impl Iterator<Item = syn::Ident> + Clone,166) -> proc_macro2::TokenStream {167 let field_names = field_names.enumerate().map(|(i, field)| {168 if is_named_fields {169 quote!(#field,)170 } else {171 let field = proc_macro2::Ident::new(172 format!("field{}", i).as_str(),173 proc_macro2::Span::call_site(),174 );175 quote!(#field,)176 }177 });178179 if is_named_fields {180 quote! {#name {#(#field_names)*}}181 } else {182 quote! {#name (#(#field_names)*)}183 }184}185186fn extract_docs(attrs: &[syn::Attribute]) -> syn::Result<Vec<String>> {187 attrs188 .iter()189 .filter_map(|attr| {190 if let Some(ps) = attr.path.segments.first() {191 if ps.ident == "doc" {192 let meta = match attr.parse_meta() {193 Ok(meta) => meta,194 Err(e) => return Some(Err(e)),195 };196 match meta {197 syn::Meta::NameValue(mnv) => match &mnv.lit {198 syn::Lit::Str(ls) => return Some(Ok(ls.value())),199 _ => unreachable!(),200 },201 _ => unreachable!(),202 }203 }204 }205 None206 })207 .collect()208}209210fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {211 match field.1.ident.as_ref() {212 Some(name) => name.clone(),213 None => {214 let mut name = "field".to_string();215 name.push_str(field.0.to_string().as_str());216 syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())217 }218 }219}220221fn map_field_to_type(field: &syn::Field) -> &syn::Type {222 &field.ty223}224225fn map_field_to_doc(field: &syn::Field) -> Result<Vec<std::string::String>, syn::Error> {226 extract_docs(&field.attrs)227}228229fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {230 quote! {231 impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}232 }233}234235fn impl_abi_type(236 name: &syn::Ident,237 tuple_type: proc_macro2::TokenStream,238) -> proc_macro2::TokenStream {239 quote! {240 impl ::evm_coder::abi::AbiType for #name {241 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <#tuple_type as ::evm_coder::abi::AbiType>::SIGNATURE;242 fn is_dynamic() -> bool {243 <#tuple_type as ::evm_coder::abi::AbiType>::is_dynamic()244 }245 fn size() -> usize {246 <#tuple_type as ::evm_coder::abi::AbiType>::size()247 }248 }249 }250}251252fn impl_abi_read(253 name: &syn::Ident,254 tuple_type: proc_macro2::TokenStream,255 tuple_names: proc_macro2::TokenStream,256 struct_from_tuple: proc_macro2::TokenStream,257) -> proc_macro2::TokenStream {258 quote!(259 impl ::evm_coder::abi::AbiRead for #name {260 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {261 let #tuple_names = <#tuple_type as ::evm_coder::abi::AbiRead>::abi_read(reader)?;262 Ok(#struct_from_tuple)263 }264 }265 )266}267268fn impl_abi_write(269 name: &syn::Ident,270 _is_named_fields: bool,271 tuple_type: proc_macro2::TokenStream,272 tuple_data: proc_macro2::TokenStream,273) -> proc_macro2::TokenStream {274 quote!(275 impl ::evm_coder::abi::AbiWrite for #name {276 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {277 <#tuple_type as ::evm_coder::abi::AbiWrite>::abi_write(&#tuple_data, writer)278 }279 }280 )281}282283fn impl_solidity_type<'a>(284 name: &syn::Ident,285 field_types: impl Iterator<Item = &'a syn::Type> + Clone,286 params_count: usize,287) -> proc_macro2::TokenStream {288 let len = proc_macro2::Literal::usize_suffixed(params_count);289 quote! {290 #[cfg(feature = "stubgen")]291 impl ::evm_coder::solidity::SolidityType for #name {292 fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {293 let mut collected =294 Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());295 #({296 let mut out = String::new();297 <#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)298 .expect("no fmt error");299 collected.push(out);300 })*301 collected302 }303304 fn len() -> usize {305 #len306 }307 }308 }309}310311fn impl_solidity_type_name<'a>(312 name: &syn::Ident,313 field_types: impl Iterator<Item = &'a syn::Type> + Clone,314 params_count: usize,315) -> proc_macro2::TokenStream {316 let arg_dafaults = field_types.enumerate().map(|(i, ty)| {317 let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName318 >::solidity_default(writer, tc)?;);319 let last_item = params_count - 1;320 if i != last_item {321 defult_value.extend(quote! {write!(writer, ",")?;})322 }323 defult_value324 });325326 quote! {327 #[cfg(feature = "stubgen")]328 impl ::evm_coder::solidity::SolidityTypeName for #name {329 fn solidity_name(330 writer: &mut impl ::core::fmt::Write,331 tc: &::evm_coder::solidity::TypeCollector,332 ) -> ::core::fmt::Result {333 write!(writer, "{}", tc.collect_struct::<Self>())334 }335336 fn is_simple() -> bool {337 false338 }339340 fn solidity_default(341 writer: &mut impl ::core::fmt::Write,342 tc: &::evm_coder::solidity::TypeCollector,343 ) -> ::core::fmt::Result {344 write!(writer, "{}(", tc.collect_struct::<Self>())?;345346 #(#arg_dafaults)*347348 write!(writer, ")")349 }350 }351 }352}353354fn impl_solidity_struct_collect<'a>(355 name: &syn::Ident,356 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,357 field_types: impl Iterator<Item = &'a syn::Type> + Clone,358 field_docs: impl Iterator<Item = syn::Result<Vec<String>>> + Clone,359 docs: &[String],360) -> syn::Result<proc_macro2::TokenStream> {361 let string_name = name.to_string();362 let name_type = field_names363 .into_iter()364 .zip(field_types)365 .zip(field_docs)366 .map(|((name, ty), doc)| {367 let field_docs = match doc {368 Ok(doc) => doc.into_iter().enumerate().map(|(i, doc)| {369 let doc = doc.trim();370 let dev = if i == 0 { " @dev" } else { "" };371 quote! {372 writeln!(str, "\t///{} {}", #dev, #doc).unwrap();373 }374 }),375 Err(e) => unreachable!("{:?}", e),376 };377 let name = format!("{}", name);378 quote!(379 #(#field_docs)*380 write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();381 writeln!(str, "{};", #name).unwrap();382 )383 });384 let docs = docs.iter().enumerate().map(|(i, doc)| {385 let doc = doc.trim();386 let dev = if i == 0 { " @dev" } else { "" };387 quote! {388 writeln!(str, "///{} {}", #dev, #doc).unwrap();389 }390 });391392 Ok(quote! {393 #[cfg(feature = "stubgen")]394 impl ::evm_coder::solidity::StructCollect for #name {395 fn name() -> String {396 #string_name.into()397 }398399 fn declaration() -> String {400 use std::fmt::Write;401402 let mut str = String::new();403 #(#docs)*404 writeln!(str, "struct {} {{", Self::name()).unwrap();405 #(#name_type)*406 writeln!(str, "}}").unwrap();407 str408 }409 }410 })411}