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 enum_options = enum_options.enumerate().map(|(i, opt)| {131 let n = proc_macro2::Literal::u8_suffixed(i as u8);132 quote! {#n => Ok(#name::#opt),}133 });134 quote!(135 impl TryFrom<u8> for #name {136 type Error = &'static str;137138 fn try_from(value: u8) -> ::std::result::Result<Self, Self::Error> {139 const err: &'static str = "Not convertible";140 match value {141 #(#enum_options)*142 _ => Err(err)143 }144 }145 }146 )147}148149fn impl_enum_abi_type(name: &syn::Ident) -> proc_macro2::TokenStream {150 quote! {151 impl ::evm_coder::abi::AbiType for #name {152 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <u8 as ::evm_coder::abi::AbiType>::SIGNATURE;153154 fn is_dynamic() -> bool {155 <u8 as ::evm_coder::abi::AbiType>::is_dynamic()156 }157 fn size() -> usize {158 <u8 as ::evm_coder::abi::AbiType>::size()159 }160 }161 }162}163164fn impl_enum_abi_read(name: &syn::Ident) -> proc_macro2::TokenStream {165 quote!(166 impl ::evm_coder::abi::AbiRead for #name {167 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {168 Ok(169 <u8 as ::evm_coder::abi::AbiRead>::abi_read(reader)?170 .try_into()?171 )172 }173 }174 )175}176177fn impl_enum_abi_write(name: &syn::Ident) -> proc_macro2::TokenStream {178 quote!(179 impl ::evm_coder::abi::AbiWrite for #name {180 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {181 ::evm_coder::abi::AbiWrite::abi_write(&(*self as u8), writer);182 }183 }184 )185}186187fn impl_enum_solidity_type_name<'a>(name: &syn::Ident) -> proc_macro2::TokenStream {188 quote!(189 #[cfg(feature = "stubgen")]190 impl ::evm_coder::solidity::SolidityTypeName for #name {191 fn solidity_name(192 writer: &mut impl ::core::fmt::Write,193 tc: &::evm_coder::solidity::TypeCollector,194 ) -> ::core::fmt::Result {195 write!(writer, "{}", tc.collect_struct::<Self>())196 }197198 fn is_simple() -> bool {199 true200 }201202 fn solidity_default(203 writer: &mut impl ::core::fmt::Write,204 tc: &::evm_coder::solidity::TypeCollector,205 ) -> ::core::fmt::Result {206 write!(writer, "{}", <#name as ::evm_coder::solidity::SolidityEnum>::solidity_option(&<#name>::default()))207 }208 }209 )210}211212fn impl_enum_solidity_struct_collect<'a>(213 name: &syn::Ident,214 enum_options: impl Iterator<Item = &'a syn::Ident>,215 option_count: usize,216 enum_options_docs: impl Iterator<Item = syn::Result<Vec<proc_macro2::TokenStream>>>,217 docs: &[proc_macro2::TokenStream],218) -> proc_macro2::TokenStream {219 let string_name = name.to_string();220 let enum_options = enum_options221 .zip(enum_options_docs)222 .enumerate()223 .map(|(i, (opt, doc))| {224 let opt = proc_macro2::Literal::string(opt.to_string().as_str());225 let doc = doc.expect("Doc parsing error");226 let comma = if i != option_count - 1 { "," } else { "" };227 quote! {228 #(#doc)*229 writeln!(str, "\t{}{}", #opt, #comma).expect("Enum format option");230 }231 });232233 quote!(234 #[cfg(feature = "stubgen")]235 impl ::evm_coder::solidity::StructCollect for #name {236 fn name() -> String {237 #string_name.into()238 }239240 fn declaration() -> String {241 use std::fmt::Write;242243 let mut str = String::new();244 #(#docs)*245 writeln!(str, "enum {} {{", <Self as ::evm_coder::solidity::StructCollect>::name()).unwrap();246 #(#enum_options)*247 writeln!(str, "}}").unwrap();248 str249 }250 }251 )252}253254fn check_and_count_option(de: &syn::DataEnum) -> syn::Result<usize> {255 let mut count = 0;256 for error in de.variants.iter().filter_map(|v| {257 if !v.fields.is_empty() {258 Some(Err(syn::Error::new(259 v.ident.span(),260 "Enumeration parameters should not have fields",261 )))262 } else if v.discriminant.is_some() {263 Some(Err(syn::Error::new(264 v.ident.span(),265 "Enumeration options should not have an explicit specified value",266 )))267 } else {268 count += 1;269 None270 }271 }) {272 return error;273 }274275 Ok(count)276}277278fn check_repr_u8(name: &syn::Ident, attrs: &Vec<syn::Attribute>) -> syn::Result<()> {279 let mut has_repr = false;280 for error in attrs.iter().filter_map(|attr| {281 if let Some(ps) = attr.path.segments.first() {282 if ps.ident == "repr" {283 has_repr = true;284 let meta = match attr.parse_meta() {285 Ok(meta) => meta,286 Err(e) => return Some(Err(e)),287 };288 match meta {289 syn::Meta::List(p) => {290 for error in p.nested.iter().filter_map(|nm| match nm {291 syn::NestedMeta::Meta(m) => match m {292 syn::Meta::Path(p) => {293 for i in p.segments.iter().filter_map(|ps| {294 if ps.ident != "u8" {295 Some(Err(syn::Error::new(296 ps.ident.span(),297 "Enum is not \"repr(u8)\"",298 )))299 } else {300 None301 }302 }) {303 return Some(i);304 }305 None306 }307 _ => None,308 },309 _ => None,310 }) {311 return Some(error);312 }313 None::<syn::Result<()>>314 }315 _ => None,316 };317 }318 }319 None320 }) {321 return error;322 }323324 if !has_repr {325 return Err(syn::Error::new(name.span(), "Enum is not \"repr(u8)\""));326 }327328 Ok(())329}330331fn tuple_type<'a>(332 field_types: impl Iterator<Item = &'a syn::Type> + Clone,333) -> proc_macro2::TokenStream {334 let field_types = field_types.map(|ty| quote!(#ty,));335 quote! {(#(#field_types)*)}336}337338fn tuple_ref_type<'a>(339 field_types: impl Iterator<Item = &'a syn::Type> + Clone,340) -> proc_macro2::TokenStream {341 let field_types = field_types.map(|ty| quote!(&#ty,));342 quote! {(#(#field_types)*)}343}344345fn tuple_data_as_ref(346 is_named_fields: bool,347 field_names: impl Iterator<Item = syn::Ident> + Clone,348) -> proc_macro2::TokenStream {349 let field_names = field_names.enumerate().map(|(i, field)| {350 if is_named_fields {351 quote!(&self.#field,)352 } else {353 let field = proc_macro2::Literal::usize_unsuffixed(i);354 quote!(&self.#field,)355 }356 });357 quote! {(#(#field_names)*)}358}359360fn tuple_names(361 is_named_fields: bool,362 field_names: impl Iterator<Item = syn::Ident> + Clone,363) -> proc_macro2::TokenStream {364 let field_names = field_names.enumerate().map(|(i, field)| {365 if is_named_fields {366 quote!(#field,)367 } else {368 let field = proc_macro2::Ident::new(369 format!("field{}", i).as_str(),370 proc_macro2::Span::call_site(),371 );372 quote!(#field,)373 }374 });375 quote! {(#(#field_names)*)}376}377378fn struct_from_tuple(379 name: &syn::Ident,380 is_named_fields: bool,381 field_names: impl Iterator<Item = syn::Ident> + Clone,382) -> proc_macro2::TokenStream {383 let field_names = field_names.enumerate().map(|(i, field)| {384 if is_named_fields {385 quote!(#field,)386 } else {387 let field = proc_macro2::Ident::new(388 format!("field{}", i).as_str(),389 proc_macro2::Span::call_site(),390 );391 quote!(#field,)392 }393 });394395 if is_named_fields {396 quote! {#name {#(#field_names)*}}397 } else {398 quote! {#name (#(#field_names)*)}399 }400}401402fn extract_docs(403 attrs: &[syn::Attribute],404 is_general: bool,405) -> syn::Result<Vec<proc_macro2::TokenStream>> {406 attrs407 .iter()408 .filter_map(|attr| {409 if let Some(ps) = attr.path.segments.first() {410 if ps.ident == "doc" {411 let meta = match attr.parse_meta() {412 Ok(meta) => meta,413 Err(e) => return Some(Err(e)),414 };415 match meta {416 syn::Meta::NameValue(mnv) => match &mnv.lit {417 syn::Lit::Str(ls) => return Some(Ok(ls.value())),418 _ => unreachable!(),419 },420 _ => unreachable!(),421 }422 }423 }424 None425 })426 .enumerate()427 .map(|(i, doc)| {428 let doc = doc?;429 let doc = doc.trim();430 let dev = if i == 0 { " @dev" } else { "" };431 let tab = if is_general { "" } else { "\t" };432 Ok(quote! {433 writeln!(str, "{}///{} {}", #tab, #dev, #doc).unwrap();434 })435 })436 .collect()437}438439fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {440 match field.1.ident.as_ref() {441 Some(name) => name.clone(),442 None => {443 let mut name = "field".to_string();444 name.push_str(field.0.to_string().as_str());445 syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())446 }447 }448}449450fn map_field_to_type(field: &syn::Field) -> &syn::Type {451 &field.ty452}453454fn map_field_to_doc(field: &syn::Field) -> syn::Result<Vec<proc_macro2::TokenStream>> {455 extract_docs(&field.attrs, false)456}457458fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {459 quote! {460 impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}461 }462}463464fn impl_struct_abi_type(465 name: &syn::Ident,466 tuple_type: proc_macro2::TokenStream,467) -> proc_macro2::TokenStream {468 quote! {469 impl ::evm_coder::abi::AbiType for #name {470 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <#tuple_type as ::evm_coder::abi::AbiType>::SIGNATURE;471 fn is_dynamic() -> bool {472 <#tuple_type as ::evm_coder::abi::AbiType>::is_dynamic()473 }474 fn size() -> usize {475 <#tuple_type as ::evm_coder::abi::AbiType>::size()476 }477 }478 }479}480481fn impl_struct_abi_read(482 name: &syn::Ident,483 tuple_type: proc_macro2::TokenStream,484 tuple_names: proc_macro2::TokenStream,485 struct_from_tuple: proc_macro2::TokenStream,486) -> proc_macro2::TokenStream {487 quote!(488 impl ::evm_coder::abi::AbiRead for #name {489 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {490 let #tuple_names = <#tuple_type as ::evm_coder::abi::AbiRead>::abi_read(reader)?;491 Ok(#struct_from_tuple)492 }493 }494 )495}496497fn impl_struct_abi_write(498 name: &syn::Ident,499 _is_named_fields: bool,500 tuple_type: proc_macro2::TokenStream,501 tuple_data: proc_macro2::TokenStream,502) -> proc_macro2::TokenStream {503 quote!(504 impl ::evm_coder::abi::AbiWrite for #name {505 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {506 <#tuple_type as ::evm_coder::abi::AbiWrite>::abi_write(&#tuple_data, writer)507 }508 }509 )510}511512fn impl_struct_solidity_type<'a>(513 name: &syn::Ident,514 field_types: impl Iterator<Item = &'a syn::Type> + Clone,515 params_count: usize,516) -> proc_macro2::TokenStream {517 let len = proc_macro2::Literal::usize_suffixed(params_count);518 quote! {519 #[cfg(feature = "stubgen")]520 impl ::evm_coder::solidity::SolidityType for #name {521 fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {522 let mut collected =523 Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());524 #({525 let mut out = String::new();526 <#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)527 .expect("no fmt error");528 collected.push(out);529 })*530 collected531 }532533 fn len() -> usize {534 #len535 }536 }537 }538}539540fn impl_struct_solidity_type_name<'a>(541 name: &syn::Ident,542 field_types: impl Iterator<Item = &'a syn::Type> + Clone,543 params_count: usize,544) -> proc_macro2::TokenStream {545 let arg_dafaults = field_types.enumerate().map(|(i, ty)| {546 let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName547 >::solidity_default(writer, tc)?;);548 let last_item = params_count - 1;549 if i != last_item {550 defult_value.extend(quote! {write!(writer, ",")?;})551 }552 defult_value553 });554555 quote! {556 #[cfg(feature = "stubgen")]557 impl ::evm_coder::solidity::SolidityTypeName for #name {558 fn solidity_name(559 writer: &mut impl ::core::fmt::Write,560 tc: &::evm_coder::solidity::TypeCollector,561 ) -> ::core::fmt::Result {562 write!(writer, "{}", tc.collect_struct::<Self>())563 }564565 fn is_simple() -> bool {566 false567 }568569 fn solidity_default(570 writer: &mut impl ::core::fmt::Write,571 tc: &::evm_coder::solidity::TypeCollector,572 ) -> ::core::fmt::Result {573 write!(writer, "{}(", tc.collect_struct::<Self>())?;574575 #(#arg_dafaults)*576577 write!(writer, ")")578 }579 }580 }581}582583fn impl_struct_solidity_struct_collect<'a>(584 name: &syn::Ident,585 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,586 field_types: impl Iterator<Item = &'a syn::Type> + Clone,587 field_docs: impl Iterator<Item = syn::Result<Vec<proc_macro2::TokenStream>>> + Clone,588 docs: &[proc_macro2::TokenStream],589) -> syn::Result<proc_macro2::TokenStream> {590 let string_name = name.to_string();591 let name_type = field_names592 .into_iter()593 .zip(field_types)594 .zip(field_docs)595 .map(|((name, ty), doc)| {596 let field_docs = doc.expect("Doc parse error");597 let name = format!("{}", name);598 quote!(599 #(#field_docs)*600 write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();601 writeln!(str, "{};", #name).unwrap();602 )603 });604605 Ok(quote! {606 #[cfg(feature = "stubgen")]607 impl ::evm_coder::solidity::StructCollect for #name {608 fn name() -> String {609 #string_name.into()610 }611612 fn declaration() -> String {613 use std::fmt::Write;614615 let mut str = String::new();616 #(#docs)*617 writeln!(str, "struct {} {{", Self::name()).unwrap();618 #(#name_type)*619 writeln!(str, "}}").unwrap();620 str621 }622 }623 })624}