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

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					}191				}192			} else if lookahead.peek(Token![,]) || input.is_empty() {193				// Pass194			} else {195				return Err(lookahead.error());196			};197			out.push(Is {198				pascal_call_name: pascal_ident_to_call(&name),199				snake_call_name: pascal_ident_to_snake_call(&name),200				name,201				via,202				condition,203			});204			if input.peek(Token![,]) {205				input.parse::<Token![,]>()?;206				continue;207			} else {208				break;209			}210		}211		Ok(Self(out))212	}213}214215pub struct InterfaceInfo {216	name: Ident,217	is: IsList,218	inline_is: IsList,219	events: IsList,220	expect_selector: Option<u32>,221}222impl Parse for InterfaceInfo {223	fn parse(input: ParseStream) -> syn::Result<Self> {224		let mut name = None;225		let mut is = None;226		let mut inline_is = None;227		let mut events = None;228		let mut expect_selector = None;229		// TODO: create proc-macro to optimize proc-macro boilerplate? :D230		loop {231			let lookahead = input.lookahead1();232			if lookahead.peek(kw::name) {233				let k = input.parse::<kw::name>()?;234				input.parse::<Token![=]>()?;235				if name.replace(input.parse::<Ident>()?).is_some() {236					return Err(syn::Error::new(k.span(), "name is already set"));237				}238			} else if lookahead.peek(kw::is) {239				let k = input.parse::<kw::is>()?;240				let contents;241				parenthesized!(contents in input);242				if is.replace(contents.parse::<IsList>()?).is_some() {243					return Err(syn::Error::new(k.span(), "is is already set"));244				}245			} else if lookahead.peek(kw::inline_is) {246				let k = input.parse::<kw::inline_is>()?;247				let contents;248				parenthesized!(contents in input);249				if inline_is.replace(contents.parse::<IsList>()?).is_some() {250					return Err(syn::Error::new(k.span(), "inline_is is already set"));251				}252			} else if lookahead.peek(kw::events) {253				let k = input.parse::<kw::events>()?;254				let contents;255				parenthesized!(contents in input);256				if events.replace(contents.parse::<IsList>()?).is_some() {257					return Err(syn::Error::new(k.span(), "events is already set"));258				}259			} else if lookahead.peek(kw::expect_selector) {260				let k = input.parse::<kw::expect_selector>()?;261				input.parse::<Token![=]>()?;262				let value = input.parse::<LitInt>()?;263				if expect_selector264					.replace(value.base10_parse::<u32>()?)265					.is_some()266				{267					return Err(syn::Error::new(k.span(), "expect_selector is already set"));268				}269			} else if input.is_empty() {270				break;271			} else {272				return Err(lookahead.error());273			}274			if input.peek(Token![,]) {275				input.parse::<Token![,]>()?;276			} else {277				break;278			}279		}280		Ok(Self {281			name: name.ok_or_else(|| syn::Error::new(input.span(), "missing name"))?,282			is: is.unwrap_or_default(),283			inline_is: inline_is.unwrap_or_default(),284			events: events.unwrap_or_default(),285			expect_selector,286		})287	}288}289290struct MethodInfo {291	rename_selector: Option<String>,292}293impl Parse for MethodInfo {294	fn parse(input: ParseStream) -> syn::Result<Self> {295		let mut rename_selector = None;296		let lookahead = input.lookahead1();297		if lookahead.peek(kw::rename_selector) {298			let k = input.parse::<kw::rename_selector>()?;299			input.parse::<Token![=]>()?;300			if rename_selector301				.replace(input.parse::<LitStr>()?.value())302				.is_some()303			{304				return Err(syn::Error::new(k.span(), "rename_selector is already set"));305			}306		}307		Ok(Self { rename_selector })308	}309}310311enum AbiType {312	// type313	Plain(Ident),314	// (type1,type2)315	Tuple(Vec<AbiType>),316	// type[]317	Vec(Box<AbiType>),318	// type[20]319	Array(Box<AbiType>, usize),320}321impl AbiType {322	fn try_from(value: &Type) -> syn::Result<Self> {323		let value = Self::try_maybe_special_from(value)?;324		if value.is_special() {325			return Err(syn::Error::new(value.span(), "unexpected special type"));326		}327		Ok(value)328	}329	fn try_maybe_special_from(value: &Type) -> syn::Result<Self> {330		match value {331			Type::Array(arr) => {332				let wrapped = AbiType::try_from(&arr.elem)?;333				match &arr.len {334					Expr::Lit(l) => match &l.lit {335						Lit::Int(i) => {336							let num = i.base10_parse::<usize>()?;337							Ok(AbiType::Array(Box::new(wrapped), num as usize))338						}339						_ => Err(syn::Error::new(arr.len.span(), "should be int literal")),340					},341					_ => Err(syn::Error::new(arr.len.span(), "should be literal")),342				}343			}344			Type::Path(_) => {345				let path = parse_path(value)?;346				let segment = parse_path_segment(path)?;347				if segment.ident == "Vec" {348					let args = match &segment.arguments {349						PathArguments::AngleBracketed(e) => e,350						_ => {351							return Err(syn::Error::new(352								segment.arguments.span(),353								"missing Vec generic",354							))355						}356					};357					let args = &args.args;358					if args.len() != 1 {359						return Err(syn::Error::new(360							args.span(),361							"expected only one generic for vec",362						));363					}364					let arg = args.first().expect("first arg");365366					let ty = match arg {367						GenericArgument::Type(ty) => ty,368						_ => {369							return Err(syn::Error::new(370								arg.span(),371								"expected first generic to be type",372							))373						}374					};375376					let wrapped = AbiType::try_from(ty)?;377					Ok(Self::Vec(Box::new(wrapped)))378				} else {379					if !segment.arguments.is_empty() {380						return Err(syn::Error::new(381							segment.arguments.span(),382							"unexpected generic arguments for non-vec type",383						));384					}385					Ok(Self::Plain(segment.ident.clone()))386				}387			}388			Type::Tuple(t) => {389				let mut out = Vec::with_capacity(t.elems.len());390				for el in t.elems.iter() {391					out.push(AbiType::try_from(el)?)392				}393				Ok(Self::Tuple(out))394			}395			_ => Err(syn::Error::new(396				value.span(),397				"unexpected type, only arrays, plain types and tuples are supported",398			)),399		}400	}401	fn is_value(&self) -> bool {402		matches!(self, Self::Plain(v) if v == "value")403	}404	fn is_caller(&self) -> bool {405		matches!(self, Self::Plain(v) if v == "caller")406	}407	fn is_special(&self) -> bool {408		self.is_caller() || self.is_value()409	}410	fn selector_ty_buf(&self, buf: &mut String) -> std::fmt::Result {411		match self {412			AbiType::Plain(t) => {413				write!(buf, "{}", t)414			}415			AbiType::Tuple(t) => {416				write!(buf, "(")?;417				for (i, t) in t.iter().enumerate() {418					if i != 0 {419						write!(buf, ",")?;420					}421					t.selector_ty_buf(buf)?;422				}423				write!(buf, ")")424			}425			AbiType::Vec(v) => {426				v.selector_ty_buf(buf)?;427				write!(buf, "[]")428			}429			AbiType::Array(v, len) => {430				v.selector_ty_buf(buf)?;431				write!(buf, "[{}]", len)432			}433		}434	}435	fn selector_ty(&self) -> String {436		let mut out = String::new();437		self.selector_ty_buf(&mut out).expect("no fmt error");438		out439	}440}441impl ToTokens for AbiType {442	fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {443		match self {444			AbiType::Plain(t) => tokens.extend(quote! {#t}),445			AbiType::Tuple(t) => {446				tokens.extend(quote! {(447					#(#t),*448				)});449			}450			AbiType::Vec(v) => tokens.extend(quote! {Vec<#v>}),451			AbiType::Array(v, l) => tokens.extend(quote! {[#v; #l]}),452		}453	}454}455456struct MethodArg {457	name: Ident,458	camel_name: String,459	ty: AbiType,460}461impl MethodArg {462	fn try_from(value: &PatType) -> syn::Result<Self> {463		let name = parse_ident_from_pat(&value.pat)?.clone();464		Ok(Self {465			camel_name: cases::camelcase::to_camel_case(&name.to_string()),466			name,467			ty: AbiType::try_maybe_special_from(&value.ty)?,468		})469	}470	fn is_value(&self) -> bool {471		self.ty.is_value()472	}473	fn is_caller(&self) -> bool {474		self.ty.is_caller()475	}476	fn is_special(&self) -> bool {477		self.ty.is_special()478	}479	fn selector_ty(&self) -> String {480		assert!(!self.is_special());481		self.ty.selector_ty()482	}483484	fn expand_call_def(&self) -> proc_macro2::TokenStream {485		assert!(!self.is_special());486		let name = &self.name;487		let ty = &self.ty;488489		quote! {490			#name: #ty491		}492	}493494	fn expand_parse(&self) -> proc_macro2::TokenStream {495		assert!(!self.is_special());496		let name = &self.name;497		quote! {498			#name: reader.abi_read()?499		}500	}501502	fn expand_call_arg(&self) -> proc_macro2::TokenStream {503		if self.is_value() {504			quote! {505				c.value.clone()506			}507		} else if self.is_caller() {508			quote! {509				c.caller.clone()510			}511		} else {512			let name = &self.name;513			quote! {514				#name515			}516		}517	}518519	fn expand_solidity_argument(&self) -> proc_macro2::TokenStream {520		let camel_name = &self.camel_name.to_string();521		let ty = &self.ty;522		quote! {523			<NamedArgument<#ty>>::new(#camel_name)524		}525	}526}527528#[derive(PartialEq)]529enum Mutability {530	Mutable,531	View,532	Pure,533}534535/// Group all keywords for this macro. Usage example:536/// #[solidity_interface(name = "B", inline_is(A))]537mod kw {538	syn::custom_keyword!(weight);539540	syn::custom_keyword!(via);541	syn::custom_keyword!(returns);542	syn::custom_keyword!(name);543	syn::custom_keyword!(is);544	syn::custom_keyword!(inline_is);545	syn::custom_keyword!(events);546	syn::custom_keyword!(expect_selector);547548	syn::custom_keyword!(rename_selector);549}550551/// Rust methods are parsed into this structure when Solidity code is generated552struct Method {553	name: Ident,554	camel_name: String,555	pascal_name: Ident,556	screaming_name: Ident,557	selector_str: String,558	selector: u32,559	args: Vec<MethodArg>,560	has_normal_args: bool,561	mutability: Mutability,562	result: Type,563	weight: Option<Expr>,564	docs: Vec<String>,565}566impl Method {567	fn try_from(value: &ImplItemMethod) -> syn::Result<Self> {568		let mut info = MethodInfo {569			rename_selector: None,570		};571		let mut docs = Vec::new();572		let mut weight = None;573		for attr in &value.attrs {574			let ident = parse_ident_from_path(&attr.path, false)?;575			if ident == "solidity" {576				info = attr.parse_args::<MethodInfo>()?;577			} else if ident == "doc" {578				let args = attr.parse_meta().unwrap();579				let value = match args {580					Meta::NameValue(MetaNameValue {581						lit: Lit::Str(str), ..582					}) => str.value(),583					_ => unreachable!(),584				};585				docs.push(value);586			} else if ident == "weight" {587				weight = Some(attr.parse_args::<Expr>()?);588			}589		}590		let ident = &value.sig.ident;591		let ident_str = ident.to_string();592		if !cases::snakecase::is_snake_case(&ident_str) {593			return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));594		}595596		let mut mutability = Mutability::Pure;597598		if let Some(FnArg::Receiver(receiver)) = value599			.sig600			.inputs601			.iter()602			.find(|arg| matches!(arg, FnArg::Receiver(_)))603		{604			if receiver.reference.is_none() {605				return Err(syn::Error::new(606					receiver.span(),607					"receiver should be by ref",608				));609			}610			if receiver.mutability.is_some() {611				mutability = Mutability::Mutable;612			} else {613				mutability = Mutability::View;614			}615		}616		let mut args = Vec::new();617		for typ in value618			.sig619			.inputs620			.iter()621			.filter(|arg| matches!(arg, FnArg::Typed(_)))622		{623			let typ = match typ {624				FnArg::Typed(typ) => typ,625				_ => unreachable!(),626			};627			args.push(MethodArg::try_from(typ)?);628		}629630		if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {631			return Err(syn::Error::new(632				args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),633				"payable function should be mutable",634			));635		}636637		let result = match &value.sig.output {638			ReturnType::Type(_, ty) => ty,639			_ => 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)")),640		};641		let result = parse_result_ok(result)?;642643		let camel_name = info644			.rename_selector645			.unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));646		let mut selector_str = camel_name.clone();647		selector_str.push('(');648		let mut has_normal_args = false;649		for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {650			if i != 0 {651				selector_str.push(',');652			}653			write!(selector_str, "{}", arg.selector_ty()).unwrap();654			has_normal_args = true;655		}656		selector_str.push(')');657		let selector = fn_selector_str(&selector_str);658659		Ok(Self {660			name: ident.clone(),661			camel_name,662			pascal_name: snake_ident_to_pascal(ident),663			screaming_name: snake_ident_to_screaming(ident),664			selector_str,665			selector,666			args,667			has_normal_args,668			mutability,669			result: result.clone(),670			weight,671			docs,672		})673	}674	fn expand_call_def(&self) -> proc_macro2::TokenStream {675		let defs = self676			.args677			.iter()678			.filter(|a| !a.is_special())679			.map(|a| a.expand_call_def());680		let pascal_name = &self.pascal_name;681		let docs = &self.docs;682683		if self.has_normal_args {684			quote! {685				#(#[doc = #docs])*686				#[allow(missing_docs)]687				#pascal_name {688					#(689						#defs,690					)*691				}692			}693		} else {694			quote! {#pascal_name}695		}696	}697698	fn expand_const(&self) -> proc_macro2::TokenStream {699		let screaming_name = &self.screaming_name;700		let selector = u32::to_be_bytes(self.selector);701		let selector_str = &self.selector_str;702		quote! {703			#[doc = #selector_str]704			const #screaming_name: ::evm_coder::types::bytes4 = [#(#selector,)*];705		}706	}707708	fn expand_interface_id(&self) -> proc_macro2::TokenStream {709		let screaming_name = &self.screaming_name;710		quote! {711			interface_id ^= u32::from_be_bytes(Self::#screaming_name);712		}713	}714715	fn expand_parse(&self) -> proc_macro2::TokenStream {716		let pascal_name = &self.pascal_name;717		let screaming_name = &self.screaming_name;718		if self.has_normal_args {719			let parsers = self720				.args721				.iter()722				.filter(|a| !a.is_special())723				.map(|a| a.expand_parse());724			quote! {725				Self::#screaming_name => return Ok(Some(Self::#pascal_name {726					#(727						#parsers,728					)*729				}))730			}731		} else {732			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }733		}734	}735736	fn expand_variant_call(&self, call_name: &proc_macro2::Ident) -> proc_macro2::TokenStream {737		let pascal_name = &self.pascal_name;738		let name = &self.name;739740		let matcher = if self.has_normal_args {741			let names = self742				.args743				.iter()744				.filter(|a| !a.is_special())745				.map(|a| &a.name);746747			quote! {{748				#(749					#names,750				)*751			}}752		} else {753			quote! {}754		};755756		let receiver = match self.mutability {757			Mutability::Mutable | Mutability::View => quote! {self.},758			Mutability::Pure => quote! {Self::},759		};760		let args = self.args.iter().map(|a| a.expand_call_arg());761762		quote! {763			#call_name::#pascal_name #matcher => {764				let result = #receiver #name(765					#(766						#args,767					)*768				)?;769				(&result).to_result()770			}771		}772	}773774	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {775		let pascal_name = &self.pascal_name;776		if let Some(weight) = &self.weight {777			let matcher = if self.has_normal_args {778				let names = self779					.args780					.iter()781					.filter(|a| !a.is_special())782					.map(|a| &a.name);783784				quote! {{785					#(786						#names,787					)*788				}}789			} else {790				quote! {}791			};792			quote! {793				Self::#pascal_name #matcher => (#weight).into()794			}795		} else {796			let matcher = if self.has_normal_args {797				quote! {{..}}798			} else {799				quote! {}800			};801			quote! {802				Self::#pascal_name #matcher => ().into()803			}804		}805	}806807	fn expand_solidity_function(&self) -> proc_macro2::TokenStream {808		let camel_name = &self.camel_name;809		let mutability = match self.mutability {810			Mutability::Mutable => quote! {SolidityMutability::Mutable},811			Mutability::View => quote! { SolidityMutability::View },812			Mutability::Pure => quote! {SolidityMutability::Pure},813		};814		let result = &self.result;815816		let args = self817			.args818			.iter()819			.filter(|a| !a.is_special())820			.map(MethodArg::expand_solidity_argument);821		let docs = &self.docs;822		let selector_str = &self.selector_str;823		let selector = self.selector;824825		quote! {826			SolidityFunction {827				docs: &[#(#docs),*],828				selector_str: #selector_str,829				selector: #selector,830				name: #camel_name,831				mutability: #mutability,832				args: (833					#(834						#args,835					)*836				),837				result: <UnnamedArgument<#result>>::default(),838			}839		}840	}841}842843fn generics_list(gen: &Generics) -> proc_macro2::TokenStream {844	if gen.params.is_empty() {845		return quote! {};846	}847	let params = gen.params.iter().map(|p| match p {848		syn::GenericParam::Type(id) => {849			let v = &id.ident;850			quote! {#v}851		}852		syn::GenericParam::Lifetime(lt) => {853			let v = &lt.lifetime;854			quote! {#v}855		}856		syn::GenericParam::Const(c) => {857			let i = &c.ident;858			quote! {#i}859		}860	});861	quote! { #(#params),* }862}863fn generics_reference(gen: &Generics) -> proc_macro2::TokenStream {864	if gen.params.is_empty() {865		return quote! {};866	}867	let list = generics_list(gen);868	quote! { <#list> }869}870fn generics_data(gen: &Generics) -> proc_macro2::TokenStream {871	let list = generics_list(gen);872	if gen.params.len() == 1 {873		quote! {#list}874	} else {875		quote! { (#list) }876	}877}878879pub struct SolidityInterface {880	generics: Generics,881	name: Box<syn::Type>,882	info: InterfaceInfo,883	methods: Vec<Method>,884	docs: Vec<String>,885}886impl SolidityInterface {887	pub fn try_from(info: InterfaceInfo, value: &ItemImpl) -> syn::Result<Self> {888		let mut methods = Vec::new();889890		for item in &value.items {891			if let ImplItem::Method(method) = item {892				methods.push(Method::try_from(method)?)893			}894		}895		let mut docs = vec![];896		for attr in &value.attrs {897			let ident = parse_ident_from_path(&attr.path, false)?;898			if ident == "doc" {899				let args = attr.parse_meta().unwrap();900				let value = match args {901					Meta::NameValue(MetaNameValue {902						lit: Lit::Str(str), ..903					}) => str.value(),904					_ => unreachable!(),905				};906				docs.push(value);907			}908		}909		Ok(Self {910			generics: value.generics.clone(),911			name: value.self_ty.clone(),912			info,913			methods,914			docs,915		})916	}917	pub fn expand(self) -> proc_macro2::TokenStream {918		let name = self.name;919920		let solidity_name = self.info.name.to_string();921		let call_name = pascal_ident_to_call(&self.info.name);922		let generics = self.generics;923		let gen_ref = generics_reference(&generics);924		let gen_data = generics_data(&generics);925		let gen_where = &generics.where_clause;926927		let call_sub = self928			.info929			.inline_is930			.0931			.iter()932			.chain(self.info.is.0.iter())933			.map(|c| Is::expand_call_def(c, &gen_ref));934		let call_parse = self935			.info936			.inline_is937			.0938			.iter()939			.chain(self.info.is.0.iter())940			.map(|is| Is::expand_parse(is, &gen_ref));941		let call_variants = self942			.info943			.inline_is944			.0945			.iter()946			.chain(self.info.is.0.iter())947			.map(|c| Is::expand_variant_call(c, &call_name, &gen_ref));948		let weight_variants = self949			.info950			.inline_is951			.0952			.iter()953			.chain(self.info.is.0.iter())954			.map(Is::expand_variant_weight);955956		let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);957		let supports_interface = self958			.info959			.is960			.0961			.iter()962			.map(|is| Is::expand_supports_interface(is, &gen_ref));963964		let calls = self.methods.iter().map(Method::expand_call_def);965		let consts = self.methods.iter().map(Method::expand_const);966		let interface_id = self.methods.iter().map(Method::expand_interface_id);967		let parsers = self.methods.iter().map(Method::expand_parse);968		let call_variants_this = self969			.methods970			.iter()971			.map(|m| Method::expand_variant_call(m, &call_name));972		let weight_variants_this = self.methods.iter().map(Method::expand_variant_weight);973		let solidity_functions = self.methods.iter().map(Method::expand_solidity_function);974975		// TODO: Inline inline_is976		let solidity_is = self977			.info978			.is979			.0980			.iter()981			.chain(self.info.inline_is.0.iter())982			.map(|is| is.name.to_string());983		let solidity_events_is = self.info.events.0.iter().map(|is| is.name.to_string());984		let solidity_generators = self985			.info986			.is987			.0988			.iter()989			.chain(self.info.inline_is.0.iter())990			.map(|is| Is::expand_generator(is, &gen_ref));991		let solidity_event_generators = self.info.events.0.iter().map(Is::expand_event_generator);992993		let docs = &self.docs;994995		if let Some(expect_selector) = &self.info.expect_selector {996			if !self.info.inline_is.0.is_empty() {997				return syn::Error::new(998					name.span(),999					"expect_selector is not compatible with inline_is",1000				)1001				.to_compile_error();1002			}1003			let selector = self1004				.methods1005				.iter()1006				.map(|m| m.selector)1007				.fold(0, |a, b| a ^ b);10081009			if *expect_selector != selector {1010				let mut methods = String::new();1011				for meth in self.methods.iter() {1012					write!(methods, "\n- {}", meth.selector_str).expect("write to string");1013				}1014				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();1015			}1016		}1017		// let methods = self.methods.iter().map(Method::solidity_def);10181019		quote! {1020			#[derive(Debug)]1021			#(#[doc = #docs])*1022			pub enum #call_name #gen_ref {1023				/// Inherited method1024				ERC165Call(::evm_coder::ERC165Call, ::core::marker::PhantomData<#gen_data>),1025				#(1026					#calls,1027				)*1028				#(1029					#call_sub,1030				)*1031			}1032			impl #gen_ref #call_name #gen_ref {1033				#(1034					#consts1035				)*1036				/// Return this call ERC165 selector1037				pub fn interface_id() -> ::evm_coder::types::bytes4 {1038					let mut interface_id = 0;1039					#(#interface_id)*1040					#(#inline_interface_id)*1041					u32::to_be_bytes(interface_id)1042				}1043				/// Generate solidity definitions for methods described in this interface1044				pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {1045					use evm_coder::solidity::*;1046					use core::fmt::Write;1047					let interface = SolidityInterface {1048						docs: &[#(#docs),*],1049						name: #solidity_name,1050						selector: Self::interface_id(),1051						is: &["Dummy", "ERC165", #(1052							#solidity_is,1053						)* #(1054							#solidity_events_is,1055						)* ],1056						functions: (#(1057							#solidity_functions,1058						)*),1059					};10601061					let mut out = ::evm_coder::types::string::new();1062					if #solidity_name.starts_with("Inline") {1063						out.push_str("/// @dev inlined interface\n");1064					}1065					let _ = interface.format(is_impl, &mut out, tc);1066					tc.collect(out);1067					#(1068						#solidity_event_generators1069					)*1070					#(1071						#solidity_generators1072					)*1073					if is_impl {1074						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());1075					} else {1076						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());1077					}1078				}1079			}1080			impl #gen_ref ::evm_coder::Call for #call_name #gen_ref {1081				fn parse(method_id: ::evm_coder::types::bytes4, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {1082					use ::evm_coder::abi::AbiRead;1083					match method_id {1084						::evm_coder::ERC165Call::INTERFACE_ID => return Ok(1085							::evm_coder::ERC165Call::parse(method_id, reader)?1086							.map(|c| Self::ERC165Call(c, ::core::marker::PhantomData))1087						),1088						#(1089							#parsers,1090						)*1091						_ => {},1092					}1093					#(1094						#call_parse1095					)else*1096					return Ok(None);1097				}1098			}1099			impl #generics #call_name #gen_ref1100			#gen_where1101			{1102				/// Is this contract implements specified ERC165 selector1103				pub fn supports_interface(this: &#name, interface_id: ::evm_coder::types::bytes4) -> bool {1104					interface_id != u32::to_be_bytes(0xffffff) && (1105						interface_id == ::evm_coder::ERC165Call::INTERFACE_ID ||1106						interface_id == Self::interface_id()1107						#(1108							|| #supports_interface1109						)*1110					)1111				}1112			}1113			impl #generics ::evm_coder::Weighted for #call_name #gen_ref1114			#gen_where1115			{1116				#[allow(unused_variables)]1117				fn weight(&self) -> ::evm_coder::execution::DispatchInfo {1118					match self {1119						#(1120							#weight_variants,1121						)*1122						// TODO: It should be very cheap, but not free1123						Self::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {..}, _) => 100u64.into(),1124						#(1125							#weight_variants_this,1126						)*1127					}1128				}1129			}1130			impl #generics ::evm_coder::Callable<#call_name #gen_ref> for #name1131			#gen_where1132			{1133				#[allow(unreachable_code)] // In case of no inner calls1134				fn call(&mut self, c: Msg<#call_name #gen_ref>) -> ::evm_coder::execution::ResultWithPostInfo<::evm_coder::abi::AbiWriter> {1135					use ::evm_coder::abi::AbiWrite;1136					match c.call {1137						#(1138							#call_variants,1139						)*1140						#call_name::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}, _) => {1141							let mut writer = ::evm_coder::abi::AbiWriter::default();1142							writer.bool(&<#call_name #gen_ref>::supports_interface(self, interface_id));1143							return Ok(writer.into());1144						}1145						_ => {},1146					}1147					let mut writer = ::evm_coder::abi::AbiWriter::default();1148					match c.call {1149						#(1150							#call_variants_this,1151						)*1152						_ => Err(::evm_coder::execution::Error::from("method is not available").into()),1153					}1154				}1155			}1156		}1157	}1158}