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

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, enum_options.clone());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		impl ::evm_coder::solidity::SolidityEnum for #name {109			fn solidity_option(&self) -> &str {110				match <#name>::default() {111					#(#enum_options)*112				}113			}114		}115	)116}117118fn impl_enum_from_u8<'a>(119	name: &proc_macro2::Ident,120	enum_options: impl Iterator<Item = &'a syn::Ident>,121) -> proc_macro2::TokenStream {122	let enum_options = enum_options.enumerate().map(|(i, opt)| {123		let n = proc_macro2::Literal::u8_suffixed(i as u8);124		quote! {#n => Ok(#name::#opt),}125	});126	quote!(127		impl TryFrom<u8> for #name {128			type Error = &'static str;129130			fn try_from(value: u8) -> ::std::result::Result<Self, Self::Error> {131				const err: &'static str = "Not convertible";132				match value {133					#(#enum_options)*134					_ => Err(err)135				}136			}137		}138	)139}140141fn impl_enum_abi_type(name: &syn::Ident) -> proc_macro2::TokenStream {142	quote! {143		impl ::evm_coder::abi::AbiType for #name {144			const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <u8 as ::evm_coder::abi::AbiType>::SIGNATURE;145146			fn is_dynamic() -> bool {147				<u8 as ::evm_coder::abi::AbiType>::is_dynamic()148			}149			fn size() -> usize {150				<u8 as ::evm_coder::abi::AbiType>::size()151			}152		}153	}154}155156fn impl_enum_abi_read(name: &syn::Ident) -> proc_macro2::TokenStream {157	quote!(158		impl ::evm_coder::abi::AbiRead for #name {159			fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {160				Ok(161					<u8 as ::evm_coder::abi::AbiRead>::abi_read(reader)?162						.try_into()?163				)164			}165		}166	)167}168169fn impl_enum_abi_write(name: &syn::Ident) -> proc_macro2::TokenStream {170	quote!(171		impl ::evm_coder::abi::AbiWrite for #name {172			fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {173				::evm_coder::abi::AbiWrite::abi_write(&(*self as u8), writer);174			}175		}176	)177}178179fn impl_enum_solidity_type_name<'a>(180	name: &syn::Ident,181	enum_options: impl Iterator<Item = &'a syn::Ident>,182) -> proc_macro2::TokenStream {183	let enum_options = enum_options.map(|opt| quote!(,));184	quote!(185		#[cfg(feature = "stubgen")]186		impl ::evm_coder::solidity::SolidityTypeName for #name {187			fn solidity_name(188				writer: &mut impl ::core::fmt::Write,189				tc: &::evm_coder::solidity::TypeCollector,190			) -> ::core::fmt::Result {191				write!(writer, "{}", tc.collect_struct::<Self>())192			}193194			fn is_simple() -> bool {195				true196			}197198			fn solidity_default(199				writer: &mut impl ::core::fmt::Write,200				tc: &::evm_coder::solidity::TypeCollector,201			) -> ::core::fmt::Result {202				write!(writer, "{}", <#name as ::evm_coder::solidity::SolidityEnum>::solidity_option(&<#name>::default()))203			}204		}205	)206}207208fn impl_enum_solidity_struct_collect<'a>(209	name: &syn::Ident,210	enum_options: impl Iterator<Item = &'a syn::Ident>,211	option_count: usize,212) -> proc_macro2::TokenStream {213	let string_name = name.to_string();214	let enum_options = enum_options.enumerate().map(|(i, opt)| {215		let opt = proc_macro2::Literal::string(opt.to_string().as_str());216		let comma = if i != option_count - 1 { "," } else { "" };217		quote! {218			writeln!(str, "\t{}{}", #opt, #comma).expect("Enum format option");219		}220	});221	quote!(222		#[cfg(feature = "stubgen")]223		impl ::evm_coder::solidity::StructCollect for #name {224			fn name() -> String {225				#string_name.into()226			}227228			fn declaration() -> String {229				use std::fmt::Write;230231				let mut str = String::new();232				// #(#docs)*233				writeln!(str, "enum {} {{", <Self as ::evm_coder::solidity::StructCollect>::name()).unwrap();234				#(#enum_options)*235				writeln!(str, "}}").unwrap();236				str237			}238		}239	)240}241242fn check_and_count_option(de: &syn::DataEnum) -> syn::Result<usize> {243	let mut count = 0;244	for error in de.variants.iter().filter_map(|v| {245		if !v.fields.is_empty() {246			Some(Err(syn::Error::new(247				v.ident.span(),248				"Enumeration parameters should not have fields",249			)))250		} else if v.discriminant.is_some() {251			Some(Err(syn::Error::new(252				v.ident.span(),253				"Enumeration options should not have an explicit specified value",254			)))255		} else {256			count += 1;257			None258		}259	}) {260		return error;261	}262263	Ok(count)264}265266fn check_repr_u8(name: &syn::Ident, attrs: &Vec<syn::Attribute>) -> syn::Result<()> {267	let mut has_repr = false;268	for error in attrs.iter().filter_map(|attr| {269		if let Some(ps) = attr.path.segments.first() {270			if ps.ident == "repr" {271				has_repr = true;272				let meta = match attr.parse_meta() {273					Ok(meta) => meta,274					Err(e) => return Some(Err(e)),275				};276				match meta {277					syn::Meta::List(p) => {278						for error in p.nested.iter().filter_map(|nm| match nm {279							syn::NestedMeta::Meta(m) => match m {280								syn::Meta::Path(p) => {281									for i in p.segments.iter().filter_map(|ps| {282										if ps.ident != "u8" {283											Some(Err(syn::Error::new(284												ps.ident.span(),285												"Enum is not \"repr(u8)\"",286											)))287										} else {288											None289										}290									}) {291										return Some(i);292									}293									None294								}295								_ => None,296							},297							_ => None,298						}) {299							return Some(error);300						}301						None::<syn::Result<()>>302					}303					_ => None,304				};305			}306		}307		None308	}) {309		return error;310	}311312	if !has_repr {313		return Err(syn::Error::new(name.span(), "Enum is not \"repr(u8)\""));314	}315316	Ok(())317}318319fn tuple_type<'a>(320	field_types: impl Iterator<Item = &'a syn::Type> + Clone,321) -> proc_macro2::TokenStream {322	let field_types = field_types.map(|ty| quote!(#ty,));323	quote! {(#(#field_types)*)}324}325326fn tuple_ref_type<'a>(327	field_types: impl Iterator<Item = &'a syn::Type> + Clone,328) -> proc_macro2::TokenStream {329	let field_types = field_types.map(|ty| quote!(&#ty,));330	quote! {(#(#field_types)*)}331}332333fn tuple_data_as_ref(334	is_named_fields: bool,335	field_names: impl Iterator<Item = syn::Ident> + Clone,336) -> proc_macro2::TokenStream {337	let field_names = field_names.enumerate().map(|(i, field)| {338		if is_named_fields {339			quote!(&self.#field,)340		} else {341			let field = proc_macro2::Literal::usize_unsuffixed(i);342			quote!(&self.#field,)343		}344	});345	quote! {(#(#field_names)*)}346}347348fn tuple_names(349	is_named_fields: bool,350	field_names: impl Iterator<Item = syn::Ident> + Clone,351) -> proc_macro2::TokenStream {352	let field_names = field_names.enumerate().map(|(i, field)| {353		if is_named_fields {354			quote!(#field,)355		} else {356			let field = proc_macro2::Ident::new(357				format!("field{}", i).as_str(),358				proc_macro2::Span::call_site(),359			);360			quote!(#field,)361		}362	});363	quote! {(#(#field_names)*)}364}365366fn struct_from_tuple(367	name: &syn::Ident,368	is_named_fields: bool,369	field_names: impl Iterator<Item = syn::Ident> + Clone,370) -> proc_macro2::TokenStream {371	let field_names = field_names.enumerate().map(|(i, field)| {372		if is_named_fields {373			quote!(#field,)374		} else {375			let field = proc_macro2::Ident::new(376				format!("field{}", i).as_str(),377				proc_macro2::Span::call_site(),378			);379			quote!(#field,)380		}381	});382383	if is_named_fields {384		quote! {#name {#(#field_names)*}}385	} else {386		quote! {#name (#(#field_names)*)}387	}388}389390fn extract_docs(attrs: &[syn::Attribute]) -> syn::Result<Vec<String>> {391	attrs392		.iter()393		.filter_map(|attr| {394			if let Some(ps) = attr.path.segments.first() {395				if ps.ident == "doc" {396					let meta = match attr.parse_meta() {397						Ok(meta) => meta,398						Err(e) => return Some(Err(e)),399					};400					match meta {401						syn::Meta::NameValue(mnv) => match &mnv.lit {402							syn::Lit::Str(ls) => return Some(Ok(ls.value())),403							_ => unreachable!(),404						},405						_ => unreachable!(),406					}407				}408			}409			None410		})411		.collect()412}413414fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {415	match field.1.ident.as_ref() {416		Some(name) => name.clone(),417		None => {418			let mut name = "field".to_string();419			name.push_str(field.0.to_string().as_str());420			syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())421		}422	}423}424425fn map_field_to_type(field: &syn::Field) -> &syn::Type {426	&field.ty427}428429fn map_field_to_doc(field: &syn::Field) -> Result<Vec<std::string::String>, syn::Error> {430	extract_docs(&field.attrs)431}432433fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {434	quote! {435		impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}436	}437}438439fn impl_struct_abi_type(440	name: &syn::Ident,441	tuple_type: proc_macro2::TokenStream,442) -> proc_macro2::TokenStream {443	quote! {444		impl ::evm_coder::abi::AbiType for #name {445			const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <#tuple_type as ::evm_coder::abi::AbiType>::SIGNATURE;446			fn is_dynamic() -> bool {447				<#tuple_type as ::evm_coder::abi::AbiType>::is_dynamic()448			}449			fn size() -> usize {450				<#tuple_type as ::evm_coder::abi::AbiType>::size()451			}452		}453	}454}455456fn impl_struct_abi_read(457	name: &syn::Ident,458	tuple_type: proc_macro2::TokenStream,459	tuple_names: proc_macro2::TokenStream,460	struct_from_tuple: proc_macro2::TokenStream,461) -> proc_macro2::TokenStream {462	quote!(463		impl ::evm_coder::abi::AbiRead for #name {464			fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {465				let #tuple_names = <#tuple_type as ::evm_coder::abi::AbiRead>::abi_read(reader)?;466				Ok(#struct_from_tuple)467			}468		}469	)470}471472fn impl_struct_abi_write(473	name: &syn::Ident,474	_is_named_fields: bool,475	tuple_type: proc_macro2::TokenStream,476	tuple_data: proc_macro2::TokenStream,477) -> proc_macro2::TokenStream {478	quote!(479		impl ::evm_coder::abi::AbiWrite for #name {480			fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {481				<#tuple_type as ::evm_coder::abi::AbiWrite>::abi_write(&#tuple_data, writer)482			}483		}484	)485}486487fn impl_struct_solidity_type<'a>(488	name: &syn::Ident,489	field_types: impl Iterator<Item = &'a syn::Type> + Clone,490	params_count: usize,491) -> proc_macro2::TokenStream {492	let len = proc_macro2::Literal::usize_suffixed(params_count);493	quote! {494		#[cfg(feature = "stubgen")]495		impl ::evm_coder::solidity::SolidityType for #name {496			fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {497				let mut collected =498					Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());499				#({500					let mut out = String::new();501					<#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)502						.expect("no fmt error");503					collected.push(out);504				})*505				collected506			}507508			fn len() -> usize {509				#len510			}511		}512	}513}514515fn impl_struct_solidity_type_name<'a>(516	name: &syn::Ident,517	field_types: impl Iterator<Item = &'a syn::Type> + Clone,518	params_count: usize,519) -> proc_macro2::TokenStream {520	let arg_dafaults = field_types.enumerate().map(|(i, ty)| {521		let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName522			>::solidity_default(writer, tc)?;);523		let last_item = params_count - 1;524		if i != last_item {525			defult_value.extend(quote! {write!(writer, ",")?;})526		}527		defult_value528	});529530	quote! {531		#[cfg(feature = "stubgen")]532		impl ::evm_coder::solidity::SolidityTypeName for #name {533			fn solidity_name(534				writer: &mut impl ::core::fmt::Write,535				tc: &::evm_coder::solidity::TypeCollector,536			) -> ::core::fmt::Result {537				write!(writer, "{}", tc.collect_struct::<Self>())538			}539540			fn is_simple() -> bool {541				false542			}543544			fn solidity_default(545				writer: &mut impl ::core::fmt::Write,546				tc: &::evm_coder::solidity::TypeCollector,547			) -> ::core::fmt::Result {548				write!(writer, "{}(", tc.collect_struct::<Self>())?;549550				#(#arg_dafaults)*551552				write!(writer, ")")553			}554		}555	}556}557558fn impl_struct_solidity_struct_collect<'a>(559	name: &syn::Ident,560	field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,561	field_types: impl Iterator<Item = &'a syn::Type> + Clone,562	field_docs: impl Iterator<Item = syn::Result<Vec<String>>> + Clone,563	docs: &[String],564) -> syn::Result<proc_macro2::TokenStream> {565	let string_name = name.to_string();566	let name_type = field_names567		.into_iter()568		.zip(field_types)569		.zip(field_docs)570		.map(|((name, ty), doc)| {571			let field_docs = match doc {572				Ok(doc) => doc.into_iter().enumerate().map(|(i, doc)| {573					let doc = doc.trim();574					let dev = if i == 0 { " @dev" } else { "" };575					quote! {576						writeln!(str, "\t///{} {}", #dev, #doc).unwrap();577					}578				}),579				Err(e) => unreachable!("{:?}", e),580			};581			let name = format!("{}", name);582			quote!(583				#(#field_docs)*584				write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();585				writeln!(str, "{};", #name).unwrap();586			)587		});588	let docs = docs.iter().enumerate().map(|(i, doc)| {589		let doc = doc.trim();590		let dev = if i == 0 { " @dev" } else { "" };591		quote! {592			writeln!(str, "///{} {}", #dev, #doc).unwrap();593		}594	});595596	Ok(quote! {597		#[cfg(feature = "stubgen")]598		impl ::evm_coder::solidity::StructCollect for #name {599			fn name() -> String {600				#string_name.into()601			}602603			fn declaration() -> String {604				use std::fmt::Write;605606				let mut str = String::new();607				#(#docs)*608				writeln!(str, "struct {} {{", Self::name()).unwrap();609				#(#name_type)*610				writeln!(str, "}}").unwrap();611				str612			}613		}614	})615}