1#![allow(dead_code)]23use quote::quote;4use darling::FromMeta;5use inflector::cases;6use std::fmt::Write;7use syn::{FnArg, Ident, ItemTrait, Meta, NestedMeta, PatType, Path, ReturnType, TraitItem, TraitItemMethod, Type, Visibility, spanned::Spanned};89use crate::{10 fn_selector_str, parse_ident_from_pat, parse_ident_from_path, parse_ident_from_type,11 parse_result_ok, pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,12 snake_ident_to_screaming,13};1415struct Is {16 name: Ident,17 pascal_call_name: Ident,18 snake_call_name: Ident,19}20impl Is {21 fn try_from(path: &Path) -> syn::Result<Self> {22 let name = parse_ident_from_path(path)?.clone();23 Ok(Self {24 pascal_call_name: pascal_ident_to_call(&name),25 snake_call_name: pascal_ident_to_snake_call(&name),26 name,27 })28 }2930 fn expand_call_def(&self) -> proc_macro2::TokenStream {31 let name = &self.name;32 let pascal_call_name = &self.pascal_call_name;33 quote! {34 #name(#pascal_call_name)35 }36 }3738 fn expand_interface_id(&self) -> proc_macro2::TokenStream {39 let pascal_call_name = &self.pascal_call_name;40 quote! {41 interface_id ^= #pascal_call_name::interface_id();42 }43 }4445 fn expand_supports_interface(&self) -> proc_macro2::TokenStream {46 let pascal_call_name = &self.pascal_call_name;47 quote! {48 #pascal_call_name::supports_interface(interface_id)49 }50 }5152 fn expand_variant_call(&self) -> proc_macro2::TokenStream {53 let name = &self.name;54 let snake_call_name = &self.snake_call_name;55 quote! {56 InternalCall::#name(call) => return self.#snake_call_name(Msg {57 call,58 caller: c.caller,59 value: c.value,60 })61 }62 }6364 fn expand_call_inner(&self) -> proc_macro2::TokenStream {65 let snake_call_name = &self.snake_call_name;66 let pascal_call_name = &self.pascal_call_name;67 quote! {68 fn #snake_call_name(&mut self, c: Msg<#pascal_call_name>) -> Result<::evm_coder::abi::AbiWriter>;69 }70 }7172 fn expand_parse(&self) -> proc_macro2::TokenStream {73 let name = &self.name;74 let pascal_call_name = &self.pascal_call_name;75 quote! {76 if let Some(parsed_call) = #pascal_call_name::parse(method_id, reader)? {77 return Ok(Some(Self::#name(parsed_call)))78 }79 }80 }81}8283#[derive(Default)]84struct IsList(Vec<Is>);85impl FromMeta for IsList {86 fn from_list(items: &[NestedMeta]) -> darling::Result<Self> {87 let mut out = Vec::new();88 for item in items {89 match item {90 NestedMeta::Meta(Meta::Path(path)) => out.push(Is::try_from(path)?),91 _ => return Err(syn::Error::new(item.span(), "expected path").into()),92 }93 }94 Ok(Self(out))95 }96}9798#[derive(FromMeta)]99pub struct InterfaceInfo {100 #[darling(default)]101 is: IsList,102 #[darling(default)]103 inline_is: IsList,104 #[darling(default)]105 events: IsList,106}107108#[derive(FromMeta)]109struct MethodInfo {110 #[darling(default)]111 rename_selector: Option<String>,112}113114struct MethodArg {115 name: Ident,116 ty: Ident,117}118impl MethodArg {119 fn try_from(value: &PatType) -> syn::Result<Self> {120 Ok(Self {121 name: parse_ident_from_pat(&value.pat)?.clone(),122 ty: parse_ident_from_type(&value.ty)?.clone(),123 })124 }125 fn is_value(&self) -> bool {126 self.ty == "value"127 }128 fn is_caller(&self) -> bool {129 self.ty == "caller"130 }131 fn is_special(&self) -> bool {132 self.is_value() || self.is_caller()133 }134 fn selector_ty(&self) -> &Ident {135 assert!(!self.is_special());136 &self.ty137 }138139 fn expand_call_def(&self) -> proc_macro2::TokenStream {140 assert!(!self.is_special());141 let name = &self.name;142 let ty = &self.ty;143144 quote! {145 #name: #ty146 }147 }148149 fn expand_parse(&self) -> proc_macro2::TokenStream {150 assert!(!self.is_special());151 let name = &self.name;152 quote! {153 #name: reader.abi_read()?154 }155 }156157 fn expand_call_arg(&self) -> proc_macro2::TokenStream {158 if self.is_value() {159 quote! {160 c.value.clone()161 }162 } else if self.is_caller() {163 quote! {164 c.caller.clone()165 }166 } else {167 let name = &self.name;168 quote! {169 #name170 }171 }172 }173}174175#[derive(PartialEq)]176enum Mutability {177 Mutable,178 View,179 Pure,180}181182struct Method {183 name: Ident,184 camel_name: String,185 pascal_name: Ident,186 screaming_name: Ident,187 selector_str: String,188 selector: u32,189 args: Vec<MethodArg>,190 has_normal_args: bool,191 mutability: Mutability,192 result: Type,193}194impl Method {195 fn try_from(value: &TraitItemMethod) -> syn::Result<Self> {196 let mut info = MethodInfo {197 rename_selector: None,198 };199 for attr in &value.attrs {200 let ident = parse_ident_from_path(&attr.path)?;201 if ident == "solidity" {202 let args = attr.parse_meta().unwrap();203 info = MethodInfo::from_meta(&args).unwrap();204 } else if ident == "doc" {205 206 }207 }208 let ident = &value.sig.ident;209 let ident_str = ident.to_string();210 if !cases::snakecase::is_snake_case(&ident_str) {211 return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));212 }213214 let mut mutability = Mutability::Pure;215216 if let Some(FnArg::Receiver(receiver)) = value217 .sig218 .inputs219 .iter()220 .find(|arg| matches!(arg, FnArg::Receiver(_)))221 {222 if receiver.reference.is_none() {223 return Err(syn::Error::new(224 receiver.span(),225 "receiver should be by ref",226 ));227 }228 if receiver.mutability.is_some() {229 mutability = Mutability::Mutable;230 } else {231 mutability = Mutability::View;232 }233 }234 let mut args = Vec::new();235 for typ in value236 .sig237 .inputs238 .iter()239 .filter(|arg| matches!(arg, FnArg::Typed(_)))240 {241 let typ = match typ {242 FnArg::Typed(typ) => typ,243 _ => unreachable!(),244 };245 args.push(MethodArg::try_from(typ)?);246 }247248 if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {249 return Err(syn::Error::new(250 args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),251 "payable function should be mutable",252 ));253 }254255 let result = match &value.sig.output {256 ReturnType::Type(_, ty) => ty,257 _ => 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)")),258 };259 let result = parse_result_ok(result)?;260261 let camel_name = info262 .rename_selector263 .unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));264 let mut selector_str = camel_name.clone();265 selector_str.push('(');266 let mut has_normal_args = false;267 for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {268 if i != 0 {269 selector_str.push(',');270 }271 write!(selector_str, "{}", arg.selector_ty()).unwrap();272 has_normal_args = true;273 }274 selector_str.push(')');275 let selector = fn_selector_str(&selector_str);276277 Ok(Self {278 name: ident.clone(),279 camel_name,280 pascal_name: snake_ident_to_pascal(ident),281 screaming_name: snake_ident_to_screaming(ident),282 selector_str,283 selector,284 args,285 has_normal_args,286 mutability,287 result: result.clone(),288 })289 }290 fn expand_call_def(&self) -> proc_macro2::TokenStream {291 let defs = self292 .args293 .iter()294 .filter(|a| !a.is_special())295 .map(|a| a.expand_call_def());296 let pascal_name = &self.pascal_name;297298 if self.has_normal_args {299 quote! {300 #pascal_name {301 #(302 #defs,303 )*304 }305 }306 } else {307 quote! {#pascal_name}308 }309 }310311 fn expand_const(&self) -> proc_macro2::TokenStream {312 let screaming_name = &self.screaming_name;313 let selector = self.selector;314 let selector_str = &self.selector_str;315 quote! {316 #[doc = #selector_str]317 const #screaming_name: u32 = #selector;318 }319 }320321 fn expand_interface_id(&self) -> proc_macro2::TokenStream {322 let screaming_name = &self.screaming_name;323 quote! {324 interface_id ^= Self::#screaming_name;325 }326 }327328 fn expand_parse(&self) -> proc_macro2::TokenStream {329 let pascal_name = &self.pascal_name;330 let screaming_name = &self.screaming_name;331 if self.has_normal_args {332 let parsers = self333 .args334 .iter()335 .filter(|a| !a.is_special())336 .map(|a| a.expand_parse());337 quote! {338 Self::#screaming_name => return Ok(Some(Self::#pascal_name {339 #(340 #parsers,341 )*342 }))343 }344 } else {345 quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }346 }347 }348349 fn expand_variant_call(&self) -> proc_macro2::TokenStream {350 let pascal_name = &self.pascal_name;351 let name = &self.name;352353 let matcher = if self.has_normal_args {354 let names = self355 .args356 .iter()357 .filter(|a| !a.is_special())358 .map(|a| &a.name);359360 quote! {{361 #(362 #names,363 )*364 }}365 } else {366 quote! {}367 };368369 let receiver = match self.mutability {370 Mutability::Mutable | Mutability::View => quote! {self.},371 Mutability::Pure => quote! {Self::},372 };373 let args = self.args.iter().map(|a| a.expand_call_arg());374375 quote! {376 InternalCall::#pascal_name #matcher => {377 let result = #receiver #name(378 #(379 #args,380 )*381 )?;382 (&result).abi_write(&mut writer);383 }384 }385 }386}387388pub struct SolidityInterface {389 vis: Visibility,390 name: Ident,391 info: InterfaceInfo,392 methods: Vec<Method>,393 items: Vec<TraitItem>,394}395impl SolidityInterface {396 pub fn try_from(info: InterfaceInfo, value: &ItemTrait) -> syn::Result<Self> {397 let mut methods = Vec::new();398399 for item in &value.items {400 match item {401 TraitItem::Method(method) => methods.push(Method::try_from(method)?),402 _ => {}403 }404 }405 Ok(Self {406 vis: value.vis.clone(),407 name: value.ident.clone(),408 info,409 methods,410 items: value.items.clone(),411 })412 }413 pub fn expand(self) -> proc_macro2::TokenStream {414 let vis = self.vis;415 let name = self.name;416 let items = self.items;417418 let call_name = pascal_ident_to_call(&name);419420 let call_sub = self421 .info422 .inline_is423 .0424 .iter()425 .chain(self.info.is.0.iter())426 .map(Is::expand_call_def);427 let call_inner = self428 .info429 .inline_is430 .0431 .iter()432 .chain(self.info.is.0.iter())433 .map(Is::expand_call_inner);434 let call_parse = self435 .info436 .inline_is437 .0438 .iter()439 .chain(self.info.is.0.iter())440 .map(Is::expand_parse);441 let call_variants = self442 .info443 .inline_is444 .0445 .iter()446 .chain(self.info.is.0.iter())447 .map(Is::expand_variant_call);448449 let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);450 let supports_interface = self.info.is.0.iter().map(Is::expand_supports_interface);451452 let calls = self.methods.iter().map(Method::expand_call_def);453 let consts = self.methods.iter().map(Method::expand_const);454 let interface_id = self.methods.iter().map(Method::expand_interface_id);455 let parsers = self.methods.iter().map(Method::expand_parse);456 let call_variants_this = self.methods.iter().map(Method::expand_variant_call);457458 459460 quote! {461 #[derive(Debug)]462 #vis enum #call_name {463 #(464 #calls,465 )*466 #(467 #call_sub,468 )*469 }470 impl #call_name {471 #(472 #consts473 )*474 pub const fn interface_id() -> u32 {475 let mut interface_id = 0;476 #(#interface_id)*477 #(#inline_interface_id)*478 interface_id479 }480 pub fn supports_interface(interface_id: u32) -> bool {481 interface_id != 0xffffff && (482 interface_id == Self::interface_id()483 #(484 || #supports_interface485 )*486 )487 }488 }489 impl ::evm_coder::Call for #call_name {490 fn parse(method_id: u32, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {491 use ::evm_coder::abi::AbiRead;492 match method_id {493 #(494 #parsers,495 )*496 _ => {},497 }498 #(499 #call_parse500 )else*501 return Ok(None);502 }503 }504 #vis trait #name {505 #(506 #items507 )*508 #(509 #call_inner510 )*511 }512 impl<T> ::evm_coder::Callable for T where T: #name {513 type Call = #call_name;514 #[allow(unreachable_code)] 515 fn call(&mut self, c: Msg<#call_name>) -> Result<::evm_coder::abi::AbiWriter> {516 use ::evm_coder::abi::AbiWrite;517 type InternalCall = #call_name;518 match c.call {519 #(520 #call_variants,521 )*522 _ => {},523 }524 let mut writer = ::evm_coder::abi::AbiWriter::default();525 match c.call {526 #(527 #call_variants_this,528 )*529 _ => unreachable!()530 }531 Ok(writer)532 }533 }534 }535 }536}