Add a compact flag to Field to indicate that this type is to be e…

…ncoded/decoded as a SCALE Compact type

derive/src/lib.rs

@@ -92,7 +92,6 @@ fn generate_type(input: TokenStream2) -> Result<TokenStream2> {
                     .path(::scale_info::Path::new(stringify!(#ident), module_path!()))
                     .type_params(::scale_info::prelude::vec![ #( #generic_type_ids ),* ])
                     .#build_type
-                    .into()
             }
         }
     };

src/build.rs

@@ -248,6 +248,15 @@ impl<T> FieldsBuilder<T> {
     pub fn finalize(self) -> Vec<Field<MetaForm>> {
         self.fields
     }
+
+    /// Mark last field as compact, meaning that encoding/decoding should be in the [`scale_codec::Compact`] format.
+    pub fn compact(mut self) -> Self {
+        self.fields.iter_mut().last().and_then(|f| {
+            f.compact();
+            Some(f)
+        });
+        self
+    }
 }
 
 impl FieldsBuilder<NamedFields> {

src/registry.rs

@@ -303,7 +303,6 @@ mod tests {
                                 "&mut RecursiveRefs",
                             ),
                     )
-                    .into()
             }
         }
 

src/tests.rs

@@ -134,7 +134,6 @@ fn struct_with_generics() {
                 .path(Path::new("MyStruct", module_path!()))
                 .type_params(tuple_meta_type!(T))
                 .composite(Fields::named().field_of::<T>("data", "T"))
-                .into()
         }
     }
 

src/ty/fields.rs

@@ -86,6 +86,14 @@ pub struct Field<T: Form = MetaForm> {
     ty: T::Type,
     /// The name of the type of the field as it appears in the source code.
     type_name: T::String,
+    /// This field should be encode/decoded as a
+    /// [`Compact`](parity_scale_codec::Compact) field
+    #[cfg_attr(feature = "serde", serde(skip_serializing_if = "is_false", default))]
+    compact: bool,
+}
+
+fn is_false(v: &bool) -> bool {
+    !v
 }
 
 impl IntoFrozen for Field {
@@ -96,6 +104,7 @@ impl IntoFrozen for Field {
             name: self.name.map(|name| name.into_frozen(registry)),
             ty: registry.register_type(&self.ty),
             type_name: self.type_name.into_frozen(registry),
+            compact: self.compact,
         }
     }
 }
@@ -108,11 +117,13 @@ impl Field {
         name: Option<&'static str>,
         ty: MetaType,
         type_name: &'static str,
+        compact: bool,
     ) -> Self {
         Self {
             name,
             ty,
             type_name,
+            compact,
         }
     }
 
@@ -124,7 +135,7 @@ impl Field {
     where
         T: TypeInfo + ?Sized + 'static,
     {
-        Self::new(Some(name), MetaType::new::<T>(), type_name)
+        Self::new(Some(name), MetaType::new::<T>(), type_name, false)
     }
 
     /// Creates a new unnamed field.
@@ -135,7 +146,7 @@ impl Field {
     where
         T: TypeInfo + ?Sized + 'static,
     {
-        Self::new(None, MetaType::new::<T>(), type_name)
+        Self::new(None, MetaType::new::<T>(), type_name, false)
     }
 }
 
@@ -161,4 +172,10 @@ where
     pub fn type_name(&self) -> &T::String {
         &self.type_name
     }
+
+    /// Set the `compact` property to true, signalling that this type is to be
+    /// encoded/decoded as a [`parity_scale_codec::Compact`].
+    pub fn compact(&mut self) {
+        self.compact = true;
+    }
 }

test_suite/tests/json.rs

@@ -196,6 +196,54 @@ fn test_struct() {
     }));
 }
 
+#[test]
+fn test_struct_with_some_fields_marked_as_compact() {
+    use scale::Encode;
+
+    // #[derive(TypeInfo, Encode)]
+    #[derive(Encode)]
+    struct Dense {
+        #[codec(compact)]
+        a: u128,
+        b: [u8; 32],
+        #[codec(compact)]
+        c: u64,
+    }
+    use scale_info::{
+        build::Fields,
+        Path,
+        Type,
+    };
+    impl TypeInfo for Dense {
+        type Identity = Self;
+        fn type_info() -> Type {
+            Type::builder()
+                .path(Path::new("Dense", module_path!()))
+                .composite(
+                    Fields::named()
+                        .field_of::<u8>("a", "i32")
+                        .compact()
+                        .field_of::<[u8; 32]>("b", "[u8; 32]")
+                        .field_of::<u64>("c", "u64")
+                        .compact(),
+                )
+        }
+    }
+
+    assert_json_for_type::<Dense>(json![{
+    "path": ["json", "Dense"],
+        "def": {
+            "composite": {
+                "fields": [
+                    { "name": "a", "type": 1, "typeName": "i32", "compact": true },
+                    { "name": "b", "type": 2, "typeName": "[u8; 32]" },
+                    { "name": "c", "type": 3, "typeName": "u64", "compact": true },
+                ],
+            },
+        }
+    }]);
+}
+
 #[test]
 fn test_clike_enum() {
     #[derive(TypeInfo)]