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, true)?;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 docs = extract_docs(&ast.attrs, true)?;74 let option_count = check_and_count_option(de)?;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));7778 let from = impl_enum_from_u8(name, enum_options.clone());79 let solidity_option = impl_solidity_option(name, enum_options.clone());80 let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);81 let abi_type = impl_enum_abi_type(name);82 let abi_read = impl_enum_abi_read(name);83 let abi_write = impl_enum_abi_write(name);84 let solidity_type_name = impl_enum_solidity_type_name(name);85 let solidity_struct_collect = impl_enum_solidity_struct_collect(86 name,87 enum_options,88 option_count,89 enum_options_docs,90 &docs,91 );9293 Ok(quote! {94 #from95 #solidity_option96 #can_be_plcaed_in_vec97 #abi_type98 #abi_read99 #abi_write100 #solidity_type_name101 #solidity_struct_collect102 })103}104105fn impl_solidity_option<'a>(106 name: &proc_macro2::Ident,107 enum_options: impl Iterator<Item = &'a syn::Ident>,108) -> proc_macro2::TokenStream {109 let enum_options = enum_options.map(|opt| {110 let s = name.to_string() + "." + opt.to_string().as_str();111 let as_string = proc_macro2::Literal::string(s.as_str());112 quote!(#name::#opt => #as_string,)113 });114 quote!(115 #[cfg(feature = "stubgen")]116 impl ::evm_coder::solidity::SolidityEnum for #name {117 fn solidity_option(&self) -> &str {118 match <#name>::default() {119 #(#enum_options)*120 }121 }122 }123 )124}125126fn impl_enum_from_u8<'a>(127 name: &proc_macro2::Ident,128 enum_options: impl Iterator<Item = &'a syn::Ident>,129) -> proc_macro2::TokenStream {130 let error_str = format!("Value not convertible into enum \"{name}\"");131 let error_str = proc_macro2::Literal::string(&error_str);132 let enum_options = enum_options.enumerate().map(|(i, opt)| {133 let n = proc_macro2::Literal::u8_suffixed(i as u8);134 quote! {#n => Ok(#name::#opt),}135 });136137 quote!(138 impl TryFrom<u8> for #name {139 type Error = &'static str;140141 fn try_from(value: u8) -> ::core::result::Result<Self, Self::Error> {142 const err: &'static str = #error_str;143 match value {144 #(#enum_options)*145 _ => Err(err)146 }147 }148 }149 )150}151152fn impl_enum_abi_type(name: &syn::Ident) -> proc_macro2::TokenStream {153 quote! {154 impl ::evm_coder::abi::AbiType for #name {155 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <u8 as ::evm_coder::abi::AbiType>::SIGNATURE;156157 fn is_dynamic() -> bool {158 <u8 as ::evm_coder::abi::AbiType>::is_dynamic()159 }160 fn size() -> usize {161 <u8 as ::evm_coder::abi::AbiType>::size()162 }163 }164 }165}166167fn impl_enum_abi_read(name: &syn::Ident) -> proc_macro2::TokenStream {168 quote!(169 impl ::evm_coder::abi::AbiRead for #name {170 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {171 Ok(172 <u8 as ::evm_coder::abi::AbiRead>::abi_read(reader)?173 .try_into()?174 )175 }176 }177 )178}179180fn impl_enum_abi_write(name: &syn::Ident) -> proc_macro2::TokenStream {181 quote!(182 impl ::evm_coder::abi::AbiWrite for #name {183 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {184 ::evm_coder::abi::AbiWrite::abi_write(&(*self as u8), writer);185 }186 }187 )188}189190fn impl_enum_solidity_type_name<'a>(name: &syn::Ident) -> proc_macro2::TokenStream {191 quote!(192 #[cfg(feature = "stubgen")]193 impl ::evm_coder::solidity::SolidityTypeName for #name {194 fn solidity_name(195 writer: &mut impl ::core::fmt::Write,196 tc: &::evm_coder::solidity::TypeCollector,197 ) -> ::core::fmt::Result {198 write!(writer, "{}", tc.collect_struct::<Self>())199 }200201 fn is_simple() -> bool {202 true203 }204205 fn solidity_default(206 writer: &mut impl ::core::fmt::Write,207 tc: &::evm_coder::solidity::TypeCollector,208 ) -> ::core::fmt::Result {209 write!(writer, "{}", <#name as ::evm_coder::solidity::SolidityEnum>::solidity_option(&<#name>::default()))210 }211 }212 )213}214215fn impl_enum_solidity_struct_collect<'a>(216 name: &syn::Ident,217 enum_options: impl Iterator<Item = &'a syn::Ident>,218 option_count: usize,219 enum_options_docs: impl Iterator<Item = syn::Result<Vec<proc_macro2::TokenStream>>>,220 docs: &[proc_macro2::TokenStream],221) -> proc_macro2::TokenStream {222 let string_name = name.to_string();223 let enum_options = enum_options224 .zip(enum_options_docs)225 .enumerate()226 .map(|(i, (opt, doc))| {227 let opt = proc_macro2::Literal::string(opt.to_string().as_str());228 let doc = doc.expect("Doc parsing error");229 let comma = if i != option_count - 1 { "," } else { "" };230 quote! {231 #(#doc)*232 writeln!(str, "\t{}{}", #opt, #comma).expect("Enum format option");233 }234 });235236 quote!(237 #[cfg(feature = "stubgen")]238 impl ::evm_coder::solidity::StructCollect for #name {239 fn name() -> String {240 #string_name.into()241 }242243 fn declaration() -> String {244 use std::fmt::Write;245246 let mut str = String::new();247 #(#docs)*248 writeln!(str, "enum {} {{", <Self as ::evm_coder::solidity::StructCollect>::name()).unwrap();249 #(#enum_options)*250 writeln!(str, "}}").unwrap();251 str252 }253 }254 )255}256257fn check_and_count_option(de: &syn::DataEnum) -> syn::Result<usize> {258 let mut count = 0;259 for error in de.variants.iter().filter_map(|v| {260 if !v.fields.is_empty() {261 Some(Err(syn::Error::new(262 v.ident.span(),263 "Enumeration parameters should not have fields",264 )))265 } else if v.discriminant.is_some() {266 Some(Err(syn::Error::new(267 v.ident.span(),268 "Enumeration options should not have an explicit specified value",269 )))270 } else {271 count += 1;272 None273 }274 }) {275 return error;276 }277278 Ok(count)279}280281fn check_repr_u8(name: &syn::Ident, attrs: &Vec<syn::Attribute>) -> syn::Result<()> {282 let mut has_repr = false;283 for error in attrs.iter().filter_map(|attr| {284 if let Some(ps) = attr.path.segments.first() {285 if ps.ident == "repr" {286 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 {292 syn::Meta::List(p) => {293 for error in p.nested.iter().filter_map(|nm| match nm {294 syn::NestedMeta::Meta(m) => match m {295 syn::Meta::Path(p) => {296 for i in p.segments.iter().filter_map(|ps| {297 if ps.ident != "u8" {298 Some(Err(syn::Error::new(299 ps.ident.span(),300 "Enum is not \"repr(u8)\"",301 )))302 } else {303 None304 }305 }) {306 return Some(i);307 }308 None309 }310 _ => None,311 },312 _ => None,313 }) {314 return Some(error);315 }316 None::<syn::Result<()>>317 }318 _ => None,319 };320 }321 }322 None323 }) {324 return error;325 }326327 if !has_repr {328 return Err(syn::Error::new(name.span(), "Enum is not \"repr(u8)\""));329 }330331 Ok(())332}333334fn tuple_type<'a>(335 field_types: impl Iterator<Item = &'a syn::Type> + Clone,336) -> proc_macro2::TokenStream {337 let field_types = field_types.map(|ty| quote!(#ty,));338 quote! {(#(#field_types)*)}339}340341fn tuple_ref_type<'a>(342 field_types: impl Iterator<Item = &'a syn::Type> + Clone,343) -> proc_macro2::TokenStream {344 let field_types = field_types.map(|ty| quote!(&#ty,));345 quote! {(#(#field_types)*)}346}347348fn tuple_data_as_ref(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!(&self.#field,)355 } else {356 let field = proc_macro2::Literal::usize_unsuffixed(i);357 quote!(&self.#field,)358 }359 });360 quote! {(#(#field_names)*)}361}362363fn tuple_names(364 is_named_fields: bool,365 field_names: impl Iterator<Item = syn::Ident> + Clone,366) -> proc_macro2::TokenStream {367 let field_names = field_names.enumerate().map(|(i, field)| {368 if is_named_fields {369 quote!(#field,)370 } else {371 let field = proc_macro2::Ident::new(372 format!("field{}", i).as_str(),373 proc_macro2::Span::call_site(),374 );375 quote!(#field,)376 }377 });378 quote! {(#(#field_names)*)}379}380381fn struct_from_tuple(382 name: &syn::Ident,383 is_named_fields: bool,384 field_names: impl Iterator<Item = syn::Ident> + Clone,385) -> proc_macro2::TokenStream {386 let field_names = field_names.enumerate().map(|(i, field)| {387 if is_named_fields {388 quote!(#field,)389 } else {390 let field = proc_macro2::Ident::new(391 format!("field{}", i).as_str(),392 proc_macro2::Span::call_site(),393 );394 quote!(#field,)395 }396 });397398 if is_named_fields {399 quote! {#name {#(#field_names)*}}400 } else {401 quote! {#name (#(#field_names)*)}402 }403}404405fn extract_docs(406 attrs: &[syn::Attribute],407 is_general: bool,408) -> syn::Result<Vec<proc_macro2::TokenStream>> {409 attrs410 .iter()411 .filter_map(|attr| {412 if let Some(ps) = attr.path.segments.first() {413 if ps.ident == "doc" {414 let meta = match attr.parse_meta() {415 Ok(meta) => meta,416 Err(e) => return Some(Err(e)),417 };418 match meta {419 syn::Meta::NameValue(mnv) => match &mnv.lit {420 syn::Lit::Str(ls) => return Some(Ok(ls.value())),421 _ => unreachable!(),422 },423 _ => unreachable!(),424 }425 }426 }427 None428 })429 .enumerate()430 .map(|(i, doc)| {431 let doc = doc?;432 let doc = doc.trim();433 let dev = if i == 0 { " @dev" } else { "" };434 let tab = if is_general { "" } else { "\t" };435 Ok(quote! {436 writeln!(str, "{}///{} {}", #tab, #dev, #doc).unwrap();437 })438 })439 .collect()440}441442fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {443 match field.1.ident.as_ref() {444 Some(name) => name.clone(),445 None => {446 let mut name = "field".to_string();447 name.push_str(field.0.to_string().as_str());448 syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())449 }450 }451}452453fn map_field_to_type(field: &syn::Field) -> &syn::Type {454 &field.ty455}456457fn map_field_to_doc(field: &syn::Field) -> syn::Result<Vec<proc_macro2::TokenStream>> {458 extract_docs(&field.attrs, false)459}460461fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {462 quote! {463 impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}464 }465}466467fn impl_struct_abi_type(468 name: &syn::Ident,469 tuple_type: proc_macro2::TokenStream,470) -> proc_macro2::TokenStream {471 quote! {472 impl ::evm_coder::abi::AbiType for #name {473 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <#tuple_type as ::evm_coder::abi::AbiType>::SIGNATURE;474 fn is_dynamic() -> bool {475 <#tuple_type as ::evm_coder::abi::AbiType>::is_dynamic()476 }477 fn size() -> usize {478 <#tuple_type as ::evm_coder::abi::AbiType>::size()479 }480 }481 }482}483484fn impl_struct_abi_read(485 name: &syn::Ident,486 tuple_type: proc_macro2::TokenStream,487 tuple_names: proc_macro2::TokenStream,488 struct_from_tuple: proc_macro2::TokenStream,489) -> proc_macro2::TokenStream {490 quote!(491 impl ::evm_coder::abi::AbiRead for #name {492 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {493 let #tuple_names = <#tuple_type as ::evm_coder::abi::AbiRead>::abi_read(reader)?;494 Ok(#struct_from_tuple)495 }496 }497 )498}499500fn impl_struct_abi_write(501 name: &syn::Ident,502 _is_named_fields: bool,503 tuple_type: proc_macro2::TokenStream,504 tuple_data: proc_macro2::TokenStream,505) -> proc_macro2::TokenStream {506 quote!(507 impl ::evm_coder::abi::AbiWrite for #name {508 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {509 <#tuple_type as ::evm_coder::abi::AbiWrite>::abi_write(&#tuple_data, writer)510 }511 }512 )513}514515fn impl_struct_solidity_type<'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 len = proc_macro2::Literal::usize_suffixed(params_count);521 quote! {522 #[cfg(feature = "stubgen")]523 impl ::evm_coder::solidity::SolidityType for #name {524 fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {525 let mut collected =526 Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());527 #({528 let mut out = String::new();529 <#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)530 .expect("no fmt error");531 collected.push(out);532 })*533 collected534 }535536 fn len() -> usize {537 #len538 }539 }540 }541}542543fn impl_struct_solidity_type_name<'a>(544 name: &syn::Ident,545 field_types: impl Iterator<Item = &'a syn::Type> + Clone,546 params_count: usize,547) -> proc_macro2::TokenStream {548 let arg_dafaults = field_types.enumerate().map(|(i, ty)| {549 let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName550 >::solidity_default(writer, tc)?;);551 let last_item = params_count - 1;552 if i != last_item {553 defult_value.extend(quote! {write!(writer, ",")?;})554 }555 defult_value556 });557558 quote! {559 #[cfg(feature = "stubgen")]560 impl ::evm_coder::solidity::SolidityTypeName for #name {561 fn solidity_name(562 writer: &mut impl ::core::fmt::Write,563 tc: &::evm_coder::solidity::TypeCollector,564 ) -> ::core::fmt::Result {565 write!(writer, "{}", tc.collect_struct::<Self>())566 }567568 fn is_simple() -> bool {569 false570 }571572 fn solidity_default(573 writer: &mut impl ::core::fmt::Write,574 tc: &::evm_coder::solidity::TypeCollector,575 ) -> ::core::fmt::Result {576 write!(writer, "{}(", tc.collect_struct::<Self>())?;577578 #(#arg_dafaults)*579580 write!(writer, ")")581 }582 }583 }584}585586fn impl_struct_solidity_struct_collect<'a>(587 name: &syn::Ident,588 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,589 field_types: impl Iterator<Item = &'a syn::Type> + Clone,590 field_docs: impl Iterator<Item = syn::Result<Vec<proc_macro2::TokenStream>>> + Clone,591 docs: &[proc_macro2::TokenStream],592) -> syn::Result<proc_macro2::TokenStream> {593 let string_name = name.to_string();594 let name_type = field_names595 .into_iter()596 .zip(field_types)597 .zip(field_docs)598 .map(|((name, ty), doc)| {599 let field_docs = doc.expect("Doc parse error");600 let name = format!("{}", name);601 quote!(602 #(#field_docs)*603 write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();604 writeln!(str, "{};", #name).unwrap();605 )606 });607608 Ok(quote! {609 #[cfg(feature = "stubgen")]610 impl ::evm_coder::solidity::StructCollect for #name {611 fn name() -> String {612 #string_name.into()613 }614615 fn declaration() -> String {616 use std::fmt::Write;617618 let mut str = String::new();619 #(#docs)*620 writeln!(str, "struct {} {{", Self::name()).unwrap();621 #(#name_type)*622 writeln!(str, "}}").unwrap();623 str624 }625 }626 })627}