1use quote::quote;23pub(crate) fn impl_abi_macro(ast: &syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream> {4 let name = &ast.ident;5 match &ast.data {6 syn::Data::Struct(ds) => expand_struct(ds, ast),7 syn::Data::Enum(de) => expand_enum(de, ast),8 syn::Data::Union(_) => Err(syn::Error::new(name.span(), "Unions not supported")),9 }10}1112fn expand_struct(13 ds: &syn::DataStruct,14 ast: &syn::DeriveInput,15) -> syn::Result<proc_macro2::TokenStream> {16 let name = &ast.ident;17 let docs = extract_docs(&ast.attrs)?;18 let (is_named_fields, field_names, field_types, field_docs, params_count) = match ds.fields {19 syn::Fields::Named(ref fields) => Ok((20 true,21 fields.named.iter().enumerate().map(map_field_to_name),22 fields.named.iter().map(map_field_to_type),23 fields.named.iter().map(map_field_to_doc),24 fields.named.len(),25 )),26 syn::Fields::Unnamed(ref fields) => Ok((27 false,28 fields.unnamed.iter().enumerate().map(map_field_to_name),29 fields.unnamed.iter().map(map_field_to_type),30 fields.unnamed.iter().map(map_field_to_doc),31 fields.unnamed.len(),32 )),33 syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),34 }?;3536 if params_count == 0 {37 return Err(syn::Error::new(name.span(), "Empty structs not supported"));38 };3940 let tuple_type = tuple_type(field_types.clone());41 let tuple_ref_type = tuple_ref_type(field_types.clone());42 let tuple_data = tuple_data_as_ref(is_named_fields, field_names.clone());43 let tuple_names = tuple_names(is_named_fields, field_names.clone());44 let struct_from_tuple = struct_from_tuple(name, is_named_fields, field_names.clone());4546 let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);47 let abi_type = impl_struct_abi_type(name, tuple_type.clone());48 let abi_read = impl_struct_abi_read(name, tuple_type, tuple_names, struct_from_tuple);49 let abi_write = impl_struct_abi_write(name, is_named_fields, tuple_ref_type, tuple_data);50 let solidity_type = impl_struct_solidity_type(name, field_types.clone(), params_count);51 let solidity_type_name =52 impl_struct_solidity_type_name(name, field_types.clone(), params_count);53 let solidity_struct_collect =54 impl_struct_solidity_struct_collect(name, field_names, field_types, field_docs, &docs)?;5556 Ok(quote! {57 #can_be_plcaed_in_vec58 #abi_type59 #abi_read60 #abi_write61 #solidity_type62 #solidity_type_name63 #solidity_struct_collect64 })65}6667fn expand_enum(68 de: &syn::DataEnum,69 ast: &syn::DeriveInput,70) -> syn::Result<proc_macro2::TokenStream> {71 let name = &ast.ident;72 check_repr_u8(name, &ast.attrs)?;73 let option_count = check_and_count_option(de)?;74 let enum_options = de.variants.iter().map(|v| &v.ident);7576 let from = impl_enum_from_u8(name, enum_options.clone());77 let solidity_option = impl_solidity_option(name, enum_options.clone());78 let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);79 let abi_type = impl_enum_abi_type(name);80 let abi_read = impl_enum_abi_read(name);81 let abi_write = impl_enum_abi_write(name);82 let solidity_type_name = impl_enum_solidity_type_name(name, enum_options.clone());83 let solidity_struct_collect =84 impl_enum_solidity_struct_collect(name, enum_options, option_count);8586 Ok(quote! {87 #from88 #solidity_option89 #can_be_plcaed_in_vec90 #abi_type91 #abi_read92 #abi_write93 #solidity_type_name94 #solidity_struct_collect95 })96}9798fn impl_solidity_option<'a>(99 name: &proc_macro2::Ident,100 enum_options: impl Iterator<Item = &'a syn::Ident>,101) -> proc_macro2::TokenStream {102 let enum_options = enum_options.map(|opt| {103 let s = name.to_string() + "." + opt.to_string().as_str();104 let as_string = proc_macro2::Literal::string(s.as_str());105 quote!(#name::#opt => #as_string,)106 });107 quote!(108 impl ::evm_coder::solidity::SolidityEnum for #name {109 fn solidity_option(&self) -> &str {110 match <#name>::default() {111 #(#enum_options)*112 }113 }114 }115 )116}117118fn impl_enum_from_u8<'a>(119 name: &proc_macro2::Ident,120 enum_options: impl Iterator<Item = &'a syn::Ident>,121) -> proc_macro2::TokenStream {122 let enum_options = enum_options.enumerate().map(|(i, opt)| {123 let n = proc_macro2::Literal::u8_suffixed(i as u8);124 quote! {#n => Ok(#name::#opt),}125 });126 quote!(127 impl TryFrom<u8> for #name {128 type Error = &'static str;129130 fn try_from(value: u8) -> ::std::result::Result<Self, Self::Error> {131 const err: &'static str = "Not convertible";132 match value {133 #(#enum_options)*134 _ => Err(err)135 }136 }137 }138 )139}140141fn impl_enum_abi_type(name: &syn::Ident) -> proc_macro2::TokenStream {142 quote! {143 impl ::evm_coder::abi::AbiType for #name {144 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <u8 as ::evm_coder::abi::AbiType>::SIGNATURE;145146 fn is_dynamic() -> bool {147 <u8 as ::evm_coder::abi::AbiType>::is_dynamic()148 }149 fn size() -> usize {150 <u8 as ::evm_coder::abi::AbiType>::size()151 }152 }153 }154}155156fn impl_enum_abi_read(name: &syn::Ident) -> proc_macro2::TokenStream {157 quote!(158 impl ::evm_coder::abi::AbiRead for #name {159 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {160 Ok(161 <u8 as ::evm_coder::abi::AbiRead>::abi_read(reader)?162 .try_into()?163 )164 }165 }166 )167}168169fn impl_enum_abi_write(name: &syn::Ident) -> proc_macro2::TokenStream {170 quote!(171 impl ::evm_coder::abi::AbiWrite for #name {172 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {173 ::evm_coder::abi::AbiWrite::abi_write(&(*self as u8), writer);174 }175 }176 )177}178179fn impl_enum_solidity_type_name<'a>(180 name: &syn::Ident,181 enum_options: impl Iterator<Item = &'a syn::Ident>,182) -> proc_macro2::TokenStream {183 let enum_options = enum_options.map(|opt| quote!(,));184 quote!(185 #[cfg(feature = "stubgen")]186 impl ::evm_coder::solidity::SolidityTypeName for #name {187 fn solidity_name(188 writer: &mut impl ::core::fmt::Write,189 tc: &::evm_coder::solidity::TypeCollector,190 ) -> ::core::fmt::Result {191 write!(writer, "{}", tc.collect_struct::<Self>())192 }193194 fn is_simple() -> bool {195 true196 }197198 fn solidity_default(199 writer: &mut impl ::core::fmt::Write,200 tc: &::evm_coder::solidity::TypeCollector,201 ) -> ::core::fmt::Result {202 write!(writer, "{}", <#name as ::evm_coder::solidity::SolidityEnum>::solidity_option(&<#name>::default()))203 }204 }205 )206}207208fn impl_enum_solidity_struct_collect<'a>(209 name: &syn::Ident,210 enum_options: impl Iterator<Item = &'a syn::Ident>,211 option_count: usize,212) -> proc_macro2::TokenStream {213 let string_name = name.to_string();214 let enum_options = enum_options.enumerate().map(|(i, opt)| {215 let opt = proc_macro2::Literal::string(opt.to_string().as_str());216 let comma = if i != option_count - 1 { "," } else { "" };217 quote! {218 writeln!(str, "\t{}{}", #opt, #comma).expect("Enum format option");219 }220 });221 quote!(222 #[cfg(feature = "stubgen")]223 impl ::evm_coder::solidity::StructCollect for #name {224 fn name() -> String {225 #string_name.into()226 }227228 fn declaration() -> String {229 use std::fmt::Write;230231 let mut str = String::new();232 233 writeln!(str, "enum {} {{", <Self as ::evm_coder::solidity::StructCollect>::name()).unwrap();234 #(#enum_options)*235 writeln!(str, "}}").unwrap();236 str237 }238 }239 )240}241242fn check_and_count_option(de: &syn::DataEnum) -> syn::Result<usize> {243 let mut count = 0;244 for error in de.variants.iter().filter_map(|v| {245 if !v.fields.is_empty() {246 Some(Err(syn::Error::new(247 v.ident.span(),248 "Enumeration parameters should not have fields",249 )))250 } else if v.discriminant.is_some() {251 Some(Err(syn::Error::new(252 v.ident.span(),253 "Enumeration options should not have an explicit specified value",254 )))255 } else {256 count += 1;257 None258 }259 }) {260 return error;261 }262263 Ok(count)264}265266fn check_repr_u8(name: &syn::Ident, attrs: &Vec<syn::Attribute>) -> syn::Result<()> {267 let mut has_repr = false;268 for error in attrs.iter().filter_map(|attr| {269 if let Some(ps) = attr.path.segments.first() {270 if ps.ident == "repr" {271 has_repr = true;272 let meta = match attr.parse_meta() {273 Ok(meta) => meta,274 Err(e) => return Some(Err(e)),275 };276 match meta {277 syn::Meta::List(p) => {278 for error in p.nested.iter().filter_map(|nm| match nm {279 syn::NestedMeta::Meta(m) => match m {280 syn::Meta::Path(p) => {281 for i in p.segments.iter().filter_map(|ps| {282 if ps.ident != "u8" {283 Some(Err(syn::Error::new(284 ps.ident.span(),285 "Enum is not \"repr(u8)\"",286 )))287 } else {288 None289 }290 }) {291 return Some(i);292 }293 None294 }295 _ => None,296 },297 _ => None,298 }) {299 return Some(error);300 }301 None::<syn::Result<()>>302 }303 _ => None,304 };305 }306 }307 None308 }) {309 return error;310 }311312 if !has_repr {313 return Err(syn::Error::new(name.span(), "Enum is not \"repr(u8)\""));314 }315316 Ok(())317}318319fn tuple_type<'a>(320 field_types: impl Iterator<Item = &'a syn::Type> + Clone,321) -> proc_macro2::TokenStream {322 let field_types = field_types.map(|ty| quote!(#ty,));323 quote! {(#(#field_types)*)}324}325326fn tuple_ref_type<'a>(327 field_types: impl Iterator<Item = &'a syn::Type> + Clone,328) -> proc_macro2::TokenStream {329 let field_types = field_types.map(|ty| quote!(&#ty,));330 quote! {(#(#field_types)*)}331}332333fn tuple_data_as_ref(334 is_named_fields: bool,335 field_names: impl Iterator<Item = syn::Ident> + Clone,336) -> proc_macro2::TokenStream {337 let field_names = field_names.enumerate().map(|(i, field)| {338 if is_named_fields {339 quote!(&self.#field,)340 } else {341 let field = proc_macro2::Literal::usize_unsuffixed(i);342 quote!(&self.#field,)343 }344 });345 quote! {(#(#field_names)*)}346}347348fn tuple_names(349 is_named_fields: bool,350 field_names: impl Iterator<Item = syn::Ident> + Clone,351) -> proc_macro2::TokenStream {352 let field_names = field_names.enumerate().map(|(i, field)| {353 if is_named_fields {354 quote!(#field,)355 } else {356 let field = proc_macro2::Ident::new(357 format!("field{}", i).as_str(),358 proc_macro2::Span::call_site(),359 );360 quote!(#field,)361 }362 });363 quote! {(#(#field_names)*)}364}365366fn struct_from_tuple(367 name: &syn::Ident,368 is_named_fields: bool,369 field_names: impl Iterator<Item = syn::Ident> + Clone,370) -> proc_macro2::TokenStream {371 let field_names = field_names.enumerate().map(|(i, field)| {372 if is_named_fields {373 quote!(#field,)374 } else {375 let field = proc_macro2::Ident::new(376 format!("field{}", i).as_str(),377 proc_macro2::Span::call_site(),378 );379 quote!(#field,)380 }381 });382383 if is_named_fields {384 quote! {#name {#(#field_names)*}}385 } else {386 quote! {#name (#(#field_names)*)}387 }388}389390fn extract_docs(attrs: &[syn::Attribute]) -> syn::Result<Vec<String>> {391 attrs392 .iter()393 .filter_map(|attr| {394 if let Some(ps) = attr.path.segments.first() {395 if ps.ident == "doc" {396 let meta = match attr.parse_meta() {397 Ok(meta) => meta,398 Err(e) => return Some(Err(e)),399 };400 match meta {401 syn::Meta::NameValue(mnv) => match &mnv.lit {402 syn::Lit::Str(ls) => return Some(Ok(ls.value())),403 _ => unreachable!(),404 },405 _ => unreachable!(),406 }407 }408 }409 None410 })411 .collect()412}413414fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {415 match field.1.ident.as_ref() {416 Some(name) => name.clone(),417 None => {418 let mut name = "field".to_string();419 name.push_str(field.0.to_string().as_str());420 syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())421 }422 }423}424425fn map_field_to_type(field: &syn::Field) -> &syn::Type {426 &field.ty427}428429fn map_field_to_doc(field: &syn::Field) -> Result<Vec<std::string::String>, syn::Error> {430 extract_docs(&field.attrs)431}432433fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {434 quote! {435 impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}436 }437}438439fn impl_struct_abi_type(440 name: &syn::Ident,441 tuple_type: proc_macro2::TokenStream,442) -> proc_macro2::TokenStream {443 quote! {444 impl ::evm_coder::abi::AbiType for #name {445 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <#tuple_type as ::evm_coder::abi::AbiType>::SIGNATURE;446 fn is_dynamic() -> bool {447 <#tuple_type as ::evm_coder::abi::AbiType>::is_dynamic()448 }449 fn size() -> usize {450 <#tuple_type as ::evm_coder::abi::AbiType>::size()451 }452 }453 }454}455456fn impl_struct_abi_read(457 name: &syn::Ident,458 tuple_type: proc_macro2::TokenStream,459 tuple_names: proc_macro2::TokenStream,460 struct_from_tuple: proc_macro2::TokenStream,461) -> proc_macro2::TokenStream {462 quote!(463 impl ::evm_coder::abi::AbiRead for #name {464 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {465 let #tuple_names = <#tuple_type as ::evm_coder::abi::AbiRead>::abi_read(reader)?;466 Ok(#struct_from_tuple)467 }468 }469 )470}471472fn impl_struct_abi_write(473 name: &syn::Ident,474 _is_named_fields: bool,475 tuple_type: proc_macro2::TokenStream,476 tuple_data: proc_macro2::TokenStream,477) -> proc_macro2::TokenStream {478 quote!(479 impl ::evm_coder::abi::AbiWrite for #name {480 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {481 <#tuple_type as ::evm_coder::abi::AbiWrite>::abi_write(&#tuple_data, writer)482 }483 }484 )485}486487fn impl_struct_solidity_type<'a>(488 name: &syn::Ident,489 field_types: impl Iterator<Item = &'a syn::Type> + Clone,490 params_count: usize,491) -> proc_macro2::TokenStream {492 let len = proc_macro2::Literal::usize_suffixed(params_count);493 quote! {494 #[cfg(feature = "stubgen")]495 impl ::evm_coder::solidity::SolidityType for #name {496 fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {497 let mut collected =498 Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());499 #({500 let mut out = String::new();501 <#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)502 .expect("no fmt error");503 collected.push(out);504 })*505 collected506 }507508 fn len() -> usize {509 #len510 }511 }512 }513}514515fn impl_struct_solidity_type_name<'a>(516 name: &syn::Ident,517 field_types: impl Iterator<Item = &'a syn::Type> + Clone,518 params_count: usize,519) -> proc_macro2::TokenStream {520 let arg_dafaults = field_types.enumerate().map(|(i, ty)| {521 let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName522 >::solidity_default(writer, tc)?;);523 let last_item = params_count - 1;524 if i != last_item {525 defult_value.extend(quote! {write!(writer, ",")?;})526 }527 defult_value528 });529530 quote! {531 #[cfg(feature = "stubgen")]532 impl ::evm_coder::solidity::SolidityTypeName for #name {533 fn solidity_name(534 writer: &mut impl ::core::fmt::Write,535 tc: &::evm_coder::solidity::TypeCollector,536 ) -> ::core::fmt::Result {537 write!(writer, "{}", tc.collect_struct::<Self>())538 }539540 fn is_simple() -> bool {541 false542 }543544 fn solidity_default(545 writer: &mut impl ::core::fmt::Write,546 tc: &::evm_coder::solidity::TypeCollector,547 ) -> ::core::fmt::Result {548 write!(writer, "{}(", tc.collect_struct::<Self>())?;549550 #(#arg_dafaults)*551552 write!(writer, ")")553 }554 }555 }556}557558fn impl_struct_solidity_struct_collect<'a>(559 name: &syn::Ident,560 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,561 field_types: impl Iterator<Item = &'a syn::Type> + Clone,562 field_docs: impl Iterator<Item = syn::Result<Vec<String>>> + Clone,563 docs: &[String],564) -> syn::Result<proc_macro2::TokenStream> {565 let string_name = name.to_string();566 let name_type = field_names567 .into_iter()568 .zip(field_types)569 .zip(field_docs)570 .map(|((name, ty), doc)| {571 let field_docs = match doc {572 Ok(doc) => doc.into_iter().enumerate().map(|(i, doc)| {573 let doc = doc.trim();574 let dev = if i == 0 { " @dev" } else { "" };575 quote! {576 writeln!(str, "\t///{} {}", #dev, #doc).unwrap();577 }578 }),579 Err(e) => unreachable!("{:?}", e),580 };581 let name = format!("{}", name);582 quote!(583 #(#field_docs)*584 write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();585 writeln!(str, "{};", #name).unwrap();586 )587 });588 let docs = docs.iter().enumerate().map(|(i, doc)| {589 let doc = doc.trim();590 let dev = if i == 0 { " @dev" } else { "" };591 quote! {592 writeln!(str, "///{} {}", #dev, #doc).unwrap();593 }594 });595596 Ok(quote! {597 #[cfg(feature = "stubgen")]598 impl ::evm_coder::solidity::StructCollect for #name {599 fn name() -> String {600 #string_name.into()601 }602603 fn declaration() -> String {604 use std::fmt::Write;605606 let mut str = String::new();607 #(#docs)*608 writeln!(str, "struct {} {{", Self::name()).unwrap();609 #(#name_type)*610 writeln!(str, "}}").unwrap();611 str612 }613 }614 })615}