difftreelog
reafactor: Better error reporting
in: master
2 files changed
crates/evm-coder/procedural/src/abi_derive.rsdiffbeforeafterboth1use quote::quote;23pub(crate) fn impl_abi_macro(ast: &syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream> {4 let name = &ast.ident;56 match &ast.data {7 syn::Data::Struct(ds) => {8 let docs = extract_docs(&ast.attrs)?;9 let (is_named_fields, field_names, field_types, field_docs, params_count) =10 match ds.fields {11 syn::Fields::Named(ref fields) => Ok((12 true,13 fields.named.iter().enumerate().map(map_field_to_name),14 fields.named.iter().map(map_field_to_type),15 fields.named.iter().map(map_field_to_doc),16 fields.named.len(),17 )),18 syn::Fields::Unnamed(ref fields) => Ok((19 false,20 fields.unnamed.iter().enumerate().map(map_field_to_name),21 fields.unnamed.iter().map(map_field_to_type),22 fields.unnamed.iter().map(map_field_to_doc),23 fields.unnamed.len(),24 )),25 syn::Fields::Unit => {26 Err(syn::Error::new(name.span(), "Unit structs not supported"))27 }28 }?;2930 if params_count == 0 {31 return Err(syn::Error::new(name.span(), "Empty structs not supported"));32 };3334 let tuple_type = tuple_type(field_types.clone());35 let tuple_ref_type = tuple_ref_type(field_types.clone());36 let tuple_data = tuple_data_as_ref(is_named_fields, field_names.clone());37 let tuple_names = tuple_names(is_named_fields, field_names.clone());38 let struct_from_tuple = struct_from_tuple(name, is_named_fields, field_names.clone());3940 let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);41 let abi_type = impl_abi_type(name, tuple_type.clone());42 let abi_read = impl_abi_read(name, tuple_type, tuple_names, struct_from_tuple);43 let abi_write = impl_abi_write(name, is_named_fields, tuple_ref_type, tuple_data);44 let solidity_type = impl_solidity_type(name, field_types.clone(), params_count);45 let solidity_type_name =46 impl_solidity_type_name(name, field_types.clone(), params_count);47 let solidity_struct_collect =48 impl_solidity_struct_collect(name, field_names, field_types, field_docs, &docs)?;4950 Ok(quote! {51 #can_be_plcaed_in_vec52 #abi_type53 #abi_read54 #abi_write55 #solidity_type56 #solidity_type_name57 #solidity_struct_collect58 })59 }60 syn::Data::Enum(de) => {61 check_repr_u8(name, &ast.attrs)?;6263 dbg!(&de);64 for f in de.variants.iter().filter_map(|v| {65 if !v.fields.is_empty() {66 Some(Err(syn::Error::new(67 v.ident.span(),68 "Enumeration parameters should not have fields",69 )))70 } else if v.discriminant.is_some() {71 Some(Err(syn::Error::new(72 v.ident.span(),73 "Enumeration options should not have an explicit specified value",74 )))75 } else {76 None77 }78 }) {79 f?;80 }81 Ok(quote!())82 }83 syn::Data::Union(_) => Err(syn::Error::new(name.span(), "Unions not supported")),84 }85}8687fn check_repr_u8(name: &syn::Ident, attrs: &Vec<syn::Attribute>) -> syn::Result<()> {88 let repr_u8 = attrs89 .iter()90 .filter_map(|attr| {91 if let Some(ps) = attr.path.segments.first() {92 if ps.ident == "repr" {93 let meta = match attr.parse_meta() {94 Ok(meta) => meta,95 Err(e) => return Some(Err(e)),96 };97 let is_repr_u8 = match meta {98 syn::Meta::List(p) => {99 p.nested100 .iter()101 .filter(|nm| match nm {102 syn::NestedMeta::Meta(m) => match m {103 syn::Meta::Path(p) => {104 p.segments.iter().filter(|ps| ps.ident == "u8").count()105 == 1106 }107 _ => false,108 },109 _ => false,110 })111 .count() == 1112 }113 _ => false,114 };115116 if is_repr_u8 {117 return Some(Ok(()));118 };119 }120 }121 None::<syn::Result<()>>122 })123 .collect::<syn::Result<Vec<_>>>()?;124125 if repr_u8.len() != 1 {126 return Err(syn::Error::new(name.span(), "Enum is not \"repr(u8)\""));127 };128129 Ok(())130}131132fn tuple_type<'a>(133 field_types: impl Iterator<Item = &'a syn::Type> + Clone,134) -> proc_macro2::TokenStream {135 let field_types = field_types.map(|ty| quote!(#ty,));136 quote! {(#(#field_types)*)}137}138139fn tuple_ref_type<'a>(140 field_types: impl Iterator<Item = &'a syn::Type> + Clone,141) -> proc_macro2::TokenStream {142 let field_types = field_types.map(|ty| quote!(&#ty,));143 quote! {(#(#field_types)*)}144}145146fn tuple_data_as_ref(147 is_named_fields: bool,148 field_names: impl Iterator<Item = syn::Ident> + Clone,149) -> proc_macro2::TokenStream {150 let field_names = field_names.enumerate().map(|(i, field)| {151 if is_named_fields {152 quote!(&self.#field,)153 } else {154 let field = proc_macro2::Literal::usize_unsuffixed(i);155 quote!(&self.#field,)156 }157 });158 quote! {(#(#field_names)*)}159}160161fn tuple_names(162 is_named_fields: bool,163 field_names: impl Iterator<Item = syn::Ident> + Clone,164) -> proc_macro2::TokenStream {165 let field_names = field_names.enumerate().map(|(i, field)| {166 if is_named_fields {167 quote!(#field,)168 } else {169 let field = proc_macro2::Ident::new(170 format!("field{}", i).as_str(),171 proc_macro2::Span::call_site(),172 );173 quote!(#field,)174 }175 });176 quote! {(#(#field_names)*)}177}178179fn struct_from_tuple(180 name: &syn::Ident,181 is_named_fields: bool,182 field_names: impl Iterator<Item = syn::Ident> + Clone,183) -> proc_macro2::TokenStream {184 let field_names = field_names.enumerate().map(|(i, field)| {185 if is_named_fields {186 quote!(#field,)187 } else {188 let field = proc_macro2::Ident::new(189 format!("field{}", i).as_str(),190 proc_macro2::Span::call_site(),191 );192 quote!(#field,)193 }194 });195196 if is_named_fields {197 quote! {#name {#(#field_names)*}}198 } else {199 quote! {#name (#(#field_names)*)}200 }201}202203fn extract_docs(attrs: &[syn::Attribute]) -> syn::Result<Vec<String>> {204 attrs205 .iter()206 .filter_map(|attr| {207 if let Some(ps) = attr.path.segments.first() {208 if ps.ident == "doc" {209 let meta = match attr.parse_meta() {210 Ok(meta) => meta,211 Err(e) => return Some(Err(e)),212 };213 match meta {214 syn::Meta::NameValue(mnv) => match &mnv.lit {215 syn::Lit::Str(ls) => return Some(Ok(ls.value())),216 _ => unreachable!(),217 },218 _ => unreachable!(),219 }220 }221 }222 None223 })224 .collect()225}226227fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {228 match field.1.ident.as_ref() {229 Some(name) => name.clone(),230 None => {231 let mut name = "field".to_string();232 name.push_str(field.0.to_string().as_str());233 syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())234 }235 }236}237238fn map_field_to_type(field: &syn::Field) -> &syn::Type {239 &field.ty240}241242fn map_field_to_doc(field: &syn::Field) -> Result<Vec<std::string::String>, syn::Error> {243 extract_docs(&field.attrs)244}245246fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {247 quote! {248 impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}249 }250}251252fn impl_abi_type(253 name: &syn::Ident,254 tuple_type: proc_macro2::TokenStream,255) -> proc_macro2::TokenStream {256 quote! {257 impl ::evm_coder::abi::AbiType for #name {258 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <#tuple_type as ::evm_coder::abi::AbiType>::SIGNATURE;259 fn is_dynamic() -> bool {260 <#tuple_type as ::evm_coder::abi::AbiType>::is_dynamic()261 }262 fn size() -> usize {263 <#tuple_type as ::evm_coder::abi::AbiType>::size()264 }265 }266 }267}268269fn impl_abi_read(270 name: &syn::Ident,271 tuple_type: proc_macro2::TokenStream,272 tuple_names: proc_macro2::TokenStream,273 struct_from_tuple: proc_macro2::TokenStream,274) -> proc_macro2::TokenStream {275 quote!(276 impl ::evm_coder::abi::AbiRead for #name {277 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {278 let #tuple_names = <#tuple_type as ::evm_coder::abi::AbiRead>::abi_read(reader)?;279 Ok(#struct_from_tuple)280 }281 }282 )283}284285fn impl_abi_write(286 name: &syn::Ident,287 _is_named_fields: bool,288 tuple_type: proc_macro2::TokenStream,289 tuple_data: proc_macro2::TokenStream,290) -> proc_macro2::TokenStream {291 quote!(292 impl ::evm_coder::abi::AbiWrite for #name {293 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {294 <#tuple_type as ::evm_coder::abi::AbiWrite>::abi_write(&#tuple_data, writer)295 }296 }297 )298}299300fn impl_solidity_type<'a>(301 name: &syn::Ident,302 field_types: impl Iterator<Item = &'a syn::Type> + Clone,303 params_count: usize,304) -> proc_macro2::TokenStream {305 let len = proc_macro2::Literal::usize_suffixed(params_count);306 quote! {307 #[cfg(feature = "stubgen")]308 impl ::evm_coder::solidity::SolidityType for #name {309 fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {310 let mut collected =311 Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());312 #({313 let mut out = String::new();314 <#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)315 .expect("no fmt error");316 collected.push(out);317 })*318 collected319 }320321 fn len() -> usize {322 #len323 }324 }325 }326}327328fn impl_solidity_type_name<'a>(329 name: &syn::Ident,330 field_types: impl Iterator<Item = &'a syn::Type> + Clone,331 params_count: usize,332) -> proc_macro2::TokenStream {333 let arg_dafaults = field_types.enumerate().map(|(i, ty)| {334 let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName335 >::solidity_default(writer, tc)?;);336 let last_item = params_count - 1;337 if i != last_item {338 defult_value.extend(quote! {write!(writer, ",")?;})339 }340 defult_value341 });342343 quote! {344 #[cfg(feature = "stubgen")]345 impl ::evm_coder::solidity::SolidityTypeName for #name {346 fn solidity_name(347 writer: &mut impl ::core::fmt::Write,348 tc: &::evm_coder::solidity::TypeCollector,349 ) -> ::core::fmt::Result {350 write!(writer, "{}", tc.collect_struct::<Self>())351 }352353 fn is_simple() -> bool {354 false355 }356357 fn solidity_default(358 writer: &mut impl ::core::fmt::Write,359 tc: &::evm_coder::solidity::TypeCollector,360 ) -> ::core::fmt::Result {361 write!(writer, "{}(", tc.collect_struct::<Self>())?;362363 #(#arg_dafaults)*364365 write!(writer, ")")366 }367 }368 }369}370371fn impl_solidity_struct_collect<'a>(372 name: &syn::Ident,373 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,374 field_types: impl Iterator<Item = &'a syn::Type> + Clone,375 field_docs: impl Iterator<Item = syn::Result<Vec<String>>> + Clone,376 docs: &[String],377) -> syn::Result<proc_macro2::TokenStream> {378 let string_name = name.to_string();379 let name_type = field_names380 .into_iter()381 .zip(field_types)382 .zip(field_docs)383 .map(|((name, ty), doc)| {384 let field_docs = match doc {385 Ok(doc) => doc.into_iter().enumerate().map(|(i, doc)| {386 let doc = doc.trim();387 let dev = if i == 0 { " @dev" } else { "" };388 quote! {389 writeln!(str, "\t///{} {}", #dev, #doc).unwrap();390 }391 }),392 Err(e) => unreachable!("{:?}", e),393 };394 let name = format!("{}", name);395 quote!(396 #(#field_docs)*397 write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();398 writeln!(str, "{};", #name).unwrap();399 )400 });401 let docs = docs.iter().enumerate().map(|(i, doc)| {402 let doc = doc.trim();403 let dev = if i == 0 { " @dev" } else { "" };404 quote! {405 writeln!(str, "///{} {}", #dev, #doc).unwrap();406 }407 });408409 Ok(quote! {410 #[cfg(feature = "stubgen")]411 impl ::evm_coder::solidity::StructCollect for #name {412 fn name() -> String {413 #string_name.into()414 }415416 fn declaration() -> String {417 use std::fmt::Write;418419 let mut str = String::new();420 #(#docs)*421 writeln!(str, "struct {} {{", Self::name()).unwrap();422 #(#name_type)*423 writeln!(str, "}}").unwrap();424 str425 }426 }427 })428}1use quote::quote;23pub(crate) fn impl_abi_macro(ast: &syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream> {4 let name = &ast.ident;5 match &ast.data {6 syn::Data::Struct(ds) => expand_struct(ds, ast),7 syn::Data::Enum(de) => expand_enum(de, ast),8 syn::Data::Union(_) => Err(syn::Error::new(name.span(), "Unions not supported")),9 }10}1112fn expand_struct(13 ds: &syn::DataStruct,14 ast: &syn::DeriveInput,15) -> syn::Result<proc_macro2::TokenStream> {16 let name = &ast.ident;17 let docs = extract_docs(&ast.attrs)?;18 let (is_named_fields, field_names, field_types, field_docs, params_count) = match ds.fields {19 syn::Fields::Named(ref fields) => Ok((20 true,21 fields.named.iter().enumerate().map(map_field_to_name),22 fields.named.iter().map(map_field_to_type),23 fields.named.iter().map(map_field_to_doc),24 fields.named.len(),25 )),26 syn::Fields::Unnamed(ref fields) => Ok((27 false,28 fields.unnamed.iter().enumerate().map(map_field_to_name),29 fields.unnamed.iter().map(map_field_to_type),30 fields.unnamed.iter().map(map_field_to_doc),31 fields.unnamed.len(),32 )),33 syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),34 }?;3536 if params_count == 0 {37 return Err(syn::Error::new(name.span(), "Empty structs not supported"));38 };3940 let tuple_type = tuple_type(field_types.clone());41 let tuple_ref_type = tuple_ref_type(field_types.clone());42 let tuple_data = tuple_data_as_ref(is_named_fields, field_names.clone());43 let tuple_names = tuple_names(is_named_fields, field_names.clone());44 let struct_from_tuple = struct_from_tuple(name, is_named_fields, field_names.clone());4546 let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);47 let abi_type = impl_abi_type(name, tuple_type.clone());48 let abi_read = impl_abi_read(name, tuple_type, tuple_names, struct_from_tuple);49 let abi_write = impl_abi_write(name, is_named_fields, tuple_ref_type, tuple_data);50 let solidity_type = impl_solidity_type(name, field_types.clone(), params_count);51 let solidity_type_name = impl_solidity_type_name(name, field_types.clone(), params_count);52 let solidity_struct_collect =53 impl_solidity_struct_collect(name, field_names, field_types, field_docs, &docs)?;5455 Ok(quote! {56 #can_be_plcaed_in_vec57 #abi_type58 #abi_read59 #abi_write60 #solidity_type61 #solidity_type_name62 #solidity_struct_collect63 })64}6566fn expand_enum(67 de: &syn::DataEnum,68 ast: &syn::DeriveInput,69) -> syn::Result<proc_macro2::TokenStream> {70 let name = &ast.ident;71 check_repr_u8(name, &ast.attrs)?;72 check_option_validity(de)?;7374 dbg!(&de);7576 Ok(quote!())77}7879fn check_option_validity(de: &syn::DataEnum) -> syn::Result<()> {80 for error in de.variants.iter().filter_map(|v| {81 if !v.fields.is_empty() {82 Some(Err(syn::Error::new(83 v.ident.span(),84 "Enumeration parameters should not have fields",85 )))86 } else if v.discriminant.is_some() {87 Some(Err(syn::Error::new(88 v.ident.span(),89 "Enumeration options should not have an explicit specified value",90 )))91 } else {92 None93 }94 }) {95 return error;96 }9798 Ok(())99}100101fn check_repr_u8(name: &syn::Ident, attrs: &Vec<syn::Attribute>) -> syn::Result<()> {102 let mut has_repr = false;103 for error in attrs.iter().filter_map(|attr| {104 if let Some(ps) = attr.path.segments.first() {105 if ps.ident == "repr" {106 has_repr = true;107 let meta = match attr.parse_meta() {108 Ok(meta) => meta,109 Err(e) => return Some(Err(e)),110 };111 match meta {112 syn::Meta::List(p) => {113 for error in p.nested.iter().filter_map(|nm| match nm {114 syn::NestedMeta::Meta(m) => match m {115 syn::Meta::Path(p) => {116 for i in p.segments.iter().filter_map(|ps| {117 if ps.ident != "u8" {118 Some(Err(syn::Error::new(119 ps.ident.span(),120 "Enum is not \"repr(u8)\"",121 )))122 } else {123 None124 }125 }) {126 return Some(i);127 }128 None129 }130 _ => None,131 },132 _ => None,133 }) {134 return Some(error);135 }136 None::<syn::Result<()>>137 }138 _ => None,139 };140 }141 }142 None143 }) {144 return error;145 }146147 if !has_repr {148 return Err(syn::Error::new(name.span(), "Enum is not \"repr(u8)\""));149 }150151 Ok(())152}153154fn tuple_type<'a>(155 field_types: impl Iterator<Item = &'a syn::Type> + Clone,156) -> proc_macro2::TokenStream {157 let field_types = field_types.map(|ty| quote!(#ty,));158 quote! {(#(#field_types)*)}159}160161fn tuple_ref_type<'a>(162 field_types: impl Iterator<Item = &'a syn::Type> + Clone,163) -> proc_macro2::TokenStream {164 let field_types = field_types.map(|ty| quote!(&#ty,));165 quote! {(#(#field_types)*)}166}167168fn tuple_data_as_ref(169 is_named_fields: bool,170 field_names: impl Iterator<Item = syn::Ident> + Clone,171) -> proc_macro2::TokenStream {172 let field_names = field_names.enumerate().map(|(i, field)| {173 if is_named_fields {174 quote!(&self.#field,)175 } else {176 let field = proc_macro2::Literal::usize_unsuffixed(i);177 quote!(&self.#field,)178 }179 });180 quote! {(#(#field_names)*)}181}182183fn tuple_names(184 is_named_fields: bool,185 field_names: impl Iterator<Item = syn::Ident> + Clone,186) -> proc_macro2::TokenStream {187 let field_names = field_names.enumerate().map(|(i, field)| {188 if is_named_fields {189 quote!(#field,)190 } else {191 let field = proc_macro2::Ident::new(192 format!("field{}", i).as_str(),193 proc_macro2::Span::call_site(),194 );195 quote!(#field,)196 }197 });198 quote! {(#(#field_names)*)}199}200201fn struct_from_tuple(202 name: &syn::Ident,203 is_named_fields: bool,204 field_names: impl Iterator<Item = syn::Ident> + Clone,205) -> proc_macro2::TokenStream {206 let field_names = field_names.enumerate().map(|(i, field)| {207 if is_named_fields {208 quote!(#field,)209 } else {210 let field = proc_macro2::Ident::new(211 format!("field{}", i).as_str(),212 proc_macro2::Span::call_site(),213 );214 quote!(#field,)215 }216 });217218 if is_named_fields {219 quote! {#name {#(#field_names)*}}220 } else {221 quote! {#name (#(#field_names)*)}222 }223}224225fn extract_docs(attrs: &[syn::Attribute]) -> syn::Result<Vec<String>> {226 attrs227 .iter()228 .filter_map(|attr| {229 if let Some(ps) = attr.path.segments.first() {230 if ps.ident == "doc" {231 let meta = match attr.parse_meta() {232 Ok(meta) => meta,233 Err(e) => return Some(Err(e)),234 };235 match meta {236 syn::Meta::NameValue(mnv) => match &mnv.lit {237 syn::Lit::Str(ls) => return Some(Ok(ls.value())),238 _ => unreachable!(),239 },240 _ => unreachable!(),241 }242 }243 }244 None245 })246 .collect()247}248249fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {250 match field.1.ident.as_ref() {251 Some(name) => name.clone(),252 None => {253 let mut name = "field".to_string();254 name.push_str(field.0.to_string().as_str());255 syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())256 }257 }258}259260fn map_field_to_type(field: &syn::Field) -> &syn::Type {261 &field.ty262}263264fn map_field_to_doc(field: &syn::Field) -> Result<Vec<std::string::String>, syn::Error> {265 extract_docs(&field.attrs)266}267268fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {269 quote! {270 impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}271 }272}273274fn impl_abi_type(275 name: &syn::Ident,276 tuple_type: proc_macro2::TokenStream,277) -> proc_macro2::TokenStream {278 quote! {279 impl ::evm_coder::abi::AbiType for #name {280 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <#tuple_type as ::evm_coder::abi::AbiType>::SIGNATURE;281 fn is_dynamic() -> bool {282 <#tuple_type as ::evm_coder::abi::AbiType>::is_dynamic()283 }284 fn size() -> usize {285 <#tuple_type as ::evm_coder::abi::AbiType>::size()286 }287 }288 }289}290291fn impl_abi_read(292 name: &syn::Ident,293 tuple_type: proc_macro2::TokenStream,294 tuple_names: proc_macro2::TokenStream,295 struct_from_tuple: proc_macro2::TokenStream,296) -> proc_macro2::TokenStream {297 quote!(298 impl ::evm_coder::abi::AbiRead for #name {299 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {300 let #tuple_names = <#tuple_type as ::evm_coder::abi::AbiRead>::abi_read(reader)?;301 Ok(#struct_from_tuple)302 }303 }304 )305}306307fn impl_abi_write(308 name: &syn::Ident,309 _is_named_fields: bool,310 tuple_type: proc_macro2::TokenStream,311 tuple_data: proc_macro2::TokenStream,312) -> proc_macro2::TokenStream {313 quote!(314 impl ::evm_coder::abi::AbiWrite for #name {315 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {316 <#tuple_type as ::evm_coder::abi::AbiWrite>::abi_write(&#tuple_data, writer)317 }318 }319 )320}321322fn impl_solidity_type<'a>(323 name: &syn::Ident,324 field_types: impl Iterator<Item = &'a syn::Type> + Clone,325 params_count: usize,326) -> proc_macro2::TokenStream {327 let len = proc_macro2::Literal::usize_suffixed(params_count);328 quote! {329 #[cfg(feature = "stubgen")]330 impl ::evm_coder::solidity::SolidityType for #name {331 fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {332 let mut collected =333 Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());334 #({335 let mut out = String::new();336 <#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)337 .expect("no fmt error");338 collected.push(out);339 })*340 collected341 }342343 fn len() -> usize {344 #len345 }346 }347 }348}349350fn impl_solidity_type_name<'a>(351 name: &syn::Ident,352 field_types: impl Iterator<Item = &'a syn::Type> + Clone,353 params_count: usize,354) -> proc_macro2::TokenStream {355 let arg_dafaults = field_types.enumerate().map(|(i, ty)| {356 let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName357 >::solidity_default(writer, tc)?;);358 let last_item = params_count - 1;359 if i != last_item {360 defult_value.extend(quote! {write!(writer, ",")?;})361 }362 defult_value363 });364365 quote! {366 #[cfg(feature = "stubgen")]367 impl ::evm_coder::solidity::SolidityTypeName for #name {368 fn solidity_name(369 writer: &mut impl ::core::fmt::Write,370 tc: &::evm_coder::solidity::TypeCollector,371 ) -> ::core::fmt::Result {372 write!(writer, "{}", tc.collect_struct::<Self>())373 }374375 fn is_simple() -> bool {376 false377 }378379 fn solidity_default(380 writer: &mut impl ::core::fmt::Write,381 tc: &::evm_coder::solidity::TypeCollector,382 ) -> ::core::fmt::Result {383 write!(writer, "{}(", tc.collect_struct::<Self>())?;384385 #(#arg_dafaults)*386387 write!(writer, ")")388 }389 }390 }391}392393fn impl_solidity_struct_collect<'a>(394 name: &syn::Ident,395 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,396 field_types: impl Iterator<Item = &'a syn::Type> + Clone,397 field_docs: impl Iterator<Item = syn::Result<Vec<String>>> + Clone,398 docs: &[String],399) -> syn::Result<proc_macro2::TokenStream> {400 let string_name = name.to_string();401 let name_type = field_names402 .into_iter()403 .zip(field_types)404 .zip(field_docs)405 .map(|((name, ty), doc)| {406 let field_docs = match doc {407 Ok(doc) => doc.into_iter().enumerate().map(|(i, doc)| {408 let doc = doc.trim();409 let dev = if i == 0 { " @dev" } else { "" };410 quote! {411 writeln!(str, "\t///{} {}", #dev, #doc).unwrap();412 }413 }),414 Err(e) => unreachable!("{:?}", e),415 };416 let name = format!("{}", name);417 quote!(418 #(#field_docs)*419 write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();420 writeln!(str, "{};", #name).unwrap();421 )422 });423 let docs = docs.iter().enumerate().map(|(i, doc)| {424 let doc = doc.trim();425 let dev = if i == 0 { " @dev" } else { "" };426 quote! {427 writeln!(str, "///{} {}", #dev, #doc).unwrap();428 }429 });430431 Ok(quote! {432 #[cfg(feature = "stubgen")]433 impl ::evm_coder::solidity::StructCollect for #name {434 fn name() -> String {435 #string_name.into()436 }437438 fn declaration() -> String {439 use std::fmt::Write;440441 let mut str = String::new();442 #(#docs)*443 writeln!(str, "struct {} {{", Self::name()).unwrap();444 #(#name_type)*445 writeln!(str, "}}").unwrap();446 str447 }448 }449 })450}crates/evm-coder/tests/build_failed/abi_derive_enum_generation.stderrdiffbeforeafterboth--- a/crates/evm-coder/tests/build_failed/abi_derive_enum_generation.stderr
+++ b/crates/evm-coder/tests/build_failed/abi_derive_enum_generation.stderr
@@ -5,10 +5,10 @@
| ^^^^^^^
error: Enum is not "repr(u8)"
- --> tests/build_failed/abi_derive_enum_generation.rs:12:6
+ --> tests/build_failed/abi_derive_enum_generation.rs:11:8
|
-12 | enum NonReprU8 {
- | ^^^^^^^^^
+11 | #[repr(u32)]
+ | ^^^
error: Enumeration parameters should not have fields
--> tests/build_failed/abi_derive_enum_generation.rs:21:2