Add a TypeDef to handle Compact types

derive/src/lib.rs

@@ -39,6 +39,7 @@ use syn::{
     punctuated::Punctuated,
     token::Comma,
     visit_mut::VisitMut,
+    AttrStyle,
     Data,
     DataEnum,
     DataStruct,
@@ -49,6 +50,9 @@ use syn::{
     Fields,
     Lifetime,
     Lit,
+    Meta,
+    MetaList,
+    NestedMeta,
     Variant,
 };
 
@@ -100,7 +104,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()
             }
         }
     };
@@ -127,20 +130,37 @@ fn generate_fields(fields: &FieldsList) -> Vec<TokenStream2> {
             StaticLifetimesReplace.visit_type_mut(&mut ty);
 
             let type_name = clean_type_string(&quote!(#ty).to_string());
-
-            if let Some(i) = ident {
-                quote! {
-                    .field_of::<#ty>(stringify!(#i), #type_name)
-                }
+            let method_call = if is_compact(f) {
+                quote!(.compact_of::<#ty>)
             } else {
-                quote! {
-                    .field_of::<#ty>(#type_name)
-                }
+                quote!(.field_of::<#ty>)
+            };
+            if let Some(ident) = ident {
+                quote!(#method_call(stringify!(#ident), #type_name))
+            } else {
+                quote!(#method_call(#type_name))
             }
         })
         .collect()
 }
 
+/// Look for a `#[codec(compact)]` outer attribute.
+fn is_compact(f: &Field) -> bool {
+    f.attrs.iter().any(|attr| {
+        let mut is_compact = false;
+        if attr.style == AttrStyle::Outer && attr.path.is_ident("codec") {
+            if let Ok(Meta::List(MetaList { nested, .. })) = attr.parse_meta() {
+                if let Some(NestedMeta::Meta(Meta::Path(path))) = nested.iter().next() {
+                    if path.is_ident("compact") {
+                        is_compact = true;
+                    }
+                }
+            }
+        }
+        is_compact
+    })
+}
+
 fn clean_type_string(input: &str) -> String {
     input
         .replace(" ::", "::")

derive/src/trait_bounds.rs

@@ -51,10 +51,21 @@ pub fn make_where_clause<'a>(
 
     let types = collect_types_to_bind(input_ident, data, &ty_params_ids)?;
 
-    types.into_iter().for_each(|ty| {
-        where_clause
-            .predicates
-            .push(parse_quote!(#ty : ::scale_info::TypeInfo + 'static))
+    types.into_iter().for_each(|(ty, is_compact)| {
+        // Compact types need extra bounds, T: HasCompact and <T as
+        // HasCompact>::Type: TypeInfo + 'static
+        if is_compact {
+            where_clause
+                .predicates
+                .push(parse_quote!(#ty : ::scale::HasCompact));
+            where_clause
+                .predicates
+                .push(parse_quote!(<#ty as ::scale::HasCompact>::Type : ::scale_info::TypeInfo + 'static));
+        } else {
+            where_clause
+                .predicates
+                .push(parse_quote!(#ty : ::scale_info::TypeInfo + 'static));
+        }
     });
 
     generics.type_params().into_iter().for_each(|type_param| {
@@ -94,14 +105,14 @@ fn type_contains_idents(ty: &Type, idents: &[Ident]) -> bool {
     visitor.result
 }
 
-/// Returns all types that must be added to the where clause with the respective
-/// trait bound.
+/// Returns all types that must be added to the where clause with a boolean
+/// indicating if the field is [`scale::Compact`] or not.
 fn collect_types_to_bind(
     input_ident: &Ident,
     data: &syn::Data,
     ty_params: &[Ident],
-) -> Result<Vec<Type>> {
-    let types_from_fields = |fields: &Punctuated<syn::Field, _>| -> Vec<syn::Type> {
+) -> Result<Vec<(Type, bool)>> {
+    let types_from_fields = |fields: &Punctuated<syn::Field, _>| -> Vec<(Type, bool)> {
         fields
             .iter()
             .filter(|field| {
@@ -112,7 +123,7 @@ fn collect_types_to_bind(
                 // to not have them in the where clause.
                 !type_contains_idents(&field.ty, &[input_ident.clone()])
             })
-            .map(|f| f.ty.clone())
+            .map(|f| (f.ty.clone(), super::is_compact(f)))
             .collect()
     };
 

src/build.rs

@@ -259,6 +259,17 @@ impl FieldsBuilder<NamedFields> {
         self.fields.push(Field::named_of::<T>(name, type_name));
         self
     }
+
+    /// Add a named, [`Compact`] field of type `T`.
+    pub fn compact_of<T>(mut self, name: &'static str, type_name: &'static str) -> Self
+    where
+        T: scale::HasCompact,
+        <T as scale::HasCompact>::Type: TypeInfo + 'static,
+    {
+        self.fields
+            .push(Field::compact_of::<T>(Some(name), type_name));
+        self
+    }
 }
 
 impl FieldsBuilder<UnnamedFields> {
@@ -270,6 +281,16 @@ impl FieldsBuilder<UnnamedFields> {
         self.fields.push(Field::unnamed_of::<T>(type_name));
         self
     }
+
+    /// Add an unnamed, [`Compact`] field of type `T`.
+    pub fn compact_of<T>(mut self, type_name: &'static str) -> Self
+    where
+        T: scale::HasCompact,
+        <T as scale::HasCompact>::Type: TypeInfo + 'static,
+    {
+        self.fields.push(Field::compact_of::<T>(None, type_name));
+        self
+    }
 }
 
 /// Build a type with no variants.

src/impls.rs

@@ -26,6 +26,7 @@ use crate::{
     Path,
     Type,
     TypeDefArray,
+    TypeDefCompact,
     TypeDefPhantom,
     TypeDefPrimitive,
     TypeDefSequence,
@@ -251,3 +252,13 @@ where
         TypeDefPhantom::new(MetaType::new::<T>()).into()
     }
 }
+
+impl<T> TypeInfo for scale::Compact<T>
+where
+    T: TypeInfo + 'static,
+{
+    type Identity = Self;
+    fn type_info() -> Type {
+        TypeDefCompact::new(MetaType::new::<T>()).into()
+    }
+}

src/registry.rs

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

src/tests.rs

@@ -17,6 +17,7 @@ use crate::{
     *,
 };
 use core::marker::PhantomData;
+use scale::Compact;
 
 #[cfg(not(feature = "std"))]
 use alloc::{
@@ -77,6 +78,11 @@ fn prelude_items() {
     assert_type!(PhantomData<i32>, TypeDefPhantom::new(meta_type::<i32>()));
 }
 
+#[test]
+fn scale_compact_types() {
+    assert_type!(Compact<i32>, TypeDefCompact::new(meta_type::<i32>()))
+}
+
 #[test]
 fn tuple_primitives() {
     // unit
@@ -128,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

@@ -26,6 +26,7 @@ use crate::{
 use scale::{
     Decode,
     Encode,
+    HasCompact,
 };
 #[cfg(feature = "serde")]
 use serde::{
@@ -129,6 +130,15 @@ impl Field {
     {
         Self::new(None, MetaType::new::<T>(), type_name)
     }
+
+    /// Creates a new [`Compact`] field.
+    pub fn compact_of<T>(name: Option<&'static str>, type_name: &'static str) -> Field
+    where
+        T: HasCompact,
+        <T as HasCompact>::Type: TypeInfo + 'static,
+    {
+        Self::new(name, MetaType::new::<<T as HasCompact>::Type>(), type_name)
+    }
 }
 
 impl<T> Field<T>

src/ty/mod.rs

@@ -94,35 +94,24 @@ impl IntoPortable for Type {
     }
 }
 
-impl From<TypeDefPrimitive> for Type {
-    fn from(primitive: TypeDefPrimitive) -> Self {
-        Self::new(Path::voldemort(), Vec::new(), primitive)
-    }
-}
-
-impl From<TypeDefArray> for Type {
-    fn from(array: TypeDefArray) -> Self {
-        Self::new(Path::voldemort(), Vec::new(), array)
-    }
-}
-
-impl From<TypeDefSequence> for Type {
-    fn from(sequence: TypeDefSequence) -> Self {
-        Self::new(Path::voldemort(), Vec::new(), sequence)
-    }
-}
-
-impl From<TypeDefTuple> for Type {
-    fn from(tuple: TypeDefTuple) -> Self {
-        Self::new(Path::voldemort(), Vec::new(), tuple)
-    }
+macro_rules! impl_from_type_def_for_type {
+    ( $( $t:ty  ), + $(,)?) => { $(
+        impl From<$t> for Type {
+            fn from(item: $t) -> Self {
+                Self::new(Path::voldemort(), Vec::new(), item)
+            }
+        }
+    )* }
 }
 
-impl From<TypeDefPhantom> for Type {
-    fn from(phantom: TypeDefPhantom) -> Self {
-        Self::new(Path::voldemort(), Vec::new(), phantom)
-    }
-}
+impl_from_type_def_for_type!(
+    TypeDefPrimitive,
+    TypeDefArray,
+    TypeDefSequence,
+    TypeDefTuple,
+    TypeDefCompact,
+    TypeDefPhantom,
+);
 
 impl Type {
     /// Create a [`TypeBuilder`](`crate::build::TypeBuilder`) the public API for constructing a [`Type`]
@@ -187,6 +176,8 @@ pub enum TypeDef<T: Form = MetaForm> {
     Tuple(TypeDefTuple<T>),
     /// A Rust primitive type.
     Primitive(TypeDefPrimitive),
+    /// A type using the [`Compact`] encoding
+    Compact(TypeDefCompact<T>),
     /// A PhantomData type.
     Phantom(TypeDefPhantom<T>),
 }
@@ -202,6 +193,7 @@ impl IntoPortable for TypeDef {
             TypeDef::Array(array) => array.into_portable(registry).into(),
             TypeDef::Tuple(tuple) => tuple.into_portable(registry).into(),
             TypeDef::Primitive(primitive) => primitive.into(),
+            TypeDef::Compact(compact) => compact.into_portable(registry).into(),
             TypeDef::Phantom(phantom) => phantom.into_portable(registry).into(),
         }
     }
@@ -391,6 +383,41 @@ where
     }
 }
 
+/// A type wrapped in [`Compact`].
+#[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Encode, Decode, Debug)]
+#[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+pub struct TypeDefCompact<T: Form = MetaForm> {
+    /// The type wrapped in [`Compact`], i.e. the `T` in `Compact<T>`.
+    #[cfg_attr(feature = "serde", serde(rename = "type"))]
+    type_param: T::Type,
+}
+
+impl IntoPortable for TypeDefCompact {
+    type Output = TypeDefCompact<PortableForm>;
+
+    fn into_portable(self, registry: &mut Registry) -> Self::Output {
+        TypeDefCompact {
+            type_param: registry.register_type(&self.type_param),
+        }
+    }
+}
+
+impl TypeDefCompact {
+    /// Creates a new type wrapped in [`Compact`].
+    pub fn new(type_param: MetaType) -> Self {
+        Self { type_param }
+    }
+}
+impl<T> TypeDefCompact<T>
+where
+    T: Form,
+{
+    /// Returns the [`Compact`] wrapped type, i.e. the `T` in `Compact<T>`.
+    pub fn type_param(&self) -> &T::Type {
+        &self.type_param
+    }
+}
+
 /// A type describing a `PhantomData<T>` type.
 ///
 /// In the context of SCALE encoded types, including `PhantomData<T>` types in