Generate metadata for constructor return type

CHANGELOG.md

@@ -5,7 +5,7 @@ The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
 ## [Unreleased]
-- Allows to use `Result<Self, Error>` as a return type in constructors - [#1446](https://github.com/paritytech/ink/pull/1446)
+- Allows to use `Result<Self, Error>` as a return type in constructors - [#1446](https://github.com/paritytech/ink/pull/1446) and indicate it in metadata - [#1460](https://github.com/paritytech/ink/pull/1460)
 
 - Remove random function from ink!.
 

crates/ink/codegen/src/generator/metadata.rs

@@ -24,6 +24,7 @@ use proc_macro2::TokenStream as TokenStream2;
 use quote::{
     quote,
     quote_spanned,
+    ToTokens,
 };
 use syn::spanned::Spanned as _;
 
@@ -131,6 +132,7 @@ impl Metadata<'_> {
         let constructor = constructor.callable();
         let ident = constructor.ident();
         let args = constructor.inputs().map(Self::generate_dispatch_argument);
+        let ret_ty = Self::generate_constructor_return_type(constructor.output());
         quote_spanned!(span=>
             ::ink::metadata::ConstructorSpec::from_label(::core::stringify!(#ident))
                 .selector([
@@ -140,6 +142,7 @@ impl Metadata<'_> {
                     #( #args ),*
                 ])
                 .payable(#is_payable)
+                .returns(#ret_ty)
                 .docs([
                     #( #docs ),*
                 ])
@@ -190,6 +193,41 @@ impl Metadata<'_> {
         }
     }
 
+    /// Generates the ink! metadata for the given type.
+    fn generate_constructor_type_spec(ty: &syn::Type) -> TokenStream2 {
+        fn without_display_name(ty: TokenStream2) -> TokenStream2 {
+            quote! {
+                ::ink::metadata::TransformResult::<#ty>::new_type_spec(None)
+            }
+        }
+        if let syn::Type::Path(type_path) = ty {
+            if type_path.qself.is_some() {
+                let ty = Self::replace_self_with_unit(ty);
+                return without_display_name(ty)
+            }
+            let path = &type_path.path;
+            if path.segments.is_empty() {
+                let ty = Self::replace_self_with_unit(ty);
+                return without_display_name(ty)
+            }
+            let segs = path
+                .segments
+                .iter()
+                .map(|seg| &seg.ident)
+                .collect::<Vec<_>>();
+            let ty = Self::replace_self_with_unit(ty);
+            quote! {
+                 ::ink::metadata::TransformResult::<#ty>::new_type_spec(
+                    Some(::core::iter::IntoIterator::into_iter([ #( ::core::stringify!(#segs) ),* ])
+                        .map(::core::convert::AsRef::as_ref)
+                    ))
+            }
+        } else {
+            let ty = Self::replace_self_with_unit(ty);
+            without_display_name(ty)
+        }
+    }
+
     /// Generates the ink! metadata for all ink! smart contract messages.
     fn generate_messages(&self) -> Vec<TokenStream2> {
         let mut messages = Vec::new();
@@ -316,6 +354,48 @@ impl Metadata<'_> {
         }
     }
 
+    /// Generates ink! metadata for the given return type of a constructor.
+    fn generate_constructor_return_type(ret_ty: Option<&syn::Type>) -> TokenStream2 {
+        /// Returns `true` if the given type is `Self`.
+        fn type_is_self_val(ty: &syn::Type) -> bool {
+            matches!(ty, syn::Type::Path(syn::TypePath {
+            qself: None,
+            path
+        }) if path.is_ident("Self"))
+        }
+
+        match ret_ty {
+            None => {
+                quote! {
+                    ::ink::metadata::ReturnTypeSpec::new(::core::option::Option::None)
+                }
+            }
+            Some(ty) => {
+                if type_is_self_val(ty) {
+                    return quote! { ::ink::metadata::ReturnTypeSpec::new(::core::option::Option::None)}
+                }
+                let type_spec = Self::generate_constructor_type_spec(ty);
+                let type_token = Self::replace_self_with_unit(ty);
+                quote! {
+                    if !::ink::is_result_type!(#type_token) {
+                        ::ink::metadata::ReturnTypeSpec::new(::core::option::Option::None)
+                    } else {
+                       ::ink::metadata::ReturnTypeSpec::new(#type_spec)
+                    }
+                }
+            }
+        }
+    }
+
+    fn replace_self_with_unit(ty: &syn::Type) -> TokenStream2 {
+        if ty.to_token_stream().to_string().contains("< Self") {
+            let s = ty.to_token_stream().to_string().replace("< Self", "< ()");
+            s.parse().unwrap()
+        } else {
+            ty.to_token_stream()
+        }
+    }
+
     /// Generates ink! metadata for all user provided ink! event definitions.
     fn generate_events(&self) -> impl Iterator<Item = TokenStream2> + '_ {
         self.contract.module().events().map(|event| {

crates/ink/src/codegen/dispatch/execution.rs

@@ -68,7 +68,7 @@ where
                 &Contract::KEY,
                 contract,
             );
-            Ok(())
+            ink_env::return_value(ReturnFlags::default().set_reverted(false), &());
         }
         Err(error) => {
             // Constructor is fallible and failed.

crates/ink/src/result_info.rs

@@ -77,6 +77,44 @@ macro_rules! is_result_err {
     }};
 }
 
+// trying to evaluate error type here
+
+// pub struct GetResultErr<'lt, T>(pub &'lt T);
+
+// impl<T, E> GetResultErr<'_, ::core::result::Result<T, E>>
+//     where E: ToString{
+//     #[inline]
+//     // We need to allow for dead code at this point because
+//     // the Rust compiler thinks this function is unused even
+//     // though it acts as the specialized case for detection.
+//     #[allow(dead_code)]
+//     pub fn value(&self) -> String {
+//     }
+// }
+
+// pub trait GetResultErrFallback {
+//     #[inline]
+//     fn value(&self) -> bool {
+//         false
+//     }
+// }
+// impl<T> GetResultErrFallback for GetResultErr<'_, T> {}
+
+// /// Evaluates to `true` if the given expression is a `Result::Err(_)`.
+// ///
+// /// # Note
+// ///
+// /// This given expression is not required to be of type `Result`.
+// #[macro_export]
+// #[doc(hidden)]
+// macro_rules! get_result_err {
+//     ( $e:expr $(,)? ) => {{
+//         #[allow(unused_imports)]
+//         use $crate::result_info::GetResultErrFallback as _;
+//         $crate::result_info::GetResultErr(&$e).value()
+//     }};
+// }
+
 #[cfg(test)]
 mod tests {
     #[test]

crates/metadata/src/lib.rs

@@ -44,6 +44,7 @@ pub use self::specs::{
     MessageSpecBuilder,
     ReturnTypeSpec,
     Selector,
+    TransformResult,
     TypeSpec,
 };
 

crates/metadata/src/specs.rs

@@ -24,7 +24,10 @@ use alloc::{
     vec,
     vec::Vec,
 };
-use core::marker::PhantomData;
+use core::{
+    any::TypeId,
+    marker::PhantomData,
+};
 use scale_info::{
     form::{
         Form,
@@ -221,8 +224,9 @@ impl ContractSpec {
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(bound(
     serialize = "F::Type: Serialize, F::String: Serialize",
-    deserialize = "F::Type: DeserializeOwned, F::String: DeserializeOwned"
+    deserialize = "F::Type: DeserializeOwned, F::String: DeserializeOwned",
 ))]
+#[serde(rename_all = "camelCase")]
 pub struct ConstructorSpec<F: Form = MetaForm> {
     /// The label of the constructor.
     ///
@@ -234,6 +238,8 @@ pub struct ConstructorSpec<F: Form = MetaForm> {
     pub payable: bool,
     /// The parameters of the deployment handler.
     pub args: Vec<MessageParamSpec<F>>,
+    /// The return type of the constructor..
+    pub return_type: ReturnTypeSpec<F>,
     /// The deployment handler documentation.
     pub docs: Vec<F::String>,
 }
@@ -251,6 +257,7 @@ impl IntoPortable for ConstructorSpec {
                 .into_iter()
                 .map(|arg| arg.into_portable(registry))
                 .collect::<Vec<_>>(),
+            return_type: self.return_type.into_portable(registry),
             docs: registry.map_into_portable(self.docs),
         }
     }
@@ -267,7 +274,7 @@ where
         &self.label
     }
 
-    /// Returns the selector hash of the message.
+    /// Returns the selector hash of the constructor.
     pub fn selector(&self) -> &Selector {
         &self.selector
     }
@@ -282,6 +289,11 @@ where
         &self.args
     }
 
+    /// Returns the return type of the constructor.
+    pub fn return_type(&self) -> &ReturnTypeSpec<F> {
+        &self.return_type
+    }
+
     /// Returns the deployment handler documentation.
     pub fn docs(&self) -> &[F::String] {
         &self.docs
@@ -295,36 +307,42 @@ where
 /// Some fields are guarded by a type-state pattern to fail at
 /// compile-time instead of at run-time. This is useful to better
 /// debug code-gen macros.
+#[allow(clippy::type_complexity)]
 #[must_use]
-pub struct ConstructorSpecBuilder<Selector, IsPayable> {
+pub struct ConstructorSpecBuilder<Selector, IsPayable, Returns> {
     spec: ConstructorSpec,
-    marker: PhantomData<fn() -> (Selector, IsPayable)>,
+    marker: PhantomData<fn() -> (Selector, IsPayable, Returns)>,
 }
 
 impl ConstructorSpec {
     /// Creates a new constructor spec builder.
     pub fn from_label(
         label: &'static str,
-    ) -> ConstructorSpecBuilder<Missing<state::Selector>, Missing<state::IsPayable>> {
+    ) -> ConstructorSpecBuilder<
+        Missing<state::Selector>,
+        Missing<state::IsPayable>,
+        Missing<state::Returns>,
+    > {
         ConstructorSpecBuilder {
             spec: Self {
                 label,
                 selector: Selector::default(),
                 payable: Default::default(),
                 args: Vec::new(),
+                return_type: ReturnTypeSpec::new(None),
                 docs: Vec::new(),
             },
             marker: PhantomData,
         }
     }
 }
 
-impl<P> ConstructorSpecBuilder<Missing<state::Selector>, P> {
+impl<P, R> ConstructorSpecBuilder<Missing<state::Selector>, P, R> {
     /// Sets the function selector of the message.
     pub fn selector(
         self,
         selector: [u8; 4],
-    ) -> ConstructorSpecBuilder<state::Selector, P> {
+    ) -> ConstructorSpecBuilder<state::Selector, P, R> {
         ConstructorSpecBuilder {
             spec: ConstructorSpec {
                 selector: selector.into(),
@@ -335,12 +353,12 @@ impl<P> ConstructorSpecBuilder<Missing<state::Selector>, P> {
     }
 }
 
-impl<S> ConstructorSpecBuilder<S, Missing<state::IsPayable>> {
+impl<S, R> ConstructorSpecBuilder<S, Missing<state::IsPayable>, R> {
     /// Sets if the constructor is payable, thus accepting value for the caller.
     pub fn payable(
         self,
         is_payable: bool,
-    ) -> ConstructorSpecBuilder<S, state::IsPayable> {
+    ) -> ConstructorSpecBuilder<S, state::IsPayable, R> {
         ConstructorSpecBuilder {
             spec: ConstructorSpec {
                 payable: is_payable,
@@ -351,7 +369,23 @@ impl<S> ConstructorSpecBuilder<S, Missing<state::IsPayable>> {
     }
 }
 
-impl<S, P> ConstructorSpecBuilder<S, P> {
+impl<S, P> ConstructorSpecBuilder<S, P, Missing<state::Returns>> {
+    /// Sets the return type of the message.
+    pub fn returns(
+        self,
+        return_type: ReturnTypeSpec,
+    ) -> ConstructorSpecBuilder<S, P, state::Returns> {
+        ConstructorSpecBuilder {
+            spec: ConstructorSpec {
+                return_type,
+                ..self.spec
+            },
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<S, P, R> ConstructorSpecBuilder<S, P, R> {
     /// Sets the input arguments of the message specification.
     pub fn args<A>(self, args: A) -> Self
     where
@@ -378,7 +412,7 @@ impl<S, P> ConstructorSpecBuilder<S, P> {
     }
 }
 
-impl ConstructorSpecBuilder<state::Selector, state::IsPayable> {
+impl ConstructorSpecBuilder<state::Selector, state::IsPayable, state::Returns> {
     /// Finishes construction of the constructor.
     pub fn done(self) -> ConstructorSpec {
         self.spec
@@ -890,6 +924,33 @@ where
     }
 }
 
+/// This is wrapper for [TypeSpec] which acts as a factory.
+/// The whole purpose of the factory is to take replace the type of
+/// `Ok` variant of `Result` with `()` because constructors do not return
+/// any data upon successful instantiation.
+///
+/// # Important Note
+/// Only use this factory with constructors!
+pub struct TransformResult<T> {
+    marker: core::marker::PhantomData<fn() -> T>,
+}
+
+impl<O, E> TransformResult<core::result::Result<O, E>>
+where
+    E: TypeInfo + 'static,
+{
+    pub fn new_type_spec<S>(segments_opt: Option<S>) -> TypeSpec
+    where
+        S: IntoIterator<Item = &'static str>,
+    {
+        if let Some(segments) = segments_opt {
+            TypeSpec::with_name_segs::<core::result::Result<(), E>, S>(segments)
+        } else {
+            TypeSpec::new::<core::result::Result<(), E>>()
+        }
+    }
+}
+
 /// Describes a pair of parameter label and type.
 #[derive(Debug, PartialEq, Eq, Serialize, Deserialize)]
 #[serde(bound(