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,10 @@ 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 clean --verbose --manifest-path ./examples/lang-err-integration-tests/${contract}/Cargo.toml;
+ 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 +404,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 +413,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 +431,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 +440,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
  |