difftreelog
feat support complex types in solidity defs
in: master
5 files changed
crates/evm-coder-macros/src/solidity_interface.rsdiffbeforeafterboth--- a/crates/evm-coder-macros/src/solidity_interface.rs
+++ b/crates/evm-coder-macros/src/solidity_interface.rs
@@ -1,16 +1,16 @@
#![allow(dead_code)]
use quote::quote;
-use darling::FromMeta;
+use darling::{FromMeta, ToTokens};
use inflector::cases;
use std::fmt::Write;
use syn::{
- FnArg, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Meta, NestedMeta, PatType, Path,
- ReturnType, Type, spanned::Spanned,
+ Expr, FnArg, GenericArgument, Generics, Ident, ImplItem, ImplItemMethod, ItemImpl, Lit, Meta,
+ NestedMeta, PatType, Path, PathArguments, ReturnType, Type, spanned::Spanned,
};
use crate::{
- fn_selector_str, parse_ident_from_pat, parse_ident_from_path, parse_ident_from_type,
+ fn_selector_str, parse_ident_from_pat, parse_ident_from_path, parse_path, parse_path_segment,
parse_result_ok, pascal_ident_to_call, pascal_ident_to_snake_call, snake_ident_to_pascal,
snake_ident_to_screaming,
};
@@ -77,14 +77,14 @@
fn expand_generator(&self) -> proc_macro2::TokenStream {
let pascal_call_name = &self.pascal_call_name;
quote! {
- #pascal_call_name::generate_solidity_interface(out_set, is_impl);
+ #pascal_call_name::generate_solidity_interface(tc, is_impl);
}
}
fn expand_event_generator(&self) -> proc_macro2::TokenStream {
let name = &self.name;
quote! {
- #name::generate_solidity_interface(out_set, is_impl);
+ #name::generate_solidity_interface(tc, is_impl);
}
}
}
@@ -121,10 +121,161 @@
rename_selector: Option<String>,
}
+enum AbiType {
+ // type
+ Plain(Ident),
+ // (type1,type2)
+ Tuple(Vec<AbiType>),
+ // type[]
+ Vec(Box<AbiType>),
+ // type[20]
+ Array(Box<AbiType>, usize),
+}
+impl AbiType {
+ fn try_from(value: &Type) -> syn::Result<Self> {
+ let value = Self::try_maybe_special_from(value)?;
+ if value.is_special() {
+ return Err(syn::Error::new(value.span(), "unexpected special type"));
+ }
+ Ok(value)
+ }
+ fn try_maybe_special_from(value: &Type) -> syn::Result<Self> {
+ match value {
+ Type::Array(arr) => {
+ let wrapped = AbiType::try_from(&arr.elem)?;
+ match &arr.len {
+ Expr::Lit(l) => match &l.lit {
+ Lit::Int(i) => {
+ let num = i.base10_parse::<usize>()?;
+ Ok(AbiType::Array(Box::new(wrapped), num as usize))
+ }
+ _ => Err(syn::Error::new(arr.len.span(), "should be int literal")),
+ },
+ _ => Err(syn::Error::new(arr.len.span(), "should be literal")),
+ }
+ }
+ Type::Path(_) => {
+ let path = parse_path(value)?;
+ let segment = parse_path_segment(path)?;
+ if segment.ident == "Vec" {
+ let args = match &segment.arguments {
+ PathArguments::AngleBracketed(e) => e,
+ _ => {
+ return Err(syn::Error::new(
+ segment.arguments.span(),
+ "missing Vec generic",
+ ))
+ }
+ };
+ let args = &args.args;
+ if args.len() != 1 {
+ return Err(syn::Error::new(
+ args.span(),
+ "expected only one generic for vec",
+ ));
+ }
+ let arg = args.first().unwrap();
+
+ let ty = match arg {
+ GenericArgument::Type(ty) => ty,
+ _ => {
+ return Err(syn::Error::new(
+ arg.span(),
+ "expected first generic to be type",
+ ))
+ }
+ };
+
+ let wrapped = AbiType::try_from(ty)?;
+ Ok(Self::Vec(Box::new(wrapped)))
+ } else {
+ if !segment.arguments.is_empty() {
+ return Err(syn::Error::new(
+ segment.arguments.span(),
+ "unexpected generic arguments for non-vec type",
+ ));
+ }
+ Ok(Self::Plain(segment.ident.clone()))
+ }
+ }
+ Type::Tuple(t) => {
+ let mut out = Vec::with_capacity(t.elems.len());
+ for el in t.elems.iter() {
+ out.push(AbiType::try_from(el)?)
+ }
+ Ok(Self::Tuple(out))
+ }
+ _ => Err(syn::Error::new(
+ value.span(),
+ "unexpected type, only arrays, plain types and tuples are supported",
+ )),
+ }
+ }
+ fn is_value(&self) -> bool {
+ match self {
+ Self::Plain(v) if v == "value" => true,
+ _ => false,
+ }
+ }
+ fn is_caller(&self) -> bool {
+ match self {
+ Self::Plain(v) if v == "caller" => true,
+ _ => false,
+ }
+ }
+ fn is_special(&self) -> bool {
+ self.is_caller() || self.is_value()
+ }
+ fn selector_ty_buf(&self, buf: &mut String) -> std::fmt::Result {
+ match self {
+ AbiType::Plain(t) => {
+ write!(buf, "{}", t)
+ }
+ AbiType::Tuple(t) => {
+ write!(buf, "(")?;
+ for (i, t) in t.iter().enumerate() {
+ if i != 0 {
+ write!(buf, ",")?;
+ }
+ t.selector_ty_buf(buf)?;
+ }
+ write!(buf, ")")
+ }
+ AbiType::Vec(v) => {
+ v.selector_ty_buf(buf)?;
+ write!(buf, "[]")
+ }
+ AbiType::Array(v, len) => {
+ v.selector_ty_buf(buf)?;
+ write!(buf, "[{}]", len)
+ }
+ }
+ }
+ fn selector_ty(&self) -> String {
+ let mut out = String::new();
+ self.selector_ty_buf(&mut out).expect("no fmt error");
+ out
+ }
+}
+impl ToTokens for AbiType {
+ fn to_tokens(&self, tokens: &mut proc_macro2::TokenStream) {
+ match self {
+ AbiType::Plain(t) => tokens.extend(quote! {#t}),
+ AbiType::Tuple(t) => {
+ tokens.extend(quote! {(
+ #(#t),*
+ )});
+ }
+ AbiType::Vec(v) => tokens.extend(quote! {Vec<#v>}),
+ AbiType::Array(v, l) => tokens.extend(quote! {[#v; #l]}),
+ }
+ }
+}
+
struct MethodArg {
name: Ident,
camel_name: String,
- ty: Ident,
+ ty: AbiType,
}
impl MethodArg {
fn try_from(value: &PatType) -> syn::Result<Self> {
@@ -132,21 +283,21 @@
Ok(Self {
camel_name: cases::camelcase::to_camel_case(&name.to_string()),
name,
- ty: parse_ident_from_type(&value.ty, false)?.clone(),
+ ty: AbiType::try_maybe_special_from(&value.ty)?,
})
}
fn is_value(&self) -> bool {
- self.ty == "value"
+ self.ty.is_value()
}
fn is_caller(&self) -> bool {
- self.ty == "caller"
+ self.ty.is_caller()
}
fn is_special(&self) -> bool {
- self.is_value() || self.is_caller()
+ self.ty.is_special()
}
- fn selector_ty(&self) -> &Ident {
+ fn selector_ty(&self) -> String {
assert!(!self.is_special());
- &self.ty
+ self.ty.selector_ty()
}
fn expand_call_def(&self) -> proc_macro2::TokenStream {
@@ -544,7 +695,7 @@
)*
)
}
- pub fn generate_solidity_interface(out_set: &mut sp_std::collections::btree_set::BTreeSet<string>, is_impl: bool) {
+ pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {
use evm_coder::solidity::*;
use core::fmt::Write;
let interface = SolidityInterface {
@@ -559,9 +710,9 @@
)*),
};
if is_impl {
- out_set.insert("// Common stubs holder\ncontract Dummy {\n\tuint8 dummy;\n\tstring stub_error = \"this contract is implemented in native\";\n}\n".into());
+ tc.collect("// Common stubs holder\ncontract Dummy {\n\tuint8 dummy;\n\tstring stub_error = \"this contract is implemented in native\";\n}\n".into());
} else {
- out_set.insert("// Common stubs holder\ninterface Dummy {\n}\n".into());
+ tc.collect("// Common stubs holder\ninterface Dummy {\n}\n".into());
}
#(
#solidity_generators
@@ -576,8 +727,8 @@
if #solidity_name.starts_with("Inline") {
out.push_str("// Inline\n");
}
- let _ = interface.format(is_impl, &mut out);
- out_set.insert(out);
+ let _ = interface.format(is_impl, &mut out, tc);
+ tc.collect(out);
}
}
impl ::evm_coder::Call for #call_name {
crates/evm-coder-macros/src/to_log.rsdiffbeforeafterboth--- a/crates/evm-coder-macros/src/to_log.rs
+++ b/crates/evm-coder-macros/src/to_log.rs
@@ -179,7 +179,7 @@
#consts
)*
- pub fn generate_solidity_interface(out_set: &mut sp_std::collections::btree_set::BTreeSet<string>, is_impl: bool) {
+ pub fn generate_solidity_interface(tc: &evm_coder::solidity::TypeCollector, is_impl: bool) {
use evm_coder::solidity::*;
use core::fmt::Write;
let interface = SolidityInterface {
@@ -191,8 +191,8 @@
};
let mut out = string::new();
out.push_str("// Inline\n");
- let _ = interface.format(is_impl, &mut out);
- out_set.insert(out);
+ let _ = interface.format(is_impl, &mut out, tc);
+ tc.collect(out);
}
}
crates/evm-coder/src/abi.rsdiffbeforeafterboth--- a/crates/evm-coder/src/abi.rs
+++ b/crates/evm-coder/src/abi.rs
@@ -247,6 +247,51 @@
impl_abi_readable!(bool, bool);
impl_abi_readable!(string, string);
+mod sealed {
+ /// Not all types can be placed in vec, i.e `Vec<u8>` is restricted, `bytes` should be used instead
+ pub trait CanBePlacedInVec {}
+}
+
+impl sealed::CanBePlacedInVec for U256 {}
+impl sealed::CanBePlacedInVec for string {}
+impl sealed::CanBePlacedInVec for H160 {}
+
+impl<R: sealed::CanBePlacedInVec> AbiRead<Vec<R>> for AbiReader<'_>
+where
+ Self: AbiRead<R>,
+{
+ fn abi_read(&mut self) -> Result<Vec<R>> {
+ todo!()
+ }
+}
+
+macro_rules! impl_tuples {
+ ($($ident:ident)+) => {
+ impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}
+ impl<$($ident),+> AbiRead<($($ident,)+)> for AbiReader<'_>
+ where
+ $(Self: AbiRead<$ident>),+
+ {
+ fn abi_read(&mut self) -> Result<($($ident,)+)> {
+ Ok((
+ $(<Self as AbiRead<$ident>>::abi_read(self)?,)+
+ ))
+ }
+ }
+ };
+}
+
+impl_tuples! {A}
+impl_tuples! {A B}
+impl_tuples! {A B C}
+impl_tuples! {A B C D}
+impl_tuples! {A B C D E}
+impl_tuples! {A B C D E F}
+impl_tuples! {A B C D E F G}
+impl_tuples! {A B C D E F G H}
+impl_tuples! {A B C D E F G H I}
+impl_tuples! {A B C D E F G H I J}
+
pub trait AbiWrite {
fn abi_write(&self, writer: &mut AbiWriter);
}
crates/evm-coder/src/lib.rsdiffbeforeafterboth--- a/crates/evm-coder/src/lib.rs
+++ b/crates/evm-coder/src/lib.rs
@@ -67,8 +67,8 @@
#[test]
#[ignore]
fn $name() {
- use sp_std::collections::btree_set::BTreeSet;
- let mut out = BTreeSet::new();
+ use evm_coder::solidity::TypeCollector;
+ let mut out = TypeCollector::new();
$decl::generate_solidity_interface(&mut out, $is_impl);
println!("=== SNIP START ===");
println!("// SPDX-License-Identifier: OTHER");
@@ -76,7 +76,7 @@
println!();
println!("pragma solidity >=0.8.0 <0.9.0;");
println!();
- for b in out {
+ for b in out.finish() {
println!("{}", b);
}
println!("=== SNIP END ===");
crates/evm-coder/src/solidity.rsdiffbeforeafterboth1#[cfg(not(feature = "std"))]1#[cfg(not(feature = "std"))]2use alloc::{string::String};2use alloc::{3 string::String,4 vec::Vec,5 collections::{BTreeSet, BTreeMap},6 format,7};8#[cfg(feature = "std")]9use std::collections::{BTreeSet, BTreeMap};3use core::{fmt, marker::PhantomData};10use core::{11 fmt::{self, Write},12 marker::PhantomData,13 cell::{Cell, RefCell},14};4use impl_trait_for_tuples::impl_for_tuples;15use impl_trait_for_tuples::impl_for_tuples;5use crate::types::*;16use crate::types::*;1718#[derive(Default)]19pub struct TypeCollector {20 structs: RefCell<BTreeSet<string>>,21 anonymous: RefCell<BTreeMap<Vec<string>, usize>>,22 id: Cell<usize>,23}24impl TypeCollector {25 pub fn new() -> Self {26 Self::default()27 }28 pub fn collect(&self, item: string) {29 self.structs.borrow_mut().insert(item);30 }31 pub fn next_id(&self) -> usize {32 let v = self.id.get();33 self.id.set(v + 1);34 v35 }36 pub fn collect_tuple<T: SolidityTupleType>(&self) -> String {37 let names = T::names(self);38 if let Some(id) = self.anonymous.borrow().get(&names).cloned() {39 return format!("Tuple{}", id);40 }41 let id = self.next_id();42 let mut str = String::new();43 writeln!(str, "// Anonymous struct").unwrap();44 writeln!(str, "struct Tuple{} {{", id).unwrap();45 for (i, name) in names.iter().enumerate() {46 writeln!(str, "\t{} field_{};", name, i).unwrap();47 }48 writeln!(str, "}}").unwrap();49 self.collect(str);50 self.anonymous.borrow_mut().insert(names, id);51 format!("Tuple{}", id)52 }53 pub fn finish(self) -> BTreeSet<string> {54 self.structs.into_inner()55 }56}6577pub trait SolidityTypeName: 'static {58pub trait SolidityTypeName: 'static {8 fn solidity_name(writer: &mut impl fmt::Write) -> fmt::Result;59 fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;60 fn is_simple() -> bool;9 fn solidity_default(writer: &mut impl fmt::Write) -> fmt::Result;61 fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;10 fn is_void() -> bool {62 fn is_void() -> bool {11 false63 false12 }64 }13}65}1415macro_rules! solidity_type_name {66macro_rules! solidity_type_name {16 ($($ty:ident => $name:literal = $default:literal),* $(,)?) => {67 ($($ty:ty => $name:literal $simple:literal = $default:literal),* $(,)?) => {17 $(68 $(18 impl SolidityTypeName for $ty {69 impl SolidityTypeName for $ty {19 fn solidity_name(writer: &mut impl core::fmt::Write) -> core::fmt::Result {70 fn solidity_name(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {20 write!(writer, $name)71 write!(writer, $name)21 }72 }73 fn is_simple() -> bool {74 $simple75 }22 fn solidity_default(writer: &mut impl core::fmt::Write) -> core::fmt::Result {76 fn solidity_default(writer: &mut impl core::fmt::Write, _tc: &TypeCollector) -> core::fmt::Result {23 write!(writer, $default)77 write!(writer, $default)24 }78 }25 }79 }28}82}298330solidity_type_name! {84solidity_type_name! {31 uint8 => "uint8" = "0",85 uint8 => "uint8" true = "0",32 uint32 => "uint32" = "0",86 uint32 => "uint32" true = "0",33 uint128 => "uint128" = "0",87 uint128 => "uint128" true = "0",34 uint256 => "uint256" = "0",88 uint256 => "uint256" true = "0",35 address => "address" = "0x0000000000000000000000000000000000000000",89 address => "address" true = "0x0000000000000000000000000000000000000000",36 string => "string memory" = "\"\"",90 string => "string" false = "\"\"",37 bytes => "bytes memory" = "hex\"\"",91 bytes => "bytes" false = "hex\"\"",38 bool => "bool" = "false",92 bool => "bool" true = "false",39}93}40impl SolidityTypeName for void {94impl SolidityTypeName for void {41 fn solidity_name(_writer: &mut impl fmt::Write) -> fmt::Result {95 fn solidity_name(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {42 Ok(())96 Ok(())43 }97 }98 fn is_simple() -> bool {99 true100 }44 fn solidity_default(_writer: &mut impl fmt::Write) -> fmt::Result {101 fn solidity_default(_writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {45 Ok(())102 Ok(())46 }103 }47 fn is_void() -> bool {104 fn is_void() -> bool {48 true105 true49 }106 }50}107}108109mod sealed {110 pub trait CanBePlacedInVec {}111}112113impl sealed::CanBePlacedInVec for uint256 {}114impl sealed::CanBePlacedInVec for string {}115impl sealed::CanBePlacedInVec for address {}116117impl<T: SolidityTypeName + sealed::CanBePlacedInVec> SolidityTypeName for Vec<T> {118 fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {119 T::solidity_name(writer, tc)?;120 write!(writer, "[]")121 }122 fn is_simple() -> bool {123 false124 }125 fn solidity_default(writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {126 write!(writer, "[]")127 }128}129130pub trait SolidityTupleType {131 fn names(tc: &TypeCollector) -> Vec<String>;132 fn len() -> usize;133}134135macro_rules! count {136 () => (0usize);137 ( $x:tt $($xs:tt)* ) => (1usize + count!($($xs)*));138}139140macro_rules! impl_tuples {141 ($($ident:ident)+) => {142 impl<$($ident),+> sealed::CanBePlacedInVec for ($($ident,)+) {}143 impl<$($ident: SolidityTypeName + 'static),+> SolidityTupleType for ($($ident,)+) {144 fn names(tc: &TypeCollector) -> Vec<string> {145 let mut collected = Vec::with_capacity(Self::len());146 $({147 let mut out = string::new();148 $ident::solidity_name(&mut out, tc).expect("no fmt error");149 collected.push(out);150 })*;151 collected152 }153154 fn len() -> usize {155 count!($($ident)*)156 }157 }158 impl<$($ident: SolidityTypeName + 'static),+> SolidityTypeName for ($($ident,)+) {159 fn solidity_name(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {160 write!(writer, "{}", tc.collect_tuple::<Self>())161 }162 fn is_simple() -> bool {163 false164 }165 fn solidity_default(writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {166 write!(writer, "{}(", tc.collect_tuple::<Self>())?;167 $(168 <$ident>::solidity_default(writer, tc)?;169 )*170 write!(writer, ")")171 }172 }173 };174}175176impl_tuples! {A}177impl_tuples! {A B}178impl_tuples! {A B C}179impl_tuples! {A B C D}180impl_tuples! {A B C D E}181impl_tuples! {A B C D E F}182impl_tuples! {A B C D E F G}183impl_tuples! {A B C D E F G H}184impl_tuples! {A B C D E F G H I}185impl_tuples! {A B C D E F G H I J}5118652pub trait SolidityArguments {187pub trait SolidityArguments {53 fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result;188 fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;54 fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result;189 fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result;55 fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result;190 fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result;56 fn is_empty(&self) -> bool {191 fn is_empty(&self) -> bool {57 self.len() == 0192 self.len() == 058 }193 }63pub struct UnnamedArgument<T>(PhantomData<*const T>);198pub struct UnnamedArgument<T>(PhantomData<*const T>);6419965impl<T: SolidityTypeName> SolidityArguments for UnnamedArgument<T> {200impl<T: SolidityTypeName> SolidityArguments for UnnamedArgument<T> {66 fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result {201 fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {67 if !T::is_void() {202 if !T::is_void() {68 T::solidity_name(writer)203 T::solidity_name(writer, tc)?;204 if !T::is_simple() {205 write!(writer, " memory")?;206 }207 Ok(())69 } else {208 } else {70 Ok(())209 Ok(())71 }210 }72 }211 }73 fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {212 fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {74 Ok(())213 Ok(())75 }214 }76 fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result {215 fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {77 T::solidity_default(writer)216 T::solidity_default(writer, tc)78 }217 }79 fn len(&self) -> usize {218 fn len(&self) -> usize {80 if T::is_void() {219 if T::is_void() {94}233}9523496impl<T: SolidityTypeName> SolidityArguments for NamedArgument<T> {235impl<T: SolidityTypeName> SolidityArguments for NamedArgument<T> {97 fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result {236 fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {98 if !T::is_void() {237 if !T::is_void() {99 T::solidity_name(writer)?;238 T::solidity_name(writer, tc)?;239 if !T::is_simple() {240 write!(writer, " memory")?;241 }100 write!(writer, " {}", self.0)242 write!(writer, " {}", self.0)101 } else {243 } else {102 Ok(())244 Ok(())105 fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {247 fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {106 writeln!(writer, "\t\t{};", self.0)248 writeln!(writer, "\t\t{};", self.0)107 }249 }108 fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result {250 fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {109 T::solidity_default(writer)251 T::solidity_default(writer, tc)110 }252 }111 fn len(&self) -> usize {253 fn len(&self) -> usize {112 if T::is_void() {254 if T::is_void() {126}268}127269128impl<T: SolidityTypeName> SolidityArguments for SolidityEventArgument<T> {270impl<T: SolidityTypeName> SolidityArguments for SolidityEventArgument<T> {129 fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result {271 fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {130 if !T::is_void() {272 if !T::is_void() {131 T::solidity_name(writer)?;273 T::solidity_name(writer, tc)?;132 if self.0 {274 if self.0 {133 write!(writer, " indexed")?;275 write!(writer, " indexed")?;134 }276 }140 fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {282 fn solidity_get(&self, writer: &mut impl fmt::Write) -> fmt::Result {141 writeln!(writer, "\t\t{};", self.1)283 writeln!(writer, "\t\t{};", self.1)142 }284 }143 fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result {285 fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {144 T::solidity_default(writer)286 T::solidity_default(writer, tc)145 }287 }146 fn len(&self) -> usize {288 fn len(&self) -> usize {147 if T::is_void() {289 if T::is_void() {153}295}154296155impl SolidityArguments for () {297impl SolidityArguments for () {156 fn solidity_name(&self, _writer: &mut impl fmt::Write) -> fmt::Result {298 fn solidity_name(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {157 Ok(())299 Ok(())158 }300 }159 fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {301 fn solidity_get(&self, _writer: &mut impl fmt::Write) -> fmt::Result {160 Ok(())302 Ok(())161 }303 }162 fn solidity_default(&self, _writer: &mut impl fmt::Write) -> fmt::Result {304 fn solidity_default(&self, _writer: &mut impl fmt::Write, _tc: &TypeCollector) -> fmt::Result {163 Ok(())305 Ok(())164 }306 }165 fn len(&self) -> usize {307 fn len(&self) -> usize {171impl SolidityArguments for Tuple {313impl SolidityArguments for Tuple {172 for_tuples!( where #( Tuple: SolidityArguments ),* );314 for_tuples!( where #( Tuple: SolidityArguments ),* );173315174 fn solidity_name(&self, writer: &mut impl fmt::Write) -> fmt::Result {316 fn solidity_name(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {175 let mut first = true;317 let mut first = true;176 for_tuples!( #(318 for_tuples!( #(177 if !Tuple.is_empty() {319 if !Tuple.is_empty() {178 if !first {320 if !first {179 write!(writer, ", ")?;321 write!(writer, ", ")?;180 }322 }181 first = false;323 first = false;182 Tuple.solidity_name(writer)?;324 Tuple.solidity_name(writer, tc)?;183 }325 }184 )* );326 )* );185 Ok(())327 Ok(())190 )* );332 )* );191 Ok(())333 Ok(())192 }334 }193 fn solidity_default(&self, writer: &mut impl fmt::Write) -> fmt::Result {335 fn solidity_default(&self, writer: &mut impl fmt::Write, tc: &TypeCollector) -> fmt::Result {194 if self.is_empty() {336 if self.is_empty() {195 Ok(())337 Ok(())196 } else if self.len() == 1 {338 } else if self.len() == 1 {197 for_tuples!( #(339 for_tuples!( #(198 Tuple.solidity_default(writer)?;340 Tuple.solidity_default(writer, tc)?;199 )* );341 )* );200 Ok(())342 Ok(())201 } else {343 } else {207 write!(writer, ", ")?;349 write!(writer, ", ")?;208 }350 }209 first = false;351 first = false;210 Tuple.solidity_name(writer)?;352 Tuple.solidity_default(writer, tc)?;211 }353 }212 )* );354 )* );213 write!(writer, ")")?;355 write!(writer, ")")?;223 fn solidity_name(&self, is_impl: bool, writer: &mut impl fmt::Write) -> fmt::Result;365 fn solidity_name(366 &self,367 is_impl: bool,368 writer: &mut impl fmt::Write,369 tc: &TypeCollector,370 ) -> fmt::Result;224}371}225372238 fn solidity_name(&self, is_impl: bool, writer: &mut impl fmt::Write) -> fmt::Result {385 fn solidity_name(386 &self,387 is_impl: bool,388 writer: &mut impl fmt::Write,389 tc: &TypeCollector,390 ) -> fmt::Result {239 write!(writer, "\tfunction {}(", self.name)?;391 write!(writer, "\tfunction {}(", self.name)?;240 self.args.solidity_name(writer)?;392 self.args.solidity_name(writer, tc)?;241 write!(writer, ")")?;393 write!(writer, ")")?;242 if is_impl {394 if is_impl {243 write!(writer, " public")?;395 write!(writer, " public")?;251 }403 }252 if !self.result.is_empty() {404 if !self.result.is_empty() {253 write!(writer, " returns (")?;405 write!(writer, " returns (")?;254 self.result.solidity_name(writer)?;406 self.result.solidity_name(writer, tc)?;255 write!(writer, ")")?;407 write!(writer, ")")?;256 }408 }257 if is_impl {409 if is_impl {265 }417 }266 if !self.result.is_empty() {418 if !self.result.is_empty() {267 write!(writer, "\t\treturn ")?;419 write!(writer, "\t\treturn ")?;268 self.result.solidity_default(writer)?;420 self.result.solidity_default(writer, tc)?;269 writeln!(writer, ";")?;421 writeln!(writer, ";")?;270 }422 }271 writeln!(writer, "\t}}")?;423 writeln!(writer, "\t}}")?;283 fn solidity_name(&self, is_impl: bool, writer: &mut impl fmt::Write) -> fmt::Result {435 fn solidity_name(436 &self,437 is_impl: bool,438 writer: &mut impl fmt::Write,439 tc: &TypeCollector,440 ) -> fmt::Result {284 let mut first = false;441 let mut first = false;285 for_tuples!( #(442 for_tuples!( #(286 Tuple.solidity_name(is_impl, writer)?;443 Tuple.solidity_name(is_impl, writer, tc)?;287 )* );444 )* );288 Ok(())445 Ok(())289 }446 }299 pub fn format(&self, is_impl: bool, out: &mut impl fmt::Write) -> fmt::Result {456 pub fn format(457 &self,458 is_impl: bool,459 out: &mut impl fmt::Write,460 tc: &TypeCollector,461 ) -> fmt::Result {300 if is_impl {462 if is_impl {301 write!(out, "contract ")?;463 write!(out, "contract ")?;313 }475 }314 }476 }315 writeln!(out, " {{")?;477 writeln!(out, " {{")?;316 self.functions.solidity_name(is_impl, out)?;478 self.functions.solidity_name(is_impl, out, tc)?;317 writeln!(out, "}}")?;479 writeln!(out, "}}")?;318 Ok(())480 Ok(())319 }481 }328 fn solidity_name(&self, _is_impl: bool, writer: &mut impl fmt::Write) -> fmt::Result {490 fn solidity_name(491 &self,492 _is_impl: bool,493 writer: &mut impl fmt::Write,494 tc: &TypeCollector,495 ) -> fmt::Result {329 write!(writer, "\tevent {}(", self.name)?;496 write!(writer, "\tevent {}(", self.name)?;330 self.args.solidity_name(writer)?;497 self.args.solidity_name(writer, tc)?;331 writeln!(writer, ");")498 writeln!(writer, ");")332 }499 }333}500}