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);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 #[cfg(feature = "stubgen")]109 impl ::evm_coder::solidity::SolidityEnum for #name {110 fn solidity_option(&self) -> &str {111 match <#name>::default() {112 #(#enum_options)*113 }114 }115 }116 )117}118119fn impl_enum_from_u8<'a>(120 name: &proc_macro2::Ident,121 enum_options: impl Iterator<Item = &'a syn::Ident>,122) -> proc_macro2::TokenStream {123 let enum_options = enum_options.enumerate().map(|(i, opt)| {124 let n = proc_macro2::Literal::u8_suffixed(i as u8);125 quote! {#n => Ok(#name::#opt),}126 });127 quote!(128 impl TryFrom<u8> for #name {129 type Error = &'static str;130131 fn try_from(value: u8) -> ::std::result::Result<Self, Self::Error> {132 const err: &'static str = "Not convertible";133 match value {134 #(#enum_options)*135 _ => Err(err)136 }137 }138 }139 )140}141142fn impl_enum_abi_type(name: &syn::Ident) -> proc_macro2::TokenStream {143 quote! {144 impl ::evm_coder::abi::AbiType for #name {145 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <u8 as ::evm_coder::abi::AbiType>::SIGNATURE;146147 fn is_dynamic() -> bool {148 <u8 as ::evm_coder::abi::AbiType>::is_dynamic()149 }150 fn size() -> usize {151 <u8 as ::evm_coder::abi::AbiType>::size()152 }153 }154 }155}156157fn impl_enum_abi_read(name: &syn::Ident) -> proc_macro2::TokenStream {158 quote!(159 impl ::evm_coder::abi::AbiRead for #name {160 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {161 Ok(162 <u8 as ::evm_coder::abi::AbiRead>::abi_read(reader)?163 .try_into()?164 )165 }166 }167 )168}169170fn impl_enum_abi_write(name: &syn::Ident) -> proc_macro2::TokenStream {171 quote!(172 impl ::evm_coder::abi::AbiWrite for #name {173 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {174 ::evm_coder::abi::AbiWrite::abi_write(&(*self as u8), writer);175 }176 }177 )178}179180fn impl_enum_solidity_type_name<'a>(name: &syn::Ident) -> proc_macro2::TokenStream {181 quote!(182 #[cfg(feature = "stubgen")]183 impl ::evm_coder::solidity::SolidityTypeName for #name {184 fn solidity_name(185 writer: &mut impl ::core::fmt::Write,186 tc: &::evm_coder::solidity::TypeCollector,187 ) -> ::core::fmt::Result {188 write!(writer, "{}", tc.collect_struct::<Self>())189 }190191 fn is_simple() -> bool {192 true193 }194195 fn solidity_default(196 writer: &mut impl ::core::fmt::Write,197 tc: &::evm_coder::solidity::TypeCollector,198 ) -> ::core::fmt::Result {199 write!(writer, "{}", <#name as ::evm_coder::solidity::SolidityEnum>::solidity_option(&<#name>::default()))200 }201 }202 )203}204205fn impl_enum_solidity_struct_collect<'a>(206 name: &syn::Ident,207 enum_options: impl Iterator<Item = &'a syn::Ident>,208 option_count: usize,209) -> proc_macro2::TokenStream {210 let string_name = name.to_string();211 let enum_options = enum_options.enumerate().map(|(i, opt)| {212 let opt = proc_macro2::Literal::string(opt.to_string().as_str());213 let comma = if i != option_count - 1 { "," } else { "" };214 quote! {215 writeln!(str, "\t{}{}", #opt, #comma).expect("Enum format option");216 }217 });218 quote!(219 #[cfg(feature = "stubgen")]220 impl ::evm_coder::solidity::StructCollect for #name {221 fn name() -> String {222 #string_name.into()223 }224225 fn declaration() -> String {226 use std::fmt::Write;227228 let mut str = String::new();229 230 writeln!(str, "enum {} {{", <Self as ::evm_coder::solidity::StructCollect>::name()).unwrap();231 #(#enum_options)*232 writeln!(str, "}}").unwrap();233 str234 }235 }236 )237}238239fn check_and_count_option(de: &syn::DataEnum) -> syn::Result<usize> {240 let mut count = 0;241 for error in de.variants.iter().filter_map(|v| {242 if !v.fields.is_empty() {243 Some(Err(syn::Error::new(244 v.ident.span(),245 "Enumeration parameters should not have fields",246 )))247 } else if v.discriminant.is_some() {248 Some(Err(syn::Error::new(249 v.ident.span(),250 "Enumeration options should not have an explicit specified value",251 )))252 } else {253 count += 1;254 None255 }256 }) {257 return error;258 }259260 Ok(count)261}262263fn check_repr_u8(name: &syn::Ident, attrs: &Vec<syn::Attribute>) -> syn::Result<()> {264 let mut has_repr = false;265 for error in attrs.iter().filter_map(|attr| {266 if let Some(ps) = attr.path.segments.first() {267 if ps.ident == "repr" {268 has_repr = true;269 let meta = match attr.parse_meta() {270 Ok(meta) => meta,271 Err(e) => return Some(Err(e)),272 };273 match meta {274 syn::Meta::List(p) => {275 for error in p.nested.iter().filter_map(|nm| match nm {276 syn::NestedMeta::Meta(m) => match m {277 syn::Meta::Path(p) => {278 for i in p.segments.iter().filter_map(|ps| {279 if ps.ident != "u8" {280 Some(Err(syn::Error::new(281 ps.ident.span(),282 "Enum is not \"repr(u8)\"",283 )))284 } else {285 None286 }287 }) {288 return Some(i);289 }290 None291 }292 _ => None,293 },294 _ => None,295 }) {296 return Some(error);297 }298 None::<syn::Result<()>>299 }300 _ => None,301 };302 }303 }304 None305 }) {306 return error;307 }308309 if !has_repr {310 return Err(syn::Error::new(name.span(), "Enum is not \"repr(u8)\""));311 }312313 Ok(())314}315316fn tuple_type<'a>(317 field_types: impl Iterator<Item = &'a syn::Type> + Clone,318) -> proc_macro2::TokenStream {319 let field_types = field_types.map(|ty| quote!(#ty,));320 quote! {(#(#field_types)*)}321}322323fn tuple_ref_type<'a>(324 field_types: impl Iterator<Item = &'a syn::Type> + Clone,325) -> proc_macro2::TokenStream {326 let field_types = field_types.map(|ty| quote!(&#ty,));327 quote! {(#(#field_types)*)}328}329330fn tuple_data_as_ref(331 is_named_fields: bool,332 field_names: impl Iterator<Item = syn::Ident> + Clone,333) -> proc_macro2::TokenStream {334 let field_names = field_names.enumerate().map(|(i, field)| {335 if is_named_fields {336 quote!(&self.#field,)337 } else {338 let field = proc_macro2::Literal::usize_unsuffixed(i);339 quote!(&self.#field,)340 }341 });342 quote! {(#(#field_names)*)}343}344345fn tuple_names(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!(#field,)352 } else {353 let field = proc_macro2::Ident::new(354 format!("field{}", i).as_str(),355 proc_macro2::Span::call_site(),356 );357 quote!(#field,)358 }359 });360 quote! {(#(#field_names)*)}361}362363fn struct_from_tuple(364 name: &syn::Ident,365 is_named_fields: bool,366 field_names: impl Iterator<Item = syn::Ident> + Clone,367) -> proc_macro2::TokenStream {368 let field_names = field_names.enumerate().map(|(i, field)| {369 if is_named_fields {370 quote!(#field,)371 } else {372 let field = proc_macro2::Ident::new(373 format!("field{}", i).as_str(),374 proc_macro2::Span::call_site(),375 );376 quote!(#field,)377 }378 });379380 if is_named_fields {381 quote! {#name {#(#field_names)*}}382 } else {383 quote! {#name (#(#field_names)*)}384 }385}386387fn extract_docs(attrs: &[syn::Attribute]) -> syn::Result<Vec<String>> {388 attrs389 .iter()390 .filter_map(|attr| {391 if let Some(ps) = attr.path.segments.first() {392 if ps.ident == "doc" {393 let meta = match attr.parse_meta() {394 Ok(meta) => meta,395 Err(e) => return Some(Err(e)),396 };397 match meta {398 syn::Meta::NameValue(mnv) => match &mnv.lit {399 syn::Lit::Str(ls) => return Some(Ok(ls.value())),400 _ => unreachable!(),401 },402 _ => unreachable!(),403 }404 }405 }406 None407 })408 .collect()409}410411fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {412 match field.1.ident.as_ref() {413 Some(name) => name.clone(),414 None => {415 let mut name = "field".to_string();416 name.push_str(field.0.to_string().as_str());417 syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())418 }419 }420}421422fn map_field_to_type(field: &syn::Field) -> &syn::Type {423 &field.ty424}425426fn map_field_to_doc(field: &syn::Field) -> Result<Vec<std::string::String>, syn::Error> {427 extract_docs(&field.attrs)428}429430fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {431 quote! {432 impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}433 }434}435436fn impl_struct_abi_type(437 name: &syn::Ident,438 tuple_type: proc_macro2::TokenStream,439) -> proc_macro2::TokenStream {440 quote! {441 impl ::evm_coder::abi::AbiType for #name {442 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <#tuple_type as ::evm_coder::abi::AbiType>::SIGNATURE;443 fn is_dynamic() -> bool {444 <#tuple_type as ::evm_coder::abi::AbiType>::is_dynamic()445 }446 fn size() -> usize {447 <#tuple_type as ::evm_coder::abi::AbiType>::size()448 }449 }450 }451}452453fn impl_struct_abi_read(454 name: &syn::Ident,455 tuple_type: proc_macro2::TokenStream,456 tuple_names: proc_macro2::TokenStream,457 struct_from_tuple: proc_macro2::TokenStream,458) -> proc_macro2::TokenStream {459 quote!(460 impl ::evm_coder::abi::AbiRead for #name {461 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {462 let #tuple_names = <#tuple_type as ::evm_coder::abi::AbiRead>::abi_read(reader)?;463 Ok(#struct_from_tuple)464 }465 }466 )467}468469fn impl_struct_abi_write(470 name: &syn::Ident,471 _is_named_fields: bool,472 tuple_type: proc_macro2::TokenStream,473 tuple_data: proc_macro2::TokenStream,474) -> proc_macro2::TokenStream {475 quote!(476 impl ::evm_coder::abi::AbiWrite for #name {477 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {478 <#tuple_type as ::evm_coder::abi::AbiWrite>::abi_write(&#tuple_data, writer)479 }480 }481 )482}483484fn impl_struct_solidity_type<'a>(485 name: &syn::Ident,486 field_types: impl Iterator<Item = &'a syn::Type> + Clone,487 params_count: usize,488) -> proc_macro2::TokenStream {489 let len = proc_macro2::Literal::usize_suffixed(params_count);490 quote! {491 #[cfg(feature = "stubgen")]492 impl ::evm_coder::solidity::SolidityType for #name {493 fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {494 let mut collected =495 Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());496 #({497 let mut out = String::new();498 <#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)499 .expect("no fmt error");500 collected.push(out);501 })*502 collected503 }504505 fn len() -> usize {506 #len507 }508 }509 }510}511512fn impl_struct_solidity_type_name<'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 arg_dafaults = field_types.enumerate().map(|(i, ty)| {518 let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName519 >::solidity_default(writer, tc)?;);520 let last_item = params_count - 1;521 if i != last_item {522 defult_value.extend(quote! {write!(writer, ",")?;})523 }524 defult_value525 });526527 quote! {528 #[cfg(feature = "stubgen")]529 impl ::evm_coder::solidity::SolidityTypeName for #name {530 fn solidity_name(531 writer: &mut impl ::core::fmt::Write,532 tc: &::evm_coder::solidity::TypeCollector,533 ) -> ::core::fmt::Result {534 write!(writer, "{}", tc.collect_struct::<Self>())535 }536537 fn is_simple() -> bool {538 false539 }540541 fn solidity_default(542 writer: &mut impl ::core::fmt::Write,543 tc: &::evm_coder::solidity::TypeCollector,544 ) -> ::core::fmt::Result {545 write!(writer, "{}(", tc.collect_struct::<Self>())?;546547 #(#arg_dafaults)*548549 write!(writer, ")")550 }551 }552 }553}554555fn impl_struct_solidity_struct_collect<'a>(556 name: &syn::Ident,557 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,558 field_types: impl Iterator<Item = &'a syn::Type> + Clone,559 field_docs: impl Iterator<Item = syn::Result<Vec<String>>> + Clone,560 docs: &[String],561) -> syn::Result<proc_macro2::TokenStream> {562 let string_name = name.to_string();563 let name_type = field_names564 .into_iter()565 .zip(field_types)566 .zip(field_docs)567 .map(|((name, ty), doc)| {568 let field_docs = match doc {569 Ok(doc) => doc.into_iter().enumerate().map(|(i, doc)| {570 let doc = doc.trim();571 let dev = if i == 0 { " @dev" } else { "" };572 quote! {573 writeln!(str, "\t///{} {}", #dev, #doc).unwrap();574 }575 }),576 Err(e) => unreachable!("{:?}", e),577 };578 let name = format!("{}", name);579 quote!(580 #(#field_docs)*581 write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();582 writeln!(str, "{};", #name).unwrap();583 )584 });585 let docs = docs.iter().enumerate().map(|(i, doc)| {586 let doc = doc.trim();587 let dev = if i == 0 { " @dev" } else { "" };588 quote! {589 writeln!(str, "///{} {}", #dev, #doc).unwrap();590 }591 });592593 Ok(quote! {594 #[cfg(feature = "stubgen")]595 impl ::evm_coder::solidity::StructCollect for #name {596 fn name() -> String {597 #string_name.into()598 }599600 fn declaration() -> String {601 use std::fmt::Write;602603 let mut str = String::new();604 #(#docs)*605 writeln!(str, "struct {} {{", Self::name()).unwrap();606 #(#name_type)*607 writeln!(str, "}}").unwrap();608 str609 }610 }611 })612}