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

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				loop {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::<Token![,]>()?;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 if input.is_empty() {185						break;186					} else {187						return Err(lookahead.error());188					}189190					if input.peek(Token![,]) {191						input.parse::<Token![,]>()?;192					} else {193						break;194					}195				}196			} else if lookahead.peek(Token![,]) || input.is_empty() {197				// Pass198			} else {199				return Err(lookahead.error());200			};201			out.push(Is {202				pascal_call_name: pascal_ident_to_call(&name),203				snake_call_name: pascal_ident_to_snake_call(&name),204				name,205				via,206				condition,207			});208			if input.peek(Token![,]) {209				input.parse::<Token![,]>()?;210				continue;211			} else {212				break;213			}214		}215		Ok(Self(out))216	}217}218219pub struct InterfaceInfo {220	name: Ident,221	is: IsList,222	inline_is: IsList,223	events: IsList,224	expect_selector: Option<u32>,225}226impl Parse for InterfaceInfo {227	fn parse(input: ParseStream) -> syn::Result<Self> {228		let mut name = None;229		let mut is = None;230		let mut inline_is = None;231		let mut events = None;232		let mut expect_selector = None;233		// TODO: create proc-macro to optimize proc-macro boilerplate? :D234		loop {235			let lookahead = input.lookahead1();236			if lookahead.peek(kw::name) {237				let k = input.parse::<kw::name>()?;238				input.parse::<Token![=]>()?;239				if name.replace(input.parse::<Ident>()?).is_some() {240					return Err(syn::Error::new(k.span(), "name is already set"));241				}242			} else if lookahead.peek(kw::is) {243				let k = input.parse::<kw::is>()?;244				let contents;245				parenthesized!(contents in input);246				if is.replace(contents.parse::<IsList>()?).is_some() {247					return Err(syn::Error::new(k.span(), "is is already set"));248				}249			} else if lookahead.peek(kw::inline_is) {250				let k = input.parse::<kw::inline_is>()?;251				let contents;252				parenthesized!(contents in input);253				if inline_is.replace(contents.parse::<IsList>()?).is_some() {254					return Err(syn::Error::new(k.span(), "inline_is is already set"));255				}256			} else if lookahead.peek(kw::events) {257				let k = input.parse::<kw::events>()?;258				let contents;259				parenthesized!(contents in input);260				if events.replace(contents.parse::<IsList>()?).is_some() {261					return Err(syn::Error::new(k.span(), "events is already set"));262				}263			} else if lookahead.peek(kw::expect_selector) {264				let k = input.parse::<kw::expect_selector>()?;265				input.parse::<Token![=]>()?;266				let value = input.parse::<LitInt>()?;267				if expect_selector268					.replace(value.base10_parse::<u32>()?)269					.is_some()270				{271					return Err(syn::Error::new(k.span(), "expect_selector is already set"));272				}273			} else if input.is_empty() {274				break;275			} else {276				return Err(lookahead.error());277			}278			if input.peek(Token![,]) {279				input.parse::<Token![,]>()?;280			} else {281				break;282			}283		}284		Ok(Self {285			name: name.ok_or_else(|| syn::Error::new(input.span(), "missing name"))?,286			is: is.unwrap_or_default(),287			inline_is: inline_is.unwrap_or_default(),288			events: events.unwrap_or_default(),289			expect_selector,290		})291	}292}293294struct MethodInfo {295	rename_selector: Option<String>,296}297impl Parse for MethodInfo {298	fn parse(input: ParseStream) -> syn::Result<Self> {299		let mut rename_selector = None;300		let lookahead = input.lookahead1();301		if lookahead.peek(kw::rename_selector) {302			let k = input.parse::<kw::rename_selector>()?;303			input.parse::<Token![=]>()?;304			if rename_selector305				.replace(input.parse::<LitStr>()?.value())306				.is_some()307			{308				return Err(syn::Error::new(k.span(), "rename_selector is already set"));309			}310		}311		Ok(Self { rename_selector })312	}313}314315enum AbiType {316	// type317	Plain(Ident),318	// (type1,type2)319	Tuple(Vec<AbiType>),320	// type[]321	Vec(Box<AbiType>),322	// type[20]323	Array(Box<AbiType>, usize),324}325impl AbiType {326	fn try_from(value: &Type) -> syn::Result<Self> {327		let value = Self::try_maybe_special_from(value)?;328		if value.is_special() {329			return Err(syn::Error::new(value.span(), "unexpected special type"));330		}331		Ok(value)332	}333	fn try_maybe_special_from(value: &Type) -> syn::Result<Self> {334		match value {335			Type::Array(arr) => {336				let wrapped = AbiType::try_from(&arr.elem)?;337				match &arr.len {338					Expr::Lit(l) => match &l.lit {339						Lit::Int(i) => {340							let num = i.base10_parse::<usize>()?;341							Ok(AbiType::Array(Box::new(wrapped), num as usize))342						}343						_ => Err(syn::Error::new(arr.len.span(), "should be int literal")),344					},345					_ => Err(syn::Error::new(arr.len.span(), "should be literal")),346				}347			}348			Type::Path(_) => {349				let path = parse_path(value)?;350				let segment = parse_path_segment(path)?;351				if segment.ident == "Vec" {352					let args = match &segment.arguments {353						PathArguments::AngleBracketed(e) => e,354						_ => {355							return Err(syn::Error::new(356								segment.arguments.span(),357								"missing Vec generic",358							))359						}360					};361					let args = &args.args;362					if args.len() != 1 {363						return Err(syn::Error::new(364							args.span(),365							"expected only one generic for vec",366						));367					}368					let arg = args.first().expect("first arg");369370					let ty = match arg {371						GenericArgument::Type(ty) => ty,372						_ => {373							return Err(syn::Error::new(374								arg.span(),375								"expected first generic to be type",376							))377						}378					};379380					let wrapped = AbiType::try_from(ty)?;381					Ok(Self::Vec(Box::new(wrapped)))382				} else {383					if !segment.arguments.is_empty() {384						return Err(syn::Error::new(385							segment.arguments.span(),386							"unexpected generic arguments for non-vec type",387						));388					}389					Ok(Self::Plain(segment.ident.clone()))390				}391			}392			Type::Tuple(t) => {393				let mut out = Vec::with_capacity(t.elems.len());394				for el in t.elems.iter() {395					out.push(AbiType::try_from(el)?)396				}397				Ok(Self::Tuple(out))398			}399			_ => Err(syn::Error::new(400				value.span(),401				"unexpected type, only arrays, plain types and tuples are supported",402			)),403		}404	}405	fn is_value(&self) -> bool {406		matches!(self, Self::Plain(v) if v == "value")407	}408	fn is_caller(&self) -> bool {409		matches!(self, Self::Plain(v) if v == "caller")410	}411	fn is_special(&self) -> bool {412		self.is_caller() || self.is_value()413	}414	fn selector_ty_buf(&self, buf: &mut String) -> std::fmt::Result {415		match self {416			AbiType::Plain(t) => {417				write!(buf, "{}", t)418			}419			AbiType::Tuple(t) => {420				write!(buf, "(")?;421				for (i, t) in t.iter().enumerate() {422					if i != 0 {423						write!(buf, ",")?;424					}425					t.selector_ty_buf(buf)?;426				}427				write!(buf, ")")428			}429			AbiType::Vec(v) => {430				v.selector_ty_buf(buf)?;431				write!(buf, "[]")432			}433			AbiType::Array(v, len) => {434				v.selector_ty_buf(buf)?;435				write!(buf, "[{}]", len)436			}437		}438	}439	fn selector_ty(&self) -> String {440		let mut out = String::new();441		self.selector_ty_buf(&mut out).expect("no fmt error");442		out443	}444}445impl ToTokens for AbiType {446	fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {447		match self {448			AbiType::Plain(t) => tokens.extend(quote! {#t}),449			AbiType::Tuple(t) => {450				tokens.extend(quote! {(451					#(#t),*452				)});453			}454			AbiType::Vec(v) => tokens.extend(quote! {Vec<#v>}),455			AbiType::Array(v, l) => tokens.extend(quote! {[#v; #l]}),456		}457	}458}459460struct MethodArg {461	name: Ident,462	camel_name: String,463	ty: AbiType,464}465impl MethodArg {466	fn try_from(value: &PatType) -> syn::Result<Self> {467		let name = parse_ident_from_pat(&value.pat)?.clone();468		Ok(Self {469			camel_name: cases::camelcase::to_camel_case(&name.to_string()),470			name,471			ty: AbiType::try_maybe_special_from(&value.ty)?,472		})473	}474	fn is_value(&self) -> bool {475		self.ty.is_value()476	}477	fn is_caller(&self) -> bool {478		self.ty.is_caller()479	}480	fn is_special(&self) -> bool {481		self.ty.is_special()482	}483	fn selector_ty(&self) -> String {484		assert!(!self.is_special());485		self.ty.selector_ty()486	}487488	fn expand_call_def(&self) -> proc_macro2::TokenStream {489		assert!(!self.is_special());490		let name = &self.name;491		let ty = &self.ty;492493		quote! {494			#name: #ty495		}496	}497498	fn expand_parse(&self) -> proc_macro2::TokenStream {499		assert!(!self.is_special());500		let name = &self.name;501		quote! {502			#name: reader.abi_read()?503		}504	}505506	fn expand_call_arg(&self) -> proc_macro2::TokenStream {507		if self.is_value() {508			quote! {509				c.value.clone()510			}511		} else if self.is_caller() {512			quote! {513				c.caller.clone()514			}515		} else {516			let name = &self.name;517			quote! {518				#name519			}520		}521	}522523	fn expand_solidity_argument(&self) -> proc_macro2::TokenStream {524		let camel_name = &self.camel_name.to_string();525		let ty = &self.ty;526		quote! {527			<NamedArgument<#ty>>::new(#camel_name)528		}529	}530}531532#[derive(PartialEq)]533enum Mutability {534	Mutable,535	View,536	Pure,537}538539/// Group all keywords for this macro. Usage example:540/// #[solidity_interface(name = "B", inline_is(A))]541mod kw {542	syn::custom_keyword!(weight);543544	syn::custom_keyword!(via);545	syn::custom_keyword!(name);546	syn::custom_keyword!(is);547	syn::custom_keyword!(inline_is);548	syn::custom_keyword!(events);549	syn::custom_keyword!(expect_selector);550551	syn::custom_keyword!(rename_selector);552}553554/// Rust methods are parsed into this structure when Solidity code is generated555struct Method {556	name: Ident,557	camel_name: String,558	pascal_name: Ident,559	screaming_name: Ident,560	selector_str: String,561	selector: u32,562	args: Vec<MethodArg>,563	has_normal_args: bool,564	mutability: Mutability,565	result: Type,566	weight: Option<Expr>,567	docs: Vec<String>,568}569impl Method {570	fn try_from(value: &ImplItemMethod) -> syn::Result<Self> {571		let mut info = MethodInfo {572			rename_selector: None,573		};574		let mut docs = Vec::new();575		let mut weight = None;576		for attr in &value.attrs {577			let ident = parse_ident_from_path(&attr.path, false)?;578			if ident == "solidity" {579				info = attr.parse_args::<MethodInfo>()?;580			} else if ident == "doc" {581				let args = attr.parse_meta().unwrap();582				let value = match args {583					Meta::NameValue(MetaNameValue {584						lit: Lit::Str(str), ..585					}) => str.value(),586					_ => unreachable!(),587				};588				docs.push(value);589			} else if ident == "weight" {590				weight = Some(attr.parse_args::<Expr>()?);591			}592		}593		let ident = &value.sig.ident;594		let ident_str = ident.to_string();595		if !cases::snakecase::is_snake_case(&ident_str) {596			return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));597		}598599		let mut mutability = Mutability::Pure;600601		if let Some(FnArg::Receiver(receiver)) = value602			.sig603			.inputs604			.iter()605			.find(|arg| matches!(arg, FnArg::Receiver(_)))606		{607			if receiver.reference.is_none() {608				return Err(syn::Error::new(609					receiver.span(),610					"receiver should be by ref",611				));612			}613			if receiver.mutability.is_some() {614				mutability = Mutability::Mutable;615			} else {616				mutability = Mutability::View;617			}618		}619		let mut args = Vec::new();620		for typ in value621			.sig622			.inputs623			.iter()624			.filter(|arg| matches!(arg, FnArg::Typed(_)))625		{626			let typ = match typ {627				FnArg::Typed(typ) => typ,628				_ => unreachable!(),629			};630			args.push(MethodArg::try_from(typ)?);631		}632633		if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {634			return Err(syn::Error::new(635				args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),636				"payable function should be mutable",637			));638		}639640		let result = match &value.sig.output {641			ReturnType::Type(_, ty) => ty,642			_ => 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)")),643		};644		let result = parse_result_ok(result)?;645646		let camel_name = info647			.rename_selector648			.unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));649		let mut selector_str = camel_name.clone();650		selector_str.push('(');651		let mut has_normal_args = false;652		for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {653			if i != 0 {654				selector_str.push(',');655			}656			write!(selector_str, "{}", arg.selector_ty()).unwrap();657			has_normal_args = true;658		}659		selector_str.push(')');660		let selector = fn_selector_str(&selector_str);661662		Ok(Self {663			name: ident.clone(),664			camel_name,665			pascal_name: snake_ident_to_pascal(ident),666			screaming_name: snake_ident_to_screaming(ident),667			selector_str,668			selector,669			args,670			has_normal_args,671			mutability,672			result: result.clone(),673			weight,674			docs,675		})676	}677	fn expand_call_def(&self) -> proc_macro2::TokenStream {678		let defs = self679			.args680			.iter()681			.filter(|a| !a.is_special())682			.map(|a| a.expand_call_def());683		let pascal_name = &self.pascal_name;684		let docs = &self.docs;685686		if self.has_normal_args {687			quote! {688				#(#[doc = #docs])*689				#[allow(missing_docs)]690				#pascal_name {691					#(692						#defs,693					)*694				}695			}696		} else {697			quote! {#pascal_name}698		}699	}700701	fn expand_const(&self) -> proc_macro2::TokenStream {702		let screaming_name = &self.screaming_name;703		let selector = u32::to_be_bytes(self.selector);704		let selector_str = &self.selector_str;705		quote! {706			#[doc = #selector_str]707			const #screaming_name: ::evm_coder::types::bytes4 = [#(#selector,)*];708		}709	}710711	fn expand_interface_id(&self) -> proc_macro2::TokenStream {712		let screaming_name = &self.screaming_name;713		quote! {714			interface_id ^= u32::from_be_bytes(Self::#screaming_name);715		}716	}717718	fn expand_parse(&self) -> proc_macro2::TokenStream {719		let pascal_name = &self.pascal_name;720		let screaming_name = &self.screaming_name;721		if self.has_normal_args {722			let parsers = self723				.args724				.iter()725				.filter(|a| !a.is_special())726				.map(|a| a.expand_parse());727			quote! {728				Self::#screaming_name => return Ok(Some(Self::#pascal_name {729					#(730						#parsers,731					)*732				}))733			}734		} else {735			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }736		}737	}738739	fn expand_variant_call(&self, call_name: &proc_macro2::Ident) -> proc_macro2::TokenStream {740		let pascal_name = &self.pascal_name;741		let name = &self.name;742743		let matcher = if self.has_normal_args {744			let names = self745				.args746				.iter()747				.filter(|a| !a.is_special())748				.map(|a| &a.name);749750			quote! {{751				#(752					#names,753				)*754			}}755		} else {756			quote! {}757		};758759		let receiver = match self.mutability {760			Mutability::Mutable | Mutability::View => quote! {self.},761			Mutability::Pure => quote! {Self::},762		};763		let args = self.args.iter().map(|a| a.expand_call_arg());764765		quote! {766			#call_name::#pascal_name #matcher => {767				let result = #receiver #name(768					#(769						#args,770					)*771				)?;772				(&result).to_result()773			}774		}775	}776777	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {778		let pascal_name = &self.pascal_name;779		if let Some(weight) = &self.weight {780			let matcher = if self.has_normal_args {781				let names = self782					.args783					.iter()784					.filter(|a| !a.is_special())785					.map(|a| &a.name);786787				quote! {{788					#(789						#names,790					)*791				}}792			} else {793				quote! {}794			};795			quote! {796				Self::#pascal_name #matcher => (#weight).into()797			}798		} else {799			let matcher = if self.has_normal_args {800				quote! {{..}}801			} else {802				quote! {}803			};804			quote! {805				Self::#pascal_name #matcher => ().into()806			}807		}808	}809810	fn expand_solidity_function(&self) -> proc_macro2::TokenStream {811		let camel_name = &self.camel_name;812		let mutability = match self.mutability {813			Mutability::Mutable => quote! {SolidityMutability::Mutable},814			Mutability::View => quote! { SolidityMutability::View },815			Mutability::Pure => quote! {SolidityMutability::Pure},816		};817		let result = &self.result;818819		let args = self820			.args821			.iter()822			.filter(|a| !a.is_special())823			.map(MethodArg::expand_solidity_argument);824		let docs = &self.docs;825		let selector_str = &self.selector_str;826		let selector = self.selector;827828		quote! {829			SolidityFunction {830				docs: &[#(#docs),*],831				selector_str: #selector_str,832				selector: #selector,833				name: #camel_name,834				mutability: #mutability,835				args: (836					#(837						#args,838					)*839				),840				result: <UnnamedArgument<#result>>::default(),841			}842		}843	}844}845846fn generics_list(gen: &Generics) -> proc_macro2::TokenStream {847	if gen.params.is_empty() {848		return quote! {};849	}850	let params = gen.params.iter().map(|p| match p {851		syn::GenericParam::Type(id) => {852			let v = &id.ident;853			quote! {#v}854		}855		syn::GenericParam::Lifetime(lt) => {856			let v = &lt.lifetime;857			quote! {#v}858		}859		syn::GenericParam::Const(c) => {860			let i = &c.ident;861			quote! {#i}862		}863	});864	quote! { #(#params),* }865}866fn generics_reference(gen: &Generics) -> proc_macro2::TokenStream {867	if gen.params.is_empty() {868		return quote! {};869	}870	let list = generics_list(gen);871	quote! { <#list> }872}873fn generics_data(gen: &Generics) -> proc_macro2::TokenStream {874	let list = generics_list(gen);875	if gen.params.len() == 1 {876		quote! {#list}877	} else {878		quote! { (#list) }879	}880}881882pub struct SolidityInterface {883	generics: Generics,884	name: Box<syn::Type>,885	info: InterfaceInfo,886	methods: Vec<Method>,887	docs: Vec<String>,888}889impl SolidityInterface {890	pub fn try_from(info: InterfaceInfo, value: &ItemImpl) -> syn::Result<Self> {891		let mut methods = Vec::new();892893		for item in &value.items {894			if let ImplItem::Method(method) = item {895				methods.push(Method::try_from(method)?)896			}897		}898		let mut docs = vec![];899		for attr in &value.attrs {900			let ident = parse_ident_from_path(&attr.path, false)?;901			if ident == "doc" {902				let args = attr.parse_meta().unwrap();903				let value = match args {904					Meta::NameValue(MetaNameValue {905						lit: Lit::Str(str), ..906					}) => str.value(),907					_ => unreachable!(),908				};909				docs.push(value);910			}911		}912		Ok(Self {913			generics: value.generics.clone(),914			name: value.self_ty.clone(),915			info,916			methods,917			docs,918		})919	}920	pub fn expand(self) -> proc_macro2::TokenStream {921		let name = self.name;922923		let solidity_name = self.info.name.to_string();924		let call_name = pascal_ident_to_call(&self.info.name);925		let generics = self.generics;926		let gen_ref = generics_reference(&generics);927		let gen_data = generics_data(&generics);928		let gen_where = &generics.where_clause;929930		let call_sub = self931			.info932			.inline_is933			.0934			.iter()935			.chain(self.info.is.0.iter())936			.map(|c| Is::expand_call_def(c, &gen_ref));937		let call_parse = self938			.info939			.inline_is940			.0941			.iter()942			.chain(self.info.is.0.iter())943			.map(|is| Is::expand_parse(is, &gen_ref));944		let call_variants = self945			.info946			.inline_is947			.0948			.iter()949			.chain(self.info.is.0.iter())950			.map(|c| Is::expand_variant_call(c, &call_name, &gen_ref));951		let weight_variants = self952			.info953			.inline_is954			.0955			.iter()956			.chain(self.info.is.0.iter())957			.map(Is::expand_variant_weight);958959		let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);960		let supports_interface = self961			.info962			.is963			.0964			.iter()965			.map(|is| Is::expand_supports_interface(is, &gen_ref));966967		let calls = self.methods.iter().map(Method::expand_call_def);968		let consts = self.methods.iter().map(Method::expand_const);969		let interface_id = self.methods.iter().map(Method::expand_interface_id);970		let parsers = self.methods.iter().map(Method::expand_parse);971		let call_variants_this = self972			.methods973			.iter()974			.map(|m| Method::expand_variant_call(m, &call_name));975		let weight_variants_this = self.methods.iter().map(Method::expand_variant_weight);976		let solidity_functions = self.methods.iter().map(Method::expand_solidity_function);977978		// TODO: Inline inline_is979		let solidity_is = self980			.info981			.is982			.0983			.iter()984			.chain(self.info.inline_is.0.iter())985			.map(|is| is.name.to_string());986		let solidity_events_is = self.info.events.0.iter().map(|is| is.name.to_string());987		let solidity_generators = self988			.info989			.is990			.0991			.iter()992			.chain(self.info.inline_is.0.iter())993			.map(|is| Is::expand_generator(is, &gen_ref));994		let solidity_event_generators = self.info.events.0.iter().map(Is::expand_event_generator);995996		let docs = &self.docs;997998		if let Some(expect_selector) = &self.info.expect_selector {999			if !self.info.inline_is.0.is_empty() {1000				return syn::Error::new(1001					name.span(),1002					"expect_selector is not compatible with inline_is",1003				)1004				.to_compile_error();1005			}1006			let selector = self1007				.methods1008				.iter()1009				.map(|m| m.selector)1010				.fold(0, |a, b| a ^ b);10111012			if *expect_selector != selector {1013				let mut methods = String::new();1014				for meth in self.methods.iter() {1015					write!(methods, "\n- {}", meth.selector_str).expect("write to string");1016				}1017				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();1018			}1019		}1020		// let methods = self.methods.iter().map(Method::solidity_def);10211022		quote! {1023			#[derive(Debug)]1024			#(#[doc = #docs])*1025			pub enum #call_name #gen_ref {1026				/// Inherited method1027				ERC165Call(::evm_coder::ERC165Call, ::core::marker::PhantomData<#gen_data>),1028				#(1029					#calls,1030				)*1031				#(1032					#call_sub,1033				)*1034			}1035			impl #gen_ref #call_name #gen_ref {1036				#(1037					#consts1038				)*1039				/// Return this call ERC165 selector1040				pub fn interface_id() -> ::evm_coder::types::bytes4 {1041					let mut interface_id = 0;1042					#(#interface_id)*1043					#(#inline_interface_id)*1044					u32::to_be_bytes(interface_id)1045				}1046				/// Generate solidity definitions for methods described in this interface1047				pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {1048					use evm_coder::solidity::*;1049					use core::fmt::Write;1050					let interface = SolidityInterface {1051						docs: &[#(#docs),*],1052						name: #solidity_name,1053						selector: Self::interface_id(),1054						is: &["Dummy", "ERC165", #(1055							#solidity_is,1056						)* #(1057							#solidity_events_is,1058						)* ],1059						functions: (#(1060							#solidity_functions,1061						)*),1062					};10631064					let mut out = ::evm_coder::types::string::new();1065					if #solidity_name.starts_with("Inline") {1066						out.push_str("/// @dev inlined interface\n");1067					}1068					let _ = interface.format(is_impl, &mut out, tc);1069					tc.collect(out);1070					#(1071						#solidity_event_generators1072					)*1073					#(1074						#solidity_generators1075					)*1076					if is_impl {1077						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());1078					} else {1079						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());1080					}1081				}1082			}1083			impl #gen_ref ::evm_coder::Call for #call_name #gen_ref {1084				fn parse(method_id: ::evm_coder::types::bytes4, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {1085					use ::evm_coder::abi::AbiRead;1086					match method_id {1087						::evm_coder::ERC165Call::INTERFACE_ID => return Ok(1088							::evm_coder::ERC165Call::parse(method_id, reader)?1089							.map(|c| Self::ERC165Call(c, ::core::marker::PhantomData))1090						),1091						#(1092							#parsers,1093						)*1094						_ => {},1095					}1096					#(1097						#call_parse1098					)else*1099					return Ok(None);1100				}1101			}1102			impl #generics #call_name #gen_ref1103			#gen_where1104			{1105				/// Is this contract implements specified ERC165 selector1106				pub fn supports_interface(this: &#name, interface_id: ::evm_coder::types::bytes4) -> bool {1107					interface_id != u32::to_be_bytes(0xffffff) && (1108						interface_id == ::evm_coder::ERC165Call::INTERFACE_ID ||1109						interface_id == Self::interface_id()1110						#(1111							|| #supports_interface1112						)*1113					)1114				}1115			}1116			impl #generics ::evm_coder::Weighted for #call_name #gen_ref1117			#gen_where1118			{1119				#[allow(unused_variables)]1120				fn weight(&self) -> ::evm_coder::execution::DispatchInfo {1121					match self {1122						#(1123							#weight_variants,1124						)*1125						// TODO: It should be very cheap, but not free1126						Self::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {..}, _) => 100u64.into(),1127						#(1128							#weight_variants_this,1129						)*1130					}1131				}1132			}1133			impl #generics ::evm_coder::Callable<#call_name #gen_ref> for #name1134			#gen_where1135			{1136				#[allow(unreachable_code)] // In case of no inner calls1137				fn call(&mut self, c: Msg<#call_name #gen_ref>) -> ::evm_coder::execution::ResultWithPostInfo<::evm_coder::abi::AbiWriter> {1138					use ::evm_coder::abi::AbiWrite;1139					match c.call {1140						#(1141							#call_variants,1142						)*1143						#call_name::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}, _) => {1144							let mut writer = ::evm_coder::abi::AbiWriter::default();1145							writer.bool(&<#call_name #gen_ref>::supports_interface(self, interface_id));1146							return Ok(writer.into());1147						}1148						_ => {},1149					}1150					let mut writer = ::evm_coder::abi::AbiWriter::default();1151					match c.call {1152						#(1153							#call_variants_this,1154						)*1155						_ => Err(::evm_coder::execution::Error::from("method is not available").into()),1156					}1157				}1158			}1159		}1160	}1161}