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