git.delta.rocks / unique-network / refs/commits / 12eee8195c76

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 = ast6		.attrs7		.iter()8		.filter_map(|attr| {9			if let Some(ps) = attr.path.segments.first() {10				if ps.ident == "doc" {11					let meta = match attr.parse_meta() {12						Ok(meta) => meta,13						Err(e) => return Some(Err(e)),14					};15					match meta {16						syn::Meta::NameValue(mnv) => match &mnv.lit {17							syn::Lit::Str(ls) => return Some(Ok(ls.value())),18							_ => unreachable!(),19						},20						_ => unreachable!(),21					}22				}23			}24			None25		})26		.collect::<syn::Result<Vec<_>>>()?;2728	let (is_named_fields, field_names, field_types, params_count) = match &ast.data {29		syn::Data::Struct(ds) => match ds.fields {30			syn::Fields::Named(ref fields) => Ok((31				true,32				fields.named.iter().enumerate().map(map_field_to_name),33				fields.named.iter().map(map_field_to_type),34				fields.named.len(),35			)),36			syn::Fields::Unnamed(ref fields) => Ok((37				false,38				fields.unnamed.iter().enumerate().map(map_field_to_name),39				fields.unnamed.iter().map(map_field_to_type),40				fields.unnamed.len(),41			)),42			syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),43		},44		syn::Data::Enum(_) => Err(syn::Error::new(name.span(), "Enums not supported")),45		syn::Data::Union(_) => Err(syn::Error::new(name.span(), "Unions not supported")),46	}?;4748	if params_count == 0 {49		return Err(syn::Error::new(name.span(), "Empty structs not supported"));50	};5152	let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);53	let abi_type = impl_abi_type(name, field_types.clone());54	let abi_read = impl_abi_read(55		name,56		is_named_fields,57		field_names.clone(),58		field_types.clone(),59	);60	let abi_write = impl_abi_write(name, is_named_fields, params_count, field_names.clone());61	let solidity_type = impl_solidity_type(name, field_types.clone(), params_count);62	let solidity_type_name = impl_solidity_type_name(name, field_types.clone(), params_count);63	let solidity_struct_collect =64		impl_solidity_struct_collect(name, field_names, field_types, &docs);6566	Ok(quote! {67		#can_be_plcaed_in_vec68		#abi_type69		#abi_read70		#abi_write71		#solidity_type72		#solidity_type_name73		#solidity_struct_collect74	})75}7677fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {78	quote! {79		impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}80	}81}8283fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {84	match field.1.ident.as_ref() {85		Some(name) => name.clone(),86		None => {87			let mut name = "field".to_string();88			name.push_str(field.0.to_string().as_str());89			syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())90		}91	}92}9394fn map_field_to_type<'a>(field: &'a syn::Field) -> &'a syn::Type {95	&field.ty96}9798fn impl_abi_type<'a>(99	name: &syn::Ident,100	field_types: impl Iterator<Item = &'a syn::Type> + Clone,101) -> proc_macro2::TokenStream {102	let mut params_signature = {103		let types = field_types.clone();104		quote!(105			#(nameof(<#types as ::evm_coder::abi::AbiType>::SIGNATURE) fixed(","))*106		)107	};108109	params_signature.extend(quote!(shift_left(1)));110111	let fields_for_dynamic = field_types.clone();112113	quote! {114		impl ::evm_coder::abi::AbiType for #name {115			const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = ::evm_coder::make_signature!(116				new fixed("(")117				#params_signature118				fixed(")")119			);120			fn is_dynamic() -> bool {121				false122				#(123					|| <#fields_for_dynamic as ::evm_coder::abi::AbiType>::is_dynamic()124				)*125			}126			fn size() -> usize {127				0 #(+ <#field_types as ::evm_coder::abi::AbiType>::size())*128			}129		}130	}131}132133fn impl_abi_read<'a>(134	name: &syn::Ident,135	is_named_fields: bool,136	field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,137	field_types: impl Iterator<Item = &'a syn::Type> + Clone,138) -> proc_macro2::TokenStream {139	let field_names1 = field_names.clone();140141	let struct_constructor = if is_named_fields {142		quote!(Ok(Self { #(#field_names1),* }))143	} else {144		quote!(Ok(Self ( #(#field_names1),* )))145	};146	quote!(147		impl ::evm_coder::abi::AbiRead for #name {148			fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {149				let is_dynamic = <Self as ::evm_coder::abi::AbiType>::is_dynamic();150				let size = if !is_dynamic {151					Some(<Self as ::evm_coder::abi::AbiType>::size())152				} else {153					None154				};155				let mut subresult = reader.subresult(size)?;156				#(157					let #field_names = {158						let value = <#field_types as ::evm_coder::abi::AbiRead>::abi_read(&mut subresult)?;159						if !is_dynamic {subresult.bytes_read(<#field_types as ::evm_coder::abi::AbiType>::size())};160						value161					};162				)*163164				#struct_constructor165			}166		}167	)168}169170fn impl_abi_write<'a>(171	name: &syn::Ident,172	is_named_fields: bool,173	params_count: usize,174	field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,175) -> proc_macro2::TokenStream {176	let abi_write = if is_named_fields {177		quote!(178			#(179				::evm_coder::abi::AbiWrite::abi_write(&self.#field_names, sub);180			)*181		)182	} else {183		let field_names = (0..params_count)184			.into_iter()185			.map(proc_macro2::Literal::usize_unsuffixed);186		quote!(187			#(188				::evm_coder::abi::AbiWrite::abi_write(&self.#field_names, sub);189			)*190		)191	};192	quote!(193		impl ::evm_coder::abi::AbiWrite for #name {194			fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {195				if <Self as ::evm_coder::abi::AbiType>::is_dynamic() {196					let mut sub = ::evm_coder::abi::AbiWriter::new();197					{198						let sub = &mut sub;199						#abi_write200					}201					writer.write_subresult(sub);202				} else {203					let sub = writer;204					#abi_write205				}206			}207		}208	)209}210211fn impl_solidity_type<'a>(212	name: &syn::Ident,213	field_types: impl Iterator<Item = &'a syn::Type> + Clone,214	params_count: usize,215) -> proc_macro2::TokenStream {216	let len = proc_macro2::Literal::usize_suffixed(params_count);217	quote! {218		#[cfg(feature = "stubgen")]219		impl ::evm_coder::solidity::SolidityType for #name {220			fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {221				let mut collected =222					Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());223				#({224					let mut out = String::new();225					<#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)226						.expect("no fmt error");227					collected.push(out);228				})*229				collected230			}231232			fn len() -> usize {233				#len234			}235		}236	}237}238239fn impl_solidity_type_name<'a>(240	name: &syn::Ident,241	field_types: impl Iterator<Item = &'a syn::Type> + Clone,242	params_count: usize,243) -> proc_macro2::TokenStream {244	let arg_dafaults = field_types.enumerate().map(|(i, ty)| {245		let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName246			>::solidity_default(writer, tc)?;);247		let last_item = params_count - 1;248		if i != last_item {249			defult_value.extend(quote! {write!(writer, ",")?;})250		}251		defult_value252	});253254	quote! {255		#[cfg(feature = "stubgen")]256		impl ::evm_coder::solidity::SolidityTypeName for #name {257			fn solidity_name(258				writer: &mut impl ::core::fmt::Write,259				tc: &::evm_coder::solidity::TypeCollector,260			) -> ::core::fmt::Result {261				write!(writer, "{}", tc.collect_struct::<Self>())262			}263264			fn is_simple() -> bool {265				false266			}267268			fn solidity_default(269				writer: &mut impl ::core::fmt::Write,270				tc: &::evm_coder::solidity::TypeCollector,271			) -> ::core::fmt::Result {272				write!(writer, "{}(", tc.collect_struct::<Self>())?;273274				#(#arg_dafaults)*275276				write!(writer, ")")277			}278		}279	}280}281282fn impl_solidity_struct_collect<'a>(283	name: &syn::Ident,284	field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,285	field_types: impl Iterator<Item = &'a syn::Type> + Clone,286	docs: &Vec<String>,287) -> proc_macro2::TokenStream {288	let string_name = name.to_string();289	let name_type = field_names290		.into_iter()291		.zip(field_types.into_iter())292		.map(|(name, ty)| {293			let name = format!("{}", name);294			quote!(295				write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();296				write!(str, "{};", #name).unwrap();297			)298		});299	let docs = docs.iter().enumerate().map(|(i, doc)| {300		let doc = doc.trim();301		let dev = if i == 0 { " @dev" } else { "" };302		quote! {303			writeln!(str, "///{} {}", #dev, #doc).unwrap();304		}305	});306307	quote! {308		#[cfg(feature = "stubgen")]309		impl ::evm_coder::solidity::StructCollect for #name {310			fn name() -> String {311				#string_name.into()312			}313314			fn declaration() -> String {315				use std::fmt::Write;316317				let mut str = String::new();318				#(#docs)*319				writeln!(str, "struct {} {{", Self::name()).unwrap();320				#(#name_type)*321				writeln!(str, "}}").unwrap();322				str323			}324		}325	}326}