git.delta.rocks / unique-network / refs/commits / 033edc764dba

1// Copyright 2019-2022 Unique Network (Gibraltar) Ltd.2// This file is part of Unique Network.34// Unique Network is free software: you can redistribute it and/or modify5// it under the terms of the GNU General Public License as published by6// the Free Software Foundation, either version 3 of the License, or7// (at your option) any later version.89// Unique Network is distributed in the hope that it will be useful,10// but WITHOUT ANY WARRANTY; without even the implied warranty of11// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the12// GNU General Public License for more details.1314// You should have received a copy of the GNU General Public License15// along with Unique Network. If not, see <http://www.gnu.org/licenses/>.1617#![allow(dead_code)]1819// NOTE: In order to understand this Rust macro better, first read this chapter20// about Procedural Macros in Rust book:21// https://doc.rust-lang.org/reference/procedural-macros.html2223use quote::{quote, ToTokens};24use inflector::cases;25use std::fmt::Write;26use syn::{27	Expr, FnArg, GenericArgument, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, Meta,28	MetaNameValue, PatType, PathArguments, ReturnType, Type,29	spanned::Spanned,30	parse::{Parse, ParseStream},31	parenthesized, Token, LitInt, LitStr,32};3334use crate::{35	fn_selector_str, parse_ident_from_pat, parse_ident_from_path, parse_path, parse_path_segment,36	parse_result_ok, pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,37	snake_ident_to_screaming,38};3940struct Is {41	name: Ident,42	pascal_call_name: Ident,43	snake_call_name: Ident,44	via: Option<(Type, Ident)>,45	condition: Option<Expr>,46}47impl Is {48	fn expand_call_def(&self, gen_ref: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {49		let name = &self.name;50		let pascal_call_name = &self.pascal_call_name;51		quote! {52			#name(#pascal_call_name #gen_ref)53		}54	}5556	fn expand_interface_id(&self) -> proc_macro2::TokenStream {57		let pascal_call_name = &self.pascal_call_name;58		quote! {59			interface_id ^= u32::from_be_bytes(#pascal_call_name::interface_id());60		}61	}6263	fn expand_supports_interface(64		&self,65		generics: &proc_macro2::TokenStream,66	) -> proc_macro2::TokenStream {67		let pascal_call_name = &self.pascal_call_name;68		let condition = self.condition.as_ref().map(|condition| {69			quote! {70				(#condition) &&71			}72		});73		quote! {74			#condition <#pascal_call_name #generics>::supports_interface(this, interface_id)75		}76	}7778	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {79		let name = &self.name;80		quote! {81			Self::#name(call) => call.weight()82		}83	}8485	fn expand_variant_call(86		&self,87		call_name: &proc_macro2::Ident,88		generics: &proc_macro2::TokenStream,89	) -> proc_macro2::TokenStream {90		let name = &self.name;91		let pascal_call_name = &self.pascal_call_name;92		let via_typ = self93			.via94			.as_ref()95			.map(|(t, _)| quote! {#t})96			.unwrap_or_else(|| quote! {Self});97		let via_map = self98			.via99			.as_ref()100			.map(|(_, i)| quote! {.#i()})101			.unwrap_or_default();102		let condition = self.condition.as_ref().map(|condition| {103			quote! {104				if ({let this = &self; (#condition)})105			}106		});107		quote! {108			#call_name::#name(call) #condition => return <#via_typ as ::evm_coder::Callable<#pascal_call_name #generics>>::call(self #via_map, Msg {109				call,110				caller: c.caller,111				value: c.value,112			})113		}114	}115116	fn expand_parse(&self, generics: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {117		let name = &self.name;118		let pascal_call_name = &self.pascal_call_name;119		quote! {120			if let Some(parsed_call) = <#pascal_call_name #generics>::parse(method_id, reader)? {121				return Ok(Some(Self::#name(parsed_call)))122			}123		}124	}125126	fn expand_generator(&self, generics: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {127		let pascal_call_name = &self.pascal_call_name;128		quote! {129			<#pascal_call_name #generics>::generate_solidity_interface(tc, is_impl);130		}131	}132133	fn expand_event_generator(&self) -> proc_macro2::TokenStream {134		let name = &self.name;135		quote! {136			#name::generate_solidity_interface(tc, is_impl);137		}138	}139}140141#[derive(Default)]142struct IsList(Vec<Is>);143impl Parse for IsList {144	fn parse(input: ParseStream) -> syn::Result<Self> {145		let mut out = vec![];146		loop {147			if input.is_empty() {148				break;149			}150			let name = input.parse::<Ident>()?;151			let lookahead = input.lookahead1();152153			let mut condition: Option<Expr> = None;154			let mut via: Option<(Type, Ident)> = None;155156			if lookahead.peek(syn::token::Paren) {157				let contents;158				parenthesized!(contents in input);159				let input = contents;160161				while !input.is_empty() {162					let lookahead = input.lookahead1();163					if lookahead.peek(Token![if]) {164						input.parse::<Token![if]>()?;165						let contents;166						parenthesized!(contents in input);167						let contents = contents.parse::<Expr>()?;168169						if condition.replace(contents).is_some() {170							return Err(syn::Error::new(input.span(), "condition is already set"));171						}172					} else if lookahead.peek(kw::via) {173						input.parse::<kw::via>()?;174						let contents;175						parenthesized!(contents in input);176177						let method = contents.parse::<Ident>()?;178						contents.parse::<kw::returns>()?;179						let ty = contents.parse::<Type>()?;180181						if via.replace((ty, method)).is_some() {182							return Err(syn::Error::new(input.span(), "via is already set"));183						}184					} else {185						return Err(lookahead.error());186					}187188					if input.peek(Token![,]) {189						input.parse::<Token![,]>()?;190					} else if !input.is_empty() {191						return Err(syn::Error::new(input.span(), "expected end"));192					}193				}194			} else if lookahead.peek(Token![,]) || input.is_empty() {195				// Pass196			} else {197				return Err(lookahead.error());198			};199			out.push(Is {200				pascal_call_name: pascal_ident_to_call(&name),201				snake_call_name: pascal_ident_to_snake_call(&name),202				name,203				via,204				condition,205			});206			if input.peek(Token![,]) {207				input.parse::<Token![,]>()?;208				continue;209			} else {210				break;211			}212		}213		Ok(Self(out))214	}215}216217pub struct InterfaceInfo {218	name: Ident,219	is: IsList,220	inline_is: IsList,221	events: IsList,222	expect_selector: Option<u32>,223}224impl Parse for InterfaceInfo {225	fn parse(input: ParseStream) -> syn::Result<Self> {226		let mut name = None;227		let mut is = None;228		let mut inline_is = None;229		let mut events = None;230		let mut expect_selector = None;231		// TODO: create proc-macro to optimize proc-macro boilerplate? :D232		loop {233			let lookahead = input.lookahead1();234			if lookahead.peek(kw::name) {235				let k = input.parse::<kw::name>()?;236				input.parse::<Token![=]>()?;237				if name.replace(input.parse::<Ident>()?).is_some() {238					return Err(syn::Error::new(k.span(), "name is already set"));239				}240			} else if lookahead.peek(kw::is) {241				let k = input.parse::<kw::is>()?;242				let contents;243				parenthesized!(contents in input);244				if is.replace(contents.parse::<IsList>()?).is_some() {245					return Err(syn::Error::new(k.span(), "is is already set"));246				}247			} else if lookahead.peek(kw::inline_is) {248				let k = input.parse::<kw::inline_is>()?;249				let contents;250				parenthesized!(contents in input);251				if inline_is.replace(contents.parse::<IsList>()?).is_some() {252					return Err(syn::Error::new(k.span(), "inline_is is already set"));253				}254			} else if lookahead.peek(kw::events) {255				let k = input.parse::<kw::events>()?;256				let contents;257				parenthesized!(contents in input);258				if events.replace(contents.parse::<IsList>()?).is_some() {259					return Err(syn::Error::new(k.span(), "events is already set"));260				}261			} else if lookahead.peek(kw::expect_selector) {262				let k = input.parse::<kw::expect_selector>()?;263				input.parse::<Token![=]>()?;264				let value = input.parse::<LitInt>()?;265				if expect_selector266					.replace(value.base10_parse::<u32>()?)267					.is_some()268				{269					return Err(syn::Error::new(k.span(), "expect_selector is already set"));270				}271			} else if input.is_empty() {272				break;273			} else {274				return Err(lookahead.error());275			}276			if input.peek(Token![,]) {277				input.parse::<Token![,]>()?;278			} else {279				break;280			}281		}282		Ok(Self {283			name: name.ok_or_else(|| syn::Error::new(input.span(), "missing name"))?,284			is: is.unwrap_or_default(),285			inline_is: inline_is.unwrap_or_default(),286			events: events.unwrap_or_default(),287			expect_selector,288		})289	}290}291292struct MethodInfo {293	rename_selector: Option<String>,294	hide: bool,295}296impl Parse for MethodInfo {297	fn parse(input: ParseStream) -> syn::Result<Self> {298		let mut rename_selector = None;299		let mut hide = false;300		while !input.is_empty() {301			let lookahead = input.lookahead1();302			if lookahead.peek(kw::rename_selector) {303				let k = input.parse::<kw::rename_selector>()?;304				input.parse::<Token![=]>()?;305				if rename_selector306					.replace(input.parse::<LitStr>()?.value())307					.is_some()308				{309					return Err(syn::Error::new(k.span(), "rename_selector is already set"));310				}311			} else if lookahead.peek(kw::hide) {312				input.parse::<kw::hide>()?;313				hide = true;314			} else {315				return Err(lookahead.error());316			}317318			if input.peek(Token![,]) {319				input.parse::<Token![,]>()?;320			} else if !input.is_empty() {321				return Err(syn::Error::new(input.span(), "expected end"));322			}323		}324		Ok(Self {325			rename_selector,326			hide,327		})328	}329}330331enum AbiType {332	// type333	Plain(Ident),334	// (type1,type2)335	Tuple(Vec<AbiType>),336	// type[]337	Vec(Box<AbiType>),338	// type[20]339	Array(Box<AbiType>, usize),340}341impl AbiType {342	fn try_from(value: &Type) -> syn::Result<Self> {343		let value = Self::try_maybe_special_from(value)?;344		if value.is_special() {345			return Err(syn::Error::new(value.span(), "unexpected special type"));346		}347		Ok(value)348	}349	fn try_maybe_special_from(value: &Type) -> syn::Result<Self> {350		match value {351			Type::Array(arr) => {352				let wrapped = AbiType::try_from(&arr.elem)?;353				match &arr.len {354					Expr::Lit(l) => match &l.lit {355						Lit::Int(i) => {356							let num = i.base10_parse::<usize>()?;357							Ok(AbiType::Array(Box::new(wrapped), num as usize))358						}359						_ => Err(syn::Error::new(arr.len.span(), "should be int literal")),360					},361					_ => Err(syn::Error::new(arr.len.span(), "should be literal")),362				}363			}364			Type::Path(_) => {365				let path = parse_path(value)?;366				let segment = parse_path_segment(path)?;367				if segment.ident == "Vec" {368					let args = match &segment.arguments {369						PathArguments::AngleBracketed(e) => e,370						_ => {371							return Err(syn::Error::new(372								segment.arguments.span(),373								"missing Vec generic",374							))375						}376					};377					let args = &args.args;378					if args.len() != 1 {379						return Err(syn::Error::new(380							args.span(),381							"expected only one generic for vec",382						));383					}384					let arg = args.first().expect("first arg");385386					let ty = match arg {387						GenericArgument::Type(ty) => ty,388						_ => {389							return Err(syn::Error::new(390								arg.span(),391								"expected first generic to be type",392							))393						}394					};395396					let wrapped = AbiType::try_from(ty)?;397					Ok(Self::Vec(Box::new(wrapped)))398				} else {399					if !segment.arguments.is_empty() {400						return Err(syn::Error::new(401							segment.arguments.span(),402							"unexpected generic arguments for non-vec type",403						));404					}405					Ok(Self::Plain(segment.ident.clone()))406				}407			}408			Type::Tuple(t) => {409				let mut out = Vec::with_capacity(t.elems.len());410				for el in t.elems.iter() {411					out.push(AbiType::try_from(el)?)412				}413				Ok(Self::Tuple(out))414			}415			_ => Err(syn::Error::new(416				value.span(),417				"unexpected type, only arrays, plain types and tuples are supported",418			)),419		}420	}421	fn is_value(&self) -> bool {422		matches!(self, Self::Plain(v) if v == "value")423	}424	fn is_caller(&self) -> bool {425		matches!(self, Self::Plain(v) if v == "caller")426	}427	fn is_special(&self) -> bool {428		self.is_caller() || self.is_value()429	}430	fn selector_ty_buf(&self, buf: &mut String) -> std::fmt::Result {431		match self {432			AbiType::Plain(t) => {433				write!(buf, "{}", t)434			}435			AbiType::Tuple(t) => {436				write!(buf, "(")?;437				for (i, t) in t.iter().enumerate() {438					if i != 0 {439						write!(buf, ",")?;440					}441					t.selector_ty_buf(buf)?;442				}443				write!(buf, ")")444			}445			AbiType::Vec(v) => {446				v.selector_ty_buf(buf)?;447				write!(buf, "[]")448			}449			AbiType::Array(v, len) => {450				v.selector_ty_buf(buf)?;451				write!(buf, "[{}]", len)452			}453		}454	}455	fn selector_ty(&self) -> String {456		let mut out = String::new();457		self.selector_ty_buf(&mut out).expect("no fmt error");458		out459	}460}461impl ToTokens for AbiType {462	fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {463		match self {464			AbiType::Plain(t) => tokens.extend(quote! {#t}),465			AbiType::Tuple(t) => {466				tokens.extend(quote! {(467					#(#t),*468				)});469			}470			AbiType::Vec(v) => tokens.extend(quote! {Vec<#v>}),471			AbiType::Array(v, l) => tokens.extend(quote! {[#v; #l]}),472		}473	}474}475476struct MethodArg {477	name: Ident,478	camel_name: String,479	ty: AbiType,480}481impl MethodArg {482	fn try_from(value: &PatType) -> syn::Result<Self> {483		let name = parse_ident_from_pat(&value.pat)?.clone();484		Ok(Self {485			camel_name: cases::camelcase::to_camel_case(&name.to_string()),486			name,487			ty: AbiType::try_maybe_special_from(&value.ty)?,488		})489	}490	fn is_value(&self) -> bool {491		self.ty.is_value()492	}493	fn is_caller(&self) -> bool {494		self.ty.is_caller()495	}496	fn is_special(&self) -> bool {497		self.ty.is_special()498	}499	fn selector_ty(&self) -> String {500		assert!(!self.is_special());501		self.ty.selector_ty()502	}503504	fn expand_call_def(&self) -> proc_macro2::TokenStream {505		assert!(!self.is_special());506		let name = &self.name;507		let ty = &self.ty;508509		quote! {510			#name: #ty511		}512	}513514	fn expand_parse(&self) -> proc_macro2::TokenStream {515		assert!(!self.is_special());516		let name = &self.name;517		quote! {518			#name: reader.abi_read()?519		}520	}521522	fn expand_call_arg(&self) -> proc_macro2::TokenStream {523		if self.is_value() {524			quote! {525				c.value.clone()526			}527		} else if self.is_caller() {528			quote! {529				c.caller.clone()530			}531		} else {532			let name = &self.name;533			quote! {534				#name535			}536		}537	}538539	fn expand_solidity_argument(&self) -> proc_macro2::TokenStream {540		let camel_name = &self.camel_name.to_string();541		let ty = &self.ty;542		quote! {543			<NamedArgument<#ty>>::new(#camel_name)544		}545	}546}547548#[derive(PartialEq)]549enum Mutability {550	Mutable,551	View,552	Pure,553}554555/// Group all keywords for this macro. Usage example:556/// #[solidity_interface(name = "B", inline_is(A))]557mod kw {558	syn::custom_keyword!(weight);559560	syn::custom_keyword!(via);561	syn::custom_keyword!(returns);562	syn::custom_keyword!(name);563	syn::custom_keyword!(is);564	syn::custom_keyword!(inline_is);565	syn::custom_keyword!(events);566	syn::custom_keyword!(expect_selector);567568	syn::custom_keyword!(rename_selector);569	syn::custom_keyword!(hide);570}571572/// Rust methods are parsed into this structure when Solidity code is generated573struct Method {574	name: Ident,575	camel_name: String,576	pascal_name: Ident,577	screaming_name: Ident,578	selector_str: String,579	selector: u32,580	hide: bool,581	args: Vec<MethodArg>,582	has_normal_args: bool,583	has_value_args: bool,584	mutability: Mutability,585	result: Type,586	weight: Option<Expr>,587	docs: Vec<String>,588}589impl Method {590	fn try_from(value: &ImplItemMethod) -> syn::Result<Self> {591		let mut info = MethodInfo {592			rename_selector: None,593			hide: false,594		};595		let mut docs = Vec::new();596		let mut weight = None;597		for attr in &value.attrs {598			let ident = parse_ident_from_path(&attr.path, false)?;599			if ident == "solidity" {600				info = attr.parse_args::<MethodInfo>()?;601			} else if ident == "doc" {602				let args = attr.parse_meta().unwrap();603				let value = match args {604					Meta::NameValue(MetaNameValue {605						lit: Lit::Str(str), ..606					}) => str.value(),607					_ => unreachable!(),608				};609				docs.push(value);610			} else if ident == "weight" {611				weight = Some(attr.parse_args::<Expr>()?);612			}613		}614		let ident = &value.sig.ident;615		let ident_str = ident.to_string();616		if !cases::snakecase::is_snake_case(&ident_str) {617			return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));618		}619620		let mut mutability = Mutability::Pure;621622		if let Some(FnArg::Receiver(receiver)) = value623			.sig624			.inputs625			.iter()626			.find(|arg| matches!(arg, FnArg::Receiver(_)))627		{628			if receiver.reference.is_none() {629				return Err(syn::Error::new(630					receiver.span(),631					"receiver should be by ref",632				));633			}634			if receiver.mutability.is_some() {635				mutability = Mutability::Mutable;636			} else {637				mutability = Mutability::View;638			}639		}640		let mut args = Vec::new();641		for typ in value642			.sig643			.inputs644			.iter()645			.filter(|arg| matches!(arg, FnArg::Typed(_)))646		{647			let typ = match typ {648				FnArg::Typed(typ) => typ,649				_ => unreachable!(),650			};651			args.push(MethodArg::try_from(typ)?);652		}653654		if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {655			return Err(syn::Error::new(656				args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),657				"payable function should be mutable",658			));659		}660661		let result = match &value.sig.output {662			ReturnType::Type(_, ty) => ty,663			_ => return Err(syn::Error::new(value.sig.output.span(), "interface method should return Result<value>\nif there is no value to return - specify void (which is alias to unit)")),664		};665		let result = parse_result_ok(result)?;666667		let camel_name = info668			.rename_selector669			.unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));670		let mut selector_str = camel_name.clone();671		selector_str.push('(');672		let mut has_normal_args = false;673		for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {674			if i != 0 {675				selector_str.push(',');676			}677			write!(selector_str, "{}", arg.selector_ty()).unwrap();678			has_normal_args = true;679		}680		let has_value_args = args.iter().any(|a| a.is_value());681		selector_str.push(')');682		let selector = fn_selector_str(&selector_str);683684		Ok(Self {685			name: ident.clone(),686			camel_name,687			pascal_name: snake_ident_to_pascal(ident),688			screaming_name: snake_ident_to_screaming(ident),689			selector_str,690			selector,691			hide: info.hide,692			args,693			has_normal_args,694			has_value_args,695			mutability,696			result: result.clone(),697			weight,698			docs,699		})700	}701	fn expand_call_def(&self) -> proc_macro2::TokenStream {702		let defs = self703			.args704			.iter()705			.filter(|a| !a.is_special())706			.map(|a| a.expand_call_def());707		let pascal_name = &self.pascal_name;708		let docs = &self.docs;709710		if self.has_normal_args {711			quote! {712				#(#[doc = #docs])*713				#[allow(missing_docs)]714				#pascal_name {715					#(716						#defs,717					)*718				}719			}720		} else {721			quote! {722				#(#[doc = #docs])*723				#[allow(missing_docs)]724				#pascal_name725			}726		}727	}728729	fn expand_const(&self) -> proc_macro2::TokenStream {730		let screaming_name = &self.screaming_name;731		let selector = u32::to_be_bytes(self.selector);732		let selector_str = &self.selector_str;733		quote! {734			#[doc = #selector_str]735			const #screaming_name: ::evm_coder::types::bytes4 = [#(#selector,)*];736		}737	}738739	fn expand_interface_id(&self) -> proc_macro2::TokenStream {740		let screaming_name = &self.screaming_name;741		quote! {742			interface_id ^= u32::from_be_bytes(Self::#screaming_name);743		}744	}745746	fn expand_parse(&self) -> proc_macro2::TokenStream {747		let pascal_name = &self.pascal_name;748		let screaming_name = &self.screaming_name;749		if self.has_normal_args {750			let parsers = self751				.args752				.iter()753				.filter(|a| !a.is_special())754				.map(|a| a.expand_parse());755			quote! {756				Self::#screaming_name => return Ok(Some(Self::#pascal_name {757					#(758						#parsers,759					)*760				}))761			}762		} else {763			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }764		}765	}766767	fn expand_variant_call(&self, call_name: &proc_macro2::Ident) -> proc_macro2::TokenStream {768		let pascal_name = &self.pascal_name;769		let name = &self.name;770771		let matcher = if self.has_normal_args {772			let names = self773				.args774				.iter()775				.filter(|a| !a.is_special())776				.map(|a| &a.name);777778			quote! {{779				#(780					#names,781				)*782			}}783		} else {784			quote! {}785		};786787		let receiver = match self.mutability {788			Mutability::Mutable | Mutability::View => quote! {self.},789			Mutability::Pure => quote! {Self::},790		};791		let args = self.args.iter().map(|a| a.expand_call_arg());792793		quote! {794			#call_name::#pascal_name #matcher => {795				#[allow(deprecated)]796				let result = #receiver #name(797					#(798						#args,799					)*800				)?;801				(&result).to_result()802			}803		}804	}805806	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {807		let pascal_name = &self.pascal_name;808		if let Some(weight) = &self.weight {809			let matcher = if self.has_normal_args {810				let names = self811					.args812					.iter()813					.filter(|a| !a.is_special())814					.map(|a| &a.name);815816				quote! {{817					#(818						#names,819					)*820				}}821			} else {822				quote! {}823			};824			quote! {825				Self::#pascal_name #matcher => (#weight).into()826			}827		} else {828			let matcher = if self.has_normal_args {829				quote! {{..}}830			} else {831				quote! {}832			};833			quote! {834				Self::#pascal_name #matcher => ().into()835			}836		}837	}838839	fn expand_solidity_function(&self) -> proc_macro2::TokenStream {840		let camel_name = &self.camel_name;841		let mutability = match self.mutability {842			Mutability::Mutable => quote! {SolidityMutability::Mutable},843			Mutability::View => quote! { SolidityMutability::View },844			Mutability::Pure => quote! {SolidityMutability::Pure},845		};846		let result = &self.result;847848		let args = self849			.args850			.iter()851			.filter(|a| !a.is_special())852			.map(MethodArg::expand_solidity_argument);853		let docs = &self.docs;854		let selector_str = &self.selector_str;855		let selector = self.selector;856		let hide = self.hide;857		let is_payable = self.has_value_args;858		quote! {859			SolidityFunction {860				docs: &[#(#docs),*],861				selector_str: #selector_str,862				selector: #selector,863				hide: #hide,864				name: #camel_name,865				mutability: #mutability,866				is_payable: #is_payable,867				args: (868					#(869						#args,870					)*871				),872				result: <UnnamedArgument<#result>>::default(),873			}874		}875	}876}877878fn generics_list(gen: &Generics) -> proc_macro2::TokenStream {879	if gen.params.is_empty() {880		return quote! {};881	}882	let params = gen.params.iter().map(|p| match p {883		syn::GenericParam::Type(id) => {884			let v = &id.ident;885			quote! {#v}886		}887		syn::GenericParam::Lifetime(lt) => {888			let v = &lt.lifetime;889			quote! {#v}890		}891		syn::GenericParam::Const(c) => {892			let i = &c.ident;893			quote! {#i}894		}895	});896	quote! { #(#params),* }897}898fn generics_reference(gen: &Generics) -> proc_macro2::TokenStream {899	if gen.params.is_empty() {900		return quote! {};901	}902	let list = generics_list(gen);903	quote! { <#list> }904}905fn generics_data(gen: &Generics) -> proc_macro2::TokenStream {906	let list = generics_list(gen);907	if gen.params.len() == 1 {908		quote! {#list}909	} else {910		quote! { (#list) }911	}912}913914pub struct SolidityInterface {915	generics: Generics,916	name: Box<syn::Type>,917	info: InterfaceInfo,918	methods: Vec<Method>,919	docs: Vec<String>,920}921impl SolidityInterface {922	pub fn try_from(info: InterfaceInfo, value: &ItemImpl) -> syn::Result<Self> {923		let mut methods = Vec::new();924925		for item in &value.items {926			if let ImplItem::Method(method) = item {927				methods.push(Method::try_from(method)?)928			}929		}930		let mut docs = vec![];931		for attr in &value.attrs {932			let ident = parse_ident_from_path(&attr.path, false)?;933			if ident == "doc" {934				let args = attr.parse_meta().unwrap();935				let value = match args {936					Meta::NameValue(MetaNameValue {937						lit: Lit::Str(str), ..938					}) => str.value(),939					_ => unreachable!(),940				};941				docs.push(value);942			}943		}944		Ok(Self {945			generics: value.generics.clone(),946			name: value.self_ty.clone(),947			info,948			methods,949			docs,950		})951	}952	pub fn expand(self) -> proc_macro2::TokenStream {953		let name = self.name;954955		let solidity_name = self.info.name.to_string();956		let call_name = pascal_ident_to_call(&self.info.name);957		let generics = self.generics;958		let gen_ref = generics_reference(&generics);959		let gen_data = generics_data(&generics);960		let gen_where = &generics.where_clause;961962		let call_sub = self963			.info964			.inline_is965			.0966			.iter()967			.chain(self.info.is.0.iter())968			.map(|c| Is::expand_call_def(c, &gen_ref));969		let call_parse = self970			.info971			.inline_is972			.0973			.iter()974			.chain(self.info.is.0.iter())975			.map(|is| Is::expand_parse(is, &gen_ref));976		let call_variants = self977			.info978			.inline_is979			.0980			.iter()981			.chain(self.info.is.0.iter())982			.map(|c| Is::expand_variant_call(c, &call_name, &gen_ref));983		let weight_variants = self984			.info985			.inline_is986			.0987			.iter()988			.chain(self.info.is.0.iter())989			.map(Is::expand_variant_weight);990991		let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);992		let supports_interface = self993			.info994			.is995			.0996			.iter()997			.map(|is| Is::expand_supports_interface(is, &gen_ref));998999		let calls = self.methods.iter().map(Method::expand_call_def);1000		let consts = self.methods.iter().map(Method::expand_const);1001		let interface_id = self.methods.iter().map(Method::expand_interface_id);1002		let parsers = self.methods.iter().map(Method::expand_parse);1003		let call_variants_this = self1004			.methods1005			.iter()1006			.map(|m| Method::expand_variant_call(m, &call_name));1007		let weight_variants_this = self.methods.iter().map(Method::expand_variant_weight);1008		let solidity_functions = self.methods.iter().map(Method::expand_solidity_function);10091010		// TODO: Inline inline_is1011		let solidity_is = self1012			.info1013			.is1014			.01015			.iter()1016			.chain(self.info.inline_is.0.iter())1017			.map(|is| is.name.to_string());1018		let solidity_events_is = self.info.events.0.iter().map(|is| is.name.to_string());1019		let solidity_generators = self1020			.info1021			.is1022			.01023			.iter()1024			.chain(self.info.inline_is.0.iter())1025			.map(|is| Is::expand_generator(is, &gen_ref));1026		let solidity_event_generators = self.info.events.0.iter().map(Is::expand_event_generator);10271028		let docs = &self.docs;10291030		if let Some(expect_selector) = &self.info.expect_selector {1031			if !self.info.inline_is.0.is_empty() {1032				return syn::Error::new(1033					name.span(),1034					"expect_selector is not compatible with inline_is",1035				)1036				.to_compile_error();1037			}1038			let selector = self1039				.methods1040				.iter()1041				.map(|m| m.selector)1042				.fold(0, |a, b| a ^ b);10431044			if *expect_selector != selector {1045				let mut methods = String::new();1046				for meth in self.methods.iter() {1047					write!(methods, "\n- {}", meth.selector_str).expect("write to string");1048				}1049				return syn::Error::new(name.span(), format!("expected selector mismatch, expected {expect_selector:0>8x}, but implementation has {selector:0>8x}{methods}")).to_compile_error();1050			}1051		}1052		// let methods = self.methods.iter().map(Method::solidity_def);10531054		quote! {1055			#[derive(Debug)]1056			#(#[doc = #docs])*1057			pub enum #call_name #gen_ref {1058				/// Inherited method1059				ERC165Call(::evm_coder::ERC165Call, ::core::marker::PhantomData<#gen_data>),1060				#(1061					#calls,1062				)*1063				#(1064					#call_sub,1065				)*1066			}1067			impl #gen_ref #call_name #gen_ref {1068				#(1069					#consts1070				)*1071				/// Return this call ERC165 selector1072				pub fn interface_id() -> ::evm_coder::types::bytes4 {1073					let mut interface_id = 0;1074					#(#interface_id)*1075					#(#inline_interface_id)*1076					u32::to_be_bytes(interface_id)1077				}1078				/// Generate solidity definitions for methods described in this interface1079				pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {1080					use evm_coder::solidity::*;1081					use core::fmt::Write;1082					let interface = SolidityInterface {1083						docs: &[#(#docs),*],1084						name: #solidity_name,1085						selector: Self::interface_id(),1086						is: &["Dummy", "ERC165", #(1087							#solidity_is,1088						)* #(1089							#solidity_events_is,1090						)* ],1091						functions: (#(1092							#solidity_functions,1093						)*),1094					};10951096					let mut out = ::evm_coder::types::string::new();1097					if #solidity_name.starts_with("Inline") {1098						out.push_str("/// @dev inlined interface\n");1099					}1100					let _ = interface.format(is_impl, &mut out, tc);1101					tc.collect(out);1102					#(1103						#solidity_event_generators1104					)*1105					#(1106						#solidity_generators1107					)*1108					if is_impl {1109						tc.collect("/// @dev common stubs holder\ncontract Dummy {\n\tuint8 dummy;\n\tstring stub_error = \"this contract is implemented in native\";\n}\ncontract ERC165 is Dummy {\n\tfunction supportsInterface(bytes4 interfaceID) external view returns (bool) {\n\t\trequire(false, stub_error);\n\t\tinterfaceID;\n\t\treturn true;\n\t}\n}\n".into());1110					} else {1111						tc.collect("/// @dev common stubs holder\ninterface Dummy {\n}\ninterface ERC165 is Dummy {\n\tfunction supportsInterface(bytes4 interfaceID) external view returns (bool);\n}\n".into());1112					}1113				}1114			}1115			impl #gen_ref ::evm_coder::Call for #call_name #gen_ref {1116				fn parse(method_id: ::evm_coder::types::bytes4, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {1117					use ::evm_coder::abi::AbiRead;1118					match method_id {1119						::evm_coder::ERC165Call::INTERFACE_ID => return Ok(1120							::evm_coder::ERC165Call::parse(method_id, reader)?1121							.map(|c| Self::ERC165Call(c, ::core::marker::PhantomData))1122						),1123						#(1124							#parsers,1125						)*1126						_ => {},1127					}1128					#(1129						#call_parse1130					)else*1131					return Ok(None);1132				}1133			}1134			impl #generics #call_name #gen_ref1135			#gen_where1136			{1137				/// Is this contract implements specified ERC165 selector1138				pub fn supports_interface(this: &#name, interface_id: ::evm_coder::types::bytes4) -> bool {1139					interface_id != u32::to_be_bytes(0xffffff) && (1140						interface_id == ::evm_coder::ERC165Call::INTERFACE_ID ||1141						interface_id == Self::interface_id()1142						#(1143							|| #supports_interface1144						)*1145					)1146				}1147			}1148			impl #generics ::evm_coder::Weighted for #call_name #gen_ref1149			#gen_where1150			{1151				#[allow(unused_variables)]1152				fn weight(&self) -> ::evm_coder::execution::DispatchInfo {1153					match self {1154						#(1155							#weight_variants,1156						)*1157						// TODO: It should be very cheap, but not free1158						Self::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {..}, _) => ::frame_support::weights::Weight::from_ref_time(100).into(),1159						#(1160							#weight_variants_this,1161						)*1162					}1163				}1164			}1165			impl #generics ::evm_coder::Callable<#call_name #gen_ref> for #name1166			#gen_where1167			{1168				#[allow(unreachable_code)] // In case of no inner calls1169				fn call(&mut self, c: Msg<#call_name #gen_ref>) -> ::evm_coder::execution::ResultWithPostInfo<::evm_coder::abi::AbiWriter> {1170					use ::evm_coder::abi::AbiWrite;1171					match c.call {1172						#(1173							#call_variants,1174						)*1175						#call_name::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}, _) => {1176							let mut writer = ::evm_coder::abi::AbiWriter::default();1177							writer.bool(&<#call_name #gen_ref>::supports_interface(self, interface_id));1178							return Ok(writer.into());1179						}1180						_ => {},1181					}1182					let mut writer = ::evm_coder::abi::AbiWriter::default();1183					match c.call {1184						#(1185							#call_variants_this,1186						)*1187						_ => Err(::evm_coder::execution::Error::from("method is not available").into()),1188					}1189				}1190			}1191		}1192	}1193}