1#![allow(dead_code)]23use quote::quote;4use darling::FromMeta;5use inflector::cases;6use std::fmt::Write;7use syn::{8 FnArg, Ident, ItemTrait, Meta, NestedMeta, PatType, Path, ReturnType, TraitItem,9 TraitItemMethod, Visibility, spanned::Spanned,10};1112use crate::{13 fn_selector_str, format_ty, parse_ident_from_pat, parse_ident_from_path, parse_ident_from_type,14 parse_result_ok, pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,15 snake_ident_to_screaming,16};1718struct Is {19 name: Ident,20 pascal_call_name: Ident,21 snake_call_name: Ident,22}23impl Is {24 fn try_from(path: &Path) -> syn::Result<Self> {25 let name = parse_ident_from_path(path)?.clone();26 Ok(Self {27 pascal_call_name: pascal_ident_to_call(&name),28 snake_call_name: pascal_ident_to_snake_call(&name),29 name,30 })31 }3233 fn expand_call_def(&self) -> proc_macro2::TokenStream {34 let name = &self.name;35 let pascal_call_name = &self.pascal_call_name;36 quote! {37 #name(#pascal_call_name)38 }39 }4041 fn expand_interface_id(&self) -> proc_macro2::TokenStream {42 let pascal_call_name = &self.pascal_call_name;43 quote! {44 interface_id ^= #pascal_call_name::interface_id();45 }46 }4748 fn expand_supports_interface(&self) -> proc_macro2::TokenStream {49 let pascal_call_name = &self.pascal_call_name;50 quote! {51 #pascal_call_name::supports_interface(interface_id)52 }53 }5455 fn expand_variant_call(&self) -> proc_macro2::TokenStream {56 let name = &self.name;57 let snake_call_name = &self.snake_call_name;58 quote! {59 InternalCall::#name(call) => return self.#snake_call_name(Msg {60 call,61 caller: c.caller,62 value: c.value,63 })64 }65 }6667 fn expand_call_inner(&self) -> proc_macro2::TokenStream {68 let snake_call_name = &self.snake_call_name;69 let pascal_call_name = &self.pascal_call_name;70 quote! {71 fn #snake_call_name(&mut self, c: Msg<#pascal_call_name>) -> ::core::result::Result<::evm_coder::abi::AbiWriter, Self::Error>;72 }73 }7475 fn expand_parse(&self) -> proc_macro2::TokenStream {76 let name = &self.name;77 let pascal_call_name = &self.pascal_call_name;78 quote! {79 if let Some(parsed_call) = #pascal_call_name::parse(method_id, reader)? {80 return Ok(Some(Self::#name(parsed_call)))81 }82 }83 }84}8586#[derive(Default)]87struct IsList(Vec<Is>);88impl FromMeta for IsList {89 fn from_list(items: &[NestedMeta]) -> darling::Result<Self> {90 let mut out = Vec::new();91 for item in items {92 match item {93 NestedMeta::Meta(Meta::Path(path)) => out.push(Is::try_from(path)?),94 _ => return Err(syn::Error::new(item.span(), "expected path").into()),95 }96 }97 Ok(Self(out))98 }99}100101#[derive(FromMeta)]102pub struct InterfaceInfo {103 #[darling(default)]104 is: IsList,105 #[darling(default)]106 inline_is: IsList,107 #[darling(default)]108 events: IsList,109}110111#[derive(FromMeta)]112struct MethodInfo {113 #[darling(default)]114 rename_selector: Option<String>,115}116117struct MethodArg {118 name: Ident,119 ty: Ident,120}121impl MethodArg {122 fn try_from(value: &PatType) -> syn::Result<Self> {123 Ok(Self {124 name: parse_ident_from_pat(&value.pat)?.clone(),125 ty: parse_ident_from_type(&value.ty)?.clone(),126 })127 }128 fn is_value(&self) -> bool {129 self.ty == "value"130 }131 fn is_caller(&self) -> bool {132 self.ty == "caller"133 }134 fn is_special(&self) -> bool {135 self.is_value() || self.is_caller()136 }137 fn selector_ty(&self) -> &Ident {138 assert!(!self.is_special());139 &self.ty140 }141142 fn expand_call_def(&self) -> proc_macro2::TokenStream {143 assert!(!self.is_special());144 let name = &self.name;145 let ty = &self.ty;146147 quote! {148 #name: #ty149 }150 }151152 fn expand_parse(&self) -> proc_macro2::TokenStream {153 assert!(!self.is_special());154 let name = &self.name;155 quote! {156 #name: reader.abi_read()?157 }158 }159160 fn expand_call_arg(&self) -> proc_macro2::TokenStream {161 if self.is_value() {162 quote! {163 c.value.clone()164 }165 } else if self.is_caller() {166 quote! {167 c.caller.clone()168 }169 } else {170 let name = &self.name;171 quote! {172 #name173 }174 }175 }176177 fn solidity_def(&self) -> String {178 assert!(!self.is_special());179 format!("{} {}", format_ty(&self.ty), self.name)180 }181}182183#[derive(PartialEq)]184enum Mutability {185 Mutable,186 View,187 Pure,188}189190struct Method {191 name: Ident,192 camel_name: String,193 pascal_name: Ident,194 screaming_name: Ident,195 selector_str: String,196 selector: u32,197 args: Vec<MethodArg>,198 has_normal_args: bool,199 mutability: Mutability,200 result: Ident,201}202impl Method {203 fn try_from(value: &TraitItemMethod) -> syn::Result<Self> {204 let mut info = MethodInfo {205 rename_selector: None,206 };207 for attr in &value.attrs {208 let ident = parse_ident_from_path(&attr.path)?;209 if ident == "solidity" {210 let args = attr.parse_meta().unwrap();211 info = MethodInfo::from_meta(&args).unwrap();212 } else if ident == "doc" {213 214 }215 }216 let ident = &value.sig.ident;217 let ident_str = ident.to_string();218 if !cases::snakecase::is_snake_case(&ident_str) {219 return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));220 }221222 let mut mutability = Mutability::Pure;223224 if let Some(FnArg::Receiver(receiver)) = value225 .sig226 .inputs227 .iter()228 .find(|arg| matches!(arg, FnArg::Receiver(_)))229 {230 if receiver.reference.is_none() {231 return Err(syn::Error::new(232 receiver.span(),233 "receiver should be by ref",234 ));235 }236 if receiver.mutability.is_some() {237 mutability = Mutability::Mutable;238 } else {239 mutability = Mutability::View;240 }241 }242 let mut args = Vec::new();243 for typ in value244 .sig245 .inputs246 .iter()247 .filter(|arg| matches!(arg, FnArg::Typed(_)))248 {249 let typ = match typ {250 FnArg::Typed(typ) => typ,251 _ => unreachable!(),252 };253 args.push(MethodArg::try_from(typ)?);254 }255256 if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {257 return Err(syn::Error::new(258 args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),259 "payable function should be mutable",260 ));261 }262263 let result = match &value.sig.output {264 ReturnType::Type(_, ty) => ty,265 _ => 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)")),266 };267 let result = parse_result_ok(&result)?;268269 let camel_name = info270 .rename_selector271 .unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));272 let mut selector_str = camel_name.clone();273 selector_str.push('(');274 let mut has_normal_args = false;275 for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {276 if i != 0 {277 selector_str.push(',');278 }279 write!(selector_str, "{}", arg.selector_ty()).unwrap();280 has_normal_args = true;281 }282 selector_str.push(')');283 let selector = fn_selector_str(&selector_str);284285 Ok(Self {286 name: ident.clone(),287 camel_name,288 pascal_name: snake_ident_to_pascal(&ident),289 screaming_name: snake_ident_to_screaming(&ident),290 selector_str,291 selector,292 args,293 has_normal_args,294 mutability,295 result: result.clone(),296 })297 }298 fn expand_call_def(&self) -> proc_macro2::TokenStream {299 let defs = self300 .args301 .iter()302 .filter(|a| !a.is_special())303 .map(|a| a.expand_call_def());304 let pascal_name = &self.pascal_name;305306 if self.has_normal_args {307 quote! {308 #pascal_name {309 #(310 #defs,311 )*312 }313 }314 } else {315 quote! {#pascal_name}316 }317 }318319 fn expand_const(&self) -> proc_macro2::TokenStream {320 let screaming_name = &self.screaming_name;321 let selector = self.selector;322 let selector_str = &self.selector_str;323 quote! {324 #[doc = #selector_str]325 const #screaming_name: u32 = #selector;326 }327 }328329 fn expand_interface_id(&self) -> proc_macro2::TokenStream {330 let screaming_name = &self.screaming_name;331 quote! {332 interface_id ^= Self::#screaming_name;333 }334 }335336 fn expand_parse(&self) -> proc_macro2::TokenStream {337 let pascal_name = &self.pascal_name;338 let screaming_name = &self.screaming_name;339 if self.has_normal_args {340 let parsers = self341 .args342 .iter()343 .filter(|a| !a.is_special())344 .map(|a| a.expand_parse());345 quote! {346 Self::#screaming_name => return Ok(Some(Self::#pascal_name {347 #(348 #parsers,349 )*350 }))351 }352 } else {353 quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }354 }355 }356357 fn expand_variant_call(&self) -> proc_macro2::TokenStream {358 let pascal_name = &self.pascal_name;359 let name = &self.name;360361 let matcher = if self.has_normal_args {362 let names = self363 .args364 .iter()365 .filter(|a| !a.is_special())366 .map(|a| &a.name);367368 quote! {{369 #(370 #names,371 )*372 }}373 } else {374 quote! {}375 };376377 let receiver = match self.mutability {378 Mutability::Mutable | Mutability::View => quote! {self.},379 Mutability::Pure => quote! {Self::},380 };381 let args = self.args.iter().map(|a| a.expand_call_arg());382383 quote! {384 InternalCall::#pascal_name #matcher => {385 let result = #receiver #name(386 #(387 #args,388 )*389 )?;390 (&result).abi_write(&mut writer);391 }392 }393 }394395 fn solidity_def(&self) -> String {396 let mut out = format!("function {}(", self.camel_name);397 for (i, arg) in self.args.iter().filter(|a| !a.is_special()).enumerate() {398 if i != 0 {399 out.push_str(", ");400 }401 out.push_str(&arg.solidity_def());402 }403 out.push(')');404 match self.mutability {405 Mutability::Mutable => {}406 Mutability::View => write!(out, " view").unwrap(),407 Mutability::Pure => write!(out, " pure").unwrap(),408 }409 if self.result != "void" {410 write!(out, " returns ({})", format_ty(&self.result)).unwrap();411 }412 out.push(';');413 out414 }415}416417pub struct SolidityInterface {418 vis: Visibility,419 name: Ident,420 info: InterfaceInfo,421 methods: Vec<Method>,422 items: Vec<TraitItem>,423}424impl SolidityInterface {425 pub fn try_from(info: InterfaceInfo, value: &ItemTrait) -> syn::Result<Self> {426 let mut found_error = false;427 let mut methods = Vec::new();428429 for item in &value.items {430 match item {431 TraitItem::Type(ty) => {432 if ty.ident == "Error" {433 found_error = true;434 }435 }436 TraitItem::Method(method) => methods.push(Method::try_from(&method)?),437 _ => {}438 }439 }440 if !found_error {441 return Err(syn::Error::new(442 value.span(),443 "expected associated type called Error, which should implement From<&str>",444 ));445 }446 Ok(Self {447 vis: value.vis.clone(),448 name: value.ident.clone(),449 info,450 methods,451 items: value.items.clone(),452 })453 }454 pub fn expand(self) -> proc_macro2::TokenStream {455 let vis = self.vis;456 let name = self.name;457 let items = self.items;458459 let call_name = pascal_ident_to_call(&name);460461 let call_sub = self462 .info463 .inline_is464 .0465 .iter()466 .chain(self.info.is.0.iter())467 .map(Is::expand_call_def);468 let call_inner = self469 .info470 .inline_is471 .0472 .iter()473 .chain(self.info.is.0.iter())474 .map(Is::expand_call_inner);475 let call_parse = self476 .info477 .inline_is478 .0479 .iter()480 .chain(self.info.is.0.iter())481 .map(Is::expand_parse);482 let call_variants = self483 .info484 .inline_is485 .0486 .iter()487 .chain(self.info.is.0.iter())488 .map(Is::expand_variant_call);489490 let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);491 let supports_interface = self.info.is.0.iter().map(Is::expand_supports_interface);492493 let calls = self.methods.iter().map(Method::expand_call_def);494 let consts = self.methods.iter().map(Method::expand_const);495 let interface_id = self.methods.iter().map(Method::expand_interface_id);496 let parsers = self.methods.iter().map(Method::expand_parse);497 let call_variants_this = self.methods.iter().map(Method::expand_variant_call);498499 500501 quote! {502 #[derive(Debug)]503 #vis enum #call_name {504 #(505 #calls,506 )*507 #(508 #call_sub,509 )*510 }511 impl #call_name {512 #(513 #consts514 )*515 pub fn parse(method_id: u32, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::abi::Result<Option<Self>> {516 use ::evm_coder::abi::AbiRead;517 match method_id {518 #(519 #parsers,520 )*521 _ => {},522 }523 #(524 #call_parse525 )else*526 return Ok(None);527 }528 pub const fn interface_id() -> u32 {529 let mut interface_id = 0;530 #(#interface_id)*531 #(#inline_interface_id)*532 interface_id533 }534 pub fn supports_interface(interface_id: u32) -> bool {535 interface_id != 0xffffff && (536 interface_id == Self::interface_id()537 #(538 || #supports_interface539 )*540 )541 }542 }543 #vis trait #name {544 #(545 #items546 )*547 #(548 #call_inner549 )*550 #[allow(unreachable_code)] 551 fn call(&mut self, c: Msg<#call_name>) -> ::core::result::Result<::evm_coder::abi::AbiWriter, Self::Error> {552 use ::evm_coder::abi::AbiWrite;553 type InternalCall = #call_name;554 match c.call {555 #(556 #call_variants,557 )*558 _ => {},559 }560 let mut writer = ::evm_coder::abi::AbiWriter::default();561 match c.call {562 #(563 #call_variants_this,564 )*565 _ => unreachable!()566 }567 Ok(writer)568 }569 }570 }571 }572}