difftreelog
fix deny comma absence between if/via
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 while !input.is_empty() {162 let lookahead = input.lookahead1();163 if lookahead.peek(Token![if]) {164 input.parse::<Token![if]>()?;165 let contents;166 parenthesized!(contents in input);167 let contents = contents.parse::<Expr>()?;168169 if condition.replace(contents).is_some() {170 return Err(syn::Error::new(input.span(), "condition is already set"));171 }172 } else if lookahead.peek(kw::via) {173 input.parse::<kw::via>()?;174 let contents;175 parenthesized!(contents in input);176177 let method = contents.parse::<Ident>()?;178 contents.parse::<kw::returns>()?;179 let ty = contents.parse::<Type>()?;180181 if via.replace((ty, method)).is_some() {182 return Err(syn::Error::new(input.span(), "via is already set"));183 }184 } else {185 return Err(lookahead.error());186 }187188 if input.peek(Token![,]) {189 input.parse::<Token![,]>()?;190 }191 }192 } else if lookahead.peek(Token![,]) || input.is_empty() {193 // Pass194 } else {195 return Err(lookahead.error());196 };197 out.push(Is {198 pascal_call_name: pascal_ident_to_call(&name),199 snake_call_name: pascal_ident_to_snake_call(&name),200 name,201 via,202 condition,203 });204 if input.peek(Token![,]) {205 input.parse::<Token![,]>()?;206 continue;207 } else {208 break;209 }210 }211 Ok(Self(out))212 }213}214215pub struct InterfaceInfo {216 name: Ident,217 is: IsList,218 inline_is: IsList,219 events: IsList,220 expect_selector: Option<u32>,221}222impl Parse for InterfaceInfo {223 fn parse(input: ParseStream) -> syn::Result<Self> {224 let mut name = None;225 let mut is = None;226 let mut inline_is = None;227 let mut events = None;228 let mut expect_selector = None;229 // TODO: create proc-macro to optimize proc-macro boilerplate? :D230 loop {231 let lookahead = input.lookahead1();232 if lookahead.peek(kw::name) {233 let k = input.parse::<kw::name>()?;234 input.parse::<Token![=]>()?;235 if name.replace(input.parse::<Ident>()?).is_some() {236 return Err(syn::Error::new(k.span(), "name is already set"));237 }238 } else if lookahead.peek(kw::is) {239 let k = input.parse::<kw::is>()?;240 let contents;241 parenthesized!(contents in input);242 if is.replace(contents.parse::<IsList>()?).is_some() {243 return Err(syn::Error::new(k.span(), "is is already set"));244 }245 } else if lookahead.peek(kw::inline_is) {246 let k = input.parse::<kw::inline_is>()?;247 let contents;248 parenthesized!(contents in input);249 if inline_is.replace(contents.parse::<IsList>()?).is_some() {250 return Err(syn::Error::new(k.span(), "inline_is is already set"));251 }252 } else if lookahead.peek(kw::events) {253 let k = input.parse::<kw::events>()?;254 let contents;255 parenthesized!(contents in input);256 if events.replace(contents.parse::<IsList>()?).is_some() {257 return Err(syn::Error::new(k.span(), "events is already set"));258 }259 } else if lookahead.peek(kw::expect_selector) {260 let k = input.parse::<kw::expect_selector>()?;261 input.parse::<Token![=]>()?;262 let value = input.parse::<LitInt>()?;263 if expect_selector264 .replace(value.base10_parse::<u32>()?)265 .is_some()266 {267 return Err(syn::Error::new(k.span(), "expect_selector is already set"));268 }269 } else if input.is_empty() {270 break;271 } else {272 return Err(lookahead.error());273 }274 if input.peek(Token![,]) {275 input.parse::<Token![,]>()?;276 } else {277 break;278 }279 }280 Ok(Self {281 name: name.ok_or_else(|| syn::Error::new(input.span(), "missing name"))?,282 is: is.unwrap_or_default(),283 inline_is: inline_is.unwrap_or_default(),284 events: events.unwrap_or_default(),285 expect_selector,286 })287 }288}289290struct MethodInfo {291 rename_selector: Option<String>,292}293impl Parse for MethodInfo {294 fn parse(input: ParseStream) -> syn::Result<Self> {295 let mut rename_selector = None;296 let lookahead = input.lookahead1();297 if lookahead.peek(kw::rename_selector) {298 let k = input.parse::<kw::rename_selector>()?;299 input.parse::<Token![=]>()?;300 if rename_selector301 .replace(input.parse::<LitStr>()?.value())302 .is_some()303 {304 return Err(syn::Error::new(k.span(), "rename_selector is already set"));305 }306 }307 Ok(Self { rename_selector })308 }309}310311enum AbiType {312 // type313 Plain(Ident),314 // (type1,type2)315 Tuple(Vec<AbiType>),316 // type[]317 Vec(Box<AbiType>),318 // type[20]319 Array(Box<AbiType>, usize),320}321impl AbiType {322 fn try_from(value: &Type) -> syn::Result<Self> {323 let value = Self::try_maybe_special_from(value)?;324 if value.is_special() {325 return Err(syn::Error::new(value.span(), "unexpected special type"));326 }327 Ok(value)328 }329 fn try_maybe_special_from(value: &Type) -> syn::Result<Self> {330 match value {331 Type::Array(arr) => {332 let wrapped = AbiType::try_from(&arr.elem)?;333 match &arr.len {334 Expr::Lit(l) => match &l.lit {335 Lit::Int(i) => {336 let num = i.base10_parse::<usize>()?;337 Ok(AbiType::Array(Box::new(wrapped), num as usize))338 }339 _ => Err(syn::Error::new(arr.len.span(), "should be int literal")),340 },341 _ => Err(syn::Error::new(arr.len.span(), "should be literal")),342 }343 }344 Type::Path(_) => {345 let path = parse_path(value)?;346 let segment = parse_path_segment(path)?;347 if segment.ident == "Vec" {348 let args = match &segment.arguments {349 PathArguments::AngleBracketed(e) => e,350 _ => {351 return Err(syn::Error::new(352 segment.arguments.span(),353 "missing Vec generic",354 ))355 }356 };357 let args = &args.args;358 if args.len() != 1 {359 return Err(syn::Error::new(360 args.span(),361 "expected only one generic for vec",362 ));363 }364 let arg = args.first().expect("first arg");365366 let ty = match arg {367 GenericArgument::Type(ty) => ty,368 _ => {369 return Err(syn::Error::new(370 arg.span(),371 "expected first generic to be type",372 ))373 }374 };375376 let wrapped = AbiType::try_from(ty)?;377 Ok(Self::Vec(Box::new(wrapped)))378 } else {379 if !segment.arguments.is_empty() {380 return Err(syn::Error::new(381 segment.arguments.span(),382 "unexpected generic arguments for non-vec type",383 ));384 }385 Ok(Self::Plain(segment.ident.clone()))386 }387 }388 Type::Tuple(t) => {389 let mut out = Vec::with_capacity(t.elems.len());390 for el in t.elems.iter() {391 out.push(AbiType::try_from(el)?)392 }393 Ok(Self::Tuple(out))394 }395 _ => Err(syn::Error::new(396 value.span(),397 "unexpected type, only arrays, plain types and tuples are supported",398 )),399 }400 }401 fn is_value(&self) -> bool {402 matches!(self, Self::Plain(v) if v == "value")403 }404 fn is_caller(&self) -> bool {405 matches!(self, Self::Plain(v) if v == "caller")406 }407 fn is_special(&self) -> bool {408 self.is_caller() || self.is_value()409 }410 fn selector_ty_buf(&self, buf: &mut String) -> std::fmt::Result {411 match self {412 AbiType::Plain(t) => {413 write!(buf, "{}", t)414 }415 AbiType::Tuple(t) => {416 write!(buf, "(")?;417 for (i, t) in t.iter().enumerate() {418 if i != 0 {419 write!(buf, ",")?;420 }421 t.selector_ty_buf(buf)?;422 }423 write!(buf, ")")424 }425 AbiType::Vec(v) => {426 v.selector_ty_buf(buf)?;427 write!(buf, "[]")428 }429 AbiType::Array(v, len) => {430 v.selector_ty_buf(buf)?;431 write!(buf, "[{}]", len)432 }433 }434 }435 fn selector_ty(&self) -> String {436 let mut out = String::new();437 self.selector_ty_buf(&mut out).expect("no fmt error");438 out439 }440}441impl ToTokens for AbiType {442 fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {443 match self {444 AbiType::Plain(t) => tokens.extend(quote! {#t}),445 AbiType::Tuple(t) => {446 tokens.extend(quote! {(447 #(#t),*448 )});449 }450 AbiType::Vec(v) => tokens.extend(quote! {Vec<#v>}),451 AbiType::Array(v, l) => tokens.extend(quote! {[#v; #l]}),452 }453 }454}455456struct MethodArg {457 name: Ident,458 camel_name: String,459 ty: AbiType,460}461impl MethodArg {462 fn try_from(value: &PatType) -> syn::Result<Self> {463 let name = parse_ident_from_pat(&value.pat)?.clone();464 Ok(Self {465 camel_name: cases::camelcase::to_camel_case(&name.to_string()),466 name,467 ty: AbiType::try_maybe_special_from(&value.ty)?,468 })469 }470 fn is_value(&self) -> bool {471 self.ty.is_value()472 }473 fn is_caller(&self) -> bool {474 self.ty.is_caller()475 }476 fn is_special(&self) -> bool {477 self.ty.is_special()478 }479 fn selector_ty(&self) -> String {480 assert!(!self.is_special());481 self.ty.selector_ty()482 }483484 fn expand_call_def(&self) -> proc_macro2::TokenStream {485 assert!(!self.is_special());486 let name = &self.name;487 let ty = &self.ty;488489 quote! {490 #name: #ty491 }492 }493494 fn expand_parse(&self) -> proc_macro2::TokenStream {495 assert!(!self.is_special());496 let name = &self.name;497 quote! {498 #name: reader.abi_read()?499 }500 }501502 fn expand_call_arg(&self) -> proc_macro2::TokenStream {503 if self.is_value() {504 quote! {505 c.value.clone()506 }507 } else if self.is_caller() {508 quote! {509 c.caller.clone()510 }511 } else {512 let name = &self.name;513 quote! {514 #name515 }516 }517 }518519 fn expand_solidity_argument(&self) -> proc_macro2::TokenStream {520 let camel_name = &self.camel_name.to_string();521 let ty = &self.ty;522 quote! {523 <NamedArgument<#ty>>::new(#camel_name)524 }525 }526}527528#[derive(PartialEq)]529enum Mutability {530 Mutable,531 View,532 Pure,533}534535/// Group all keywords for this macro. Usage example:536/// #[solidity_interface(name = "B", inline_is(A))]537mod kw {538 syn::custom_keyword!(weight);539540 syn::custom_keyword!(via);541 syn::custom_keyword!(returns);542 syn::custom_keyword!(name);543 syn::custom_keyword!(is);544 syn::custom_keyword!(inline_is);545 syn::custom_keyword!(events);546 syn::custom_keyword!(expect_selector);547548 syn::custom_keyword!(rename_selector);549}550551/// Rust methods are parsed into this structure when Solidity code is generated552struct Method {553 name: Ident,554 camel_name: String,555 pascal_name: Ident,556 screaming_name: Ident,557 selector_str: String,558 selector: u32,559 args: Vec<MethodArg>,560 has_normal_args: bool,561 mutability: Mutability,562 result: Type,563 weight: Option<Expr>,564 docs: Vec<String>,565}566impl Method {567 fn try_from(value: &ImplItemMethod) -> syn::Result<Self> {568 let mut info = MethodInfo {569 rename_selector: None,570 };571 let mut docs = Vec::new();572 let mut weight = None;573 for attr in &value.attrs {574 let ident = parse_ident_from_path(&attr.path, false)?;575 if ident == "solidity" {576 info = attr.parse_args::<MethodInfo>()?;577 } else if ident == "doc" {578 let args = attr.parse_meta().unwrap();579 let value = match args {580 Meta::NameValue(MetaNameValue {581 lit: Lit::Str(str), ..582 }) => str.value(),583 _ => unreachable!(),584 };585 docs.push(value);586 } else if ident == "weight" {587 weight = Some(attr.parse_args::<Expr>()?);588 }589 }590 let ident = &value.sig.ident;591 let ident_str = ident.to_string();592 if !cases::snakecase::is_snake_case(&ident_str) {593 return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));594 }595596 let mut mutability = Mutability::Pure;597598 if let Some(FnArg::Receiver(receiver)) = value599 .sig600 .inputs601 .iter()602 .find(|arg| matches!(arg, FnArg::Receiver(_)))603 {604 if receiver.reference.is_none() {605 return Err(syn::Error::new(606 receiver.span(),607 "receiver should be by ref",608 ));609 }610 if receiver.mutability.is_some() {611 mutability = Mutability::Mutable;612 } else {613 mutability = Mutability::View;614 }615 }616 let mut args = Vec::new();617 for typ in value618 .sig619 .inputs620 .iter()621 .filter(|arg| matches!(arg, FnArg::Typed(_)))622 {623 let typ = match typ {624 FnArg::Typed(typ) => typ,625 _ => unreachable!(),626 };627 args.push(MethodArg::try_from(typ)?);628 }629630 if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {631 return Err(syn::Error::new(632 args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),633 "payable function should be mutable",634 ));635 }636637 let result = match &value.sig.output {638 ReturnType::Type(_, ty) => ty,639 _ => 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)")),640 };641 let result = parse_result_ok(result)?;642643 let camel_name = info644 .rename_selector645 .unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));646 let mut selector_str = camel_name.clone();647 selector_str.push('(');648 let mut has_normal_args = false;649 for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {650 if i != 0 {651 selector_str.push(',');652 }653 write!(selector_str, "{}", arg.selector_ty()).unwrap();654 has_normal_args = true;655 }656 selector_str.push(')');657 let selector = fn_selector_str(&selector_str);658659 Ok(Self {660 name: ident.clone(),661 camel_name,662 pascal_name: snake_ident_to_pascal(ident),663 screaming_name: snake_ident_to_screaming(ident),664 selector_str,665 selector,666 args,667 has_normal_args,668 mutability,669 result: result.clone(),670 weight,671 docs,672 })673 }674 fn expand_call_def(&self) -> proc_macro2::TokenStream {675 let defs = self676 .args677 .iter()678 .filter(|a| !a.is_special())679 .map(|a| a.expand_call_def());680 let pascal_name = &self.pascal_name;681 let docs = &self.docs;682683 if self.has_normal_args {684 quote! {685 #(#[doc = #docs])*686 #[allow(missing_docs)]687 #pascal_name {688 #(689 #defs,690 )*691 }692 }693 } else {694 quote! {#pascal_name}695 }696 }697698 fn expand_const(&self) -> proc_macro2::TokenStream {699 let screaming_name = &self.screaming_name;700 let selector = u32::to_be_bytes(self.selector);701 let selector_str = &self.selector_str;702 quote! {703 #[doc = #selector_str]704 const #screaming_name: ::evm_coder::types::bytes4 = [#(#selector,)*];705 }706 }707708 fn expand_interface_id(&self) -> proc_macro2::TokenStream {709 let screaming_name = &self.screaming_name;710 quote! {711 interface_id ^= u32::from_be_bytes(Self::#screaming_name);712 }713 }714715 fn expand_parse(&self) -> proc_macro2::TokenStream {716 let pascal_name = &self.pascal_name;717 let screaming_name = &self.screaming_name;718 if self.has_normal_args {719 let parsers = self720 .args721 .iter()722 .filter(|a| !a.is_special())723 .map(|a| a.expand_parse());724 quote! {725 Self::#screaming_name => return Ok(Some(Self::#pascal_name {726 #(727 #parsers,728 )*729 }))730 }731 } else {732 quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }733 }734 }735736 fn expand_variant_call(&self, call_name: &proc_macro2::Ident) -> proc_macro2::TokenStream {737 let pascal_name = &self.pascal_name;738 let name = &self.name;739740 let matcher = if self.has_normal_args {741 let names = self742 .args743 .iter()744 .filter(|a| !a.is_special())745 .map(|a| &a.name);746747 quote! {{748 #(749 #names,750 )*751 }}752 } else {753 quote! {}754 };755756 let receiver = match self.mutability {757 Mutability::Mutable | Mutability::View => quote! {self.},758 Mutability::Pure => quote! {Self::},759 };760 let args = self.args.iter().map(|a| a.expand_call_arg());761762 quote! {763 #call_name::#pascal_name #matcher => {764 let result = #receiver #name(765 #(766 #args,767 )*768 )?;769 (&result).to_result()770 }771 }772 }773774 fn expand_variant_weight(&self) -> proc_macro2::TokenStream {775 let pascal_name = &self.pascal_name;776 if let Some(weight) = &self.weight {777 let matcher = if self.has_normal_args {778 let names = self779 .args780 .iter()781 .filter(|a| !a.is_special())782 .map(|a| &a.name);783784 quote! {{785 #(786 #names,787 )*788 }}789 } else {790 quote! {}791 };792 quote! {793 Self::#pascal_name #matcher => (#weight).into()794 }795 } else {796 let matcher = if self.has_normal_args {797 quote! {{..}}798 } else {799 quote! {}800 };801 quote! {802 Self::#pascal_name #matcher => ().into()803 }804 }805 }806807 fn expand_solidity_function(&self) -> proc_macro2::TokenStream {808 let camel_name = &self.camel_name;809 let mutability = match self.mutability {810 Mutability::Mutable => quote! {SolidityMutability::Mutable},811 Mutability::View => quote! { SolidityMutability::View },812 Mutability::Pure => quote! {SolidityMutability::Pure},813 };814 let result = &self.result;815816 let args = self817 .args818 .iter()819 .filter(|a| !a.is_special())820 .map(MethodArg::expand_solidity_argument);821 let docs = &self.docs;822 let selector_str = &self.selector_str;823 let selector = self.selector;824825 quote! {826 SolidityFunction {827 docs: &[#(#docs),*],828 selector_str: #selector_str,829 selector: #selector,830 name: #camel_name,831 mutability: #mutability,832 args: (833 #(834 #args,835 )*836 ),837 result: <UnnamedArgument<#result>>::default(),838 }839 }840 }841}842843fn generics_list(gen: &Generics) -> proc_macro2::TokenStream {844 if gen.params.is_empty() {845 return quote! {};846 }847 let params = gen.params.iter().map(|p| match p {848 syn::GenericParam::Type(id) => {849 let v = &id.ident;850 quote! {#v}851 }852 syn::GenericParam::Lifetime(lt) => {853 let v = <.lifetime;854 quote! {#v}855 }856 syn::GenericParam::Const(c) => {857 let i = &c.ident;858 quote! {#i}859 }860 });861 quote! { #(#params),* }862}863fn generics_reference(gen: &Generics) -> proc_macro2::TokenStream {864 if gen.params.is_empty() {865 return quote! {};866 }867 let list = generics_list(gen);868 quote! { <#list> }869}870fn generics_data(gen: &Generics) -> proc_macro2::TokenStream {871 let list = generics_list(gen);872 if gen.params.len() == 1 {873 quote! {#list}874 } else {875 quote! { (#list) }876 }877}878879pub struct SolidityInterface {880 generics: Generics,881 name: Box<syn::Type>,882 info: InterfaceInfo,883 methods: Vec<Method>,884 docs: Vec<String>,885}886impl SolidityInterface {887 pub fn try_from(info: InterfaceInfo, value: &ItemImpl) -> syn::Result<Self> {888 let mut methods = Vec::new();889890 for item in &value.items {891 if let ImplItem::Method(method) = item {892 methods.push(Method::try_from(method)?)893 }894 }895 let mut docs = vec![];896 for attr in &value.attrs {897 let ident = parse_ident_from_path(&attr.path, false)?;898 if ident == "doc" {899 let args = attr.parse_meta().unwrap();900 let value = match args {901 Meta::NameValue(MetaNameValue {902 lit: Lit::Str(str), ..903 }) => str.value(),904 _ => unreachable!(),905 };906 docs.push(value);907 }908 }909 Ok(Self {910 generics: value.generics.clone(),911 name: value.self_ty.clone(),912 info,913 methods,914 docs,915 })916 }917 pub fn expand(self) -> proc_macro2::TokenStream {918 let name = self.name;919920 let solidity_name = self.info.name.to_string();921 let call_name = pascal_ident_to_call(&self.info.name);922 let generics = self.generics;923 let gen_ref = generics_reference(&generics);924 let gen_data = generics_data(&generics);925 let gen_where = &generics.where_clause;926927 let call_sub = self928 .info929 .inline_is930 .0931 .iter()932 .chain(self.info.is.0.iter())933 .map(|c| Is::expand_call_def(c, &gen_ref));934 let call_parse = self935 .info936 .inline_is937 .0938 .iter()939 .chain(self.info.is.0.iter())940 .map(|is| Is::expand_parse(is, &gen_ref));941 let call_variants = self942 .info943 .inline_is944 .0945 .iter()946 .chain(self.info.is.0.iter())947 .map(|c| Is::expand_variant_call(c, &call_name, &gen_ref));948 let weight_variants = self949 .info950 .inline_is951 .0952 .iter()953 .chain(self.info.is.0.iter())954 .map(Is::expand_variant_weight);955956 let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);957 let supports_interface = self958 .info959 .is960 .0961 .iter()962 .map(|is| Is::expand_supports_interface(is, &gen_ref));963964 let calls = self.methods.iter().map(Method::expand_call_def);965 let consts = self.methods.iter().map(Method::expand_const);966 let interface_id = self.methods.iter().map(Method::expand_interface_id);967 let parsers = self.methods.iter().map(Method::expand_parse);968 let call_variants_this = self969 .methods970 .iter()971 .map(|m| Method::expand_variant_call(m, &call_name));972 let weight_variants_this = self.methods.iter().map(Method::expand_variant_weight);973 let solidity_functions = self.methods.iter().map(Method::expand_solidity_function);974975 // TODO: Inline inline_is976 let solidity_is = self977 .info978 .is979 .0980 .iter()981 .chain(self.info.inline_is.0.iter())982 .map(|is| is.name.to_string());983 let solidity_events_is = self.info.events.0.iter().map(|is| is.name.to_string());984 let solidity_generators = self985 .info986 .is987 .0988 .iter()989 .chain(self.info.inline_is.0.iter())990 .map(|is| Is::expand_generator(is, &gen_ref));991 let solidity_event_generators = self.info.events.0.iter().map(Is::expand_event_generator);992993 let docs = &self.docs;994995 if let Some(expect_selector) = &self.info.expect_selector {996 if !self.info.inline_is.0.is_empty() {997 return syn::Error::new(998 name.span(),999 "expect_selector is not compatible with inline_is",1000 )1001 .to_compile_error();1002 }1003 let selector = self1004 .methods1005 .iter()1006 .map(|m| m.selector)1007 .fold(0, |a, b| a ^ b);10081009 if *expect_selector != selector {1010 let mut methods = String::new();1011 for meth in self.methods.iter() {1012 write!(methods, "\n- {}", meth.selector_str).expect("write to string");1013 }1014 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();1015 }1016 }1017 // let methods = self.methods.iter().map(Method::solidity_def);10181019 quote! {1020 #[derive(Debug)]1021 #(#[doc = #docs])*1022 pub enum #call_name #gen_ref {1023 /// Inherited method1024 ERC165Call(::evm_coder::ERC165Call, ::core::marker::PhantomData<#gen_data>),1025 #(1026 #calls,1027 )*1028 #(1029 #call_sub,1030 )*1031 }1032 impl #gen_ref #call_name #gen_ref {1033 #(1034 #consts1035 )*1036 /// Return this call ERC165 selector1037 pub fn interface_id() -> ::evm_coder::types::bytes4 {1038 let mut interface_id = 0;1039 #(#interface_id)*1040 #(#inline_interface_id)*1041 u32::to_be_bytes(interface_id)1042 }1043 /// Generate solidity definitions for methods described in this interface1044 pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {1045 use evm_coder::solidity::*;1046 use core::fmt::Write;1047 let interface = SolidityInterface {1048 docs: &[#(#docs),*],1049 name: #solidity_name,1050 selector: Self::interface_id(),1051 is: &["Dummy", "ERC165", #(1052 #solidity_is,1053 )* #(1054 #solidity_events_is,1055 )* ],1056 functions: (#(1057 #solidity_functions,1058 )*),1059 };10601061 let mut out = ::evm_coder::types::string::new();1062 if #solidity_name.starts_with("Inline") {1063 out.push_str("/// @dev inlined interface\n");1064 }1065 let _ = interface.format(is_impl, &mut out, tc);1066 tc.collect(out);1067 #(1068 #solidity_event_generators1069 )*1070 #(1071 #solidity_generators1072 )*1073 if is_impl {1074 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());1075 } else {1076 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());1077 }1078 }1079 }1080 impl #gen_ref ::evm_coder::Call for #call_name #gen_ref {1081 fn parse(method_id: ::evm_coder::types::bytes4, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {1082 use ::evm_coder::abi::AbiRead;1083 match method_id {1084 ::evm_coder::ERC165Call::INTERFACE_ID => return Ok(1085 ::evm_coder::ERC165Call::parse(method_id, reader)?1086 .map(|c| Self::ERC165Call(c, ::core::marker::PhantomData))1087 ),1088 #(1089 #parsers,1090 )*1091 _ => {},1092 }1093 #(1094 #call_parse1095 )else*1096 return Ok(None);1097 }1098 }1099 impl #generics #call_name #gen_ref1100 #gen_where1101 {1102 /// Is this contract implements specified ERC165 selector1103 pub fn supports_interface(this: &#name, interface_id: ::evm_coder::types::bytes4) -> bool {1104 interface_id != u32::to_be_bytes(0xffffff) && (1105 interface_id == ::evm_coder::ERC165Call::INTERFACE_ID ||1106 interface_id == Self::interface_id()1107 #(1108 || #supports_interface1109 )*1110 )1111 }1112 }1113 impl #generics ::evm_coder::Weighted for #call_name #gen_ref1114 #gen_where1115 {1116 #[allow(unused_variables)]1117 fn weight(&self) -> ::evm_coder::execution::DispatchInfo {1118 match self {1119 #(1120 #weight_variants,1121 )*1122 // TODO: It should be very cheap, but not free1123 Self::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {..}, _) => 100u64.into(),1124 #(1125 #weight_variants_this,1126 )*1127 }1128 }1129 }1130 impl #generics ::evm_coder::Callable<#call_name #gen_ref> for #name1131 #gen_where1132 {1133 #[allow(unreachable_code)] // In case of no inner calls1134 fn call(&mut self, c: Msg<#call_name #gen_ref>) -> ::evm_coder::execution::ResultWithPostInfo<::evm_coder::abi::AbiWriter> {1135 use ::evm_coder::abi::AbiWrite;1136 match c.call {1137 #(1138 #call_variants,1139 )*1140 #call_name::ERC165Call(::evm_coder::ERC165Call::SupportsInterface {interface_id}, _) => {1141 let mut writer = ::evm_coder::abi::AbiWriter::default();1142 writer.bool(&<#call_name #gen_ref>::supports_interface(self, interface_id));1143 return Ok(writer.into());1144 }1145 _ => {},1146 }1147 let mut writer = ::evm_coder::abi::AbiWriter::default();1148 match c.call {1149 #(1150 #call_variants_this,1151 )*1152 _ => Err(::evm_coder::execution::Error::from("method is not available").into()),1153 }1154 }1155 }1156 }1157 }1158}