git.delta.rocks / unique-network / refs/commits / bcfbebcaedee

1use quote::quote;23pub(crate) fn impl_abi_macro(ast: &syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream> {4	let name = &ast.ident;5	let docs = extract_docs(&ast.attrs)?;67	match &ast.data {8		syn::Data::Struct(ds) => {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(_) => Err(syn::Error::new(name.span(), "Enums not supported")),61		syn::Data::Union(_) => Err(syn::Error::new(name.span(), "Unions not supported")),62	}63}6465fn tuple_type<'a>(66	field_types: impl Iterator<Item = &'a syn::Type> + Clone,67) -> proc_macro2::TokenStream {68	let field_types = field_types.map(|ty| quote!(#ty,));69	quote! {(#(#field_types)*)}70}7172fn tuple_ref_type<'a>(73	field_types: impl Iterator<Item = &'a syn::Type> + Clone,74) -> proc_macro2::TokenStream {75	let field_types = field_types.map(|ty| quote!(&#ty,));76	quote! {(#(#field_types)*)}77}7879fn tuple_data_as_ref(80	is_named_fields: bool,81	field_names: impl Iterator<Item = syn::Ident> + Clone,82) -> proc_macro2::TokenStream {83	let field_names = field_names.enumerate().map(|(i, field)| {84		if is_named_fields {85			quote!(&self.#field,)86		} else {87			let field = proc_macro2::Literal::usize_unsuffixed(i);88			quote!(&self.#field,)89		}90	});91	quote! {(#(#field_names)*)}92}9394fn tuple_names(95	is_named_fields: bool,96	field_names: impl Iterator<Item = syn::Ident> + Clone,97) -> proc_macro2::TokenStream {98	let field_names = field_names.enumerate().map(|(i, field)| {99		if is_named_fields {100			quote!(#field,)101		} else {102			let field = proc_macro2::Ident::new(103				format!("field{}", i).as_str(),104				proc_macro2::Span::call_site(),105			);106			quote!(#field,)107		}108	});109	quote! {(#(#field_names)*)}110}111112fn struct_from_tuple(113	name: &syn::Ident,114	is_named_fields: bool,115	field_names: impl Iterator<Item = syn::Ident> + Clone,116) -> proc_macro2::TokenStream {117	let field_names = field_names.enumerate().map(|(i, field)| {118		if is_named_fields {119			quote!(#field,)120		} else {121			let field = proc_macro2::Ident::new(122				format!("field{}", i).as_str(),123				proc_macro2::Span::call_site(),124			);125			quote!(#field,)126		}127	});128129	if is_named_fields {130		quote! {#name {#(#field_names)*}}131	} else {132		quote! {#name (#(#field_names)*)}133	}134}135136fn extract_docs(attrs: &[syn::Attribute]) -> syn::Result<Vec<String>> {137	attrs138		.iter()139		.filter_map(|attr| {140			if let Some(ps) = attr.path.segments.first() {141				if ps.ident == "doc" {142					let meta = match attr.parse_meta() {143						Ok(meta) => meta,144						Err(e) => return Some(Err(e)),145					};146					match meta {147						syn::Meta::NameValue(mnv) => match &mnv.lit {148							syn::Lit::Str(ls) => return Some(Ok(ls.value())),149							_ => unreachable!(),150						},151						_ => unreachable!(),152					}153				}154			}155			None156		})157		.collect()158}159160fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {161	match field.1.ident.as_ref() {162		Some(name) => name.clone(),163		None => {164			let mut name = "field".to_string();165			name.push_str(field.0.to_string().as_str());166			syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())167		}168	}169}170171fn map_field_to_type(field: &syn::Field) -> &syn::Type {172	&field.ty173}174175fn map_field_to_doc(field: &syn::Field) -> Result<Vec<std::string::String>, syn::Error> {176	extract_docs(&field.attrs)177}178179fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {180	quote! {181		impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}182	}183}184185fn impl_abi_type(186	name: &syn::Ident,187	tuple_type: proc_macro2::TokenStream,188) -> proc_macro2::TokenStream {189	quote! {190		impl ::evm_coder::abi::AbiType for #name {191			const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <#tuple_type as ::evm_coder::abi::AbiType>::SIGNATURE;192			fn is_dynamic() -> bool {193				<#tuple_type as ::evm_coder::abi::AbiType>::is_dynamic()194			}195			fn size() -> usize {196				<#tuple_type as ::evm_coder::abi::AbiType>::size()197			}198		}199	}200}201202fn impl_abi_read(203	name: &syn::Ident,204	tuple_type: proc_macro2::TokenStream,205	tuple_names: proc_macro2::TokenStream,206	struct_from_tuple: proc_macro2::TokenStream,207) -> proc_macro2::TokenStream {208	quote!(209		impl ::evm_coder::abi::AbiRead for #name {210			fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {211				let #tuple_names = <#tuple_type as ::evm_coder::abi::AbiRead>::abi_read(reader)?;212				Ok(#struct_from_tuple)213			}214		}215	)216}217218fn impl_abi_write(219	name: &syn::Ident,220	_is_named_fields: bool,221	tuple_type: proc_macro2::TokenStream,222	tuple_data: proc_macro2::TokenStream,223) -> proc_macro2::TokenStream {224	quote!(225		impl ::evm_coder::abi::AbiWrite for #name {226			fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {227				<#tuple_type as ::evm_coder::abi::AbiWrite>::abi_write(&#tuple_data, writer)228			}229		}230	)231}232233fn impl_solidity_type<'a>(234	name: &syn::Ident,235	field_types: impl Iterator<Item = &'a syn::Type> + Clone,236	params_count: usize,237) -> proc_macro2::TokenStream {238	let len = proc_macro2::Literal::usize_suffixed(params_count);239	quote! {240		#[cfg(feature = "stubgen")]241		impl ::evm_coder::solidity::SolidityType for #name {242			fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {243				let mut collected =244					Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());245				#({246					let mut out = String::new();247					<#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)248						.expect("no fmt error");249					collected.push(out);250				})*251				collected252			}253254			fn len() -> usize {255				#len256			}257		}258	}259}260261fn impl_solidity_type_name<'a>(262	name: &syn::Ident,263	field_types: impl Iterator<Item = &'a syn::Type> + Clone,264	params_count: usize,265) -> proc_macro2::TokenStream {266	let arg_dafaults = field_types.enumerate().map(|(i, ty)| {267		let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName268			>::solidity_default(writer, tc)?;);269		let last_item = params_count - 1;270		if i != last_item {271			defult_value.extend(quote! {write!(writer, ",")?;})272		}273		defult_value274	});275276	quote! {277		#[cfg(feature = "stubgen")]278		impl ::evm_coder::solidity::SolidityTypeName for #name {279			fn solidity_name(280				writer: &mut impl ::core::fmt::Write,281				tc: &::evm_coder::solidity::TypeCollector,282			) -> ::core::fmt::Result {283				write!(writer, "{}", tc.collect_struct::<Self>())284			}285286			fn is_simple() -> bool {287				false288			}289290			fn solidity_default(291				writer: &mut impl ::core::fmt::Write,292				tc: &::evm_coder::solidity::TypeCollector,293			) -> ::core::fmt::Result {294				write!(writer, "{}(", tc.collect_struct::<Self>())?;295296				#(#arg_dafaults)*297298				write!(writer, ")")299			}300		}301	}302}303304fn impl_solidity_struct_collect<'a>(305	name: &syn::Ident,306	field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,307	field_types: impl Iterator<Item = &'a syn::Type> + Clone,308	field_docs: impl Iterator<Item = syn::Result<Vec<String>>> + Clone,309	docs: &[String],310) -> syn::Result<proc_macro2::TokenStream> {311	let string_name = name.to_string();312	let name_type = field_names313		.into_iter()314		.zip(field_types)315		.zip(field_docs)316		.map(|((name, ty), doc)| {317			let field_docs = match doc {318				Ok(doc) => doc.into_iter().enumerate().map(|(i, doc)| {319					let doc = doc.trim();320					let dev = if i == 0 { " @dev" } else { "" };321					quote! {322						writeln!(str, "\t///{} {}", #dev, #doc).unwrap();323					}324				}),325				Err(e) => unreachable!("{:?}", e),326			};327			let name = format!("{}", name);328			quote!(329				#(#field_docs)*330				write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();331				writeln!(str, "{};", #name).unwrap();332			)333		});334	let docs = docs.iter().enumerate().map(|(i, doc)| {335		let doc = doc.trim();336		let dev = if i == 0 { " @dev" } else { "" };337		quote! {338			writeln!(str, "///{} {}", #dev, #doc).unwrap();339		}340	});341342	Ok(quote! {343		#[cfg(feature = "stubgen")]344		impl ::evm_coder::solidity::StructCollect for #name {345			fn name() -> String {346				#string_name.into()347			}348349			fn declaration() -> String {350				use std::fmt::Write;351352				let mut str = String::new();353				#(#docs)*354				writeln!(str, "struct {} {{", Self::name()).unwrap();355				#(#name_type)*356				writeln!(str, "}}").unwrap();357				str358			}359		}360	})361}