Add support for language level errors (LangError)

.gitlab-ci.yml

@@ -34,6 +34,7 @@ variables:
   ALL_CRATES:                      "${PURELY_STD_CRATES} ${ALSO_WASM_CRATES}"
   DELEGATOR_SUBCONTRACTS:          "accumulator adder subber"
   UPGRADEABLE_CONTRACTS:           "forward-calls set-code-hash"
+  LANG_ERR_INTEGRATION_CONTRACTS:  "integration-flipper call-builder contract-ref"
   # TODO `cargo clippy --verbose --all-targets --all-features` for this crate
   # currently fails on `stable`, but succeeds on `nightly`. This is due to
   # this fix not yet in stable: https://github.com/rust-lang/rust-clippy/issues/8895.
@@ -122,6 +123,7 @@ examples-fmt:
     # Note that we disable the license header check for the examples, since they are unlicensed.
     - for example in examples/*/; do
         if [ "$example" = "examples/upgradeable-contracts/" ]; then continue; fi;
+        if [ "$example" = "examples/lang-err-integration-tests/" ]; then continue; fi;
         cargo +nightly fmt --verbose --manifest-path ${example}/Cargo.toml -- --check;
       done
     - for contract in ${DELEGATOR_SUBCONTRACTS}; do
@@ -130,6 +132,9 @@ examples-fmt:
     - for contract in ${UPGRADEABLE_CONTRACTS}; do
         cargo +nightly fmt --verbose --manifest-path ./examples/upgradeable-contracts/${contract}/Cargo.toml -- --check;
       done
+    - for contract in ${LANG_ERR_INTEGRATION_CONTRACTS}; do
+        cargo +nightly fmt --verbose --manifest-path ./examples/lang-err-integration-tests/${contract}/Cargo.toml -- --check;
+      done
     - cargo +nightly fmt --verbose --manifest-path ./examples/upgradeable-contracts/set-code-hash/updated-incrementer/Cargo.toml -- --check
     # This file is not a part of the cargo project, so it wouldn't be formatted the usual way
     - rustfmt +nightly --verbose --check ./examples/psp22-extension/runtime/psp22-extension-example.rs
@@ -161,6 +166,7 @@ examples-clippy-std:
   script:
     - for example in examples/*/; do
         if [ "$example" = "examples/upgradeable-contracts/" ]; then continue; fi;
+        if [ "$example" = "examples/lang-err-integration-tests/" ]; then continue; fi;
         cargo clippy --verbose --all-targets --manifest-path ${example}/Cargo.toml -- -D warnings -A $CLIPPY_ALLOWED;
       done
     - for contract in ${DELEGATOR_SUBCONTRACTS}; do
@@ -169,6 +175,9 @@ examples-clippy-std:
     - for contract in ${UPGRADEABLE_CONTRACTS}; do
         cargo clippy --verbose --all-targets --manifest-path ./examples/upgradeable-contracts/${contract}/Cargo.toml -- -D warnings -A $CLIPPY_ALLOWED;
       done
+    - for contract in ${LANG_ERR_INTEGRATION_CONTRACTS}; do
+        cargo clippy --verbose --all-targets --manifest-path ./examples/lang-err-integration-tests/${contract}/Cargo.toml -- -D warnings -A $CLIPPY_ALLOWED;
+      done
     - cargo clippy --verbose --all-targets --manifest-path ./examples/upgradeable-contracts/set-code-hash/updated-incrementer/Cargo.toml -- -D warnings -A $CLIPPY_ALLOWED;
   allow_failure:                   true
 
