git.delta.rocks / unique-network / refs/commits / 0affbc2bc9a0

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}