git.delta.rocks / unique-network / refs/commits / be088e7492dc

1use quote::quote;1use quote::quote;
2
3use super::extract_docs;
24
3pub fn impl_solidity_option<'a>(5pub fn impl_solidity_option<'a>(
6	docs: Vec<String>,
4	name: &proc_macro2::Ident,7	name: &proc_macro2::Ident,
5	enum_options: impl Iterator<Item = &'a syn::Ident>,8	enum_options: impl Iterator<Item = &'a syn::Variant> + Clone,
6) -> proc_macro2::TokenStream {9) -> proc_macro2::TokenStream {
7	let enum_options = enum_options.map(|opt| {10	let variant_names = enum_options.clone().map(|opt| {
11		let opt = &opt.ident;
8		let s = name.to_string() + "." + opt.to_string().as_str();12		let s = name.to_string() + "." + opt.to_string().as_str();
9		let as_string = proc_macro2::Literal::string(s.as_str());13		let as_string = proc_macro2::Literal::string(s.as_str());
10		quote!(#name::#opt => #as_string,)14		quote!(#name::#opt => #as_string,)
11	});15	});
16	let solidity_name = name.to_string();
17
18	let solidity_fields = enum_options.map(|v| {
19		let docs = extract_docs(&v.attrs).expect("TODO: handle bad docs");
20		let name = v.ident.to_string();
21		quote! {
22			SolidityEnumVariant {
23				docs: &[#(#docs),*],
24				name: #name,
25			}
26		}
27	});
28
12	quote!(29	quote!(
13		#[cfg(feature = "stubgen")]30		#[cfg(feature = "stubgen")]
14		impl ::evm_coder::solidity::SolidityEnum for #name {31		impl ::evm_coder::solidity::SolidityEnumTy for #name {
32			fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector) -> String {
33				use evm_coder::solidity::*;
34				use core::fmt::Write;
35				let interface = SolidityEnum {
36					docs: &[#(#docs),*],
37					name: #solidity_name,
38					fields: &[#(
39						#solidity_fields,
40					)*],
41				};
42				let mut out = String::new();
43				let _ = interface.format(&mut out, tc);
44				tc.collect(out);
45				#solidity_name.to_string()
46			}
15			fn solidity_option(&self) -> &str {47			fn solidity_option(&self) -> &str {
16				match self {48				match self {
17					#(#enum_options)*49					#(#variant_names)*
18				}50				}
19			}51			}
20		}52		}
2355
24pub fn impl_enum_from_u8<'a>(56pub fn impl_enum_from_u8<'a>(
25	name: &proc_macro2::Ident,57	name: &proc_macro2::Ident,
26	enum_options: impl Iterator<Item = &'a syn::Ident>,58	enum_options: impl Iterator<Item = &'a syn::Variant>,
27) -> proc_macro2::TokenStream {59) -> proc_macro2::TokenStream {
28	let error_str = format!("Value not convertible into enum \"{name}\"");60	let error_str = format!("Value not convertible into enum \"{name}\"");
29	let error_str = proc_macro2::Literal::string(&error_str);61	let error_str = proc_macro2::Literal::string(&error_str);
30	let enum_options = enum_options.enumerate().map(|(i, opt)| {62	let enum_options = enum_options.enumerate().map(|(i, opt)| {
63		let opt = &opt.ident;
31		let n = proc_macro2::Literal::u8_suffixed(i as u8);64		let n = proc_macro2::Literal::u8_suffixed(i as u8);
32		quote! {#n => Ok(#name::#opt),}65		quote! {#n => Ok(#name::#opt),}
33	});66	});
85	)118	)
86}119}
87
88pub fn impl_enum_solidity_type<'a>(name: &syn::Ident) -> proc_macro2::TokenStream {
89	quote! {
90		#[cfg(feature = "stubgen")]
91		impl ::evm_coder::solidity::SolidityType for #name {
92			fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {
93				Vec::new()
94			}
95
96			fn len() -> usize {
97				1
98			}
99		}
100	}
101}
102120
103pub fn impl_enum_solidity_type_name(name: &syn::Ident) -> proc_macro2::TokenStream {121pub fn impl_enum_solidity_type_name(name: &syn::Ident) -> proc_macro2::TokenStream {
104	quote!(122	quote!(
108				writer: &mut impl ::core::fmt::Write,126				writer: &mut impl ::core::fmt::Write,
109				tc: &::evm_coder::solidity::TypeCollector,127				tc: &::evm_coder::solidity::TypeCollector,
110			) -> ::core::fmt::Result {128			) -> ::core::fmt::Result {
111				write!(writer, "{}", tc.collect_struct::<Self>())129				write!(writer, "{}", tc.collect_enum::<Self>())
112			}130			}
113131
114			fn is_simple() -> bool {132			fn is_simple() -> bool {
119				writer: &mut impl ::core::fmt::Write,137				writer: &mut impl ::core::fmt::Write,
120				tc: &::evm_coder::solidity::TypeCollector,138				tc: &::evm_coder::solidity::TypeCollector,
121			) -> ::core::fmt::Result {139			) -> ::core::fmt::Result {
122				write!(writer, "{}", <#name as ::evm_coder::solidity::SolidityEnum>::solidity_option(&<#name>::default()))140				write!(writer, "{}", <#name as ::evm_coder::solidity::SolidityEnumTy>::solidity_option(&<#name>::default()))
123			}141			}
124		}142		}
125	)143	)
126}144}
127
128pub fn impl_enum_solidity_struct_collect<'a>(
129	name: &syn::Ident,
130	enum_options: impl Iterator<Item = &'a syn::Ident>,
131	option_count: usize,
132	enum_options_docs: impl Iterator<Item = syn::Result<Vec<proc_macro2::TokenStream>>>,
133	docs: &[proc_macro2::TokenStream],
134) -> proc_macro2::TokenStream {
135	let string_name = name.to_string();
136	let enum_options = enum_options
137		.zip(enum_options_docs)
138		.enumerate()
139		.map(|(i, (opt, doc))| {
140			let opt = proc_macro2::Literal::string(opt.to_string().as_str());
141			let doc = doc.expect("Doc parsing error");
142			let comma = if i != option_count - 1 { "," } else { "" };
143			quote! {
144				#(#doc)*
145				writeln!(str, "\t{}{}", #opt, #comma).expect("Enum format option");
146			}
147		});
148
149	quote!(
150		#[cfg(feature = "stubgen")]
151		impl ::evm_coder::solidity::StructCollect for #name {
152			fn name() -> String {
153				#string_name.into()
154			}
155
156			fn declaration() -> String {
157				use std::fmt::Write;
158
159				let mut str = String::new();
160				#(#docs)*
161				writeln!(str, "enum {} {{", <Self as ::evm_coder::solidity::StructCollect>::name()).unwrap();
162				#(#enum_options)*
163				writeln!(str, "}}").unwrap();
164				str
165			}
166		}
167	)
168}
169145
170pub fn check_and_count_options(de: &syn::DataEnum) -> syn::Result<usize> {146pub fn check_and_count_options(de: &syn::DataEnum) -> syn::Result<usize> {
171	let mut count = 0;147	let mut count = 0;

1use super::extract_docs;1use super::extract_docs;
2use quote::quote;2use quote::quote;
3use syn::Field;
34
4pub fn tuple_type<'a>(5pub fn tuple_type<'a>(
5	field_types: impl Iterator<Item = &'a syn::Type> + Clone,6	field_types: impl Iterator<Item = &'a syn::Type> + Clone,
87	&field.ty88	&field.ty
88}89}
89
90pub fn map_field_to_doc(field: &syn::Field) -> syn::Result<Vec<proc_macro2::TokenStream>> {
91	extract_docs(&field.attrs, true)
92}
9390
94pub fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {91pub fn impl_can_be_placed_in_vec(ident: &syn::Ident) -> proc_macro2::TokenStream {
95	quote! {92	quote! {
147144
148pub fn impl_struct_solidity_type<'a>(145pub fn impl_struct_solidity_type<'a>(
149	name: &syn::Ident,146	name: &syn::Ident,
147	docs: Vec<String>,
150	field_types: impl Iterator<Item = &'a syn::Type> + Clone,148	fields: impl Iterator<Item = &'a Field> + Clone,
151	params_count: usize,
152) -> proc_macro2::TokenStream {149) -> proc_macro2::TokenStream {
150	let solidity_name = name.to_string();
153	let len = proc_macro2::Literal::usize_suffixed(params_count);151	let solidity_fields = fields.enumerate().map(|(i, f)| {
152		let name = f
153			.ident
154			.as_ref()
155			.map(|i| i.to_string())
156			.unwrap_or_else(|| format!("field_{i}"));
157		let ty = &f.ty;
158		let docs = extract_docs(&f.attrs).expect("TODO: handle bad docs");
159		quote! {
160			SolidityStructField::<#ty> {
161				docs: &[#(#docs),*],
162				name: #name,
163				ty: ::core::marker::PhantomData,
164			}
165		}
166	});
154	quote! {167	quote! {
155		#[cfg(feature = "stubgen")]168		#[cfg(feature = "stubgen")]
156		impl ::evm_coder::solidity::SolidityType for #name {169		impl ::evm_coder::solidity::SolidityStructTy for #name {
170			/// Generate solidity definitions for methods described in this struct
157			fn names(tc: &::evm_coder::solidity::TypeCollector) -> Vec<String> {171			fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector) -> String {
158				let mut collected =
159					Vec::with_capacity(<Self as ::evm_coder::solidity::SolidityType>::len());172				use evm_coder::solidity::*;
173				use core::fmt::Write;
174				let interface = SolidityStruct {
175					docs: &[#(#docs),*],
160				#({176					name: #solidity_name,
177					fields: (#(
178						#solidity_fields,
179					)*),
180				};
161					let mut out = String::new();181				let mut out = String::new();
162					<#field_types as ::evm_coder::solidity::SolidityTypeName>::solidity_name(&mut out, tc)182				let _ = interface.format(&mut out, tc);
163						.expect("no fmt error");
164					collected.push(out);183				tc.collect(out);
165				})*
166				collected
167			}
168
169			fn len() -> usize {
170				#len184				#solidity_name.to_string()
171			}185			}
172		}186		}
173	}187	}
174}188}
216	}230	}
217}231}
218
219pub fn impl_struct_solidity_struct_collect<'a>(
220	name: &syn::Ident,
221	field_names: impl Iterator<Item = proc_macro2::Ident> + Clone,
222	field_types: impl Iterator<Item = &'a syn::Type> + Clone,
223	field_docs: impl Iterator<Item = syn::Result<Vec<proc_macro2::TokenStream>>> + Clone,
224	docs: &[proc_macro2::TokenStream],
225) -> syn::Result<proc_macro2::TokenStream> {
226	let string_name = name.to_string();
227	let name_type = field_names
228		.into_iter()
229		.zip(field_types)
230		.zip(field_docs)
231		.map(|((name, ty), doc)| {
232			let field_docs = doc.expect("Doc parse error");
233			let name = format!("{}", name);
234			quote!(
235				#(#field_docs)*
236				write!(str, "\t{} ", <#ty as ::evm_coder::solidity::StructCollect>::name()).unwrap();
237				writeln!(str, "{};", #name).unwrap();
238			)
239		});
240
241	Ok(quote! {
242		#[cfg(feature = "stubgen")]
243		impl ::evm_coder::solidity::StructCollect for #name {
244			fn name() -> String {
245				#string_name.into()
246			}
247
248			fn declaration() -> String {
249				use std::fmt::Write;
250
251				let mut str = String::new();
252				#(#docs)*
253				writeln!(str, "struct {} {{", Self::name()).unwrap();
254				#(#name_type)*
255				writeln!(str, "}}").unwrap();
256				str
257			}
258		}
259	})
260}
261232

19	ast: &syn::DeriveInput,19	ast: &syn::DeriveInput,
20) -> syn::Result<proc_macro2::TokenStream> {20) -> syn::Result<proc_macro2::TokenStream> {
21	let name = &ast.ident;21	let name = &ast.ident;
22	let docs = extract_docs(&ast.attrs, false)?;22	let docs = extract_docs(&ast.attrs)?;
23	let (is_named_fields, field_names, field_types, field_docs, params_count) = match ds.fields {23	let (is_named_fields, field_names, field_types, params_count) = match ds.fields {
24		syn::Fields::Named(ref fields) => Ok((24		syn::Fields::Named(ref fields) => Ok((
25			true,25			true,
26			fields.named.iter().enumerate().map(map_field_to_name),26			fields.named.iter().enumerate().map(map_field_to_name),
27			fields.named.iter().map(map_field_to_type),27			fields.named.iter().map(map_field_to_type),
28			fields.named.iter().map(map_field_to_doc),
29			fields.named.len(),28			fields.named.len(),
30		)),29		)),
31		syn::Fields::Unnamed(ref fields) => Ok((30		syn::Fields::Unnamed(ref fields) => Ok((
32			false,31			false,
33			fields.unnamed.iter().enumerate().map(map_field_to_name),32			fields.unnamed.iter().enumerate().map(map_field_to_name),
34			fields.unnamed.iter().map(map_field_to_type),33			fields.unnamed.iter().map(map_field_to_type),
35			fields.unnamed.iter().map(map_field_to_doc),
36			fields.unnamed.len(),34			fields.unnamed.len(),
37		)),35		)),
38		syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),36		syn::Fields::Unit => Err(syn::Error::new(name.span(), "Unit structs not supported")),
52	let abi_type = impl_struct_abi_type(name, tuple_type.clone());50	let abi_type = impl_struct_abi_type(name, tuple_type.clone());
53	let abi_read = impl_struct_abi_read(name, tuple_type, tuple_names, struct_from_tuple);51	let abi_read = impl_struct_abi_read(name, tuple_type, tuple_names, struct_from_tuple);
54	let abi_write = impl_struct_abi_write(name, is_named_fields, tuple_ref_type, tuple_data);52	let abi_write = impl_struct_abi_write(name, is_named_fields, tuple_ref_type, tuple_data);
55	let solidity_type = impl_struct_solidity_type(name, field_types.clone(), params_count);53	let solidity_type = impl_struct_solidity_type(name, docs, ds.fields.iter());
56	let solidity_type_name =54	let solidity_type_name =
57		impl_struct_solidity_type_name(name, field_types.clone(), params_count);55		impl_struct_solidity_type_name(name, field_types.clone(), params_count);
58	let solidity_struct_collect =
59		impl_struct_solidity_struct_collect(name, field_names, field_types, field_docs, &docs)?;
6056
61	Ok(quote! {57	Ok(quote! {
62		#can_be_plcaed_in_vec58		#can_be_plcaed_in_vec
65		#abi_write61		#abi_write
66		#solidity_type62		#solidity_type
67		#solidity_type_name63		#solidity_type_name
68		#solidity_struct_collect
69	})64	})
70}65}
7166
75) -> syn::Result<proc_macro2::TokenStream> {70) -> syn::Result<proc_macro2::TokenStream> {
76	let name = &ast.ident;71	let name = &ast.ident;
77	check_repr_u8(name, &ast.attrs)?;72	check_repr_u8(name, &ast.attrs)?;
78	let docs = extract_docs(&ast.attrs, false)?;73	let docs = extract_docs(&ast.attrs)?;
79	let option_count = check_and_count_options(de)?;
80	let enum_options = de.variants.iter().map(|v| &v.ident);74	let enum_options = de.variants.iter();
81	let enum_options_docs = de.variants.iter().map(|v| extract_docs(&v.attrs, true));
8275
83	let from = impl_enum_from_u8(name, enum_options.clone());76	let from = impl_enum_from_u8(name, enum_options.clone());
84	let solidity_option = impl_solidity_option(name, enum_options.clone());77	let solidity_option = impl_solidity_option(docs, name, enum_options.clone());
85	let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);78	let can_be_plcaed_in_vec = impl_can_be_placed_in_vec(name);
86	let abi_type = impl_enum_abi_type(name);79	let abi_type = impl_enum_abi_type(name);
87	let abi_read = impl_enum_abi_read(name);80	let abi_read = impl_enum_abi_read(name);
88	let abi_write = impl_enum_abi_write(name);81	let abi_write = impl_enum_abi_write(name);
89	let solidity_type = impl_enum_solidity_type(name);
90	let solidity_type_name = impl_enum_solidity_type_name(name);82	let solidity_type_name = impl_enum_solidity_type_name(name);
91	let solidity_struct_collect = impl_enum_solidity_struct_collect(
92		name,
93		enum_options,
94		option_count,
95		enum_options_docs,
96		&docs,
97	);
9883
99	Ok(quote! {84	Ok(quote! {
100		#from85		#from
103		#abi_type88		#abi_type
104		#abi_read89		#abi_read
105		#abi_write90		#abi_write
106		#solidity_type
107		#solidity_type_name91		#solidity_type_name
108		#solidity_struct_collect
109	})92	})
110}93}
11194
112fn extract_docs(95fn extract_docs(attrs: &[syn::Attribute]) -> syn::Result<Vec<String>> {
113	attrs: &[syn::Attribute],
114	is_field_doc: bool,
115) -> syn::Result<Vec<proc_macro2::TokenStream>> {
116	attrs96	attrs
117		.iter()97		.iter()
118		.filter_map(|attr| {98		.filter_map(|attr| {
133			}113			}
134			None114			None
135		})115		})
136		.enumerate()
137		.map(|(i, doc)| {
138			let doc = doc?;
139			let doc = doc.trim();
140			let dev = if i == 0 { " @dev" } else { "" };
141			let tab = if is_field_doc { "\t" } else { "" };
142			Ok(quote! {
143				writeln!(str, "{}///{} {}", #tab, #dev, #doc).unwrap();
144			})
145		})
146		.collect()116		.collect()
147}117}
148118