@@ -179,6 +188,7 @@ examples-clippy-wasm:
   script:
     - for example in examples/*/; do
         if [ "$example" = "examples/upgradeable-contracts/" ]; then continue; fi;
+        if [ "$example" = "examples/lang-err-integration-tests/" ]; then continue; fi;
         cargo clippy --verbose --manifest-path ${example}/Cargo.toml --no-default-features --target wasm32-unknown-unknown -- -D warnings -A $CLIPPY_ALLOWED;
       done
     - for contract in ${DELEGATOR_SUBCONTRACTS}; do
@@ -187,6 +197,9 @@ examples-clippy-wasm:
     - for contract in ${UPGRADEABLE_CONTRACTS}; do
         cargo clippy --verbose --manifest-path ./examples/upgradeable-contracts/${contract}/Cargo.toml --no-default-features --target wasm32-unknown-unknown -- -D warnings -A $CLIPPY_ALLOWED;
       done
+    - for contract in ${LANG_ERR_INTEGRATION_CONTRACTS}; do
+        cargo clippy --verbose --manifest-path ./examples/lang-err-integration-tests/${contract}/Cargo.toml --no-default-features --target wasm32-unknown-unknown -- -D warnings -A $CLIPPY_ALLOWED;
+      done
     - cargo clippy --verbose --manifest-path ./examples/upgradeable-contracts/set-code-hash/updated-incrementer/Cargo.toml --no-default-features --target wasm32-unknown-unknown -- -D warnings -A $CLIPPY_ALLOWED;
   allow_failure:                   true
 
@@ -363,6 +376,7 @@ examples-test:
     - *start-substrate-contracts-node
     - for example in examples/*/; do
         if [ "$example" = "examples/upgradeable-contracts/" ]; then continue; fi;
+        if [ "$example" = "examples/lang-err-integration-tests/" ]; then continue; fi;
         if grep -q "e2e-tests = \[\]" "${example}/Cargo.toml"; then
           cargo test --verbose --manifest-path ${example}/Cargo.toml --features e2e-tests;
         else
@@ -375,6 +389,9 @@ examples-test:
     - for contract in ${UPGRADEABLE_CONTRACTS}; do
         cargo test --verbose --manifest-path ./examples/upgradeable-contracts/${contract}/Cargo.toml;
       done
+    - for contract in ${LANG_ERR_INTEGRATION_CONTRACTS}; do
+        cargo test --verbose --manifest-path ./examples/lang-err-integration-tests/${contract}/Cargo.toml --features e2e-tests;
+      done
     - cargo test --verbose --manifest-path ./examples/upgradeable-contracts/set-code-hash/updated-incrementer/Cargo.toml;
 
 examples-contract-build:
@@ -386,6 +403,7 @@ examples-contract-build:
     - cargo contract -V
     - for example in examples/*/; do
         if [ "$example" = "examples/upgradeable-contracts/" ]; then continue; fi;
+        if [ "$example" = "examples/lang-err-integration-tests/" ]; then continue; fi;
         pushd $example &&
         cargo +stable contract build &&
         popd;
@@ -394,6 +412,9 @@ examples-contract-build:
     - for contract in ${UPGRADEABLE_CONTRACTS}; do
         cargo +stable contract build --manifest-path ./examples/upgradeable-contracts/${contract}/Cargo.toml;
       done
+    - for contract in ${LANG_ERR_INTEGRATION_CONTRACTS}; do
+        cargo +stable contract build --manifest-path ./examples/lang-err-integration-tests/${contract}/Cargo.toml;
+      done
     - cargo +stable contract build --manifest-path ./examples/upgradeable-contracts/set-code-hash/updated-incrementer/Cargo.toml
 
 examples-docs:
@@ -409,6 +430,7 @@ examples-docs:
     # of this flag.
     - for example in examples/*/; do
         if [ "$example" = "examples/upgradeable-contracts/" ]; then continue; fi;
+        if [ "$example" = "examples/lang-err-integration-tests/" ]; then continue; fi;
         cargo doc --manifest-path ${example}/Cargo.toml --document-private-items --verbose --no-deps;
       done
     - for contract in ${DELEGATOR_SUBCONTRACTS}; do
@@ -417,6 +439,9 @@ examples-docs:
     - for contract in ${UPGRADEABLE_CONTRACTS}; do
         cargo doc --manifest-path ./examples/upgradeable-contracts/${contract}/Cargo.toml --document-private-items --verbose --no-deps;
       done
+    - for contract in ${LANG_ERR_INTEGRATION_CONTRACTS}; do
+        cargo doc --manifest-path ./examples/lang-err-integration-tests/${contract}/Cargo.toml --document-private-items --verbose --no-deps;
+      done
     - cargo doc --manifest-path ./examples/upgradeable-contracts/set-code-hash/updated-incrementer/Cargo.toml --document-private-items --verbose --no-deps
 
 

crates/ink/codegen/src/generator/as_dependency/call_builder.rs

