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

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}295impl Parse for MethodInfo {296	fn parse(input: ParseStream) -> syn::Result<Self> {297		let mut rename_selector = None;298		let lookahead = input.lookahead1();299		if lookahead.peek(kw::rename_selector) {300			let k = input.parse::<kw::rename_selector>()?;301			input.parse::<Token![=]>()?;302			if rename_selector303				.replace(input.parse::<LitStr>()?.value())304				.is_some()305			{306				return Err(syn::Error::new(k.span(), "rename_selector is already set"));307			}308		}309		Ok(Self { rename_selector })310	}311}312313enum AbiType {314	// type315	Plain(Ident),316	// (type1,type2)317	Tuple(Vec<AbiType>),318	// type[]319	Vec(Box<AbiType>),320	// type[20]321	Array(Box<AbiType>, usize),322}323impl AbiType {324	fn try_from(value: &Type) -> syn::Result<Self> {325		let value = Self::try_maybe_special_from(value)?;326		if value.is_special() {327			return Err(syn::Error::new(value.span(), "unexpected special type"));328		}329		Ok(value)330	}331	fn try_maybe_special_from(value: &Type) -> syn::Result<Self> {332		match value {333			Type::Array(arr) => {334				let wrapped = AbiType::try_from(&arr.elem)?;335				match &arr.len {336					Expr::Lit(l) => match &l.lit {337						Lit::Int(i) => {338							let num = i.base10_parse::<usize>()?;339							Ok(AbiType::Array(Box::new(wrapped), num as usize))340						}341						_ => Err(syn::Error::new(arr.len.span(), "should be int literal")),342					},343					_ => Err(syn::Error::new(arr.len.span(), "should be literal")),344				}345			}346			Type::Path(_) => {347				let path = parse_path(value)?;348				let segment = parse_path_segment(path)?;349				if segment.ident == "Vec" {350					let args = match &segment.arguments {351						PathArguments::AngleBracketed(e) => e,352						_ => {353							return Err(syn::Error::new(354								segment.arguments.span(),355								"missing Vec generic",356							))357						}358					};359					let args = &args.args;360					if args.len() != 1 {361						return Err(syn::Error::new(362							args.span(),363							"expected only one generic for vec",364						));365					}366					let arg = args.first().expect("first arg");367368					let ty = match arg {369						GenericArgument::Type(ty) => ty,370						_ => {371							return Err(syn::Error::new(372								arg.span(),373								"expected first generic to be type",374							))375						}376					};377378					let wrapped = AbiType::try_from(ty)?;379					Ok(Self::Vec(Box::new(wrapped)))380				} else {381					if !segment.arguments.is_empty() {382						return Err(syn::Error::new(383							segment.arguments.span(),384							"unexpected generic arguments for non-vec type",385						));386					}387					Ok(Self::Plain(segment.ident.clone()))388				}389			}390			Type::Tuple(t) => {391				let mut out = Vec::with_capacity(t.elems.len());392				for el in t.elems.iter() {393					out.push(AbiType::try_from(el)?)394				}395				Ok(Self::Tuple(out))396			}397			_ => Err(syn::Error::new(398				value.span(),399				"unexpected type, only arrays, plain types and tuples are supported",400			)),401		}402	}403	fn is_value(&self) -> bool {404		matches!(self, Self::Plain(v) if v == "value")405	}406	fn is_caller(&self) -> bool {407		matches!(self, Self::Plain(v) if v == "caller")408	}409	fn is_special(&self) -> bool {410		self.is_caller() || self.is_value()411	}412	fn selector_ty_buf(&self, buf: &mut String) -> std::fmt::Result {413		match self {414			AbiType::Plain(t) => {415				write!(buf, "{}", t)416			}417			AbiType::Tuple(t) => {418				write!(buf, "(")?;419				for (i, t) in t.iter().enumerate() {420					if i != 0 {421						write!(buf, ",")?;422					}423					t.selector_ty_buf(buf)?;424				}425				write!(buf, ")")426			}427			AbiType::Vec(v) => {428				v.selector_ty_buf(buf)?;429				write!(buf, "[]")430			}431			AbiType::Array(v, len) => {432				v.selector_ty_buf(buf)?;433				write!(buf, "[{}]", len)434			}435		}436	}437	fn selector_ty(&self) -> String {438		let mut out = String::new();439		self.selector_ty_buf(&mut out).expect("no fmt error");440		out441	}442}443impl ToTokens for AbiType {444	fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {445		match self {446			AbiType::Plain(t) => tokens.extend(quote! {#t}),447			AbiType::Tuple(t) => {448				tokens.extend(quote! {(449					#(#t),*450				)});451			}452			AbiType::Vec(v) => tokens.extend(quote! {Vec<#v>}),453			AbiType::Array(v, l) => tokens.extend(quote! {[#v; #l]}),454		}455	}456}457458struct MethodArg {459	name: Ident,460	camel_name: String,461	ty: AbiType,462}463impl MethodArg {464	fn try_from(value: &PatType) -> syn::Result<Self> {465		let name = parse_ident_from_pat(&value.pat)?.clone();466		Ok(Self {467			camel_name: cases::camelcase::to_camel_case(&name.to_string()),468			name,469			ty: AbiType::try_maybe_special_from(&value.ty)?,470		})471	}472	fn is_value(&self) -> bool {473		self.ty.is_value()474	}475	fn is_caller(&self) -> bool {476		self.ty.is_caller()477	}478	fn is_special(&self) -> bool {479		self.ty.is_special()480	}481	fn selector_ty(&self) -> String {482		assert!(!self.is_special());483		self.ty.selector_ty()484	}485486	fn expand_call_def(&self) -> proc_macro2::TokenStream {487		assert!(!self.is_special());488		let name = &self.name;489		let ty = &self.ty;490491		quote! {492			#name: #ty493		}494	}495496	fn expand_parse(&self) -> proc_macro2::TokenStream {497		assert!(!self.is_special());498		let name = &self.name;499		quote! {500			#name: reader.abi_read()?501		}502	}503504	fn expand_call_arg(&self) -> proc_macro2::TokenStream {505		if self.is_value() {506			quote! {507				c.value.clone()508			}509		} else if self.is_caller() {510			quote! {511				c.caller.clone()512			}513		} else {514			let name = &self.name;515			quote! {516				#name517			}518		}519	}520521	fn expand_solidity_argument(&self) -> proc_macro2::TokenStream {522		let camel_name = &self.camel_name.to_string();523		let ty = &self.ty;524		quote! {525			<NamedArgument<#ty>>::new(#camel_name)526		}527	}528}529530#[derive(PartialEq)]531enum Mutability {532	Mutable,533	View,534	Pure,535}536537/// Group all keywords for this macro. Usage example:538/// #[solidity_interface(name = "B", inline_is(A))]539mod kw {540	syn::custom_keyword!(weight);541542	syn::custom_keyword!(via);543	syn::custom_keyword!(returns);544	syn::custom_keyword!(name);545	syn::custom_keyword!(is);546	syn::custom_keyword!(inline_is);547	syn::custom_keyword!(events);548	syn::custom_keyword!(expect_selector);549550	syn::custom_keyword!(rename_selector);551}552553/// Rust methods are parsed into this structure when Solidity code is generated554struct Method {555	name: Ident,556	camel_name: String,557	pascal_name: Ident,558	screaming_name: Ident,559	selector_str: String,560	selector: u32,561	args: Vec<MethodArg>,562	has_normal_args: bool,563	has_value_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 normal_args_count = 0u32;652		let mut has_value_args = false;653		for arg in args.iter() {654			if arg.is_value() {655				has_value_args = true;656			} else if !arg.is_special() {657				if normal_args_count != 0 {658					selector_str.push(',');659				}660				write!(selector_str, "{}", arg.selector_ty()).unwrap();661				normal_args_count = normal_args_count.saturating_add(1);662			}663		}664		let has_normal_args = normal_args_count > 0;665		selector_str.push(')');666		let selector = fn_selector_str(&selector_str);667668		Ok(Self {669			name: ident.clone(),670			camel_name,671			pascal_name: snake_ident_to_pascal(ident),672			screaming_name: snake_ident_to_screaming(ident),673			selector_str,674			selector,675			args,676			has_normal_args,677			has_value_args,678			mutability,679			result: result.clone(),680			weight,681			docs,682		})683	}684	fn expand_call_def(&self) -> proc_macro2::TokenStream {685		let defs = self686			.args687			.iter()688			.filter(|a| !a.is_special())689			.map(|a| a.expand_call_def());690		let pascal_name = &self.pascal_name;691		let docs = &self.docs;692693		if self.has_normal_args {694			quote! {695				#(#[doc = #docs])*696				#[allow(missing_docs)]697				#pascal_name {698					#(699						#defs,700					)*701				}702			}703		} else {704			quote! {#pascal_name}705		}706	}707708	fn expand_const(&self) -> proc_macro2::TokenStream {709		let screaming_name = &self.screaming_name;710		let selector = u32::to_be_bytes(self.selector);711		let selector_str = &self.selector_str;712		quote! {713			#[doc = #selector_str]714			const #screaming_name: ::evm_coder::types::bytes4 = [#(#selector,)*];715		}716	}717718	fn expand_interface_id(&self) -> proc_macro2::TokenStream {719		let screaming_name = &self.screaming_name;720		quote! {721			interface_id ^= u32::from_be_bytes(Self::#screaming_name);722		}723	}724725	fn expand_parse(&self) -> proc_macro2::TokenStream {726		let pascal_name = &self.pascal_name;727		let screaming_name = &self.screaming_name;728		if self.has_normal_args {729			let parsers = self730				.args731				.iter()732				.filter(|a| !a.is_special())733				.map(|a| a.expand_parse());734			quote! {735				Self::#screaming_name => return Ok(Some(Self::#pascal_name {736					#(737						#parsers,738					)*739				}))740			}741		} else {742			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }743		}744	}745746	fn expand_variant_call(&self, call_name: &proc_macro2::Ident) -> proc_macro2::TokenStream {747		let pascal_name = &self.pascal_name;748		let name = &self.name;749750		let matcher = if self.has_normal_args {751			let names = self752				.args753				.iter()754				.filter(|a| !a.is_special())755				.map(|a| &a.name);756757			quote! {{758				#(759					#names,760				)*761			}}762		} else {763			quote! {}764		};765766		let receiver = match self.mutability {767			Mutability::Mutable | Mutability::View => quote! {self.},768			Mutability::Pure => quote! {Self::},769		};770		let args = self.args.iter().map(|a| a.expand_call_arg());771772		quote! {773			#call_name::#pascal_name #matcher => {774				let result = #receiver #name(775					#(776						#args,777					)*778				)?;779				(&result).to_result()780			}781		}782	}783784	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {785		let pascal_name = &self.pascal_name;786		if let Some(weight) = &self.weight {787			let matcher = if self.has_normal_args {788				let names = self789					.args790					.iter()791					.filter(|a| !a.is_special())792					.map(|a| &a.name);793794				quote! {{795					#(796						#names,797					)*798				}}799			} else {800				quote! {}801			};802			quote! {803				Self::#pascal_name #matcher => (#weight).into()804			}805		} else {806			let matcher = if self.has_normal_args {807				quote! {{..}}808			} else {809				quote! {}810			};811			quote! {812				Self::#pascal_name #matcher => ().into()813			}814		}815	}816817	fn expand_solidity_function(&self) -> proc_macro2::TokenStream {818		let camel_name = &self.camel_name;819		let mutability = match self.mutability {820			Mutability::Mutable => quote! {SolidityMutability::Mutable},821			Mutability::View => quote! { SolidityMutability::View },822			Mutability::Pure => quote! {SolidityMutability::Pure},823		};824		let result = &self.result;825826		let args = self827			.args828			.iter()829			.filter(|a| !a.is_special())830			.map(MethodArg::expand_solidity_argument);831		let docs = &self.docs;832		let selector_str = &self.selector_str;833		let selector = self.selector;834		let is_payable = self.has_value_args;835		quote! {836			SolidityFunction {837				docs: &[#(#docs),*],838				selector_str: #selector_str,839				selector: #selector,840				name: #camel_name,841				mutability: #mutability,842				is_payable: #is_payable,843				args: (844					#(845						#args,846					)*847				),848				result: <UnnamedArgument<#result>>::default(),849			}850		}851	}852}853854fn generics_list(gen: &Generics) -> proc_macro2::TokenStream {855	if gen.params.is_empty() {856		return quote! {};857	}858	let params = gen.params.iter().map(|p| match p {859		syn::GenericParam::Type(id) => {860			let v = &id.ident;861			quote! {#v}862		}863		syn::GenericParam::Lifetime(lt) => {864			let v = &lt.lifetime;865			quote! {#v}866		}867		syn::GenericParam::Const(c) => {868			let i = &c.ident;869			quote! {#i}870		}871	});872	quote! { #(#params),* }873}874fn generics_reference(gen: &Generics) -> proc_macro2::TokenStream {875	if gen.params.is_empty() {876		return quote! {};877	}878	let list = generics_list(gen);879	quote! { <#list> }880}881fn generics_data(gen: &Generics) -> proc_macro2::TokenStream {882	let list = generics_list(gen);883	if gen.params.len() == 1 {884		quote! {#list}885	} else {886		quote! { (#list) }887	}888}889890pub struct SolidityInterface {891	generics: Generics,892	name: Box<syn::Type>,893	info: InterfaceInfo,894	methods: Vec<Method>,895	docs: Vec<String>,896}897impl SolidityInterface {898	pub fn try_from(info: InterfaceInfo, value: &ItemImpl) -> syn::Result<Self> {899		let mut methods = Vec::new();900901		for item in &value.items {902			if let ImplItem::Method(method) = item {903				methods.push(Method::try_from(method)?)904			}905		}906		let mut docs = vec![];907		for attr in &value.attrs {908			let ident = parse_ident_from_path(&attr.path, false)?;909			if ident == "doc" {910				let args = attr.parse_meta().unwrap();911				let value = match args {912					Meta::NameValue(MetaNameValue {913						lit: Lit::Str(str), ..914					}) => str.value(),915					_ => unreachable!(),916				};917				docs.push(value);918			}919		}920		Ok(Self {921			generics: value.generics.clone(),922			name: value.self_ty.clone(),923			info,924			methods,925			docs,926		})927	}928	pub fn expand(self) -> proc_macro2::TokenStream {929		let name = self.name;930931		let solidity_name = self.info.name.to_string();932		let call_name = pascal_ident_to_call(&self.info.name);933		let generics = self.generics;934		let gen_ref = generics_reference(&generics);935		let gen_data = generics_data(&generics);936		let gen_where = &generics.where_clause;937938		let call_sub = self939			.info940			.inline_is941			.0942			.iter()943			.chain(self.info.is.0.iter())944			.map(|c| Is::expand_call_def(c, &gen_ref));945		let call_parse = self946			.info947			.inline_is948			.0949			.iter()950			.chain(self.info.is.0.iter())951			.map(|is| Is::expand_parse(is, &gen_ref));952		let call_variants = self953			.info954			.inline_is955			.0956			.iter()957			.chain(self.info.is.0.iter())958			.map(|c| Is::expand_variant_call(c, &call_name, &gen_ref));959		let weight_variants = self960			.info961			.inline_is962			.0963			.iter()964			.chain(self.info.is.0.iter())965			.map(Is::expand_variant_weight);966967		let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);968		let supports_interface = self969			.info970			.is971			.0972			.iter()973			.map(|is| Is::expand_supports_interface(is, &gen_ref));974975		let calls = self.methods.iter().map(Method::expand_call_def);976		let consts = self.methods.iter().map(Method::expand_const);977		let interface_id = self.methods.iter().map(Method::expand_interface_id);978		let parsers = self.methods.iter().map(Method::expand_parse);979		let call_variants_this = self980			.methods981			.iter()982			.map(|m| Method::expand_variant_call(m, &call_name));983		let weight_variants_this = self.methods.iter().map(Method::expand_variant_weight);984		let solidity_functions = self.methods.iter().map(Method::expand_solidity_function);985986		// TODO: Inline inline_is987		let solidity_is = self988			.info989			.is990			.0991			.iter()992			.chain(self.info.inline_is.0.iter())993			.map(|is| is.name.to_string());994		let solidity_events_is = self.info.events.0.iter().map(|is| is.name.to_string());995		let solidity_generators = self996			.info997			.is998			.0999			.iter()1000			.chain(self.info.inline_is.0.iter())1001			.map(|is| Is::expand_generator(is, &gen_ref));1002		let solidity_event_generators = self.info.events.0.iter().map(Is::expand_event_generator);10031004		let docs = &self.docs;10051006		if let Some(expect_selector) = &self.info.expect_selector {1007			if !self.info.inline_is.0.is_empty() {1008				return syn::Error::new(1009					name.span(),1010					"expect_selector is not compatible with inline_is",1011				)1012				.to_compile_error();1013			}1014			let selector = self1015				.methods1016				.iter()1017				.map(|m| m.selector)1018				.fold(0, |a, b| a ^ b);10191020			if *expect_selector != selector {1021				let mut methods = String::new();1022				for meth in self.methods.iter() {1023					write!(methods, "\n- {}", meth.selector_str).expect("write to string");1024				}1025				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();1026			}1027		}1028		// let methods = self.methods.iter().map(Method::solidity_def);10291030		quote! {1031			#[derive(Debug)]1032			#(#[doc = #docs])*1033			pub enum #call_name #gen_ref {1034				/// Inherited method1035				ERC165Call(::evm_coder::ERC165Call, ::core::marker::PhantomData<#gen_data>),1036				#(1037					#calls,1038				)*1039				#(1040					#call_sub,1041				)*1042			}1043			impl #gen_ref #call_name #gen_ref {1044				#(1045					#consts1046				)*1047				/// Return this call ERC165 selector1048				pub fn interface_id() -> ::evm_coder::types::bytes4 {1049					let mut interface_id = 0;1050					#(#interface_id)*1051					#(#inline_interface_id)*1052					u32::to_be_bytes(interface_id)1053				}1054				/// Generate solidity definitions for methods described in this interface1055				pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {1056					use evm_coder::solidity::*;1057					use core::fmt::Write;1058					let interface = SolidityInterface {1059						docs: &[#(#docs),*],1060						name: #solidity_name,1061						selector: Self::interface_id(),1062						is: &["Dummy", "ERC165", #(1063							#solidity_is,1064						)* #(1065							#solidity_events_is,1066						)* ],1067						functions: (#(1068							#solidity_functions,1069						)*),1070					};10711072					let mut out = ::evm_coder::types::string::new();1073					if #solidity_name.starts_with("Inline") {1074						out.push_str("/// @dev inlined interface\n");1075					}1076					let _ = interface.format(is_impl, &mut out, tc);1077					tc.collect(out);1078					#(1079						#solidity_event_generators1080					)*1081					#(1082						#solidity_generators1083					)*1084					if is_impl {1085						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());1086					} else {1087						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());1088					}1089				}1090			}1091			impl #gen_ref ::evm_coder::Call for #call_name #gen_ref {1092				fn parse(method_id: ::evm_coder::types::bytes4, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {1093					use ::evm_coder::abi::AbiRead;1094					match method_id {1095						::evm_coder::ERC165Call::INTERFACE_ID => return Ok(1096							::evm_coder::ERC165Call::parse(method_id, reader)?1097							.map(|c| Self::ERC165Call(c, ::core::marker::PhantomData))1098						),1099						#(1100							#parsers,1101						)*1102						_ => {},1103					}1104					#(1105						#call_parse1106					)else*1107					return Ok(None);1108				}1109			}1110			impl #generics #call_name #gen_ref1111			#gen_where1112			{1113				/// Is this contract implements specified ERC165 selector1114				pub fn supports_interface(this: &#name, interface_id: ::evm_coder::types::bytes4) -> bool {1115					interface_id != u32::to_be_bytes(0xffffff) && (1116						interface_id == ::evm_coder::ERC165Call::INTERFACE_ID ||1117						interface_id == Self::interface_id()1118						#(1119							|| #supports_interface1120						)*1121					)1122				}1123			}1124			impl #generics ::evm_coder::Weighted for #call_name #gen_ref1125			#gen_where1126			{1127				#[allow(unused_variables)]1128				fn weight(&self) -> ::evm_coder::execution::DispatchInfo {1129					match self {1130						#(1131							#weight_variants,1132						)*1133						// TODO: It should be very cheap, but not free1134						Self::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {..}, _) => 100u64.into(),1135						#(1136							#weight_variants_this,1137						)*1138					}1139				}1140			}1141			impl #generics ::evm_coder::Callable<#call_name #gen_ref> for #name1142			#gen_where1143			{1144				#[allow(unreachable_code)] // In case of no inner calls1145				fn call(&mut self, c: Msg<#call_name #gen_ref>) -> ::evm_coder::execution::ResultWithPostInfo<::evm_coder::abi::AbiWriter> {1146					use ::evm_coder::abi::AbiWrite;1147					match c.call {1148						#(1149							#call_variants,1150						)*1151						#call_name::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}, _) => {1152							let mut writer = ::evm_coder::abi::AbiWriter::default();1153							writer.bool(&<#call_name #gen_ref>::supports_interface(self, interface_id));1154							return Ok(writer.into());1155						}1156						_ => {},1157					}1158					let mut writer = ::evm_coder::abi::AbiWriter::default();1159					match c.call {1160						#(1161							#call_variants_this,1162						)*1163						_ => Err(::evm_coder::execution::Error::from("method is not available").into()),1164					}1165				}1166			}1167		}1168	}1169}