git.delta.rocks / unique-network / refs/commits / 31b1faacd1c9

1use proc_macro2::TokenStream;2use quote::quote;34pub(crate) fn impl_abi_macro(ast: &syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream> {5	let name = &ast.ident;6	let docs = extract_docs(&ast.attrs)?;78	let (is_named_fields, field_names, field_types, field_docs, params_count) = match &ast.data {9		syn::Data::Struct(ds) => match ds.fields {10			syn::Fields::Named(ref fields) => Ok((11				true,12				fields.named.iter().enumerate().map(map_field_to_name),13				fields.named.iter().map(map_field_to_type),14				fields.named.iter().map(map_field_to_doc),15				fields.named.len(),16			)),17			syn::Fields::Unnamed(ref fields) => Ok((18				false,19				fields.unnamed.iter().enumerate().map(map_field_to_name),20				fields.unnamed.iter().map(map_field_to_type),21				fields.unnamed.iter().map(map_field_to_doc),22				fields.unnamed.len(),23			)),24			syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),25		},26		syn::Data::Enum(_) => Err(syn::Error::new(name.span(), "Enums not supported")),27		syn::Data::Union(_) => Err(syn::Error::new(name.span(), "Unions not supported")),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(43		name,44		tuple_type.clone(),45		tuple_names.clone(),46		struct_from_tuple,47	);48	let abi_write = impl_abi_write(name, is_named_fields, tuple_ref_type, tuple_data);49	println!(50		"=========================\n{}\n=========================",51		&abi_write52	);53	let solidity_type = impl_solidity_type(name, field_types.clone(), params_count);54	let solidity_type_name = impl_solidity_type_name(name, field_types.clone(), params_count);55	let solidity_struct_collect =56		impl_solidity_struct_collect(name, field_names, field_types, field_docs, &docs)?;5758	Ok(quote! {59		#can_be_plcaed_in_vec60		#abi_type61		#abi_read62		#abi_write63		#solidity_type64		#solidity_type_name65		#solidity_struct_collect66	})67}6869fn tuple_type<'a>(70	field_types: impl Iterator<Item = &'a syn::Type> + Clone,71) -> proc_macro2::TokenStream {72	let field_types = field_types.map(|ty| quote!(#ty,));73	quote! {(#(#field_types)*)}74}75fn tuple_ref_type<'a>(76	field_types: impl Iterator<Item = &'a syn::Type> + Clone,77) -> proc_macro2::TokenStream {78	let field_types = field_types.map(|ty| quote!(&#ty,));79	quote! {(#(#field_types)*)}80}81fn tuple_data_as_ref(82	is_named_fields: bool,83	field_names: impl Iterator<Item = syn::Ident> + Clone,84) -> proc_macro2::TokenStream {85	let field_names = field_names.enumerate().map(|(i, field)| {86		if is_named_fields {87			quote!(&self.#field,)88		} else {89			let field = proc_macro2::Literal::usize_unsuffixed(i);90			quote!(&self.#field,)91		}92	});93	quote! {(#(#field_names)*)}94}95fn tuple_names(96	is_named_fields: bool,97	field_names: impl Iterator<Item = syn::Ident> + Clone,98) -> proc_macro2::TokenStream {99	let field_names = field_names.enumerate().map(|(i, field)| {100		if is_named_fields {101			quote!(#field,)102		} else {103			let field = proc_macro2::Ident::new(104				format!("field{}", i).as_str(),105				proc_macro2::Span::call_site(),106			);107			quote!(#field,)108		}109	});110	quote! {(#(#field_names)*)}111}112fn 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: &Vec<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<'a>(field: &'a syn::Field) -> &'a 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<'a>(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<'a>(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<'a>(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: &Vec<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}