git.delta.rocks / unique-network / refs/commits / 4cc1096094ca

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}46impl Is {47	fn expand_call_def(&self, gen_ref: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {48		let name = &self.name;49		let pascal_call_name = &self.pascal_call_name;50		quote! {51			#name(#pascal_call_name #gen_ref)52		}53	}5455	fn expand_interface_id(&self) -> proc_macro2::TokenStream {56		let pascal_call_name = &self.pascal_call_name;57		quote! {58			interface_id ^= u32::from_be_bytes(#pascal_call_name::interface_id());59		}60	}6162	fn expand_supports_interface(63		&self,64		generics: &proc_macro2::TokenStream,65	) -> proc_macro2::TokenStream {66		let pascal_call_name = &self.pascal_call_name;67		quote! {68			<#pascal_call_name #generics>::supports_interface(interface_id)69		}70	}7172	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {73		let name = &self.name;74		quote! {75			Self::#name(call) => call.weight()76		}77	}7879	fn expand_variant_call(80		&self,81		call_name: &proc_macro2::Ident,82		generics: &proc_macro2::TokenStream,83	) -> proc_macro2::TokenStream {84		let name = &self.name;85		let pascal_call_name = &self.pascal_call_name;86		let via_typ = self87			.via88			.as_ref()89			.map(|(t, _)| quote! {#t})90			.unwrap_or_else(|| quote! {Self});91		let via_map = self92			.via93			.as_ref()94			.map(|(_, i)| quote! {.#i()})95			.unwrap_or_default();96		quote! {97			#call_name::#name(call) => return <#via_typ as ::evm_coder::Callable<#pascal_call_name #generics>>::call(self #via_map, Msg {98				call,99				caller: c.caller,100				value: c.value,101			})102		}103	}104105	fn expand_parse(&self, generics: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {106		let name = &self.name;107		let pascal_call_name = &self.pascal_call_name;108		quote! {109			if let Some(parsed_call) = <#pascal_call_name #generics>::parse(method_id, reader)? {110				return Ok(Some(Self::#name(parsed_call)))111			}112		}113	}114115	fn expand_generator(&self, generics: &proc_macro2::TokenStream) -> proc_macro2::TokenStream {116		let pascal_call_name = &self.pascal_call_name;117		quote! {118			<#pascal_call_name #generics>::generate_solidity_interface(tc, is_impl);119		}120	}121122	fn expand_event_generator(&self) -> proc_macro2::TokenStream {123		let name = &self.name;124		quote! {125			#name::generate_solidity_interface(tc, is_impl);126		}127	}128}129130#[derive(Default)]131struct IsList(Vec<Is>);132impl Parse for IsList {133	fn parse(input: ParseStream) -> syn::Result<Self> {134		let mut out = vec![];135		loop {136			if input.is_empty() {137				break;138			}139			let name = input.parse::<Ident>()?;140			let lookahead = input.lookahead1();141			let via = if lookahead.peek(syn::token::Paren) {142				let contents;143				parenthesized!(contents in input);144				let method = contents.parse::<Ident>()?;145				contents.parse::<Token![,]>()?;146				let ty = contents.parse::<Type>()?;147				Some((ty, method))148			} else if lookahead.peek(Token![,]) {149				None150			} else if input.is_empty() {151				None152			} else {153				return Err(lookahead.error());154			};155			out.push(Is {156				pascal_call_name: pascal_ident_to_call(&name),157				snake_call_name: pascal_ident_to_snake_call(&name),158				name,159				via,160			});161			if input.peek(Token![,]) {162				input.parse::<Token![,]>()?;163				continue;164			} else {165				break;166			}167		}168		Ok(Self(out))169	}170}171172pub struct InterfaceInfo {173	name: Ident,174	is: IsList,175	inline_is: IsList,176	events: IsList,177	expect_selector: Option<u32>,178}179impl Parse for InterfaceInfo {180	fn parse(input: ParseStream) -> syn::Result<Self> {181		let mut name = None;182		let mut is = None;183		let mut inline_is = None;184		let mut events = None;185		let mut expect_selector = None;186		// TODO: create proc-macro to optimize proc-macro boilerplate? :D187		loop {188			let lookahead = input.lookahead1();189			if lookahead.peek(kw::name) {190				let k = input.parse::<kw::name>()?;191				input.parse::<Token![=]>()?;192				if name.replace(input.parse::<Ident>()?).is_some() {193					return Err(syn::Error::new(k.span(), "name is already set"));194				}195			} else if lookahead.peek(kw::is) {196				let k = input.parse::<kw::is>()?;197				let contents;198				parenthesized!(contents in input);199				if is.replace(contents.parse::<IsList>()?).is_some() {200					return Err(syn::Error::new(k.span(), "is is already set"));201				}202			} else if lookahead.peek(kw::inline_is) {203				let k = input.parse::<kw::inline_is>()?;204				let contents;205				parenthesized!(contents in input);206				if inline_is.replace(contents.parse::<IsList>()?).is_some() {207					return Err(syn::Error::new(k.span(), "inline_is is already set"));208				}209			} else if lookahead.peek(kw::events) {210				let k = input.parse::<kw::events>()?;211				let contents;212				parenthesized!(contents in input);213				if events.replace(contents.parse::<IsList>()?).is_some() {214					return Err(syn::Error::new(k.span(), "events is already set"));215				}216			} else if lookahead.peek(kw::expect_selector) {217				let k = input.parse::<kw::expect_selector>()?;218				input.parse::<Token![=]>()?;219				let value = input.parse::<LitInt>()?;220				if expect_selector221					.replace(value.base10_parse::<u32>()?)222					.is_some()223				{224					return Err(syn::Error::new(k.span(), "expect_selector is already set"));225				}226			} else if input.is_empty() {227				break;228			} else {229				return Err(lookahead.error());230			}231			if input.peek(Token![,]) {232				input.parse::<Token![,]>()?;233			} else {234				break;235			}236		}237		Ok(Self {238			name: name.ok_or_else(|| syn::Error::new(input.span(), "missing name"))?,239			is: is.unwrap_or_default(),240			inline_is: inline_is.unwrap_or_default(),241			events: events.unwrap_or_default(),242			expect_selector,243		})244	}245}246247struct MethodInfo {248	rename_selector: Option<String>,249}250impl Parse for MethodInfo {251	fn parse(input: ParseStream) -> syn::Result<Self> {252		let mut rename_selector = None;253		let lookahead = input.lookahead1();254		if lookahead.peek(kw::rename_selector) {255			let k = input.parse::<kw::rename_selector>()?;256			input.parse::<Token![=]>()?;257			if rename_selector258				.replace(input.parse::<LitStr>()?.value())259				.is_some()260			{261				return Err(syn::Error::new(k.span(), "rename_selector is already set"));262			}263		}264		Ok(Self { rename_selector })265	}266}267268enum AbiType {269	// type270	Plain(Ident),271	// (type1,type2)272	Tuple(Vec<AbiType>),273	// type[]274	Vec(Box<AbiType>),275	// type[20]276	Array(Box<AbiType>, usize),277}278impl AbiType {279	fn try_from(value: &Type) -> syn::Result<Self> {280		let value = Self::try_maybe_special_from(value)?;281		if value.is_special() {282			return Err(syn::Error::new(value.span(), "unexpected special type"));283		}284		Ok(value)285	}286	fn try_maybe_special_from(value: &Type) -> syn::Result<Self> {287		match value {288			Type::Array(arr) => {289				let wrapped = AbiType::try_from(&arr.elem)?;290				match &arr.len {291					Expr::Lit(l) => match &l.lit {292						Lit::Int(i) => {293							let num = i.base10_parse::<usize>()?;294							Ok(AbiType::Array(Box::new(wrapped), num as usize))295						}296						_ => Err(syn::Error::new(arr.len.span(), "should be int literal")),297					},298					_ => Err(syn::Error::new(arr.len.span(), "should be literal")),299				}300			}301			Type::Path(_) => {302				let path = parse_path(value)?;303				let segment = parse_path_segment(path)?;304				if segment.ident == "Vec" {305					let args = match &segment.arguments {306						PathArguments::AngleBracketed(e) => e,307						_ => {308							return Err(syn::Error::new(309								segment.arguments.span(),310								"missing Vec generic",311							))312						}313					};314					let args = &args.args;315					if args.len() != 1 {316						return Err(syn::Error::new(317							args.span(),318							"expected only one generic for vec",319						));320					}321					let arg = args.first().expect("first arg");322323					let ty = match arg {324						GenericArgument::Type(ty) => ty,325						_ => {326							return Err(syn::Error::new(327								arg.span(),328								"expected first generic to be type",329							))330						}331					};332333					let wrapped = AbiType::try_from(ty)?;334					Ok(Self::Vec(Box::new(wrapped)))335				} else {336					if !segment.arguments.is_empty() {337						return Err(syn::Error::new(338							segment.arguments.span(),339							"unexpected generic arguments for non-vec type",340						));341					}342					Ok(Self::Plain(segment.ident.clone()))343				}344			}345			Type::Tuple(t) => {346				let mut out = Vec::with_capacity(t.elems.len());347				for el in t.elems.iter() {348					out.push(AbiType::try_from(el)?)349				}350				Ok(Self::Tuple(out))351			}352			_ => Err(syn::Error::new(353				value.span(),354				"unexpected type, only arrays, plain types and tuples are supported",355			)),356		}357	}358	fn is_value(&self) -> bool {359		matches!(self, Self::Plain(v) if v == "value")360	}361	fn is_caller(&self) -> bool {362		matches!(self, Self::Plain(v) if v == "caller")363	}364	fn is_special(&self) -> bool {365		self.is_caller() || self.is_value()366	}367	fn selector_ty_buf(&self, buf: &mut String) -> std::fmt::Result {368		match self {369			AbiType::Plain(t) => {370				write!(buf, "{}", t)371			}372			AbiType::Tuple(t) => {373				write!(buf, "(")?;374				for (i, t) in t.iter().enumerate() {375					if i != 0 {376						write!(buf, ",")?;377					}378					t.selector_ty_buf(buf)?;379				}380				write!(buf, ")")381			}382			AbiType::Vec(v) => {383				v.selector_ty_buf(buf)?;384				write!(buf, "[]")385			}386			AbiType::Array(v, len) => {387				v.selector_ty_buf(buf)?;388				write!(buf, "[{}]", len)389			}390		}391	}392	fn selector_ty(&self) -> String {393		let mut out = String::new();394		self.selector_ty_buf(&mut out).expect("no fmt error");395		out396	}397}398impl ToTokens for AbiType {399	fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {400		match self {401			AbiType::Plain(t) => tokens.extend(quote! {#t}),402			AbiType::Tuple(t) => {403				tokens.extend(quote! {(404					#(#t),*405				)});406			}407			AbiType::Vec(v) => tokens.extend(quote! {Vec<#v>}),408			AbiType::Array(v, l) => tokens.extend(quote! {[#v; #l]}),409		}410	}411}412413struct MethodArg {414	name: Ident,415	camel_name: String,416	ty: AbiType,417}418impl MethodArg {419	fn try_from(value: &PatType) -> syn::Result<Self> {420		let name = parse_ident_from_pat(&value.pat)?.clone();421		Ok(Self {422			camel_name: cases::camelcase::to_camel_case(&name.to_string()),423			name,424			ty: AbiType::try_maybe_special_from(&value.ty)?,425		})426	}427	fn is_value(&self) -> bool {428		self.ty.is_value()429	}430	fn is_caller(&self) -> bool {431		self.ty.is_caller()432	}433	fn is_special(&self) -> bool {434		self.ty.is_special()435	}436	fn selector_ty(&self) -> String {437		assert!(!self.is_special());438		self.ty.selector_ty()439	}440441	fn expand_call_def(&self) -> proc_macro2::TokenStream {442		assert!(!self.is_special());443		let name = &self.name;444		let ty = &self.ty;445446		quote! {447			#name: #ty448		}449	}450451	fn expand_parse(&self) -> proc_macro2::TokenStream {452		assert!(!self.is_special());453		let name = &self.name;454		quote! {455			#name: reader.abi_read()?456		}457	}458459	fn expand_call_arg(&self) -> proc_macro2::TokenStream {460		if self.is_value() {461			quote! {462				c.value.clone()463			}464		} else if self.is_caller() {465			quote! {466				c.caller.clone()467			}468		} else {469			let name = &self.name;470			quote! {471				#name472			}473		}474	}475476	fn expand_solidity_argument(&self) -> proc_macro2::TokenStream {477		let camel_name = &self.camel_name.to_string();478		let ty = &self.ty;479		quote! {480			<NamedArgument<#ty>>::new(#camel_name)481		}482	}483}484485#[derive(PartialEq)]486enum Mutability {487	Mutable,488	View,489	Pure,490}491492/// Group all keywords for this macro. Usage example:493/// #[solidity_interface(name = "B", inline_is(A))]494mod kw {495	syn::custom_keyword!(weight);496497	syn::custom_keyword!(via);498	syn::custom_keyword!(name);499	syn::custom_keyword!(is);500	syn::custom_keyword!(inline_is);501	syn::custom_keyword!(events);502	syn::custom_keyword!(expect_selector);503504	syn::custom_keyword!(rename_selector);505}506507/// Rust methods are parsed into this structure when Solidity code is generated508struct Method {509	name: Ident,510	camel_name: String,511	pascal_name: Ident,512	screaming_name: Ident,513	selector_str: String,514	selector: u32,515	args: Vec<MethodArg>,516	has_normal_args: bool,517	mutability: Mutability,518	result: Type,519	weight: Option<Expr>,520	docs: Vec<String>,521}522impl Method {523	fn try_from(value: &ImplItemMethod) -> syn::Result<Self> {524		let mut info = MethodInfo {525			rename_selector: None,526		};527		let mut docs = Vec::new();528		let mut weight = None;529		for attr in &value.attrs {530			let ident = parse_ident_from_path(&attr.path, false)?;531			if ident == "solidity" {532				info = attr.parse_args::<MethodInfo>()?;533			} else if ident == "doc" {534				let args = attr.parse_meta().unwrap();535				let value = match args {536					Meta::NameValue(MetaNameValue {537						lit: Lit::Str(str), ..538					}) => str.value(),539					_ => unreachable!(),540				};541				docs.push(value);542			} else if ident == "weight" {543				weight = Some(attr.parse_args::<Expr>()?);544			}545		}546		let ident = &value.sig.ident;547		let ident_str = ident.to_string();548		if !cases::snakecase::is_snake_case(&ident_str) {549			return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));550		}551552		let mut mutability = Mutability::Pure;553554		if let Some(FnArg::Receiver(receiver)) = value555			.sig556			.inputs557			.iter()558			.find(|arg| matches!(arg, FnArg::Receiver(_)))559		{560			if receiver.reference.is_none() {561				return Err(syn::Error::new(562					receiver.span(),563					"receiver should be by ref",564				));565			}566			if receiver.mutability.is_some() {567				mutability = Mutability::Mutable;568			} else {569				mutability = Mutability::View;570			}571		}572		let mut args = Vec::new();573		for typ in value574			.sig575			.inputs576			.iter()577			.filter(|arg| matches!(arg, FnArg::Typed(_)))578		{579			let typ = match typ {580				FnArg::Typed(typ) => typ,581				_ => unreachable!(),582			};583			args.push(MethodArg::try_from(typ)?);584		}585586		if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {587			return Err(syn::Error::new(588				args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),589				"payable function should be mutable",590			));591		}592593		let result = match &value.sig.output {594			ReturnType::Type(_, ty) => ty,595			_ => 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)")),596		};597		let result = parse_result_ok(result)?;598599		let camel_name = info600			.rename_selector601			.unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));602		let mut selector_str = camel_name.clone();603		selector_str.push('(');604		let mut has_normal_args = false;605		for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {606			if i != 0 {607				selector_str.push(',');608			}609			write!(selector_str, "{}", arg.selector_ty()).unwrap();610			has_normal_args = true;611		}612		selector_str.push(')');613		let selector = fn_selector_str(&selector_str);614615		Ok(Self {616			name: ident.clone(),617			camel_name,618			pascal_name: snake_ident_to_pascal(ident),619			screaming_name: snake_ident_to_screaming(ident),620			selector_str,621			selector,622			args,623			has_normal_args,624			mutability,625			result: result.clone(),626			weight,627			docs,628		})629	}630	fn expand_call_def(&self) -> proc_macro2::TokenStream {631		let defs = self632			.args633			.iter()634			.filter(|a| !a.is_special())635			.map(|a| a.expand_call_def());636		let pascal_name = &self.pascal_name;637		let docs = &self.docs;638639		if self.has_normal_args {640			quote! {641				#(#[doc = #docs])*642				#[allow(missing_docs)]643				#pascal_name {644					#(645						#defs,646					)*647				}648			}649		} else {650			quote! {#pascal_name}651		}652	}653654	fn expand_const(&self) -> proc_macro2::TokenStream {655		let screaming_name = &self.screaming_name;656		let selector = u32::to_be_bytes(self.selector);657		let selector_str = &self.selector_str;658		quote! {659			#[doc = #selector_str]660			const #screaming_name: ::evm_coder::types::bytes4 = [#(#selector,)*];661		}662	}663664	fn expand_interface_id(&self) -> proc_macro2::TokenStream {665		let screaming_name = &self.screaming_name;666		quote! {667			interface_id ^= u32::from_be_bytes(Self::#screaming_name);668		}669	}670671	fn expand_parse(&self) -> proc_macro2::TokenStream {672		let pascal_name = &self.pascal_name;673		let screaming_name = &self.screaming_name;674		if self.has_normal_args {675			let parsers = self676				.args677				.iter()678				.filter(|a| !a.is_special())679				.map(|a| a.expand_parse());680			quote! {681				Self::#screaming_name => return Ok(Some(Self::#pascal_name {682					#(683						#parsers,684					)*685				}))686			}687		} else {688			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }689		}690	}691692	fn expand_variant_call(&self, call_name: &proc_macro2::Ident) -> proc_macro2::TokenStream {693		let pascal_name = &self.pascal_name;694		let name = &self.name;695696		let matcher = if self.has_normal_args {697			let names = self698				.args699				.iter()700				.filter(|a| !a.is_special())701				.map(|a| &a.name);702703			quote! {{704				#(705					#names,706				)*707			}}708		} else {709			quote! {}710		};711712		let receiver = match self.mutability {713			Mutability::Mutable | Mutability::View => quote! {self.},714			Mutability::Pure => quote! {Self::},715		};716		let args = self.args.iter().map(|a| a.expand_call_arg());717718		quote! {719			#call_name::#pascal_name #matcher => {720				let result = #receiver #name(721					#(722						#args,723					)*724				)?;725				(&result).to_result()726			}727		}728	}729730	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {731		let pascal_name = &self.pascal_name;732		if let Some(weight) = &self.weight {733			let matcher = if self.has_normal_args {734				let names = self735					.args736					.iter()737					.filter(|a| !a.is_special())738					.map(|a| &a.name);739740				quote! {{741					#(742						#names,743					)*744				}}745			} else {746				quote! {}747			};748			quote! {749				Self::#pascal_name #matcher => (#weight).into()750			}751		} else {752			let matcher = if self.has_normal_args {753				quote! {{..}}754			} else {755				quote! {}756			};757			quote! {758				Self::#pascal_name #matcher => ().into()759			}760		}761	}762763	fn expand_solidity_function(&self) -> proc_macro2::TokenStream {764		let camel_name = &self.camel_name;765		let mutability = match self.mutability {766			Mutability::Mutable => quote! {SolidityMutability::Mutable},767			Mutability::View => quote! { SolidityMutability::View },768			Mutability::Pure => quote! {SolidityMutability::Pure},769		};770		let result = &self.result;771772		let args = self773			.args774			.iter()775			.filter(|a| !a.is_special())776			.map(MethodArg::expand_solidity_argument);777		let docs = &self.docs;778		let selector_str = &self.selector_str;779		let selector = self.selector;780781		quote! {782			SolidityFunction {783				docs: &[#(#docs),*],784				selector_str: #selector_str,785				selector: #selector,786				name: #camel_name,787				mutability: #mutability,788				args: (789					#(790						#args,791					)*792				),793				result: <UnnamedArgument<#result>>::default(),794			}795		}796	}797}798799fn generics_list(gen: &Generics) -> proc_macro2::TokenStream {800	if gen.params.is_empty() {801		return quote! {};802	}803	let params = gen.params.iter().map(|p| match p {804		syn::GenericParam::Type(id) => {805			let v = &id.ident;806			quote! {#v}807		}808		syn::GenericParam::Lifetime(lt) => {809			let v = &lt.lifetime;810			quote! {#v}811		}812		syn::GenericParam::Const(c) => {813			let i = &c.ident;814			quote! {#i}815		}816	});817	quote! { #(#params),* }818}819fn generics_reference(gen: &Generics) -> proc_macro2::TokenStream {820	if gen.params.is_empty() {821		return quote! {};822	}823	let list = generics_list(gen);824	quote! { <#list> }825}826fn generics_data(gen: &Generics) -> proc_macro2::TokenStream {827	let list = generics_list(gen);828	if gen.params.len() == 1 {829		quote! {#list}830	} else {831		quote! { (#list) }832	}833}834835pub struct SolidityInterface {836	generics: Generics,837	name: Box<syn::Type>,838	info: InterfaceInfo,839	methods: Vec<Method>,840	docs: Vec<String>,841}842impl SolidityInterface {843	pub fn try_from(info: InterfaceInfo, value: &ItemImpl) -> syn::Result<Self> {844		let mut methods = Vec::new();845846		for item in &value.items {847			if let ImplItem::Method(method) = item {848				methods.push(Method::try_from(method)?)849			}850		}851		let mut docs = vec![];852		for attr in &value.attrs {853			let ident = parse_ident_from_path(&attr.path, false)?;854			if ident == "doc" {855				let args = attr.parse_meta().unwrap();856				let value = match args {857					Meta::NameValue(MetaNameValue {858						lit: Lit::Str(str), ..859					}) => str.value(),860					_ => unreachable!(),861				};862				docs.push(value);863			}864		}865		Ok(Self {866			generics: value.generics.clone(),867			name: value.self_ty.clone(),868			info,869			methods,870			docs,871		})872	}873	pub fn expand(self) -> proc_macro2::TokenStream {874		let name = self.name;875876		let solidity_name = self.info.name.to_string();877		let call_name = pascal_ident_to_call(&self.info.name);878		let generics = self.generics;879		let gen_ref = generics_reference(&generics);880		let gen_data = generics_data(&generics);881		let gen_where = &generics.where_clause;882883		let call_sub = self884			.info885			.inline_is886			.0887			.iter()888			.chain(self.info.is.0.iter())889			.map(|c| Is::expand_call_def(c, &gen_ref));890		let call_parse = self891			.info892			.inline_is893			.0894			.iter()895			.chain(self.info.is.0.iter())896			.map(|is| Is::expand_parse(is, &gen_ref));897		let call_variants = self898			.info899			.inline_is900			.0901			.iter()902			.chain(self.info.is.0.iter())903			.map(|c| Is::expand_variant_call(c, &call_name, &gen_ref));904		let weight_variants = self905			.info906			.inline_is907			.0908			.iter()909			.chain(self.info.is.0.iter())910			.map(Is::expand_variant_weight);911912		let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);913		let supports_interface = self914			.info915			.is916			.0917			.iter()918			.map(|is| Is::expand_supports_interface(is, &gen_ref));919920		let calls = self.methods.iter().map(Method::expand_call_def);921		let consts = self.methods.iter().map(Method::expand_const);922		let interface_id = self.methods.iter().map(Method::expand_interface_id);923		let parsers = self.methods.iter().map(Method::expand_parse);924		let call_variants_this = self925			.methods926			.iter()927			.map(|m| Method::expand_variant_call(m, &call_name));928		let weight_variants_this = self.methods.iter().map(Method::expand_variant_weight);929		let solidity_functions = self.methods.iter().map(Method::expand_solidity_function);930931		// TODO: Inline inline_is932		let solidity_is = self933			.info934			.is935			.0936			.iter()937			.chain(self.info.inline_is.0.iter())938			.map(|is| is.name.to_string());939		let solidity_events_is = self.info.events.0.iter().map(|is| is.name.to_string());940		let solidity_generators = self941			.info942			.is943			.0944			.iter()945			.chain(self.info.inline_is.0.iter())946			.map(|is| Is::expand_generator(is, &gen_ref));947		let solidity_event_generators = self.info.events.0.iter().map(Is::expand_event_generator);948949		let docs = &self.docs;950951		if let Some(expect_selector) = &self.info.expect_selector {952			if !self.info.inline_is.0.is_empty() {953				return syn::Error::new(954					name.span(),955					"expect_selector is not compatible with inline_is",956				)957				.to_compile_error();958			}959			let selector = self960				.methods961				.iter()962				.map(|m| m.selector)963				.fold(0, |a, b| a ^ b);964965			if *expect_selector != selector {966				let mut methods = String::new();967				for meth in self.methods.iter() {968					write!(methods, "\n- {}", meth.selector_str).expect("write to string");969				}970				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();971			}972		}973		// let methods = self.methods.iter().map(Method::solidity_def);974975		quote! {976			#[derive(Debug)]977			#(#[doc = #docs])*978			pub enum #call_name #gen_ref {979				/// Inherited method980				ERC165Call(::evm_coder::ERC165Call, ::core::marker::PhantomData<#gen_data>),981				#(982					#calls,983				)*984				#(985					#call_sub,986				)*987			}988			impl #gen_ref #call_name #gen_ref {989				#(990					#consts991				)*992				/// Return this call ERC165 selector993				pub fn interface_id() -> ::evm_coder::types::bytes4 {994					let mut interface_id = 0;995					#(#interface_id)*996					#(#inline_interface_id)*997					u32::to_be_bytes(interface_id)998				}999				/// Is this contract implements specified ERC165 selector1000				pub fn supports_interface(interface_id: ::evm_coder::types::bytes4) -> bool {1001					interface_id != u32::to_be_bytes(0xffffff) && (1002						interface_id == ::evm_coder::ERC165Call::INTERFACE_ID ||1003						interface_id == Self::interface_id()1004						#(1005							|| #supports_interface1006						)*1007					)1008				}1009				/// Generate solidity definitions for methods described in this interface1010				pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {1011					use evm_coder::solidity::*;1012					use core::fmt::Write;1013					let interface = SolidityInterface {1014						docs: &[#(#docs),*],1015						name: #solidity_name,1016						selector: Self::interface_id(),1017						is: &["Dummy", "ERC165", #(1018							#solidity_is,1019						)* #(1020							#solidity_events_is,1021						)* ],1022						functions: (#(1023							#solidity_functions,1024						)*),1025					};10261027					let mut out = string::new();1028					if #solidity_name.starts_with("Inline") {1029						out.push_str("/// @dev inlined interface\n");1030					}1031					let _ = interface.format(is_impl, &mut out, tc);1032					tc.collect(out);1033					#(1034						#solidity_event_generators1035					)*1036					#(1037						#solidity_generators1038					)*1039					if is_impl {1040						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());1041					} else {1042						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());1043					}1044				}1045			}1046			impl #gen_ref ::evm_coder::Call for #call_name #gen_ref {1047				fn parse(method_id: ::evm_coder::types::bytes4, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {1048					use ::evm_coder::abi::AbiRead;1049					match method_id {1050						::evm_coder::ERC165Call::INTERFACE_ID => return Ok(1051							::evm_coder::ERC165Call::parse(method_id, reader)?1052							.map(|c| Self::ERC165Call(c, ::core::marker::PhantomData))1053						),1054						#(1055							#parsers,1056						)*1057						_ => {},1058					}1059					#(1060						#call_parse1061					)else*1062					return Ok(None);1063				}1064			}1065			impl #generics ::evm_coder::Weighted for #call_name #gen_ref1066			#gen_where1067			{1068				#[allow(unused_variables)]1069				fn weight(&self) -> ::evm_coder::execution::DispatchInfo {1070					match self {1071						#(1072							#weight_variants,1073						)*1074						// TODO: It should be very cheap, but not free1075						Self::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {..}, _) => 100u64.into(),1076						#(1077							#weight_variants_this,1078						)*1079					}1080				}1081			}1082			impl #generics ::evm_coder::Callable<#call_name #gen_ref> for #name1083			#gen_where1084			{1085				#[allow(unreachable_code)] // In case of no inner calls1086				fn call(&mut self, c: Msg<#call_name #gen_ref>) -> ::evm_coder::execution::ResultWithPostInfo<::evm_coder::abi::AbiWriter> {1087					use ::evm_coder::abi::AbiWrite;1088					match c.call {1089						#(1090							#call_variants,1091						)*1092						#call_name::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}, _) => {1093							let mut writer = ::evm_coder::abi::AbiWriter::default();1094							writer.bool(&<#call_name #gen_ref>::supports_interface(interface_id));1095							return Ok(writer.into());1096						}1097						_ => {},1098					}1099					let mut writer = ::evm_coder::abi::AbiWriter::default();1100					match c.call {1101						#(1102							#call_variants_this,1103						)*1104						_ => unreachable!()1105					}1106				}1107			}1108		}1109	}1110}