Suggestion from the review

crates/primitives/derive/src/storable.rs

@@ -74,7 +74,7 @@ fn storable_enum_derive(s: &synstructure::Structure) -> TokenStream2 {
         })
         .enumerate()
         .fold(quote! {}, |acc, (index, variant)| {
-            let index = index as u8;
+            let index = index as usize;
             quote! {
                 #acc
                 #index => #variant,
@@ -83,7 +83,7 @@ fn storable_enum_derive(s: &synstructure::Structure) -> TokenStream2 {
 
     let encode_body = s.variants().iter().enumerate().map(|(index, variant)| {
         let pat = variant.pat();
-        let index = index as u8;
+        let index = index as usize;
         let fields = variant.bindings().iter().map(|field| {
             let span = field.ast().ty.span();
             quote_spanned!(span =>

crates/storage/codegen/src/lib.rs

@@ -17,7 +17,9 @@ use syn::Data;
 
 /// Provides common methods for `DeriveInput`.
 ///
-/// **Note:** This is only for internal usage in the `codegen` module.
+/// # Developer Note
+///
+/// This is only for internal usage in the `codegen` module.
 pub trait DeriveUtils {
     /// Finds the salt of the structure, enum or union.
     /// The salt is any generic that has bound `StorageKey`.

crates/storage/derive/src/item.rs

@@ -36,8 +36,8 @@ fn item_inner(s: synstructure::Structure) -> TokenStream2 {
     let (impl_generics, _, where_clause) = generics.split_for_impl();
     let (_, ty_generics_original, _) = s.ast().generics.split_for_impl();
 
-    if s.ast().find_salt().is_some() {
-        let inner_salt_ident = s.ast().find_salt().unwrap().ident.to_token_stream();
+    if let Some(inner_salt_ident) = s.ast().find_salt() {
+        let inner_salt_ident = inner_salt_ident.ident.to_token_stream();
         let ty_generics: Vec<_> = s
             .ast()
             .generics

crates/storage/derive/src/lib.rs

@@ -33,7 +33,11 @@ use self::{
 };
 synstructure::decl_derive!(
     [Item] =>
-    /// Derives `ink_storage`'s `Item` trait for the given `struct` or `enum`.
+    /// Derives `ink_storage`'s [`Item`](ink_storage::traits::Item) trait for the given `struct`
+    /// or `enum`.
+    ///
+    /// If the type declaration contains generic [`StorageKey`](ink_storage::traits::StorageKey),
+    /// it will use it as salt to generate a combined storage key.
     ///
     /// # Examples
     ///
@@ -55,23 +59,13 @@ synstructure::decl_derive!(
     ///
     /// let _: NamedFields = <NamedFields as Item<AutoKey>>::Type::default();
     /// let _: NamedFields = <NamedFields as Item<ManualKey<123>>>::Type::default();
-    ///
-    /// #[derive(Item, StorageKey, Storable)]
-    /// struct NamedFieldsStorage<KEY: ink_storage::traits::StorageKey> {
-    ///     a: <u32 as AutoItem<ManualKey<0, KEY>>>::Type,
-    ///     b: <[u32; 32] as AutoItem<ManualKey<1, KEY>>>::Type,
-    /// }
-    ///
-    /// // (AutoKey | ManualKey<123>) -> ManualKey<123>
-    /// assert_eq!(123, <NamedFieldsStorage<AutoKey> as AutoItem<ManualKey<123>>>::Type::KEY);
-    /// // (ManualKey<321> | ManualKey<123>) -> ManualKey<321>
-    /// assert_eq!(321, <NamedFieldsStorage<ManualKey<321>> as AutoItem<ManualKey<123>>>::Type::KEY);
     /// ```
     item_derive
 );
 synstructure::decl_derive!(
     [StorageKey] =>
-    /// Derives `ink_storage`'s `StorageKey` trait for the given `struct` or `enum`.
+    /// Derives `ink_storage`'s [`StorageKey`](ink_storage::traits::StorageKey) trait for the given
+    /// `struct` or `enum`.
     ///
     /// # Examples
     ///
@@ -105,7 +99,8 @@ synstructure::decl_derive!(
 );
 synstructure::decl_derive!(
     [StorageLayout] =>
-    /// Derives `ink_storage`'s `StorageLayout` trait for the given `struct` or `enum`.
+    /// Derives `ink_storage`'s [`StorageKey`](ink_storage::traits::StorageLayout) trait for the
+    /// given `struct` or `enum`.
     ///
     /// # Examples
     ///

crates/storage/src/lazy/mapping.rs

@@ -258,6 +258,7 @@ const _: () = {
 #[cfg(test)]
 mod tests {
     use super::*;
+    use crate::traits::ManualKey;
 
     #[test]
     fn insert_and_get_work() {
@@ -271,6 +272,20 @@ mod tests {
         .unwrap()
     }
 
+    #[test]
+    fn insert_and_get_work_for_two_mapping_with_same_manual_key() {
+        ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {
+            let mut mapping: Mapping<u8, u8, ManualKey<123>> = Mapping::new();
+            mapping.insert(&1, &2);
+
+            let mapping2: Mapping<u8, u8, ManualKey<123>> = Mapping::new();
+            assert_eq!(mapping2.get(&1), Some(2));
+
+            Ok(())
+        })
+        .unwrap()
+    }
+
     #[test]
     fn gets_default_if_no_key_set() {
         ink_env::test::run_test::<ink_env::DefaultEnvironment, _>(|_| {