codegen: Use packed arg for ink! storage_item

Author: davidsemakula

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

@@ -53,9 +53,16 @@ impl GenerateCode for StorageItem<'_> {
             Data::Union(union_item) => self.generate_union(union_item),
         };
 
-        let mut derive = quote! {};
-        if self.item.config().derive() {
-            derive = quote! {
+        let config = self.item.config();
+        let derive = if config.packed() {
+            quote! {
+                #[cfg_attr(feature = "std", derive(
+                    ::ink::storage::traits::StorageLayout,
+                ))]
+                #[ink::scale_derive(Encode, Decode, TypeInfo)]
+            }
+        } else if config.derive() {
+            quote! {
                 #[cfg_attr(feature = "std", derive(
                     ::ink::storage::traits::StorageLayout,
                 ))]
@@ -65,10 +72,16 @@ impl GenerateCode for StorageItem<'_> {
                     ::ink::storage::traits::StorageKey,
                     ::ink::storage::traits::Storable,
                 )]
-            };
-        }
+            }
+        } else {
+            quote! {}
+        };
 
-        let type_check = self.generate_type_check();
+        let type_check = if self.item.config().packed() {
+            quote! {}
+        } else {
+            self.generate_type_check()
+        };
 
         quote! {
             #type_check
@@ -88,22 +101,32 @@ impl StorageItem<'_> {
         let generics = item.generics();
         let salt = item.salt();
 
-        let fields = struct_item.fields.iter().enumerate().map(|(i, field)| {
-            convert_into_storage_field(struct_ident, None, &salt, i, field)
-        });
+        let fields = if self.item.config().packed() {
+            let fields = struct_item.fields.iter();
+            quote! {
+                #(#fields),*
+            }
+        } else {
+            let fields = struct_item.fields.iter().enumerate().map(|(i, field)| {
+                convert_into_storage_field(struct_ident, None, &salt, i, field)
+            });
+            quote! {
+                #(#fields),*
+            }
+        };
 
         match struct_item.fields {
             Fields::Unnamed(_) => {
                 quote! {
                     #vis struct #struct_ident #generics (
-                        #(#fields),*
+                        #fields
                     );
                 }
             }
             _ => {
                 quote! {
                     #vis struct #struct_ident #generics {
-                        #(#fields),*
+                        #fields
                     }
                 }
             }
@@ -126,24 +149,29 @@ impl StorageItem<'_> {
                 quote! {}
             };
 