@@ -369,10 +369,8 @@ impl CallBuilder<'_> {
         let input_types = generator::input_types(message.inputs());
         let arg_list = generator::generate_argument_list(input_types.iter().cloned());
         let mut_tok = callable.receiver().is_ref_mut().then(|| quote! { mut });
-        let output = message.output();
-        let return_type =
-            output.map_or_else(|| quote! { () }, |output| quote! { #output });
-        let output_span = output.span();
+        let return_type = message.wrapped_output();
+        let output_span = return_type.span();
         let output_type = quote_spanned!(output_span=>
             ::ink::env::call::CallBuilder<
                 Environment,

crates/ink/codegen/src/generator/as_dependency/contract_ref.rs

@@ -336,6 +336,7 @@ impl ContractRef<'_> {
             .filter_attr(message.attrs().to_vec());
         let storage_ident = self.contract.module().storage().ident();
         let message_ident = message.ident();
+        let checked_message_ident = message.checked_ident();
         let call_operator = match message.receiver() {
             ir::Receiver::Ref => quote! { call },
             ir::Receiver::RefMut => quote! { call_mut },
@@ -344,13 +345,29 @@ impl ContractRef<'_> {
         let input_bindings = message.inputs().map(|input| &input.pat).collect::<Vec<_>>();
         let input_types = message.inputs().map(|input| &input.ty).collect::<Vec<_>>();
         let output_type = message.output().map(|ty| quote! { -> #ty });
+        let wrapped_output_type = message.wrapped_output();
         quote_spanned!(span=>
             #( #attrs )*
             #[inline]
             pub fn #message_ident(
                 & #mut_token self
                 #( , #input_bindings : #input_types )*
             ) #output_type {
+                self.#checked_message_ident( #( #input_bindings, )* )
+                    .unwrap_or_else(|error| ::core::panic!(
+                        "encountered error while calling {}::{}: {:?}",
+                        ::core::stringify!(#storage_ident),
+                        ::core::stringify!(#message_ident),
+                        error,
+                    ))
+            }
+
+            #( #attrs )*
+            #[inline]
+            pub fn #checked_message_ident(
+                & #mut_token self
+                #( , #input_bindings : #input_types )*
+            ) -> #wrapped_output_type {
                 <Self as ::ink::codegen::TraitCallBuilder>::#call_operator(self)
                     .#message_ident( #( #input_bindings ),* )
                     .fire()

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

@@ -435,16 +435,34 @@ impl Dispatch<'_> {
                         .unwrap_or_else(|error| ::core::panic!("{}", error))
                 }
 
-                ::ink::env::decode_input::<
-                        <#storage_ident as ::ink::reflect::ContractMessageDecoder>::Type>()
-                    .map_err(|_| ::ink::reflect::DispatchError::CouldNotReadInput)
-                    .and_then(|decoder| {
-                        <<#storage_ident as ::ink::reflect::ContractMessageDecoder>::Type
-                            as ::ink::reflect::ExecuteDispatchable>::execute_dispatchable(decoder)
-                    })
-                    .unwrap_or_else(|error| {
-                        ::core::panic!("dispatching ink! message failed: {}", error)
-                    })
+                let dispatchable = match ::ink::env::decode_input::<
+                    <#storage_ident as ::ink::reflect::ContractMessageDecoder>::Type,
+                >() {
+                    ::core::result::Result::Ok(decoded_dispatchable) => {
+                        decoded_dispatchable
+                    }
+                    ::core::result::Result::Err(_decoding_error) => {
+                        use ::core::default::Default;
+                        let error = ::core::result::Result::Err(::ink::LangError::CouldNotReadInput);
+
+                        // At this point we're unable to set the `Ok` variant to be the any "real"
+                        // message output since we were unable to figure out what the caller wanted
+                        // to dispatch in the first place, so we set it to `()`.
+                        //
+                        // This is okay since we're going to only be encoding the `Err` variant
+                        // into the output buffer anyways.
+                        ::ink::env::return_value::<::core::result::Result<(), ::ink::LangError>>(
+                            ::ink::env::ReturnFlags::default().set_reverted(true),
+                            &error,
+                        );
+                    }
+                };
+
+                <<#storage_ident as ::ink::reflect::ContractMessageDecoder>::Type
+                    as ::ink::reflect::ExecuteDispatchable>::execute_dispatchable(dispatchable)
+                .unwrap_or_else(|error| {
+                    ::core::panic!("dispatching ink! message failed: {}", error)
+                })
             }
         )
     }
@@ -761,23 +779,24 @@ impl Dispatch<'_> {
                     let failure = ::ink::is_result_type!(#message_output)
                         && ::ink::is_result_err!(result);
 
+                    // Currently no `LangError`s are raised at this level of the dispatch logic
+                    // so `Ok` is always returned to the caller.
+                    let return_value = ::core::result::Result::Ok(result);
+
                     if failure {
                         // We return early here since there is no need to push back the
                         // intermediate results of the contract - the transaction is going to be
                         // reverted anyways.
-                        ::ink::env::return_value::<#message_output>(
-                            ::ink::env::ReturnFlags::default().set_reverted(true), &result
+                        ::ink::env::return_value::<::ink::MessageResult::<#message_output>>(
+                            ::ink::env::ReturnFlags::default().set_reverted(true), &return_value
                         )
                     }
 
                     push_contract(contract, #mutates_storage);
 
-                    if ::core::any::TypeId::of::<#message_output>() != ::core::any::TypeId::of::<()>() {
-                        // In case the return type is `()` we do not return a value.
-                        ::ink::env::return_value::<#message_output>(
-                            ::ink::env::ReturnFlags::default(), &result
-                        )
-                    }
+                    ::ink::env::return_value::<::ink::MessageResult::<#message_output>>(
+                        ::ink::env::ReturnFlags::default(), &return_value
+                    )
                 }
             )
         });