1use super::{TypeCollector, SolidityTypeName, SolidityType, StructCollect};1use super::{TypeCollector, SolidityTypeName, SolidityTupleTy};
2use crate::{sealed, types::*};2use crate::{sealed, types::*};
3use core::fmt;3use core::fmt;
4use primitive_types::{U256, H160};4use primitive_types::{U256, H160};
18				}18				}
19            }19            }
20
21			impl StructCollect for $ty {
22				fn name() -> String {
23					$name.to_string()
24				}
25
26				fn declaration() -> String {
27					String::default()
28				}
29			}
30        )*20        )*
31    };21    };
32}22}
74	}64	}
75}65}
76
77impl<T: StructCollect + sealed::CanBePlacedInVec> StructCollect for Vec<T> {
78	fn name() -> String {
79		<T as StructCollect>::name() + "[]"
80	}
81
82	fn declaration() -> String {
83		unimplemented!("Vectors have not declarations.")
84	}
85}
8666
87macro_rules! count {67macro_rules! count {
88    () => (0usize);68    () => (0usize);
9171
92macro_rules! impl_tuples {72macro_rules! impl_tuples {
93	($($ident:ident)+) => {73	($($ident:ident)+) => {
94		impl<$($ident: SolidityTypeName + 'static),+> SolidityType for ($($ident,)+) {74		impl<$($ident: SolidityTypeName + 'static),+> SolidityTupleTy for ($($ident,)+) {
95			fn names(tc: &TypeCollector) -> Vec<string> {75			fn fields(tc: &TypeCollector) -> Vec<string> {
96				let mut collected = Vec::with_capacity(Self::len());76				let mut collected = Vec::with_capacity(Self::len());
97				$({77				$({
98					let mut out = string::new();78					let mut out = string::new();

44	/// id ordering is required to perform topo-sort on the resulting data44	/// id ordering is required to perform topo-sort on the resulting data
45	structs: RefCell<BTreeMap<string, usize>>,45	structs: RefCell<BTreeMap<string, usize>>,
46	anonymous: RefCell<BTreeMap<Vec<string>, usize>>,46	anonymous: RefCell<BTreeMap<Vec<string>, usize>>,
47	// generic: RefCell<BTreeMap<string, usize>>,
47	id: Cell<usize>,48	id: Cell<usize>,
48}49}
49impl TypeCollector {50impl TypeCollector {
59		self.id.set(v + 1);60		self.id.set(v + 1);
60		v61		v
61	}62	}
63	/// Collect typle, deduplicating it by type, and returning generated name
62	pub fn collect_tuple<T: SolidityType>(&self) -> String {64	pub fn collect_tuple<T: SolidityTupleTy>(&self) -> String {
63		let names = T::names(self);65		let names = T::fields(self);
64		if let Some(id) = self.anonymous.borrow().get(&names).cloned() {66		if let Some(id) = self.anonymous.borrow().get(&names).cloned() {
65			return format!("Tuple{}", id);67			return format!("Tuple{}", id);
66		}68		}
76		self.anonymous.borrow_mut().insert(names, id);78		self.anonymous.borrow_mut().insert(names, id);
77		format!("Tuple{}", id)79		format!("Tuple{}", id)
78	}80	}
79	pub fn collect_struct<T: StructCollect + SolidityType>(&self) -> String {81	pub fn collect_struct<T: SolidityStructTy>(&self) -> String {
80		let _names = T::names(self);82		T::generate_solidity_interface(self)
81		self.collect(<T as StructCollect>::declaration());
82		<T as StructCollect>::name()
83	}83	}
84	pub fn collect_enum<T: SolidityEnumTy>(&self) -> String {
85		T::generate_solidity_interface(self)
86	}
84	pub fn finish(self) -> Vec<string> {87	pub fn finish(self) -> Vec<string> {
85		let mut data = self.structs.into_inner().into_iter().collect::<Vec<_>>();88		let mut data = self.structs.into_inner().into_iter().collect::<Vec<_>>();
86		data.sort_by_key(|(_, id)| Reverse(*id));89		data.sort_by_key(|(_, id)| Reverse(*id));
421	}424	}
422}425}
426
427#[impl_for_tuples(0, 48)]
428impl SolidityItems for Tuple {
429	for_tuples!( where #( Tuple: SolidityItems ),* );
430
431	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
432		for_tuples!( #(
433            Tuple.solidity_name(writer, tc)?;
434        )* );
435		Ok(())
436	}
437}
438
439pub struct SolidityStructField<T> {
440	pub docs: &'static [&'static str],
441	pub name: &'static str,
442	pub ty: PhantomData<*const T>,
443}
444
445impl<T> SolidityItems for SolidityStructField<T>
446where
447	T: SolidityTypeName,
448{
449	fn solidity_name(&self, out: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
450		for doc in self.docs {
451			writeln!(out, "///{}", doc)?;
452		}
453		write!(out, "\t")?;
454		T::solidity_name(out, tc)?;
455		writeln!(out, " {};", self.name)?;
456		Ok(())
457	}
458}
459pub struct SolidityStruct<F> {
460	pub docs: &'static [&'static str],
461	// pub generics:
462	pub name: &'static str,
463	pub fields: F,
464}
465impl<F> SolidityStruct<F>
466where
467	F: SolidityItems,
468{
469	pub fn format(&self, out: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
470		for doc in self.docs {
471			writeln!(out, "///{}", doc)?;
472		}
473		writeln!(out, "struct {} {{", self.name)?;
474		self.fields.solidity_name(out, tc)?;
475		writeln!(out, "}}")?;
476		Ok(())
477	}
478}
479
480pub struct SolidityEnumVariant {
481	pub docs: &'static [&'static str],
482	pub name: &'static str,
483}
484impl SolidityItems for SolidityEnumVariant {
485	fn solidity_name(&self, out: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {
486		for doc in self.docs {
487			writeln!(out, "///{}", doc)?;
488		}
489		write!(out, "\t{}", self.name)?;
490		Ok(())
491	}
492}
493pub struct SolidityEnum {
494	pub docs: &'static [&'static str],
495	pub name: &'static str,
496	pub fields: &'static [SolidityEnumVariant],
497}
498impl SolidityEnum {
499	pub fn format(&self, out: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {
500		for doc in self.docs {
501			writeln!(out, "///{}", doc)?;
502		}
503		write!(out, "enum {} {{", self.name)?;
504		for (i, field) in self.fields.iter().enumerate() {
505			if i != 0 {
506				write!(out, ",")?;
507			}
508			writeln!(out)?;
509			field.solidity_name(out, tc)?;
510		}
511		writeln!(out)?;
512		writeln!(out, "}}")?;
513		Ok(())
514	}
515}
423516

1use super::TypeCollector;1use super::TypeCollector;
2use core::fmt;2use core::fmt;
3
4pub trait StructCollect: 'static {
5	/// Structure name.
6	fn name() -> String;
7	/// Structure declaration.
8	fn declaration() -> String;
9}
10
11pub trait SolidityEnum: 'static {
12	fn solidity_option(&self) -> &str;
13}
143
15pub trait SolidityTypeName: 'static {4pub trait SolidityTypeName: 'static {
16	fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;5	fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
23	}12	}
24}13}
2514
26pub trait SolidityType {15pub trait SolidityTupleTy: 'static {
27	fn names(tc: &TypeCollector) -> Vec<String>;16	fn fields(tc: &TypeCollector) -> Vec<String>;
28	fn len() -> usize;17	fn len() -> usize;
29}18}
19pub trait SolidityStructTy: 'static {
20	fn generate_solidity_interface(tc: &TypeCollector) -> String;
21}
22pub trait SolidityEnumTy: 'static {
23	fn generate_solidity_interface(tc: &TypeCollector) -> String;
24	fn solidity_option(&self) -> &str;
25}
3026
31pub trait SolidityArguments {27pub trait SolidityArguments {
32	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;28	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
47	) -> fmt::Result;43	) -> fmt::Result;
48}44}
45
46pub trait SolidityItems {
47	fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;
48	// For PhantomData fields
49	// fn is_void()
50}
4951