-            let fields: Vec<_> = variant
-                .fields
-                .iter()
-                .enumerate()
-                .map(|(i, field)| {
+            let fields = if self.item.config().packed() {
+                let fields = variant.fields.iter();
+                quote! {
+                    #(#fields),*
+                }
+            } else {
+                let fields = variant.fields.iter().enumerate().map(|(i, field)| {
                     convert_into_storage_field(
                         enum_ident,
                         Some(variant_ident),
                         &salt,
                         i,
                         field,
                     )
-                })
-                .collect();
+                });
+                quote! {
+                    #(#fields),*
+                }
+            };
 
             let fields = match variant.fields {
-                Fields::Named(_) => quote! { { #(#fields),* } },
-                Fields::Unnamed(_) => quote! { ( #(#fields),* ) },
+                Fields::Named(_) => quote! { { #fields } },
+                Fields::Unnamed(_) => quote! { ( #fields ) },
                 Fields::Unit => quote! {},
             };
 
@@ -167,18 +195,28 @@ impl StorageItem<'_> {
         let generics = item.generics();
         let salt = item.salt();
 
-        let fields = union_item
-            .fields
-            .named
-            .iter()
-            .enumerate()
-            .map(|(i, field)| {
-                convert_into_storage_field(union_ident, None, &salt, i, field)
-            });
+        let fields = if self.item.config().packed() {
+            let fields = union_item.fields.named.iter();
+            quote! {
+                #(#fields),*
+            }
+        } else {
+            let fields = union_item
+                .fields
+                .named
+                .iter()
+                .enumerate()
+                .map(|(i, field)| {
+                    convert_into_storage_field(union_ident, None, &salt, i, field)
+                });
+            quote! {
+                #(#fields),*
+            }
+        };
 
         quote! {
             #vis union #union_ident #generics {
-                #(#fields),*
+                #fields
             }
         }
     }

crates/ink/macro/src/lib.rs

@@ -897,13 +897,8 @@ pub fn event(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// };
 /// use ink::storage::traits::Storable;
 ///
-/// // Deriving `scale::Decode` and `scale::Encode` also derives blanket implementation of all
-/// // required traits to be storable.
-/// #[derive(scale::Decode, scale::Encode)]
-/// #[cfg_attr(
-///     feature = "std",
-///     derive(scale_info::TypeInfo, ink::storage::traits::StorageLayout)
-/// )]
+/// // Example of how to define a packed type.
+/// #[ink::storage_item(packed)]
 /// #[derive(Default, Debug)]
 /// struct Packed {
 ///     s1: u128,
@@ -912,12 +907,8 @@ pub fn event(attr: TokenStream, item: TokenStream) -> TokenStream {
 ///     // s3: Vec<NonPacked>,
 /// }
 ///
-/// // Example of how to define the packed type with generic.
-/// #[derive(scale::Decode, scale::Encode)]
-/// #[cfg_attr(
-///     feature = "std",
-///     derive(scale_info::TypeInfo, ink::storage::traits::StorageLayout)
-/// )]
+/// // Example of how to define the packed type with generics.
+/// #[ink::storage_item(packed)]
 /// #[derive(Default, Debug)]
 /// struct PackedGeneric<T: ink::storage::traits::Packed> {
 ///     s1: (u128, bool),
@@ -926,6 +917,8 @@ pub fn event(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// }
 ///
 /// // Example of how to define the non-packed type.
+/// // Note: `packed` argument defaults to `false`, so it can be omitted for non-packed types,
+/// // so the definition below is equivalent to `#[ink::storage_item(packed = false)]`.
 /// #[ink::storage_item]
 /// #[derive(Default, Debug)]
 /// struct NonPacked {
@@ -934,14 +927,27 @@ pub fn event(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// }
 ///
 /// // Example of how to define the non-packed generic type.
+/// #[ink::storage_item]
+/// #[derive(Default, Debug)]
+/// struct NonPackedGeneric<T>
+/// where
+///     T: Default + core::fmt::Debug,
+///     T: ink::storage::traits::Packed,
+/// {
+///     s1: u32,
+///     s2: T,
+///     s3: Mapping<u128, T>,
+/// }
+///
+/// // Example of how to define the non-packed generic type with manually derived storage traits.
 /// #[ink::storage_item(derive = false)]
 /// #[derive(Storable, StorableHint, StorageKey)]
 /// #[cfg_attr(
 ///     feature = "std",
 ///     derive(scale_info::TypeInfo, ink::storage::traits::StorageLayout)
 /// )]
 /// #[derive(Default, Debug)]
-/// struct NonPackedGeneric<T>
+/// struct NonPackedGenericManual<T>
 /// where
 ///     T: Default + core::fmt::Debug,
 ///     T: ink::storage::traits::Packed,
@@ -952,11 +958,7 @@ pub fn event(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// }
 ///
 /// // Example of how to define a complex packed type.
-/// #[derive(scale::Decode, scale::Encode)]
-/// #[cfg_attr(
-///     feature = "std",
-///     derive(scale_info::TypeInfo, ink::storage::traits::StorageLayout)
-/// )]
+/// #[ink::storage_item(packed)]
 /// #[derive(Default, Debug)]
 /// struct PackedComplex {
 ///     s1: u128,
@@ -985,6 +987,26 @@ pub fn event(attr: TokenStream, item: TokenStream) -> TokenStream {
 /// The `#[ink::storage_item]` macro can be provided with an additional comma-separated
 /// header argument:
 ///
+/// - `packed: flag`
+///
+///   Storage items flagged as `packed` use "packed" layout .
+///
+///   **Usage Example:**
+///   ```
+///   use ink::storage::Mapping;
+///
+///   #[ink::storage_item(packed)]
+///   struct PackedGeneric<T: ink::storage::traits::Packed> {
+///       s1: (u128, bool),
+///       s2: Vec<T>,
+///       s3: String,
+///   }
+///   ```
+///
+///   **Default value:** not set.
+///   **Note**: The default behavior is to use "non-packed" layout, and automatically
+///   derive storage keys for each field.
+///
 /// - `derive: bool`
 ///
 ///   The `derive` configuration parameter is used to enable/disable auto deriving of