Unified metadata and storage key generation. The metadata contains al…

…l names that are used during the calculation of the storage key. The updated key calculation for tuples.

Introduced `StorageKeyComposer` to manage all rules for storage creation.
Used a `SHA2` instead of `Blake2b` to calculate the storage key hash. It is because `SHA2` supports const calculation. It is required for tuples.
Implemented UI tests for `#[ink_lang::storage_item]` and fixes bugs.

crates/env/src/engine/off_chain/impls.rs

@@ -46,8 +46,8 @@ use ink_engine::{
 };
 use ink_primitives::{
     Key,
-    OldStorageKey,
     StorageKey,
+    StorageKeyComposer,
 };
 
 /// The capacity of the static buffer.
@@ -225,18 +225,19 @@ impl EnvBackend for EnvInstance {
         V: scale::Encode,
     {
         let v = scale::Encode::encode(value);
-        self.engine.set_storage(key.old_key().as_ref(), &v[..]);
+        self.engine
+            .set_storage(StorageKeyComposer::old_key(key).as_ref(), &v[..]);
     }
 
     fn get_storage_value<R>(&mut self, key: &StorageKey) -> Result<Option<R>>
     where
         R: scale::Decode,
     {
         let mut output: [u8; 9600] = [0; 9600];
-        match self
-            .engine
-            .get_storage(key.old_key().as_ref(), &mut &mut output[..])
-        {
+        match self.engine.get_storage(
+            StorageKeyComposer::old_key(key).as_ref(),
+            &mut &mut output[..],
+        ) {
             Ok(_) => (),
             Err(ext::Error::KeyNotFound) => return Ok(None),
             Err(_) => panic!("encountered unexpected error"),
@@ -246,7 +247,8 @@ impl EnvBackend for EnvInstance {
     }
 
     fn clear_storage_value(&mut self, key: &StorageKey) {
-        self.engine.clear_storage(key.old_key().as_ref())
+        self.engine
+            .clear_storage(StorageKeyComposer::old_key(key).as_ref())
     }
 
     fn decode_input<T>(&mut self) -> Result<T>

crates/env/src/engine/on_chain/impls.rs

@@ -48,8 +48,8 @@ use crate::{
 };
 use ink_primitives::{
     Key,
-    OldStorageKey,
     StorageKey,
+    StorageKeyComposer,
 };
 
 impl CryptoHash for Blake2x128 {
@@ -258,15 +258,15 @@ impl EnvBackend for EnvInstance {
         V: scale::Encode,
     {
         let buffer = self.scoped_buffer().take_encoded(value);
-        ext::set_storage(key.old_key().as_ref(), buffer);
+        ext::set_storage(StorageKeyComposer::old_key(key).as_ref(), buffer);
     }
 
     fn get_storage_value<R>(&mut self, key: &StorageKey) -> Result<Option<R>>
     where
         R: scale::Decode,
     {
         let output = &mut self.scoped_buffer().take_rest();
-        match ext::get_storage(key.old_key().as_ref(), output) {
+        match ext::get_storage(StorageKeyComposer::old_key(key).as_ref(), output) {
             Ok(_) => (),
             Err(ExtError::KeyNotFound) => return Ok(None),
             Err(_) => panic!("encountered unexpected error"),
@@ -276,7 +276,7 @@ impl EnvBackend for EnvInstance {
     }
 
     fn clear_storage_value(&mut self, key: &StorageKey) {
-        ext::clear_storage(key.old_key().as_ref())
+        ext::clear_storage(StorageKeyComposer::old_key(key).as_ref())
     }
 
     fn decode_input<T>(&mut self) -> Result<T>

crates/lang/codegen/Cargo.toml

@@ -18,6 +18,7 @@ include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE"]
 name = "ink_lang_codegen"
 
 [dependencies]
+ink_primitives = { version = "3.0.1", path = "../../primitives" }
 ir = { version = "3.0.1", package = "ink_lang_ir", path = "../ir", default-features = false }
 quote = "1"
 syn = { version = "1.0", features = ["parsing", "full", "extra-traits"] }

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

@@ -46,8 +46,12 @@ impl GenerateCode for Metadata<'_> {
             const _: () = {
                 #[no_mangle]
                 pub fn __ink_generate_metadata() -> ::ink_metadata::MetadataVersioned  {
+                    let layout = #layout;
+                    ::ink_metadata::layout::ValidateLayout::validate(&layout).unwrap_or_else(|error| {
+                        ::core::panic!("metadata ink! generation failed: {}", error)
+                    });
                     <::ink_metadata::InkProject as ::core::convert::Into<::ink_metadata::MetadataVersioned>>::into(
-                        ::ink_metadata::InkProject::new(#layout, #contract)
+                        ::ink_metadata::InkProject::new(layout, #contract)
                     )
                 }
             };
@@ -59,10 +63,17 @@ impl Metadata<'_> {
     fn generate_layout(&self) -> TokenStream2 {
         let storage_span = self.contract.module().storage().span();
         let storage_ident = self.contract.module().storage().ident();
+        let storage_key =
+            quote! { <#storage_ident as ::ink_storage::traits::StorageKeyHolder>::KEY };
         quote_spanned!(storage_span=>
-            <#storage_ident as ::ink_storage::traits::StorageLayout>::layout(
-                &<#storage_ident as ::ink_storage::traits::StorageKeyHolder>::KEY,
-            )
+            // Wrap the layout of the contract into the `RootLayout`, because
+            // contract storage key is reserved for all atomic fields
+            ::ink_metadata::layout::Layout::Root(::ink_metadata::layout::RootLayout::new(
+                ::ink_metadata::layout::LayoutKey::from(&#storage_key),
+                <#storage_ident as ::ink_storage::traits::StorageLayout>::layout(
+                    &#storage_key,
+                ),
+            ))
         )
     }
 

crates/lang/codegen/src/generator/storage_item.rs

@@ -14,16 +14,12 @@
 
 use crate::GenerateCode;
 use derive_more::From;
-use ir::Selector;
 use proc_macro2::{
     Ident,
     TokenStream as TokenStream2,
     TokenStream,
 };
-use quote::{
-    format_ident,
-    quote,
-};
+use quote::quote;
 use syn::{
     parse2,
     Data,
@@ -89,9 +85,20 @@ impl<'a> StorageItem<'a> {
             convert_into_storage_field(struct_ident, None, &salt, i, field)
         });
 
-        quote! {
-            #vis struct #struct_ident #generics {
-                #(#fields),*
+        match struct_item.fields {
+            Fields::Unnamed(_) => {
+                quote! {
+                    #vis struct #struct_ident #generics (
+                        #(#fields),*
+                    );
+                }
+            }
+            _ => {
+                quote! {
+                    #vis struct #struct_ident #generics {
+                        #(#fields),*
+                    }
+                }
             }
         }
     }
@@ -195,57 +202,30 @@ impl<'a> StorageItem<'a> {
     }
 }
 
-/// # Note
-///
-/// - `variant_ident` is `None` for structures and unions.
-/// - if the field is unnamed then `field_ident` is `field_{}` where `{}` is a number of the field.
-///
-/// Evaluates the storage key of the field in the structure, variant or union.
-///
-/// 1. Compute the ASCII byte representation of `struct_ident` and call it `S`.
-/// 1. If `variant_ident` is `Some` then computes the ASCII byte representation and call it `V`.
-/// 1. Compute the ASCII byte representation of `field_ident` and call it `F`.
-/// 1. Concatenate (`S` and `F`) or (`S`, `V` and `F`) using `::` as separator and call it `C`.
-/// 1. Apply the `BLAKE2` 256-bit hash `H` of `C`.
-/// 1. The first 4 bytes of `H` make up the storage key.
-fn compute_storage_key(
-    struct_ident: &syn::Ident,
-    variant_ident: Option<&syn::Ident>,
-    field_ident: &syn::Ident,
-) -> u32 {
-    let separator = &b"::"[..];
-    let composed_key = if let Some(variant) = variant_ident {
-        [
-            &struct_ident.to_string().into_bytes()[..],
-            &variant.to_string().into_bytes()[..],
-            &field_ident.to_string().into_bytes()[..],
-        ]
-        .join(separator)
-    } else {
-        [
-            &struct_ident.to_string().into_bytes()[..],
-            &field_ident.to_string().into_bytes()[..],
-        ]
-        .join(separator)
-    };
-
-    Selector::compute(&composed_key).into_be_u32()
-}
-
 fn convert_into_storage_field(
     struct_ident: &Ident,
     variant_ident: Option<&syn::Ident>,
     salt: &TokenStream,
     index: usize,
     field: &Field,
 ) -> Field {
-    let field_ident = if let Some(field_ident) = &field.ident {
-        field_ident.clone()
+    let field_name = if let Some(field_ident) = &field.ident {
+        field_ident.to_string()
+    } else {
+        index.to_string()
+    };
+
+    let variant_name = if let Some(variant_ident) = variant_ident {
+        variant_ident.to_string()
     } else {
-        format_ident!("field_{}", index)
+        "".to_string()
     };
 
-    let key = compute_storage_key(struct_ident, variant_ident, &field_ident);
+    let key = ink_primitives::StorageKeyComposer::compute_storage_key(
+        struct_ident.to_string().as_str(),
+        variant_name.as_str(),
+        field_name.as_str(),
+    );
 
     let mut new_field = field.clone();
     let ty = field.ty.clone();

crates/lang/codegen/src/generator/trait_def/call_builder.rs

@@ -144,13 +144,16 @@ impl CallBuilder<'_> {
                     __key: &::ink_primitives::StorageKey,
                 ) -> ::ink_metadata::layout::Layout {
                     ::ink_metadata::layout::Layout::Struct(
-                        ::ink_metadata::layout::StructLayout::new([
-                            ::ink_metadata::layout::FieldLayout::new(
-                                ::core::option::Option::Some("account_id"),
-                                <<E as ::ink_env::Environment>::AccountId
-                                    as ::ink_storage::traits::StorageLayout>::layout(__key)
-                            )
-                        ])
+                        ::ink_metadata::layout::StructLayout::new(
+                            ::core::stringify!(#call_builder_ident),
+                            [
+                                ::ink_metadata::layout::FieldLayout::new(
+                                    "account_id",
+                                    <<E as ::ink_env::Environment>::AccountId
+                                        as ::ink_storage::traits::StorageLayout>::layout(__key)
+                                )
+                            ]
+                        )
                     )
                 }
             }

crates/lang/tests/compile_tests.rs

@@ -28,6 +28,9 @@ fn ui_tests() {
     t.pass("tests/ui/contract/pass/*.rs");
     t.compile_fail("tests/ui/contract/fail/*.rs");
 
+    t.pass("tests/ui/storage_item/pass/*.rs");
+    t.compile_fail("tests/ui/storage_item/fail/*.rs");
+
     t.pass("tests/ui/trait_def/pass/*.rs");
     t.compile_fail("tests/ui/trait_def/fail/*.rs");
 

crates/lang/tests/ui/storage_item/fail/argument_derive_invalid_type.rs

@@ -0,0 +1,9 @@
+#[ink_lang::storage_item(derive = "false")]
+#[derive(Default)]
+struct Contract<KEY: StorageKeyHolder = ManualKey<123>> {
+    a: u16,
+    b: u64,
+    c: u128,
+}
+
+fn main() {}

crates/lang/tests/ui/storage_item/fail/argument_derive_invalid_type.stderr

@@ -0,0 +1,5 @@
+error: expected a bool literal for `derive` ink! storage item configuration argument
+ --> tests/ui/storage_item/fail/argument_derive_invalid_type.rs:1:26
+  |
+1 | #[ink_lang::storage_item(derive = "false")]
+  |                          ^^^^^^^^^^^^^^^^

crates/lang/tests/ui/storage_item/fail/argument_derive_missing_arg.rs

@@ -0,0 +1,9 @@
+#[ink_lang::storage_item(derive)]
+#[derive(Default)]
+struct Contract<KEY: StorageKeyHolder = ManualKey<123>> {
+    a: u16,
+    b: u64,
+    c: u128,
+}
+
+fn main() {}

crates/lang/tests/ui/storage_item/fail/argument_derive_missing_arg.stderr

@@ -0,0 +1,5 @@
+error: ink! config options require an argument separated by '='
+ --> tests/ui/storage_item/fail/argument_derive_missing_arg.rs:1:26
+  |
+1 | #[ink_lang::storage_item(derive)]
+  |                          ^^^^^^

crates/lang/tests/ui/storage_item/fail/atomic_guard_is_false_for_non_atomic.rs

@@ -0,0 +1,14 @@
+use ink_storage::{
+    traits::AtomicGuard,
+    StorageValue,
+};
+
+#[ink_lang::storage_item]
+#[derive(Default)]
+struct NonAtomic {
+    a: StorageValue<u128>,
+}
+
+fn main() {
+    let _: &dyn AtomicGuard<true> = &NonAtomic::default();
+}

crates/lang/tests/ui/storage_item/fail/atomic_guard_is_false_for_non_atomic.stderr

@@ -0,0 +1,8 @@
+error[E0277]: the trait bound `NonAtomic: AtomicGuard<true>` is not satisfied
+  --> tests/ui/storage_item/fail/atomic_guard_is_false_for_non_atomic.rs:13:37
+   |
+13 |     let _: &dyn AtomicGuard<true> = &NonAtomic::default();
+   |                                     ^^^^^^^^^^^^^^^^^^^^^ the trait `AtomicGuard<true>` is not implemented for `NonAtomic`
+   |
+   = help: the trait `AtomicGuard<false>` is implemented for `NonAtomic`
+   = note: required for the cast to the object type `dyn AtomicGuard<true>`

crates/lang/tests/ui/storage_item/fail/collections_only_atomic_1.rs

@@ -0,0 +1,14 @@
+use ink_prelude::vec::Vec;
+use ink_storage::StorageValue;
+
+#[ink_lang::storage_item]
+struct NonAtomic {
+    a: StorageValue<u128>,
+}
+
+#[ink_lang::storage_item]
+struct Contract {
+    a: Vec<NonAtomic>,
+}
+
+fn main() {}