Merge pull request #94 from ElrondNetwork/abi-output-names

andrei-marinica · web-flow · commit b981c4599129 · 2020-12-29T14:21:06.000+02:00
ABI generation - output names
diff --git a/contracts/feature-tests/abi-tester/abi_test_expected.abi.json b/contracts/feature-tests/abi-tester/abi_test_expected.abi.json
@@ -18,6 +18,7 @@
             ],
             "outputs": [
                 {
+                    "name": "single output",
                     "type": "AbiTestType"
                 }
             ]
@@ -27,12 +28,15 @@
             "inputs": [],
             "outputs": [
                 {
+                    "name": "multi-result-1",
                     "type": "i32"
                 },
                 {
+                    "name": "multi-result-2",
                     "type": "[u8; 3]"
                 },
                 {
+                    "name": "multi-result-3",
                     "type": "bytes"
                 }
             ]
@@ -42,9 +46,11 @@
             "inputs": [],
             "outputs": [
                 {
+                    "name": "multi-too-few-1",
                     "type": "i32"
                 },
                 {
+                    "name": "multi-too-few-2",
                     "type": "[u8; 3]"
                 },
                 {
diff --git a/contracts/feature-tests/abi-tester/src/lib.rs b/contracts/feature-tests/abi-tester/src/lib.rs
@@ -14,16 +14,24 @@ use abi_test_type::*;
 #[elrond_wasm_derive::contract(AbiTesterImpl)]
 pub trait AbiTester {
 	#[endpoint]
+	#[output_name("single output")]
+	#[output_name("this one doesn't show up")]
 	fn echo_abi_test_type(&self, att: AbiTestType) -> AbiTestType {
 		att
 	}
 
 	#[endpoint]
+	#[output_name("multi-result-1")]
+	#[output_name("multi-result-2")]
+	#[output_name("multi-result-3")]
+	#[output_name("multi-result-in-excess")]
 	fn multi_result_3(&self) -> MultiResult3<i32, [u8; 3], BoxedBytes> {
 		(1, [2; 3], BoxedBytes::empty()).into()
 	}
 
 	#[endpoint]
+	#[output_name("multi-too-few-1")]
+	#[output_name("multi-too-few-2")]
 	fn multi_result_4(&self) -> MultiResult4<i32, [u8; 3], BoxedBytes, OnlyShowsUpAsNested3> {
 		(
 			1,
diff --git a/elrond-wasm-debug/src/abi_json/endpoint_abi_json.rs b/elrond-wasm-debug/src/abi_json/endpoint_abi_json.rs
@@ -31,6 +31,9 @@ impl From<&InputAbi> for InputAbiJson {
 
 #[derive(Serialize, Deserialize)]
 pub struct OutputAbiJson {
+	#[serde(rename = "name")]
+	#[serde(skip_serializing_if = "String::is_empty")]
+	pub output_name: String,
 	#[serde(rename = "type")]
 	pub type_name: String,
 	/// Bool that is only serialized when true
@@ -41,6 +44,7 @@ pub struct OutputAbiJson {
 impl From<&OutputAbi> for OutputAbiJson {
 	fn from(abi: &OutputAbi) -> Self {
 		OutputAbiJson {
+			output_name: abi.output_name.into(),
 			type_name: abi.type_name.clone(),
 			multi_result: if abi.multi_result { Some(true) } else { None },
 		}
diff --git a/elrond-wasm-derive/src/abi_gen.rs b/elrond-wasm-derive/src/abi_gen.rs
@@ -36,13 +36,14 @@ pub fn generate_abi_method_body(contract: &Contract) -> proc_macro2::TokenStream
 					})
 					.collect();
 
+				let output_names = &m.output_names;
 				let output_snippet = match &m.return_type {
 					syn::ReturnType::Default => quote! {},
 					syn::ReturnType::Type(_, ty) => {
 						let mut res_type = ty.clone();
 						clear_all_type_lifetimes(&mut res_type);
 						quote! {
-							endpoint_abi.add_output::<#res_type>();
+							endpoint_abi.add_output::<#res_type>(&[ #(#output_names),* ]);
 							contract_abi.add_type_descriptions::<#res_type>();
 						}
 					},
diff --git a/elrond-wasm-derive/src/contract_gen_method.rs b/elrond-wasm-derive/src/contract_gen_method.rs
@@ -99,6 +99,7 @@ pub struct Method {
 	pub name: syn::Ident,
 	pub generics: syn::Generics,
 	pub method_args: Vec<MethodArg>,
+	pub output_names: Vec<String>,
 	pub return_type: syn::ReturnType,
 	pub body: Option<syn::Block>,
 }
@@ -327,12 +328,14 @@ impl Method {
 		let metadata = extract_metadata(m);
 		let allow_callback_args = matches!(metadata, MethodMetadata::Callback);
 		let method_args = extract_method_args(m, is_payable(m), allow_callback_args);
+		let output_names = find_output_names(m);
 		Method {
 			docs: extract_doc(m.attrs.as_slice()),
 			metadata,
 			name: m.sig.ident.clone(),
 			generics: m.sig.generics.clone(),
 			method_args,
+			output_names,
 			return_type: m.sig.output.clone(),
 			body: m.default.clone(),
 		}
diff --git a/elrond-wasm-derive/src/parse_attr.rs b/elrond-wasm-derive/src/parse_attr.rs
@@ -1,4 +1,5 @@
 static ATTR_PAYABLE: &str = "payable";
+static ATTR_OUTPUT_NAME: &str = "output_name";
 static ATTR_PAYMENT: &str = "payment";
 static ATTR_VAR_ARGS: &str = "var_args";
 static ATTR_EVENT: &str = "event";
@@ -104,6 +105,37 @@ pub fn extract_doc(attrs: &[syn::Attribute]) -> Vec<String> {
 		.collect()
 }
 
+fn attr_one_string_arg(attr: &syn::Attribute) -> String {
+	let result_str: String;
+	let mut iter = attr.clone().tokens.into_iter();
+	match iter.next() {
+		Some(proc_macro2::TokenTree::Group(group)) => {
+			if group.delimiter() != proc_macro2::Delimiter::Parenthesis {
+				panic!("event paranthesis expected");
+			}
+			let mut iter2 = group.stream().into_iter();
+			match iter2.next() {
+				Some(proc_macro2::TokenTree::Literal(lit)) => {
+					let str_val = lit.to_string();
+					if !str_val.starts_with('\"') || !str_val.ends_with('\"') {
+						panic!("string literal expected as attribute argument");
+					}
+					let substr = &str_val[1..str_val.len() - 1];
+					result_str = substr.to_string();
+				},
+				_ => panic!("literal expected as event identifier"),
+			}
+		},
+		_ => panic!("missing event identifier"),
+	}
+
+	if iter.next().is_some() {
+		panic!("event too many tokens in event attribute");
+	}
+
+	result_str
+}
+
 fn find_attr_one_string_arg(m: &syn::TraitItemMethod, attr_name: &str) -> Option<String> {
 	let event_attr = m.attrs.iter().find(|attr| {
 		if let Some(first_seg) = attr.path.segments.first() {
@@ -114,37 +146,22 @@ fn find_attr_one_string_arg(m: &syn::TraitItemMethod, attr_name: &str) -> Option
 	});
 	match event_attr {
 		None => None,
-		Some(attr) => {
-			let result_str: String;
-			let mut iter = attr.clone().tokens.into_iter();
-			match iter.next() {
-				Some(proc_macro2::TokenTree::Group(group)) => {
-					if group.delimiter() != proc_macro2::Delimiter::Parenthesis {
-						panic!("event paranthesis expected");
-					}
-					let mut iter2 = group.stream().into_iter();
-					match iter2.next() {
-						Some(proc_macro2::TokenTree::Literal(lit)) => {
-							let str_val = lit.to_string();
-							if !str_val.starts_with('\"') || !str_val.ends_with('\"') {
-								panic!("string literal expected as attribute argument");
-							}
-							let substr = &str_val[1..str_val.len() - 1];
-							result_str = substr.to_string();
-						},
-						_ => panic!("literal expected as event identifier"),
-					}
-				},
-				_ => panic!("missing event identifier"),
-			}
+		Some(attr) => Some(attr_one_string_arg(attr)),
+	}
+}
 
-			if iter.next().is_some() {
-				panic!("event too many tokens in event attribute");
+pub fn find_output_names(m: &syn::TraitItemMethod) -> Vec<String> {
+	m.attrs
+		.iter()
+		.filter(|attr| {
+			if let Some(first_seg) = attr.path.segments.first() {
+				first_seg.ident == ATTR_OUTPUT_NAME
+			} else {
+				false
 			}
-
-			Some(result_str)
-		},
-	}
+		})
+		.map(attr_one_string_arg)
+		.collect()
 }
 
 pub struct EventAttribute {
diff --git a/elrond-wasm/src/abi/endpoint_abi.rs b/elrond-wasm/src/abi/endpoint_abi.rs
@@ -11,6 +11,7 @@ pub struct InputAbi {
 
 #[derive(Clone, Debug)]
 pub struct OutputAbi {
+	pub output_name: &'static str,
 	pub type_name: String,
 	pub multi_result: bool,
 }
@@ -33,7 +34,8 @@ impl EndpointAbi {
 		});
 	}
 
-	pub fn add_output<T: TypeAbi>(&mut self) {
-		self.outputs.extend_from_slice(T::output_abis().as_slice());
+	pub fn add_output<T: TypeAbi>(&mut self, output_names: &[&'static str]) {
+		self.outputs
+			.extend_from_slice(T::output_abis(output_names).as_slice());
 	}
 }
diff --git a/elrond-wasm/src/abi/type_abi.rs b/elrond-wasm/src/abi/type_abi.rs
@@ -35,10 +35,17 @@ pub trait TypeAbi {
 	/// however, MultiResultX when top-level can be seen as multiple endpoint results.
 	/// This method gives it an opportunity to dissolve into its components.
 	/// Should only be overridden by framework types.
+	/// Output names are optionally provided in contracts via the `output_name` method attribute.
 	#[doc(hidden)]
-	fn output_abis() -> Vec<OutputAbi> {
+	fn output_abis(output_names: &[&'static str]) -> Vec<OutputAbi> {
 		let mut result = Vec::with_capacity(1);
+		let output_name = if !output_names.is_empty() {
+			output_names[0]
+		} else {
+			""
+		};
 		result.push(OutputAbi {
+			output_name,
 			type_name: Self::type_name(),
 			multi_result: Self::is_multi_arg_or_result(),
 		});
@@ -49,7 +56,7 @@ pub trait TypeAbi {
 impl TypeAbi for () {
 	/// No another exception from the 1-type-1-output-abi rule:
 	/// the unit type produces no output.
-	fn output_abis() -> Vec<OutputAbi> {
+	fn output_abis(_output_names: &[&'static str]) -> Vec<OutputAbi> {
 		Vec::new()
 	}
 }
diff --git a/elrond-wasm/src/types/multi_result.rs b/elrond-wasm/src/types/multi_result.rs
@@ -47,10 +47,16 @@ macro_rules! multi_result_impls {
                     true
                 }
 
-                fn output_abis() -> Vec<OutputAbi> {
+                fn output_abis(output_names: &[&'static str]) -> Vec<OutputAbi> {
                     let mut result = Vec::new();
                     $(
-                        result.append(&mut $name::output_abis());
+                        if output_names.len() > $n {
+                            result.append(&mut $name::output_abis(&[output_names[$n]]));
+
+                        } else {
+                            result.append(&mut $name::output_abis(&[]));
+                        }
+
                     )+
                     result
                 }
diff --git a/elrond-wasm/src/types/sc_result.rs b/elrond-wasm/src/types/sc_result.rs
@@ -70,8 +70,8 @@ impl<T: TypeAbi> TypeAbi for SCResult<T> {
 	/// just like `()`.
 	/// It is also possible to have `SCResult<MultiResultX<...>>`,
 	/// so this gives the MultiResult to dissolve into its multiple output ABIs.
-	fn output_abis() -> Vec<OutputAbi> {
-		T::output_abis()
+	fn output_abis(output_names: &[&'static str]) -> Vec<OutputAbi> {
+		T::output_abis(output_names)
 	}
 
 	fn provide_type_descriptions<TDC: TypeDescriptionContainer>(accumulator: &mut TDC) {

Original file line number	Diff line number	Diff line change
`@@ -18,6 +18,7 @@`
`18`	`18`	`],`
`19`	`19`	`"outputs": [`
`20`	`20`	`{`
	`21`	`+ "name": "single output",`
`21`	`22`	`"type": "AbiTestType"`
`22`	`23`	`}`
`23`	`24`	`]`
`@@ -27,12 +28,15 @@`
`27`	`28`	`"inputs": [],`
`28`	`29`	`"outputs": [`
`29`	`30`	`{`
	`31`	`+ "name": "multi-result-1",`
`30`	`32`	`"type": "i32"`
`31`	`33`	`},`
`32`	`34`	`{`
	`35`	`+ "name": "multi-result-2",`
`33`	`36`	`"type": "[u8; 3]"`
`34`	`37`	`},`
`35`	`38`	`{`
	`39`	`+ "name": "multi-result-3",`
`36`	`40`	`"type": "bytes"`
`37`	`41`	`}`
`38`	`42`	`]`
`@@ -42,9 +46,11 @@`
`42`	`46`	`"inputs": [],`
`43`	`47`	`"outputs": [`
`44`	`48`	`{`
	`49`	`+ "name": "multi-too-few-1",`
`45`	`50`	`"type": "i32"`
`46`	`51`	`},`
`47`	`52`	`{`
	`53`	`+ "name": "multi-too-few-2",`
`48`	`54`	`"type": "[u8; 3]"`
`49`	`55`	`},`
`50`	`56`	`{`
Original file line number	Diff line number	Diff line change
`@@ -11,6 +11,7 @@ pub struct InputAbi {`
`11`	`11`
`12`	`12`	`#[derive(Clone, Debug)]`
`13`	`13`	`pub struct OutputAbi {`
	`14`	`+ pub output_name: &'static str,`
`14`	`15`	`pub type_name: String,`
`15`	`16`	`pub multi_result: bool,`
`16`	`17`	`}`
`@@ -33,7 +34,8 @@ impl EndpointAbi {`
`33`	`34`	`});`
`34`	`35`	`}`
`35`	`36`
`36`		`- pub fn add_output<T: TypeAbi>(&mut self) {`
`37`		`- self.outputs.extend_from_slice(T::output_abis().as_slice());`
	`37`	`+ pub fn add_output<T: TypeAbi>(&mut self, output_names: &[&'static str]) {`
	`38`	`+ self.outputs`
	`39`	`+ .extend_from_slice(T::output_abis(output_names).as_slice());`
`38`	`40`	`}`
`39`	`41`	`}`