git.delta.rocks / unique-network / refs/commits / 68abc1e2a360

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 if input.peek(Token![,]) {185						input.parse::<Token![,]>()?;186					} else {187						return Err(lookahead.error());188					}189				}190			} else if lookahead.peek(Token![,]) || input.is_empty() {191				// Pass192			} else {193				return Err(lookahead.error());194			};195			out.push(Is {196				pascal_call_name: pascal_ident_to_call(&name),197				snake_call_name: pascal_ident_to_snake_call(&name),198				name,199				via,200				condition,201			});202			if input.peek(Token![,]) {203				input.parse::<Token![,]>()?;204				continue;205			} else {206				break;207			}208		}209		Ok(Self(out))210	}211}212213pub struct InterfaceInfo {214	name: Ident,215	is: IsList,216	inline_is: IsList,217	events: IsList,218	expect_selector: Option<u32>,219}220impl Parse for InterfaceInfo {221	fn parse(input: ParseStream) -> syn::Result<Self> {222		let mut name = None;223		let mut is = None;224		let mut inline_is = None;225		let mut events = None;226		let mut expect_selector = None;227		// TODO: create proc-macro to optimize proc-macro boilerplate? :D228		loop {229			let lookahead = input.lookahead1();230			if lookahead.peek(kw::name) {231				let k = input.parse::<kw::name>()?;232				input.parse::<Token![=]>()?;233				if name.replace(input.parse::<Ident>()?).is_some() {234					return Err(syn::Error::new(k.span(), "name is already set"));235				}236			} else if lookahead.peek(kw::is) {237				let k = input.parse::<kw::is>()?;238				let contents;239				parenthesized!(contents in input);240				if is.replace(contents.parse::<IsList>()?).is_some() {241					return Err(syn::Error::new(k.span(), "is is already set"));242				}243			} else if lookahead.peek(kw::inline_is) {244				let k = input.parse::<kw::inline_is>()?;245				let contents;246				parenthesized!(contents in input);247				if inline_is.replace(contents.parse::<IsList>()?).is_some() {248					return Err(syn::Error::new(k.span(), "inline_is is already set"));249				}250			} else if lookahead.peek(kw::events) {251				let k = input.parse::<kw::events>()?;252				let contents;253				parenthesized!(contents in input);254				if events.replace(contents.parse::<IsList>()?).is_some() {255					return Err(syn::Error::new(k.span(), "events is already set"));256				}257			} else if lookahead.peek(kw::expect_selector) {258				let k = input.parse::<kw::expect_selector>()?;259				input.parse::<Token![=]>()?;260				let value = input.parse::<LitInt>()?;261				if expect_selector262					.replace(value.base10_parse::<u32>()?)263					.is_some()264				{265					return Err(syn::Error::new(k.span(), "expect_selector is already set"));266				}267			} else if input.is_empty() {268				break;269			} else {270				return Err(lookahead.error());271			}272			if input.peek(Token![,]) {273				input.parse::<Token![,]>()?;274			} else {275				break;276			}277		}278		Ok(Self {279			name: name.ok_or_else(|| syn::Error::new(input.span(), "missing name"))?,280			is: is.unwrap_or_default(),281			inline_is: inline_is.unwrap_or_default(),282			events: events.unwrap_or_default(),283			expect_selector,284		})285	}286}287288struct MethodInfo {289	rename_selector: Option<String>,290}291impl Parse for MethodInfo {292	fn parse(input: ParseStream) -> syn::Result<Self> {293		let mut rename_selector = None;294		let lookahead = input.lookahead1();295		if lookahead.peek(kw::rename_selector) {296			let k = input.parse::<kw::rename_selector>()?;297			input.parse::<Token![=]>()?;298			if rename_selector299				.replace(input.parse::<LitStr>()?.value())300				.is_some()301			{302				return Err(syn::Error::new(k.span(), "rename_selector is already set"));303			}304		}305		Ok(Self { rename_selector })306	}307}308309enum AbiType {310	// type311	Plain(Ident),312	// (type1,type2)313	Tuple(Vec<AbiType>),314	// type[]315	Vec(Box<AbiType>),316	// type[20]317	Array(Box<AbiType>, usize),318}319impl AbiType {320	fn try_from(value: &Type) -> syn::Result<Self> {321		let value = Self::try_maybe_special_from(value)?;322		if value.is_special() {323			return Err(syn::Error::new(value.span(), "unexpected special type"));324		}325		Ok(value)326	}327	fn try_maybe_special_from(value: &Type) -> syn::Result<Self> {328		match value {329			Type::Array(arr) => {330				let wrapped = AbiType::try_from(&arr.elem)?;331				match &arr.len {332					Expr::Lit(l) => match &l.lit {333						Lit::Int(i) => {334							let num = i.base10_parse::<usize>()?;335							Ok(AbiType::Array(Box::new(wrapped), num as usize))336						}337						_ => Err(syn::Error::new(arr.len.span(), "should be int literal")),338					},339					_ => Err(syn::Error::new(arr.len.span(), "should be literal")),340				}341			}342			Type::Path(_) => {343				let path = parse_path(value)?;344				let segment = parse_path_segment(path)?;345				if segment.ident == "Vec" {346					let args = match &segment.arguments {347						PathArguments::AngleBracketed(e) => e,348						_ => {349							return Err(syn::Error::new(350								segment.arguments.span(),351								"missing Vec generic",352							))353						}354					};355					let args = &args.args;356					if args.len() != 1 {357						return Err(syn::Error::new(358							args.span(),359							"expected only one generic for vec",360						));361					}362					let arg = args.first().expect("first arg");363364					let ty = match arg {365						GenericArgument::Type(ty) => ty,366						_ => {367							return Err(syn::Error::new(368								arg.span(),369								"expected first generic to be type",370							))371						}372					};373374					let wrapped = AbiType::try_from(ty)?;375					Ok(Self::Vec(Box::new(wrapped)))376				} else {377					if !segment.arguments.is_empty() {378						return Err(syn::Error::new(379							segment.arguments.span(),380							"unexpected generic arguments for non-vec type",381						));382					}383					Ok(Self::Plain(segment.ident.clone()))384				}385			}386			Type::Tuple(t) => {387				let mut out = Vec::with_capacity(t.elems.len());388				for el in t.elems.iter() {389					out.push(AbiType::try_from(el)?)390				}391				Ok(Self::Tuple(out))392			}393			_ => Err(syn::Error::new(394				value.span(),395				"unexpected type, only arrays, plain types and tuples are supported",396			)),397		}398	}399	fn is_value(&self) -> bool {400		matches!(self, Self::Plain(v) if v == "value")401	}402	fn is_caller(&self) -> bool {403		matches!(self, Self::Plain(v) if v == "caller")404	}405	fn is_special(&self) -> bool {406		self.is_caller() || self.is_value()407	}408	fn selector_ty_buf(&self, buf: &mut String) -> std::fmt::Result {409		match self {410			AbiType::Plain(t) => {411				write!(buf, "{}", t)412			}413			AbiType::Tuple(t) => {414				write!(buf, "(")?;415				for (i, t) in t.iter().enumerate() {416					if i != 0 {417						write!(buf, ",")?;418					}419					t.selector_ty_buf(buf)?;420				}421				write!(buf, ")")422			}423			AbiType::Vec(v) => {424				v.selector_ty_buf(buf)?;425				write!(buf, "[]")426			}427			AbiType::Array(v, len) => {428				v.selector_ty_buf(buf)?;429				write!(buf, "[{}]", len)430			}431		}432	}433	fn selector_ty(&self) -> String {434		let mut out = String::new();435		self.selector_ty_buf(&mut out).expect("no fmt error");436		out437	}438}439impl ToTokens for AbiType {440	fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {441		match self {442			AbiType::Plain(t) => tokens.extend(quote! {#t}),443			AbiType::Tuple(t) => {444				tokens.extend(quote! {(445					#(#t),*446				)});447			}448			AbiType::Vec(v) => tokens.extend(quote! {Vec<#v>}),449			AbiType::Array(v, l) => tokens.extend(quote! {[#v; #l]}),450		}451	}452}453454struct MethodArg {455	name: Ident,456	camel_name: String,457	ty: AbiType,458}459impl MethodArg {460	fn try_from(value: &PatType) -> syn::Result<Self> {461		let name = parse_ident_from_pat(&value.pat)?.clone();462		Ok(Self {463			camel_name: cases::camelcase::to_camel_case(&name.to_string()),464			name,465			ty: AbiType::try_maybe_special_from(&value.ty)?,466		})467	}468	fn is_value(&self) -> bool {469		self.ty.is_value()470	}471	fn is_caller(&self) -> bool {472		self.ty.is_caller()473	}474	fn is_special(&self) -> bool {475		self.ty.is_special()476	}477	fn selector_ty(&self) -> String {478		assert!(!self.is_special());479		self.ty.selector_ty()480	}481482	fn expand_call_def(&self) -> proc_macro2::TokenStream {483		assert!(!self.is_special());484		let name = &self.name;485		let ty = &self.ty;486487		quote! {488			#name: #ty489		}490	}491492	fn expand_parse(&self) -> proc_macro2::TokenStream {493		assert!(!self.is_special());494		let name = &self.name;495		quote! {496			#name: reader.abi_read()?497		}498	}499500	fn expand_call_arg(&self) -> proc_macro2::TokenStream {501		if self.is_value() {502			quote! {503				c.value.clone()504			}505		} else if self.is_caller() {506			quote! {507				c.caller.clone()508			}509		} else {510			let name = &self.name;511			quote! {512				#name513			}514		}515	}516517	fn expand_solidity_argument(&self) -> proc_macro2::TokenStream {518		let camel_name = &self.camel_name.to_string();519		let ty = &self.ty;520		quote! {521			<NamedArgument<#ty>>::new(#camel_name)522		}523	}524}525526#[derive(PartialEq)]527enum Mutability {528	Mutable,529	View,530	Pure,531}532533/// Group all keywords for this macro. Usage example:534/// #[solidity_interface(name = "B", inline_is(A))]535mod kw {536	syn::custom_keyword!(weight);537538	syn::custom_keyword!(via);539	syn::custom_keyword!(returns);540	syn::custom_keyword!(name);541	syn::custom_keyword!(is);542	syn::custom_keyword!(inline_is);543	syn::custom_keyword!(events);544	syn::custom_keyword!(expect_selector);545546	syn::custom_keyword!(rename_selector);547}548549/// Rust methods are parsed into this structure when Solidity code is generated550struct Method {551	name: Ident,552	camel_name: String,553	pascal_name: Ident,554	screaming_name: Ident,555	selector_str: String,556	selector: u32,557	args: Vec<MethodArg>,558	has_normal_args: bool,559	mutability: Mutability,560	result: Type,561	weight: Option<Expr>,562	docs: Vec<String>,563}564impl Method {565	fn try_from(value: &ImplItemMethod) -> syn::Result<Self> {566		let mut info = MethodInfo {567			rename_selector: None,568		};569		let mut docs = Vec::new();570		let mut weight = None;571		for attr in &value.attrs {572			let ident = parse_ident_from_path(&attr.path, false)?;573			if ident == "solidity" {574				info = attr.parse_args::<MethodInfo>()?;575			} else if ident == "doc" {576				let args = attr.parse_meta().unwrap();577				let value = match args {578					Meta::NameValue(MetaNameValue {579						lit: Lit::Str(str), ..580					}) => str.value(),581					_ => unreachable!(),582				};583				docs.push(value);584			} else if ident == "weight" {585				weight = Some(attr.parse_args::<Expr>()?);586			}587		}588		let ident = &value.sig.ident;589		let ident_str = ident.to_string();590		if !cases::snakecase::is_snake_case(&ident_str) {591			return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));592		}593594		let mut mutability = Mutability::Pure;595596		if let Some(FnArg::Receiver(receiver)) = value597			.sig598			.inputs599			.iter()600			.find(|arg| matches!(arg, FnArg::Receiver(_)))601		{602			if receiver.reference.is_none() {603				return Err(syn::Error::new(604					receiver.span(),605					"receiver should be by ref",606				));607			}608			if receiver.mutability.is_some() {609				mutability = Mutability::Mutable;610			} else {611				mutability = Mutability::View;612			}613		}614		let mut args = Vec::new();615		for typ in value616			.sig617			.inputs618			.iter()619			.filter(|arg| matches!(arg, FnArg::Typed(_)))620		{621			let typ = match typ {622				FnArg::Typed(typ) => typ,623				_ => unreachable!(),624			};625			args.push(MethodArg::try_from(typ)?);626		}627628		if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {629			return Err(syn::Error::new(630				args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),631				"payable function should be mutable",632			));633		}634635		let result = match &value.sig.output {636			ReturnType::Type(_, ty) => ty,637			_ => 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)")),638		};639		let result = parse_result_ok(result)?;640641		let camel_name = info642			.rename_selector643			.unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));644		let mut selector_str = camel_name.clone();645		selector_str.push('(');646		let mut has_normal_args = false;647		for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {648			if i != 0 {649				selector_str.push(',');650			}651			write!(selector_str, "{}", arg.selector_ty()).unwrap();652			has_normal_args = true;653		}654		selector_str.push(')');655		let selector = fn_selector_str(&selector_str);656657		Ok(Self {658			name: ident.clone(),659			camel_name,660			pascal_name: snake_ident_to_pascal(ident),661			screaming_name: snake_ident_to_screaming(ident),662			selector_str,663			selector,664			args,665			has_normal_args,666			mutability,667			result: result.clone(),668			weight,669			docs,670		})671	}672	fn expand_call_def(&self) -> proc_macro2::TokenStream {673		let defs = self674			.args675			.iter()676			.filter(|a| !a.is_special())677			.map(|a| a.expand_call_def());678		let pascal_name = &self.pascal_name;679		let docs = &self.docs;680681		if self.has_normal_args {682			quote! {683				#(#[doc = #docs])*684				#[allow(missing_docs)]685				#pascal_name {686					#(687						#defs,688					)*689				}690			}691		} else {692			quote! {#pascal_name}693		}694	}695696	fn expand_const(&self) -> proc_macro2::TokenStream {697		let screaming_name = &self.screaming_name;698		let selector = u32::to_be_bytes(self.selector);699		let selector_str = &self.selector_str;700		quote! {701			#[doc = #selector_str]702			const #screaming_name: ::evm_coder::types::bytes4 = [#(#selector,)*];703		}704	}705706	fn expand_interface_id(&self) -> proc_macro2::TokenStream {707		let screaming_name = &self.screaming_name;708		quote! {709			interface_id ^= u32::from_be_bytes(Self::#screaming_name);710		}711	}712713	fn expand_parse(&self) -> proc_macro2::TokenStream {714		let pascal_name = &self.pascal_name;715		let screaming_name = &self.screaming_name;716		if self.has_normal_args {717			let parsers = self718				.args719				.iter()720				.filter(|a| !a.is_special())721				.map(|a| a.expand_parse());722			quote! {723				Self::#screaming_name => return Ok(Some(Self::#pascal_name {724					#(725						#parsers,726					)*727				}))728			}729		} else {730			quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }731		}732	}733734	fn expand_variant_call(&self, call_name: &proc_macro2::Ident) -> proc_macro2::TokenStream {735		let pascal_name = &self.pascal_name;736		let name = &self.name;737738		let matcher = if self.has_normal_args {739			let names = self740				.args741				.iter()742				.filter(|a| !a.is_special())743				.map(|a| &a.name);744745			quote! {{746				#(747					#names,748				)*749			}}750		} else {751			quote! {}752		};753754		let receiver = match self.mutability {755			Mutability::Mutable | Mutability::View => quote! {self.},756			Mutability::Pure => quote! {Self::},757		};758		let args = self.args.iter().map(|a| a.expand_call_arg());759760		quote! {761			#call_name::#pascal_name #matcher => {762				let result = #receiver #name(763					#(764						#args,765					)*766				)?;767				(&result).to_result()768			}769		}770	}771772	fn expand_variant_weight(&self) -> proc_macro2::TokenStream {773		let pascal_name = &self.pascal_name;774		if let Some(weight) = &self.weight {775			let matcher = if self.has_normal_args {776				let names = self777					.args778					.iter()779					.filter(|a| !a.is_special())780					.map(|a| &a.name);781782				quote! {{783					#(784						#names,785					)*786				}}787			} else {788				quote! {}789			};790			quote! {791				Self::#pascal_name #matcher => (#weight).into()792			}793		} else {794			let matcher = if self.has_normal_args {795				quote! {{..}}796			} else {797				quote! {}798			};799			quote! {800				Self::#pascal_name #matcher => ().into()801			}802		}803	}804805	fn expand_solidity_function(&self) -> proc_macro2::TokenStream {806		let camel_name = &self.camel_name;807		let mutability = match self.mutability {808			Mutability::Mutable => quote! {SolidityMutability::Mutable},809			Mutability::View => quote! { SolidityMutability::View },810			Mutability::Pure => quote! {SolidityMutability::Pure},811		};812		let result = &self.result;813814		let args = self815			.args816			.iter()817			.filter(|a| !a.is_special())818			.map(MethodArg::expand_solidity_argument);819		let docs = &self.docs;820		let selector_str = &self.selector_str;821		let selector = self.selector;822823		quote! {824			SolidityFunction {825				docs: &[#(#docs),*],826				selector_str: #selector_str,827				selector: #selector,828				name: #camel_name,829				mutability: #mutability,830				args: (831					#(832						#args,833					)*834				),835				result: <UnnamedArgument<#result>>::default(),836			}837		}838	}839}840841fn generics_list(gen: &Generics) -> proc_macro2::TokenStream {842	if gen.params.is_empty() {843		return quote! {};844	}845	let params = gen.params.iter().map(|p| match p {846		syn::GenericParam::Type(id) => {847			let v = &id.ident;848			quote! {#v}849		}850		syn::GenericParam::Lifetime(lt) => {851			let v = &lt.lifetime;852			quote! {#v}853		}854		syn::GenericParam::Const(c) => {855			let i = &c.ident;856			quote! {#i}857		}858	});859	quote! { #(#params),* }860}861fn generics_reference(gen: &Generics) -> proc_macro2::TokenStream {862	if gen.params.is_empty() {863		return quote! {};864	}865	let list = generics_list(gen);866	quote! { <#list> }867}868fn generics_data(gen: &Generics) -> proc_macro2::TokenStream {869	let list = generics_list(gen);870	if gen.params.len() == 1 {871		quote! {#list}872	} else {873		quote! { (#list) }874	}875}876877pub struct SolidityInterface {878	generics: Generics,879	name: Box<syn::Type>,880	info: InterfaceInfo,881	methods: Vec<Method>,882	docs: Vec<String>,883}884impl SolidityInterface {885	pub fn try_from(info: InterfaceInfo, value: &ItemImpl) -> syn::Result<Self> {886		let mut methods = Vec::new();887888		for item in &value.items {889			if let ImplItem::Method(method) = item {890				methods.push(Method::try_from(method)?)891			}892		}893		let mut docs = vec![];894		for attr in &value.attrs {895			let ident = parse_ident_from_path(&attr.path, false)?;896			if ident == "doc" {897				let args = attr.parse_meta().unwrap();898				let value = match args {899					Meta::NameValue(MetaNameValue {900						lit: Lit::Str(str), ..901					}) => str.value(),902					_ => unreachable!(),903				};904				docs.push(value);905			}906		}907		Ok(Self {908			generics: value.generics.clone(),909			name: value.self_ty.clone(),910			info,911			methods,912			docs,913		})914	}915	pub fn expand(self) -> proc_macro2::TokenStream {916		let name = self.name;917918		let solidity_name = self.info.name.to_string();919		let call_name = pascal_ident_to_call(&self.info.name);920		let generics = self.generics;921		let gen_ref = generics_reference(&generics);922		let gen_data = generics_data(&generics);923		let gen_where = &generics.where_clause;924925		let call_sub = self926			.info927			.inline_is928			.0929			.iter()930			.chain(self.info.is.0.iter())931			.map(|c| Is::expand_call_def(c, &gen_ref));932		let call_parse = self933			.info934			.inline_is935			.0936			.iter()937			.chain(self.info.is.0.iter())938			.map(|is| Is::expand_parse(is, &gen_ref));939		let call_variants = self940			.info941			.inline_is942			.0943			.iter()944			.chain(self.info.is.0.iter())945			.map(|c| Is::expand_variant_call(c, &call_name, &gen_ref));946		let weight_variants = self947			.info948			.inline_is949			.0950			.iter()951			.chain(self.info.is.0.iter())952			.map(Is::expand_variant_weight);953954		let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);955		let supports_interface = self956			.info957			.is958			.0959			.iter()960			.map(|is| Is::expand_supports_interface(is, &gen_ref));961962		let calls = self.methods.iter().map(Method::expand_call_def);963		let consts = self.methods.iter().map(Method::expand_const);964		let interface_id = self.methods.iter().map(Method::expand_interface_id);965		let parsers = self.methods.iter().map(Method::expand_parse);966		let call_variants_this = self967			.methods968			.iter()969			.map(|m| Method::expand_variant_call(m, &call_name));970		let weight_variants_this = self.methods.iter().map(Method::expand_variant_weight);971		let solidity_functions = self.methods.iter().map(Method::expand_solidity_function);972973		// TODO: Inline inline_is974		let solidity_is = self975			.info976			.is977			.0978			.iter()979			.chain(self.info.inline_is.0.iter())980			.map(|is| is.name.to_string());981		let solidity_events_is = self.info.events.0.iter().map(|is| is.name.to_string());982		let solidity_generators = self983			.info984			.is985			.0986			.iter()987			.chain(self.info.inline_is.0.iter())988			.map(|is| Is::expand_generator(is, &gen_ref));989		let solidity_event_generators = self.info.events.0.iter().map(Is::expand_event_generator);990991		let docs = &self.docs;992993		if let Some(expect_selector) = &self.info.expect_selector {994			if !self.info.inline_is.0.is_empty() {995				return syn::Error::new(996					name.span(),997					"expect_selector is not compatible with inline_is",998				)999				.to_compile_error();1000			}1001			let selector = self1002				.methods1003				.iter()1004				.map(|m| m.selector)1005				.fold(0, |a, b| a ^ b);10061007			if *expect_selector != selector {1008				let mut methods = String::new();1009				for meth in self.methods.iter() {1010					write!(methods, "\n- {}", meth.selector_str).expect("write to string");1011				}1012				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();1013			}1014		}1015		// let methods = self.methods.iter().map(Method::solidity_def);10161017		quote! {1018			#[derive(Debug)]1019			#(#[doc = #docs])*1020			pub enum #call_name #gen_ref {1021				/// Inherited method1022				ERC165Call(::evm_coder::ERC165Call, ::core::marker::PhantomData<#gen_data>),1023				#(1024					#calls,1025				)*1026				#(1027					#call_sub,1028				)*1029			}1030			impl #gen_ref #call_name #gen_ref {1031				#(1032					#consts1033				)*1034				/// Return this call ERC165 selector1035				pub fn interface_id() -> ::evm_coder::types::bytes4 {1036					let mut interface_id = 0;1037					#(#interface_id)*1038					#(#inline_interface_id)*1039					u32::to_be_bytes(interface_id)1040				}1041				/// Generate solidity definitions for methods described in this interface1042				pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {1043					use evm_coder::solidity::*;1044					use core::fmt::Write;1045					let interface = SolidityInterface {1046						docs: &[#(#docs),*],1047						name: #solidity_name,1048						selector: Self::interface_id(),1049						is: &["Dummy", "ERC165", #(1050							#solidity_is,1051						)* #(1052							#solidity_events_is,1053						)* ],1054						functions: (#(1055							#solidity_functions,1056						)*),1057					};10581059					let mut out = ::evm_coder::types::string::new();1060					if #solidity_name.starts_with("Inline") {1061						out.push_str("/// @dev inlined interface\n");1062					}1063					let _ = interface.format(is_impl, &mut out, tc);1064					tc.collect(out);1065					#(1066						#solidity_event_generators1067					)*1068					#(1069						#solidity_generators1070					)*1071					if is_impl {1072						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());1073					} else {1074						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());1075					}1076				}1077			}1078			impl #gen_ref ::evm_coder::Call for #call_name #gen_ref {1079				fn parse(method_id: ::evm_coder::types::bytes4, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {1080					use ::evm_coder::abi::AbiRead;1081					match method_id {1082						::evm_coder::ERC165Call::INTERFACE_ID => return Ok(1083							::evm_coder::ERC165Call::parse(method_id, reader)?1084							.map(|c| Self::ERC165Call(c, ::core::marker::PhantomData))1085						),1086						#(1087							#parsers,1088						)*1089						_ => {},1090					}1091					#(1092						#call_parse1093					)else*1094					return Ok(None);1095				}1096			}1097			impl #generics #call_name #gen_ref1098			#gen_where1099			{1100				/// Is this contract implements specified ERC165 selector1101				pub fn supports_interface(this: &#name, interface_id: ::evm_coder::types::bytes4) -> bool {1102					interface_id != u32::to_be_bytes(0xffffff) && (1103						interface_id == ::evm_coder::ERC165Call::INTERFACE_ID ||1104						interface_id == Self::interface_id()1105						#(1106							|| #supports_interface1107						)*1108					)1109				}1110			}1111			impl #generics ::evm_coder::Weighted for #call_name #gen_ref1112			#gen_where1113			{1114				#[allow(unused_variables)]1115				fn weight(&self) -> ::evm_coder::execution::DispatchInfo {1116					match self {1117						#(1118							#weight_variants,1119						)*1120						// TODO: It should be very cheap, but not free1121						Self::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {..}, _) => 100u64.into(),1122						#(1123							#weight_variants_this,1124						)*1125					}1126				}1127			}1128			impl #generics ::evm_coder::Callable<#call_name #gen_ref> for #name1129			#gen_where1130			{1131				#[allow(unreachable_code)] // In case of no inner calls1132				fn call(&mut self, c: Msg<#call_name #gen_ref>) -> ::evm_coder::execution::ResultWithPostInfo<::evm_coder::abi::AbiWriter> {1133					use ::evm_coder::abi::AbiWrite;1134					match c.call {1135						#(1136							#call_variants,1137						)*1138						#call_name::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}, _) => {1139							let mut writer = ::evm_coder::abi::AbiWriter::default();1140							writer.bool(&<#call_name #gen_ref>::supports_interface(self, interface_id));1141							return Ok(writer.into());1142						}1143						_ => {},1144					}1145					let mut writer = ::evm_coder::abi::AbiWriter::default();1146					match c.call {1147						#(1148							#call_variants_this,1149						)*1150						_ => Err(::evm_coder::execution::Error::from("method is not available").into()),1151					}1152				}1153			}1154		}1155	}1156}