@@ -848,8 +867,6 @@ impl Dispatch<'_> {
                         match self {
                             #( #message_execute ),*
                         };
-
-                        ::core::result::Result::Ok(())
                     }
                 }
 

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

@@ -93,6 +93,10 @@ impl Metadata<'_> {
             .attrs()
             .iter()
             .filter_map(|attr| attr.extract_docs());
+        let error_ty = syn::parse_quote! {
+            ::ink::LangError
+        };
+        let error = Self::generate_type_spec(&error_ty);
         quote! {
             ::ink::metadata::ContractSpec::new()
                 .constructors([
@@ -107,6 +111,9 @@ impl Metadata<'_> {
                 .docs([
                     #( #docs ),*
                 ])
+                .lang_error(
+                     #error
+                )
                 .done()
         }
     }
@@ -172,6 +179,7 @@ impl Metadata<'_> {
         fn without_display_name(ty: &syn::Type) -> TokenStream2 {
             quote! { ::ink::metadata::TypeSpec::of_type::<#ty>() }
         }
+
         if let syn::Type::Path(type_path) = ty {
             if type_path.qself.is_some() {
                 return without_display_name(ty)
@@ -256,7 +264,7 @@ impl Metadata<'_> {
                 let mutates = message.receiver().is_ref_mut();
                 let ident = message.ident();
                 let args = message.inputs().map(Self::generate_dispatch_argument);
-                let ret_ty = Self::generate_return_type(message.output());
+                let ret_ty = Self::generate_return_type(Some(&message.wrapped_output()));
                 quote_spanned!(span =>
                     ::ink::metadata::MessageSpec::from_label(::core::stringify!(#ident))
                         .selector([

crates/ink/ir/src/ir/item_impl/message.rs

@@ -291,6 +291,21 @@ impl Message {
         }
     }
 
+    /// Returns the return type of the message, but wrapped within a `Result`.
+    ///
+    /// This is used to to allow callers to handle certain types of errors which are not exposed
+    /// by messages.
+    pub fn wrapped_output(&self) -> syn::Type {
+        let return_type = self
+            .output()
+            .map(quote::ToTokens::to_token_stream)
+            .unwrap_or_else(|| quote::quote! { () });
+
+        syn::parse_quote! {
+            ::ink::MessageResult<#return_type>
+        }
+    }
+
     /// Returns a local ID unique to the ink! message with respect to its implementation block.
     ///
     /// # Note
@@ -301,6 +316,11 @@ impl Message {
     pub fn local_id(&self) -> u32 {
         utils::local_message_id(self.ident())
     }
+
+    /// Returns the identifier of the message with an additional `_checked` suffix attached.
+    pub fn checked_ident(&self) -> Ident {
+        quote::format_ident!("{}_checked", self.ident())
+    }
 }
 
 #[cfg(test)]

crates/ink/src/lib.rs

@@ -71,3 +71,7 @@ pub use ink_macro::{
     test,
     trait_definition,
 };
+pub use ink_primitives::{
+    LangError,
+    MessageResult,
+};

crates/ink/tests/ui/contract/fail/constructor-return-result-non-codec-error.stderr

@@ -36,6 +36,6 @@ error[E0277]: the trait bound `contract::Error: TypeInfo` is not satisfied
             (A, B, C, D)
             (A, B, C, D, E)
             (A, B, C, D, E, F)
-          and 64 others
+          and $N others
   = note: required for `Result<(), contract::Error>` to implement `ConstructorReturnSpec`
   = note: this error originates in the attribute macro `ink::contract` (in Nightly builds, run with -Z macro-backtrace for more info)

crates/ink/tests/ui/contract/fail/message-hygiene-checked.rs

@@ -0,0 +1,20 @@
+#[ink::contract]
+mod contract {
+    #[ink(storage)]
+    pub struct Contract {}
+
+    impl Contract {
+        #[ink(constructor)]
+        pub fn constructor() -> Self {
+            Self {}
+        }
+
+        #[ink(message)]
+        pub fn message(&self) {}
+
+        #[ink(message)]
+        pub fn message_checked(&self) {}
+    }
+}
+
+fn main() {}

crates/ink/tests/ui/contract/fail/message-hygiene-checked.stderr

@@ -0,0 +1,8 @@
+error[E0201]: duplicate definitions with name `message_checked`:
+  --> tests/ui/contract/fail/message-hygiene-checked.rs:16:9
+   |
+1  | #[ink::contract]
+   | ---------------- previous definition of `message_checked` here
+...
+16 |         pub fn message_checked(&self) {}
+   |         ^^^ duplicate definition

crates/ink/tests/ui/contract/fail/message-input-non-codec.stderr

@@ -53,11 +53,11 @@ note: required by a bound in `ExecutionInput::<ArgumentList<ArgumentListEnd, Arg
    |         T: scale::Encode,
    |            ^^^^^^^^^^^^^ required by this bound in `ExecutionInput::<ArgumentList<ArgumentListEnd, ArgumentListEnd>>::push_arg`
 
-error[E0599]: the method `fire` exists for struct `ink::ink_env::call::CallBuilder<DefaultEnvironment, Set<Call<DefaultEnvironment>>, Set<ExecutionInput<ArgumentList<ink::ink_env::call::utils::Argument<NonCodecType>, ArgumentList<ArgumentListEnd, ArgumentListEnd>>>>, Set<ReturnType<()>>>`, but its trait bounds were not satisfied
+error[E0599]: the method `fire` exists for struct `ink::ink_env::call::CallBuilder<DefaultEnvironment, Set<Call<DefaultEnvironment>>, Set<ExecutionInput<ArgumentList<ink::ink_env::call::utils::Argument<NonCodecType>, ArgumentList<ArgumentListEnd, ArgumentListEnd>>>>, Set<ReturnType<Result<(), LangError>>>>`, but its trait bounds were not satisfied
   --> tests/ui/contract/fail/message-input-non-codec.rs:16:9
    |
 16 |         pub fn message(&self, _input: NonCodecType) {}
-   |         ^^^ method cannot be called on `ink::ink_env::call::CallBuilder<DefaultEnvironment, Set<Call<DefaultEnvironment>>, Set<ExecutionInput<ArgumentList<ink::ink_env::call::utils::Argument<NonCodecType>, ArgumentList<ArgumentListEnd, ArgumentListEnd>>>>, Set<ReturnType<()>>>` due to unsatisfied trait bounds
+   |         ^^^ method cannot be called on `ink::ink_env::call::CallBuilder<DefaultEnvironment, Set<Call<DefaultEnvironment>>, Set<ExecutionInput<ArgumentList<ink::ink_env::call::utils::Argument<NonCodecType>, ArgumentList<ArgumentListEnd, ArgumentListEnd>>>>, Set<ReturnType<Result<(), LangError>>>>` due to unsatisfied trait bounds
    |
   ::: $WORKSPACE/crates/env/src/call/execution_input.rs
    |