73		_c: TypeStruct2MixedParam,73		_c: TypeStruct2MixedParam,
74	}74	}
75
76	#[test]
77	#[cfg(feature = "stubgen")]
78	fn struct_collect_type_struct3_derived_mixed_param() {
79		assert_eq!(
80			<TypeStruct3DerivedMixedParam as ::evm_coder::solidity::StructCollect>::name(),
81			"TypeStruct3DerivedMixedParam"
82		);
83		similar_asserts::assert_eq!(
84			<TypeStruct3DerivedMixedParam as ::evm_coder::solidity::StructCollect>::declaration(),
85			r#"/// @dev Some docs
86/// At multi
87/// line
88struct TypeStruct3DerivedMixedParam {
89	/// @dev Docs for A
90	/// multi
91	/// line
92	TypeStruct1SimpleParam _a;
93	/// @dev Docs for B
94	TypeStruct2DynamicParam _b;
95	/// @dev Docs for C
96	TypeStruct2MixedParam _c;
97}
98"#
99		);
100	}
101
102	#[test]
103	#[cfg(feature = "stubgen")]
104	fn struct_collect_vec() {
105		assert_eq!(
106			<Vec<u8> as ::evm_coder::solidity::StructCollect>::name(),
107			"uint8[]"
108		);
109	}
11075
111	#[test]76	#[test]
112	fn impl_abi_type_signature() {77	fn impl_abi_type_signature() {
302		TupleStruct2MixedParam,267		TupleStruct2MixedParam,
303	);268	);
304
305	#[test]
306	#[cfg(feature = "stubgen")]
307	fn struct_collect_tuple_struct3_derived_mixed_param() {
308		assert_eq!(
309			<TupleStruct3DerivedMixedParam as ::evm_coder::solidity::StructCollect>::name(),
310			"TupleStruct3DerivedMixedParam"
311		);
312		similar_asserts::assert_eq!(
313			<TupleStruct3DerivedMixedParam as ::evm_coder::solidity::StructCollect>::declaration(),
314			r#"/// @dev Some docs
315/// At multi
316/// line
317struct TupleStruct3DerivedMixedParam {
318	/// @dev Docs for A
319	/// multi
320	/// line
321	TupleStruct1SimpleParam field0;
322	TupleStruct2DynamicParam field1;
323	/// @dev Docs for C
324	TupleStruct2MixedParam field2;
325}
326"#
327		);
328	}
329269
330	#[test]270	#[test]
331	fn impl_abi_type_signature_same_for_structs() {271	fn impl_abi_type_signature_same_for_structs() {
823		}763		}
824	}764	}
825
826	#[test]
827	#[cfg(feature = "stubgen")]
828	fn struct_collect_enum() {
829		assert_eq!(
830			<Color as ::evm_coder::solidity::StructCollect>::name(),
831			"Color"
832		);
833		similar_asserts::assert_eq!(
834			<Color as ::evm_coder::solidity::StructCollect>::declaration(),
835			r#"/// @dev Some docs
836/// At multi
837/// line
838enum Color {
839	/// @dev Docs for Red
840	/// multi
841	/// line
842	Red,
843	Green,
844	/// @dev Docs for Blue
845	Blue
846}
847"#
848		);
849	}
850}765}
851766