difftreelog
refactor impl AbiType, AbiWrite, AbiRead via tuple
in: master
3 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;5 let docs = extract_docs(&ast.attrs)?;67 let (is_named_fields, field_names, field_types, field_docs, params_count) = match &ast.data {8 syn::Data::Struct(ds) => match ds.fields {9 syn::Fields::Named(ref fields) => Ok((10 true,11 fields.named.iter().enumerate().map(map_field_to_name),12 fields.named.iter().map(map_field_to_type),13 fields.named.iter().map(map_field_to_doc),14 fields.named.len(),15 )),16 syn::Fields::Unnamed(ref fields) => Ok((17 false,18 fields.unnamed.iter().enumerate().map(map_field_to_name),19 fields.unnamed.iter().map(map_field_to_type),20 fields.unnamed.iter().map(map_field_to_doc),21 fields.unnamed.len(),22 )),23 syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),24 },25 syn::Data::Enum(_) => Err(syn::Error::new(name.span(), "Enums not supported")),26 syn::Data::Union(_) => Err(syn::Error::new(name.span(), "Unions not supported")),27 }?;2829 if params_count == 0 {30 return Err(syn::Error::new(name.span(), "Empty structs not supported"));31 };3233 let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);34 let abi_type = impl_abi_type(name, field_types.clone());35 let abi_read = impl_abi_read(36 name,37 is_named_fields,38 field_names.clone(),39 field_types.clone(),40 );41 let abi_write = impl_abi_write(name, is_named_fields, params_count, field_names.clone());42 let solidity_type = impl_solidity_type(name, field_types.clone(), params_count);43 let solidity_type_name = impl_solidity_type_name(name, field_types.clone(), params_count);44 let solidity_struct_collect =45 impl_solidity_struct_collect(name, field_names, field_types, field_docs, &docs)?;4647 Ok(quote! {48 #can_be_plcaed_in_vec49 #abi_type50 #abi_read51 #abi_write52 #solidity_type53 #solidity_type_name54 #solidity_struct_collect55 })56}5758fn extract_docs(attrs: &Vec<syn::Attribute>) -> syn::Result<Vec<String>> {59 attrs60 .iter()61 .filter_map(|attr| {62 if let Some(ps) = attr.path.segments.first() {63 if ps.ident == "doc" {64 let meta = match attr.parse_meta() {65 Ok(meta) => meta,66 Err(e) => return Some(Err(e)),67 };68 match meta {69 syn::Meta::NameValue(mnv) => match &mnv.lit {70 syn::Lit::Str(ls) => return Some(Ok(ls.value())),71 _ => unreachable!(),72 },73 _ => unreachable!(),74 }75 }76 }77 None78 })79 .collect()80}8182fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {83 match field.1.ident.as_ref() {84 Some(name) => name.clone(),85 None => {86 let mut name = "field".to_string();87 name.push_str(field.0.to_string().as_str());88 syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())89 }90 }91}9293fn map_field_to_type<'a>(field: &'a syn::Field) -> &'a syn::Type {94 &field.ty95}9697fn map_field_to_doc(field: &syn::Field) -> Result<Vec<std::string::String>, syn::Error> {98 extract_docs(&field.attrs)99}100101fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {102 quote! {103 impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}104 }105}106107fn impl_abi_type<'a>(108 name: &syn::Ident,109 field_types: impl Iterator<Item = &'a syn::Type> + Clone,110) -> proc_macro2::TokenStream {111 let mut params_signature = {112 let types = field_types.clone();113 quote!(114 #(nameof(<#types as ::evm_coder::abi::AbiType>::SIGNATURE) fixed(","))*115 )116 };117118 params_signature.extend(quote!(shift_left(1)));119120 let fields_for_dynamic = field_types.clone();121122 quote! {123 impl ::evm_coder::abi::AbiType for #name {124 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = ::evm_coder::make_signature!(125 new fixed("(")126 #params_signature127 fixed(")")128 );129 fn is_dynamic() -> bool {130 false131 #(132 || <#fields_for_dynamic as ::evm_coder::abi::AbiType>::is_dynamic()133 )*134 }135 fn size() -> usize {136 0 #(+ <#field_types as ::evm_coder::abi::AbiType>::size())*137 }138 }139 }140}141142fn impl_abi_read<'a>(143 name: &syn::Ident,144 is_named_fields: bool,145 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,146 field_types: impl Iterator<Item = &'a syn::Type> + Clone,147) -> proc_macro2::TokenStream {148 let field_names1 = field_names.clone();149150 let struct_constructor = if is_named_fields {151 quote!(Ok(Self { #(#field_names1),* }))152 } else {153 quote!(Ok(Self ( #(#field_names1),* )))154 };155 quote!(156 impl ::evm_coder::abi::AbiRead for #name {157 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {158 let is_dynamic = <Self as ::evm_coder::abi::AbiType>::is_dynamic();159 let size = if !is_dynamic {160 Some(<Self as ::evm_coder::abi::AbiType>::size())161 } else {162 None163 };164 let mut subresult = reader.subresult(size)?;165 #(166 let #field_names = {167 let value = <#field_types as ::evm_coder::abi::AbiRead>::abi_read(&mut subresult)?;168 if !is_dynamic {subresult.bytes_read(<#field_types as ::evm_coder::abi::AbiType>::size())};169 value170 };171 )*172173 #struct_constructor174 }175 }176 )177}178179fn impl_abi_write<'a>(180 name: &syn::Ident,181 is_named_fields: bool,182 params_count: usize,183 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,184) -> proc_macro2::TokenStream {185 let abi_write = if is_named_fields {186 quote!(187 #(188 ::evm_coder::abi::AbiWrite::abi_write(&self.#field_names, sub);189 )*190 )191 } else {192 let field_names = (0..params_count)193 .into_iter()194 .map(proc_macro2::Literal::usize_unsuffixed);195 quote!(196 #(197 ::evm_coder::abi::AbiWrite::abi_write(&self.#field_names, sub);198 )*199 )200 };201 quote!(202 impl ::evm_coder::abi::AbiWrite for #name {203 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {204 if <Self as ::evm_coder::abi::AbiType>::is_dynamic() {205 let mut sub = ::evm_coder::abi::AbiWriter::new();206 {207 let sub = &mut sub;208 #abi_write209 }210 writer.write_subresult(sub);211 } else {212 let sub = writer;213 #abi_write214 }215 }216 }217 )218}219220fn impl_solidity_type<'a>(221 name: &syn::Ident,222 field_types: impl Iterator<Item = &'a syn::Type> + Clone,223 params_count: usize,224) -> proc_macro2::TokenStream {225 let len = proc_macro2::Literal::usize_suffixed(params_count);226 quote! {227 #[cfg(feature = "stubgen")]228 impl ::evm_coder::solidity::SolidityType for #name {229 fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {230 let mut collected =231 Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());232 #({233 let mut out = String::new();234 <#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)235 .expect("no fmt error");236 collected.push(out);237 })*238 collected239 }240241 fn len() -> usize {242 #len243 }244 }245 }246}247248fn impl_solidity_type_name<'a>(249 name: &syn::Ident,250 field_types: impl Iterator<Item = &'a syn::Type> + Clone,251 params_count: usize,252) -> proc_macro2::TokenStream {253 let arg_dafaults = field_types.enumerate().map(|(i, ty)| {254 let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName255 >::solidity_default(writer, tc)?;);256 let last_item = params_count - 1;257 if i != last_item {258 defult_value.extend(quote! {write!(writer, ",")?;})259 }260 defult_value261 });262263 quote! {264 #[cfg(feature = "stubgen")]265 impl ::evm_coder::solidity::SolidityTypeName for #name {266 fn solidity_name(267 writer: &mut impl ::core::fmt::Write,268 tc: &::evm_coder::solidity::TypeCollector,269 ) -> ::core::fmt::Result {270 write!(writer, "{}", tc.collect_struct::<Self>())271 }272273 fn is_simple() -> bool {274 false275 }276277 fn solidity_default(278 writer: &mut impl ::core::fmt::Write,279 tc: &::evm_coder::solidity::TypeCollector,280 ) -> ::core::fmt::Result {281 write!(writer, "{}(", tc.collect_struct::<Self>())?;282283 #(#arg_dafaults)*284285 write!(writer, ")")286 }287 }288 }289}290291fn impl_solidity_struct_collect<'a>(292 name: &syn::Ident,293 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,294 field_types: impl Iterator<Item = &'a syn::Type> + Clone,295 field_docs: impl Iterator<Item = syn::Result<Vec<String>>> + Clone,296 docs: &Vec<String>,297) -> syn::Result<proc_macro2::TokenStream> {298 let string_name = name.to_string();299 let name_type = field_names300 .into_iter()301 .zip(field_types)302 .zip(field_docs)303 .map(|((name, ty), doc)| {304 let field_docs = match doc {305 Ok(doc) => doc.into_iter().enumerate().map(|(i, doc)| {306 let doc = doc.trim();307 let dev = if i == 0 { " @dev" } else { "" };308 quote! {309 writeln!(str, "\t///{} {}", #dev, #doc).unwrap();310 }311 }),312 Err(e) => unreachable!("{:?}", e),313 };314 let name = format!("{}", name);315 quote!(316 #(#field_docs)*317 write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();318 writeln!(str, "{};", #name).unwrap();319 )320 });321 let docs = docs.iter().enumerate().map(|(i, doc)| {322 let doc = doc.trim();323 let dev = if i == 0 { " @dev" } else { "" };324 quote! {325 writeln!(str, "///{} {}", #dev, #doc).unwrap();326 }327 });328329 Ok(quote! {330 #[cfg(feature = "stubgen")]331 impl ::evm_coder::solidity::StructCollect for #name {332 fn name() -> String {333 #string_name.into()334 }335336 fn declaration() -> String {337 use std::fmt::Write;338339 let mut str = String::new();340 #(#docs)*341 writeln!(str, "struct {} {{", Self::name()).unwrap();342 #(#name_type)*343 writeln!(str, "}}").unwrap();344 str345 }346 }347 })348}1use proc_macro2::TokenStream;2use quote::quote;34pub(crate) fn impl_abi_macro(ast: &syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream> {5 let name = &ast.ident;6 let docs = extract_docs(&ast.attrs)?;78 let (is_named_fields, field_names, field_types, field_docs, params_count) = match &ast.data {9 syn::Data::Struct(ds) => match ds.fields {10 syn::Fields::Named(ref fields) => Ok((11 true,12 fields.named.iter().enumerate().map(map_field_to_name),13 fields.named.iter().map(map_field_to_type),14 fields.named.iter().map(map_field_to_doc),15 fields.named.len(),16 )),17 syn::Fields::Unnamed(ref fields) => Ok((18 false,19 fields.unnamed.iter().enumerate().map(map_field_to_name),20 fields.unnamed.iter().map(map_field_to_type),21 fields.unnamed.iter().map(map_field_to_doc),22 fields.unnamed.len(),23 )),24 syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),25 },26 syn::Data::Enum(_) => Err(syn::Error::new(name.span(), "Enums not supported")),27 syn::Data::Union(_) => Err(syn::Error::new(name.span(), "Unions not supported")),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(43 name,44 tuple_type.clone(),45 tuple_names.clone(),46 struct_from_tuple,47 );48 let abi_write = impl_abi_write(name, is_named_fields, tuple_ref_type, tuple_data);49 println!(50 "=========================\n{}\n=========================",51 &abi_write52 );53 let solidity_type = impl_solidity_type(name, field_types.clone(), params_count);54 let solidity_type_name = impl_solidity_type_name(name, field_types.clone(), params_count);55 let solidity_struct_collect =56 impl_solidity_struct_collect(name, field_names, field_types, field_docs, &docs)?;5758 Ok(quote! {59 #can_be_plcaed_in_vec60 #abi_type61 #abi_read62 #abi_write63 #solidity_type64 #solidity_type_name65 #solidity_struct_collect66 })67}6869fn tuple_type<'a>(70 field_types: impl Iterator<Item = &'a syn::Type> + Clone,71) -> proc_macro2::TokenStream {72 let field_types = field_types.map(|ty| quote!(#ty,));73 quote! {(#(#field_types)*)}74}75fn tuple_ref_type<'a>(76 field_types: impl Iterator<Item = &'a syn::Type> + Clone,77) -> proc_macro2::TokenStream {78 let field_types = field_types.map(|ty| quote!(&#ty,));79 quote! {(#(#field_types)*)}80}81fn tuple_data_as_ref(82 is_named_fields: bool,83 field_names: impl Iterator<Item = syn::Ident> + Clone,84) -> proc_macro2::TokenStream {85 let field_names = field_names.enumerate().map(|(i, field)| {86 if is_named_fields {87 quote!(&self.#field,)88 } else {89 let field = proc_macro2::Literal::usize_unsuffixed(i);90 quote!(&self.#field,)91 }92 });93 quote! {(#(#field_names)*)}94}95fn tuple_names(96 is_named_fields: bool,97 field_names: impl Iterator<Item = syn::Ident> + Clone,98) -> proc_macro2::TokenStream {99 let field_names = field_names.enumerate().map(|(i, field)| {100 if is_named_fields {101 quote!(#field,)102 } else {103 let field = proc_macro2::Ident::new(104 format!("field{}", i).as_str(),105 proc_macro2::Span::call_site(),106 );107 quote!(#field,)108 }109 });110 quote! {(#(#field_names)*)}111}112fn struct_from_tuple(113 name: &syn::Ident,114 is_named_fields: bool,115 field_names: impl Iterator<Item = syn::Ident> + Clone,116) -> proc_macro2::TokenStream {117 let field_names = field_names.enumerate().map(|(i, field)| {118 if is_named_fields {119 quote!(#field,)120 } else {121 let field = proc_macro2::Ident::new(122 format!("field{}", i).as_str(),123 proc_macro2::Span::call_site(),124 );125 quote!(#field,)126 }127 });128129 if is_named_fields {130 quote! {#name {#(#field_names)*}}131 } else {132 quote! {#name (#(#field_names)*)}133 }134}135136fn extract_docs(attrs: &Vec<syn::Attribute>) -> syn::Result<Vec<String>> {137 attrs138 .iter()139 .filter_map(|attr| {140 if let Some(ps) = attr.path.segments.first() {141 if ps.ident == "doc" {142 let meta = match attr.parse_meta() {143 Ok(meta) => meta,144 Err(e) => return Some(Err(e)),145 };146 match meta {147 syn::Meta::NameValue(mnv) => match &mnv.lit {148 syn::Lit::Str(ls) => return Some(Ok(ls.value())),149 _ => unreachable!(),150 },151 _ => unreachable!(),152 }153 }154 }155 None156 })157 .collect()158}159160fn map_field_to_name(field: (usize, &syn::Field)) -> syn::Ident {161 match field.1.ident.as_ref() {162 Some(name) => name.clone(),163 None => {164 let mut name = "field".to_string();165 name.push_str(field.0.to_string().as_str());166 syn::Ident::new(name.as_str(), proc_macro2::Span::call_site())167 }168 }169}170171fn map_field_to_type<'a>(field: &'a syn::Field) -> &'a syn::Type {172 &field.ty173}174175fn map_field_to_doc(field: &syn::Field) -> Result<Vec<std::string::String>, syn::Error> {176 extract_docs(&field.attrs)177}178179fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {180 quote! {181 impl ::evm_coder::sealed::CanBePlacedInVec for #ident {}182 }183}184185fn impl_abi_type<'a>(186 name: &syn::Ident,187 tuple_type: proc_macro2::TokenStream,188) -> proc_macro2::TokenStream {189 quote! {190 impl ::evm_coder::abi::AbiType for #name {191 const SIGNATURE: ::evm_coder::custom_signature::SignatureUnit = <#tuple_type as ::evm_coder::abi::AbiType>::SIGNATURE;192 fn is_dynamic() -> bool {193 <#tuple_type as ::evm_coder::abi::AbiType>::is_dynamic()194 }195 fn size() -> usize {196 <#tuple_type as ::evm_coder::abi::AbiType>::size()197 }198 }199 }200}201202fn impl_abi_read<'a>(203 name: &syn::Ident,204 tuple_type: proc_macro2::TokenStream,205 tuple_names: proc_macro2::TokenStream,206 struct_from_tuple: proc_macro2::TokenStream,207) -> proc_macro2::TokenStream {208 quote!(209 impl ::evm_coder::abi::AbiRead for #name {210 fn abi_read(reader: &mut ::evm_coder::abi::AbiReader) -> ::evm_coder::execution::Result<Self> {211 let #tuple_names = <#tuple_type as ::evm_coder::abi::AbiRead>::abi_read(reader)?;212 Ok(#struct_from_tuple)213 }214 }215 )216}217218fn impl_abi_write<'a>(219 name: &syn::Ident,220 is_named_fields: bool,221 tuple_type: proc_macro2::TokenStream,222 tuple_data: proc_macro2::TokenStream,223) -> proc_macro2::TokenStream {224 quote!(225 impl ::evm_coder::abi::AbiWrite for #name {226 fn abi_write(&self, writer: &mut ::evm_coder::abi::AbiWriter) {227 <#tuple_type as ::evm_coder::abi::AbiWrite>::abi_write(&#tuple_data, writer)228 }229 }230 )231}232233fn impl_solidity_type<'a>(234 name: &syn::Ident,235 field_types: impl Iterator<Item = &'a syn::Type> + Clone,236 params_count: usize,237) -> proc_macro2::TokenStream {238 let len = proc_macro2::Literal::usize_suffixed(params_count);239 quote! {240 #[cfg(feature = "stubgen")]241 impl ::evm_coder::solidity::SolidityType for #name {242 fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {243 let mut collected =244 Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());245 #({246 let mut out = String::new();247 <#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)248 .expect("no fmt error");249 collected.push(out);250 })*251 collected252 }253254 fn len() -> usize {255 #len256 }257 }258 }259}260261fn impl_solidity_type_name<'a>(262 name: &syn::Ident,263 field_types: impl Iterator<Item = &'a syn::Type> + Clone,264 params_count: usize,265) -> proc_macro2::TokenStream {266 let arg_dafaults = field_types.enumerate().map(|(i, ty)| {267 let mut defult_value = quote!(<#ty as ::evm_coder::solidity::SolidityTypeName268 >::solidity_default(writer, tc)?;);269 let last_item = params_count - 1;270 if i != last_item {271 defult_value.extend(quote! {write!(writer, ",")?;})272 }273 defult_value274 });275276 quote! {277 #[cfg(feature = "stubgen")]278 impl ::evm_coder::solidity::SolidityTypeName for #name {279 fn solidity_name(280 writer: &mut impl ::core::fmt::Write,281 tc: &::evm_coder::solidity::TypeCollector,282 ) -> ::core::fmt::Result {283 write!(writer, "{}", tc.collect_struct::<Self>())284 }285286 fn is_simple() -> bool {287 false288 }289290 fn solidity_default(291 writer: &mut impl ::core::fmt::Write,292 tc: &::evm_coder::solidity::TypeCollector,293 ) -> ::core::fmt::Result {294 write!(writer, "{}(", tc.collect_struct::<Self>())?;295296 #(#arg_dafaults)*297298 write!(writer, ")")299 }300 }301 }302}303304fn impl_solidity_struct_collect<'a>(305 name: &syn::Ident,306 field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,307 field_types: impl Iterator<Item = &'a syn::Type> + Clone,308 field_docs: impl Iterator<Item = syn::Result<Vec<String>>> + Clone,309 docs: &Vec<String>,310) -> syn::Result<proc_macro2::TokenStream> {311 let string_name = name.to_string();312 let name_type = field_names313 .into_iter()314 .zip(field_types)315 .zip(field_docs)316 .map(|((name, ty), doc)| {317 let field_docs = match doc {318 Ok(doc) => doc.into_iter().enumerate().map(|(i, doc)| {319 let doc = doc.trim();320 let dev = if i == 0 { " @dev" } else { "" };321 quote! {322 writeln!(str, "\t///{} {}", #dev, #doc).unwrap();323 }324 }),325 Err(e) => unreachable!("{:?}", e),326 };327 let name = format!("{}", name);328 quote!(329 #(#field_docs)*330 write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();331 writeln!(str, "{};", #name).unwrap();332 )333 });334 let docs = docs.iter().enumerate().map(|(i, doc)| {335 let doc = doc.trim();336 let dev = if i == 0 { " @dev" } else { "" };337 quote! {338 writeln!(str, "///{} {}", #dev, #doc).unwrap();339 }340 });341342 Ok(quote! {343 #[cfg(feature = "stubgen")]344 impl ::evm_coder::solidity::StructCollect for #name {345 fn name() -> String {346 #string_name.into()347 }348349 fn declaration() -> String {350 use std::fmt::Write;351352 let mut str = String::new();353 #(#docs)*354 writeln!(str, "struct {} {{", Self::name()).unwrap();355 #(#name_type)*356 writeln!(str, "}}").unwrap();357 str358 }359 }360 })361}crates/evm-coder/src/abi/impls.rsdiffbeforeafterboth--- a/crates/evm-coder/src/abi/impls.rs
+++ b/crates/evm-coder/src/abi/impls.rs
@@ -88,6 +88,24 @@
}
}
+impl<T: AbiWrite> AbiWrite for &T {
+ fn abi_write(&self, writer: &mut AbiWriter) {
+ T::abi_write(self, writer);
+ }
+}
+
+impl<T: AbiType> AbiType for &T {
+ const SIGNATURE: SignatureUnit = T::SIGNATURE;
+
+ fn is_dynamic() -> bool {
+ T::is_dynamic()
+ }
+
+ fn size() -> usize {
+ T::size()
+ }
+}
+
impl<T: AbiType + AbiRead + sealed::CanBePlacedInVec> AbiRead for Vec<T> {
fn abi_read(reader: &mut AbiReader) -> Result<Vec<T>> {
let mut sub = reader.subresult(None)?;
@@ -148,7 +166,7 @@
impl AbiWrite for Property {
fn abi_write<'a>(&'a self, writer: &mut AbiWriter) {
- (self.key.clone(), self.value.clone()).abi_write(writer);
+ (&self.key, &self.value).abi_write(writer);
}
}
crates/evm-coder/src/abi/traits.rsdiffbeforeafterboth--- a/crates/evm-coder/src/abi/traits.rs
+++ b/crates/evm-coder/src/abi/traits.rs
@@ -43,9 +43,3 @@
Ok(writer.into())
}
}
-
-impl<T: AbiWrite> AbiWrite for &T {
- fn abi_write(&self, writer: &mut AbiWriter) {
- T::abi_write(self, writer);
- }
-}