1#![allow(dead_code)]23use quote::quote;4use darling::FromMeta;5use inflector::cases;6use std::fmt::Write;7use syn::{8 FnArg, Ident, ImplItem, ImplItemMethod, ItemImpl, Meta, NestedMeta, PatType, Path, ReturnType,9 Type, spanned::Spanned,10};1112use crate::{13 fn_selector_str, 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 pascal_call_name = &self.pascal_call_name;58 quote! {59 InternalCall::#name(call) => return <Self as ::evm_coder::Callable<#pascal_call_name>>::call(self, Msg {60 call,61 caller: c.caller,62 value: c.value,63 })64 }65 }6667 fn expand_parse(&self) -> proc_macro2::TokenStream {68 let name = &self.name;69 let pascal_call_name = &self.pascal_call_name;70 quote! {71 if let Some(parsed_call) = #pascal_call_name::parse(method_id, reader)? {72 return Ok(Some(Self::#name(parsed_call)))73 }74 }75 }76}7778#[derive(Default)]79struct IsList(Vec<Is>);80impl FromMeta for IsList {81 fn from_list(items: &[NestedMeta]) -> darling::Result<Self> {82 let mut out = Vec::new();83 for item in items {84 match item {85 NestedMeta::Meta(Meta::Path(path)) => out.push(Is::try_from(path)?),86 _ => return Err(syn::Error::new(item.span(), "expected path").into()),87 }88 }89 Ok(Self(out))90 }91}9293#[derive(FromMeta)]94pub struct InterfaceInfo {95 name: Ident,96 #[darling(default)]97 is: IsList,98 #[darling(default)]99 inline_is: IsList,100 #[darling(default)]101 events: IsList,102}103104#[derive(FromMeta)]105struct MethodInfo {106 #[darling(default)]107 rename_selector: Option<String>,108}109110struct MethodArg {111 name: Ident,112 ty: Ident,113}114impl MethodArg {115 fn try_from(value: &PatType) -> syn::Result<Self> {116 Ok(Self {117 name: parse_ident_from_pat(&value.pat)?.clone(),118 ty: parse_ident_from_type(&value.ty)?.clone(),119 })120 }121 fn is_value(&self) -> bool {122 self.ty == "value"123 }124 fn is_caller(&self) -> bool {125 self.ty == "caller"126 }127 fn is_special(&self) -> bool {128 self.is_value() || self.is_caller()129 }130 fn selector_ty(&self) -> &Ident {131 assert!(!self.is_special());132 &self.ty133 }134135 fn expand_call_def(&self) -> proc_macro2::TokenStream {136 assert!(!self.is_special());137 let name = &self.name;138 let ty = &self.ty;139140 quote! {141 #name: #ty142 }143 }144145 fn expand_parse(&self) -> proc_macro2::TokenStream {146 assert!(!self.is_special());147 let name = &self.name;148 quote! {149 #name: reader.abi_read()?150 }151 }152153 fn expand_call_arg(&self) -> proc_macro2::TokenStream {154 if self.is_value() {155 quote! {156 c.value.clone()157 }158 } else if self.is_caller() {159 quote! {160 c.caller.clone()161 }162 } else {163 let name = &self.name;164 quote! {165 #name166 }167 }168 }169}170171#[derive(PartialEq)]172enum Mutability {173 Mutable,174 View,175 Pure,176}177178struct Method {179 name: Ident,180 camel_name: String,181 pascal_name: Ident,182 screaming_name: Ident,183 selector_str: String,184 selector: u32,185 args: Vec<MethodArg>,186 has_normal_args: bool,187 mutability: Mutability,188 result: Type,189}190impl Method {191 fn try_from(value: &ImplItemMethod) -> syn::Result<Self> {192 let mut info = MethodInfo {193 rename_selector: None,194 };195 for attr in &value.attrs {196 let ident = parse_ident_from_path(&attr.path)?;197 if ident == "solidity" {198 let args = attr.parse_meta().unwrap();199 info = MethodInfo::from_meta(&args).unwrap();200 } else if ident == "doc" {201 202 }203 }204 let ident = &value.sig.ident;205 let ident_str = ident.to_string();206 if !cases::snakecase::is_snake_case(&ident_str) {207 return Err(syn::Error::new(ident.span(), "method name should be snake_cased\nif alternative solidity name needs to be set - use #[solidity] attribute"));208 }209210 let mut mutability = Mutability::Pure;211212 if let Some(FnArg::Receiver(receiver)) = value213 .sig214 .inputs215 .iter()216 .find(|arg| matches!(arg, FnArg::Receiver(_)))217 {218 if receiver.reference.is_none() {219 return Err(syn::Error::new(220 receiver.span(),221 "receiver should be by ref",222 ));223 }224 if receiver.mutability.is_some() {225 mutability = Mutability::Mutable;226 } else {227 mutability = Mutability::View;228 }229 }230 let mut args = Vec::new();231 for typ in value232 .sig233 .inputs234 .iter()235 .filter(|arg| matches!(arg, FnArg::Typed(_)))236 {237 let typ = match typ {238 FnArg::Typed(typ) => typ,239 _ => unreachable!(),240 };241 args.push(MethodArg::try_from(typ)?);242 }243244 if mutability != Mutability::Mutable && args.iter().any(|arg| arg.is_value()) {245 return Err(syn::Error::new(246 args.iter().find(|arg| arg.is_value()).unwrap().ty.span(),247 "payable function should be mutable",248 ));249 }250251 let result = match &value.sig.output {252 ReturnType::Type(_, ty) => ty,253 _ => 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)")),254 };255 let result = parse_result_ok(result)?;256257 let camel_name = info258 .rename_selector259 .unwrap_or_else(|| cases::camelcase::to_camel_case(&ident.to_string()));260 let mut selector_str = camel_name.clone();261 selector_str.push('(');262 let mut has_normal_args = false;263 for (i, arg) in args.iter().filter(|arg| !arg.is_special()).enumerate() {264 if i != 0 {265 selector_str.push(',');266 }267 write!(selector_str, "{}", arg.selector_ty()).unwrap();268 has_normal_args = true;269 }270 selector_str.push(')');271 let selector = fn_selector_str(&selector_str);272273 Ok(Self {274 name: ident.clone(),275 camel_name,276 pascal_name: snake_ident_to_pascal(ident),277 screaming_name: snake_ident_to_screaming(ident),278 selector_str,279 selector,280 args,281 has_normal_args,282 mutability,283 result: result.clone(),284 })285 }286 fn expand_call_def(&self) -> proc_macro2::TokenStream {287 let defs = self288 .args289 .iter()290 .filter(|a| !a.is_special())291 .map(|a| a.expand_call_def());292 let pascal_name = &self.pascal_name;293294 if self.has_normal_args {295 quote! {296 #pascal_name {297 #(298 #defs,299 )*300 }301 }302 } else {303 quote! {#pascal_name}304 }305 }306307 fn expand_const(&self) -> proc_macro2::TokenStream {308 let screaming_name = &self.screaming_name;309 let selector = self.selector;310 let selector_str = &self.selector_str;311 quote! {312 #[doc = #selector_str]313 const #screaming_name: u32 = #selector;314 }315 }316317 fn expand_interface_id(&self) -> proc_macro2::TokenStream {318 let screaming_name = &self.screaming_name;319 quote! {320 interface_id ^= Self::#screaming_name;321 }322 }323324 fn expand_parse(&self) -> proc_macro2::TokenStream {325 let pascal_name = &self.pascal_name;326 let screaming_name = &self.screaming_name;327 if self.has_normal_args {328 let parsers = self329 .args330 .iter()331 .filter(|a| !a.is_special())332 .map(|a| a.expand_parse());333 quote! {334 Self::#screaming_name => return Ok(Some(Self::#pascal_name {335 #(336 #parsers,337 )*338 }))339 }340 } else {341 quote! { Self::#screaming_name => return Ok(Some(Self::#pascal_name)) }342 }343 }344345 fn expand_variant_call(&self) -> proc_macro2::TokenStream {346 let pascal_name = &self.pascal_name;347 let name = &self.name;348349 let matcher = if self.has_normal_args {350 let names = self351 .args352 .iter()353 .filter(|a| !a.is_special())354 .map(|a| &a.name);355356 quote! {{357 #(358 #names,359 )*360 }}361 } else {362 quote! {}363 };364365 let receiver = match self.mutability {366 Mutability::Mutable | Mutability::View => quote! {self.},367 Mutability::Pure => quote! {Self::},368 };369 let args = self.args.iter().map(|a| a.expand_call_arg());370371 quote! {372 InternalCall::#pascal_name #matcher => {373 let result = #receiver #name(374 #(375 #args,376 )*377 )?;378 (&result).abi_write(&mut writer);379 }380 }381 }382}383384pub struct SolidityInterface {385 name: Box<syn::Type>,386 ident: Ident,387 info: InterfaceInfo,388 methods: Vec<Method>,389}390impl SolidityInterface {391 pub fn try_from(info: InterfaceInfo, value: &ItemImpl) -> syn::Result<Self> {392 let mut methods = Vec::new();393394 for item in &value.items {395 if let ImplItem::Method(method) = item {396 methods.push(Method::try_from(method)?)397 }398 }399 Ok(Self {400 name: value.self_ty.clone(),401 ident: parse_ident_from_type(&value.self_ty)?.clone(),402 info,403 methods,404 })405 }406 pub fn expand(self) -> proc_macro2::TokenStream {407 let name = self.name;408409 let call_name = pascal_ident_to_call(&self.info.name);410411 let call_sub = self412 .info413 .inline_is414 .0415 .iter()416 .chain(self.info.is.0.iter())417 .map(Is::expand_call_def);418 let call_parse = self419 .info420 .inline_is421 .0422 .iter()423 .chain(self.info.is.0.iter())424 .map(Is::expand_parse);425 let call_variants = self426 .info427 .inline_is428 .0429 .iter()430 .chain(self.info.is.0.iter())431 .map(Is::expand_variant_call);432433 let inline_interface_id = self.info.inline_is.0.iter().map(Is::expand_interface_id);434 let supports_interface = self.info.is.0.iter().map(Is::expand_supports_interface);435436 let calls = self.methods.iter().map(Method::expand_call_def);437 let consts = self.methods.iter().map(Method::expand_const);438 let interface_id = self.methods.iter().map(Method::expand_interface_id);439 let parsers = self.methods.iter().map(Method::expand_parse);440 let call_variants_this = self.methods.iter().map(Method::expand_variant_call);441442 443444 quote! {445 #[derive(Debug)]446 pub enum #call_name {447 #(448 #calls,449 )*450 #(451 #call_sub,452 )*453 }454 impl #call_name {455 #(456 #consts457 )*458 pub const fn interface_id() -> u32 {459 let mut interface_id = 0;460 #(#interface_id)*461 #(#inline_interface_id)*462 interface_id463 }464 pub fn supports_interface(interface_id: u32) -> bool {465 interface_id != 0xffffff && (466 interface_id == Self::interface_id()467 #(468 || #supports_interface469 )*470 )471 }472 }473 impl ::evm_coder::Call for #call_name {474 fn parse(method_id: u32, reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Option<Self>> {475 use ::evm_coder::abi::AbiRead;476 match method_id {477 #(478 #parsers,479 )*480 _ => {},481 }482 #(483 #call_parse484 )else*485 return Ok(None);486 }487 }488 impl ::evm_coder::Callable<#call_name> for #name {489 #[allow(unreachable_code)] 490 fn call(&mut self, c: Msg<#call_name>) -> Result<::evm_coder::abi::AbiWriter> {491 use ::evm_coder::abi::AbiWrite;492 type InternalCall = #call_name;493 match c.call {494 #(495 #call_variants,496 )*497 _ => {},498 }499 let mut writer = ::evm_coder::abi::AbiWriter::default();500 match c.call {501 #(502 #call_variants_this,503 )*504 _ => unreachable!()505 }506 Ok(writer)507 }508 }509 }510 }511}