portable: Retain the provided type IDs

.github/workflows/rust.yml

@@ -31,7 +31,7 @@ jobs:
     - name: clippy
       run: |
         cargo clippy --version
-        cargo clippy --all -- -D warnings
+        cargo clippy --all-targets -- -D warnings
 
     - name: check-all-features
       run: |

.rustfmt.toml

@@ -34,7 +34,7 @@ struct_field_align_threshold = 0
 enum_discrim_align_threshold = 0
 match_arm_blocks = true
 force_multiline_blocks = true # changed
-fn_args_layout = "Tall"
+fn_params_layout = "Tall"
 brace_style = "SameLineWhere"
 control_brace_style = "AlwaysSameLine"
 trailing_semicolon = false # changed

derive/src/trait_bounds.rs

@@ -104,7 +104,7 @@ pub fn make_where_clause<'a>(
         }
     });
 
-    generics.type_params().into_iter().for_each(|type_param| {
+    generics.type_params().for_each(|type_param| {
         let ident = type_param.ident.clone();
         let mut bounds = type_param.bounds.clone();
         if attrs

src/portable.rs

@@ -27,11 +27,14 @@ use crate::{
     form::PortableForm,
     interner::Interner,
     prelude::{
+        collections::BTreeMap,
         fmt::Debug,
+        mem,
         vec::Vec,
     },
     Registry,
     Type,
+    TypeDef,
 };
 use scale::Encode;
 
@@ -70,13 +73,154 @@ impl PortableRegistry {
     pub fn types(&self) -> &[PortableType] {
         &self.types
     }
+
+    /// Retains only the portable types needed to express the provided ids.
+    ///
+    /// The type IDs retained are returned as key to the `HashMap`.
+    /// The value of the map represents the new ID of that type.
+    ///
+    /// # Note
+    ///
+    /// A given type ID can be defined by nesting type IDs, such as the case
+    /// of a [`TypeDef::Composite`] and others. To retain a valid [`PortableRegistry`]
+    /// all the types needed to express an ID are included. Therefore, the number of
+    /// elements defined by the result equals or exceeds the number of provided IDs.
+    pub fn retain<F>(&mut self, mut filter: F) -> BTreeMap<u32, u32>
+    where
+        F: FnMut(u32) -> bool,
+    {
+        let mut retained_mappings = BTreeMap::new();
+        let mut new_types = crate::prelude::vec![];
+
+        fn retain_type(
+            id: u32,
+            types: &mut [PortableType],
+            new_types: &mut Vec<PortableType>,
+            retained_mappings: &mut BTreeMap<u32, u32>,
+        ) -> u32 {
+            // Type already retained; just return the new ID for it:
+            if let Some(id) = retained_mappings.get(&id) {
+                return *id
+            }
+
+            // Take the type out of the registry that we'll be retaining:
+            let mut ty = mem::take(&mut types[id as usize]);
+
+            // Make sure any type params are also retained:
+            for param in ty.ty.type_params.iter_mut() {
+                let Some(ty) = param.ty() else {
+                    continue
+                };
+                let new_id = retain_type(ty.id(), types, new_types, retained_mappings);
+                param.ty = Some(new_id).map(Into::into);
+            }
+
+            // make sure any types inside this type are also retained and update the IDs:
+            match &mut ty.ty.type_def {
+                TypeDef::Composite(composite) => {
+                    for field in composite.fields.iter_mut() {
+                        let new_id = retain_type(
+                            field.ty.id(),
+                            types,
+                            new_types,
+                            retained_mappings,
+                        );
+                        field.ty = new_id.into();
+                    }
+                }
+                TypeDef::Variant(variant) => {
+                    for var in variant.variants.iter_mut() {
+                        for field in var.fields.iter_mut() {
+                            let new_id = retain_type(
+                                field.ty.id(),
+                                types,
+                                new_types,
+                                retained_mappings,
+                            );
+                            field.ty = new_id.into();
+                        }
+                    }
+                }
+                TypeDef::Sequence(sequence) => {
+                    let new_id = retain_type(
+                        sequence.type_param.id(),
+                        types,
+                        new_types,
+                        retained_mappings,
+                    );
+                    sequence.type_param = new_id.into();
+                }
+                TypeDef::Array(array) => {
+                    let new_id = retain_type(
+                        array.type_param.id(),
+                        types,
+                        new_types,
+                        retained_mappings,
+                    );
+                    array.type_param = new_id.into();
+                }
+                TypeDef::Tuple(tuple) => {
+                    for ty in tuple.fields.iter_mut() {
+                        let new_id =
+                            retain_type(ty.id(), types, new_types, retained_mappings);
+                        *ty = new_id.into();
+                    }
+                }
+                TypeDef::Primitive(_) => (),
+                TypeDef::Compact(compact) => {
+                    let new_id = retain_type(
+                        compact.type_param().id(),
+                        types,
+                        new_types,
+                        retained_mappings,
+                    );
+                    compact.type_param = new_id.into();
+                }
+                TypeDef::BitSequence(bit_seq) => {
+                    let bit_order_id = retain_type(
+                        bit_seq.bit_order_type().id(),
+                        types,
+                        new_types,
+                        retained_mappings,
+                    );
+                    let bit_store_id = retain_type(
+                        bit_seq.bit_store_type().id(),
+                        types,
+                        new_types,
+                        retained_mappings,
+                    );
+
+                    bit_seq.bit_order_type = bit_order_id.into();
+                    bit_seq.bit_store_type = bit_store_id.into();
+                }
+            }
+
+            // Retain this type, having updated any inner IDs:
+            let new_id = new_types.len() as u32;
+            new_types.push(ty);
+            retained_mappings.insert(id, new_id);
+            new_id
+        }
+
+        for id in 0..self.types.len() as u32 {
+            // We don't care about the type; move on:
+            if !filter(id) {
+                continue
+            }
+
+            retain_type(id, &mut self.types, &mut new_types, &mut retained_mappings);
+        }
+
+        self.types = new_types;
+        retained_mappings
+    }
 }
 
 /// Represent a type in it's portable form.
 #[cfg_attr(feature = "serde", derive(serde::Serialize))]
 #[cfg_attr(all(feature = "serde", feature = "decode"), derive(serde::Deserialize))]
 #[cfg_attr(any(feature = "std", feature = "decode"), derive(scale::Decode))]
-#[derive(Clone, Debug, PartialEq, Eq, Encode)]
+#[derive(Clone, Debug, PartialEq, Eq, Encode, Default)]
 pub struct PortableType {
     #[codec(compact)]
     id: u32,
@@ -218,4 +362,101 @@ mod tests {
         assert_eq!(Some(&vec_u32_type), registry.resolve(vec_u32_type_id));
         assert_eq!(Some(&composite_type), registry.resolve(composite_type_id));
     }
+
+    #[test]
+    fn retain_ids() {
+        let mut builder = PortableRegistryBuilder::new();
+        let u32_type = Type::new(Path::default(), vec![], TypeDefPrimitive::U32, vec![]);
+        let _u32_type_id = builder.register_type(u32_type);
+
+        let u64_type = Type::new(Path::default(), vec![], TypeDefPrimitive::U64, vec![]);
+        let u64_type_id = builder.register_type(u64_type.clone());
+
+        let mut registry = builder.finish();
+        assert_eq!(registry.types.len(), 2);
+
+        let ids_result = registry.retain(|id| id == u64_type_id);
+        assert_eq!(ids_result.len(), 1);
+        assert_eq!(ids_result.get(&u64_type_id), Some(&0));
+
+        assert_eq!(registry.types.len(), 1);
+        assert_eq!(registry.resolve(0).unwrap(), &u64_type);
+    }
+
+    #[test]
+    fn retain_recursive_ids() {
+        let mut builder = PortableRegistryBuilder::new();
+        let u32_type = Type::new(Path::default(), vec![], TypeDefPrimitive::U32, vec![]);
+        let u32_type_id = builder.register_type(u32_type.clone());
+
+        let u64_type = Type::new(Path::default(), vec![], TypeDefPrimitive::U64, vec![]);
+        let _u64_type_id = builder.register_type(u64_type);
+
+        let vec_u32_type = Type::new(
+            Path::default(),
+            vec![],
+            TypeDefSequence::new(u32_type_id.into()),
+            vec![],
+        );
+        let vec_u32_type_id = builder.register_type(vec_u32_type);
+
+        let composite_type = Type::builder_portable()
+            .path(Path::from_segments_unchecked(["MyStruct".into()]))
+            .composite(
+                Fields::named()
+                    .field_portable(|f| f.name("primitive".into()).ty(u32_type_id))
+                    .field_portable(|f| f.name("vec_of_u32".into()).ty(vec_u32_type_id)),
+            );
+        let composite_type_id = builder.register_type(composite_type);
+
+        let composite_type_second = Type::builder_portable()
+            .path(Path::from_segments_unchecked(["MyStructSecond".into()]))
+            .composite(
+                Fields::named()
+                    .field_portable(|f| f.name("vec_of_u32".into()).ty(vec_u32_type_id))
+                    .field_portable(|f| f.name("second".into()).ty(composite_type_id)),
+            );
+        let composite_type_second_id = builder.register_type(composite_type_second);
+
+        let mut registry = builder.finish();
+        assert_eq!(registry.types.len(), 5);
+
+        let ids_result = registry.retain(|id| id == composite_type_second_id);
+        assert_eq!(ids_result.len(), 4);
+        assert_eq!(ids_result.get(&u32_type_id), Some(&0));
+        assert_eq!(ids_result.get(&vec_u32_type_id), Some(&1));
+        assert_eq!(ids_result.get(&composite_type_id), Some(&2));
+        assert_eq!(ids_result.get(&composite_type_second_id), Some(&3));
+
+        assert_eq!(registry.types.len(), 4);
+
+        // New type IDs are generated in DFS manner.
+        assert_eq!(registry.resolve(0).unwrap(), &u32_type);
+
+        let expected_type = Type::new(
+            Path::default(),
+            vec![],
+            TypeDefSequence::new(0.into()),
+            vec![],
+        );
+        assert_eq!(registry.resolve(1).unwrap(), &expected_type);
+
+        let expected_type = Type::builder_portable()
+            .path(Path::from_segments_unchecked(["MyStruct".into()]))
+            .composite(
+                Fields::named()
+                    .field_portable(|f| f.name("primitive".into()).ty(0))
+                    .field_portable(|f| f.name("vec_of_u32".into()).ty(1)),
+            );
+        assert_eq!(registry.resolve(2).unwrap(), &expected_type);
+
+        let expected_type = Type::builder_portable()
+            .path(Path::from_segments_unchecked(["MyStructSecond".into()]))
+            .composite(
+                Fields::named()
+                    .field_portable(|f| f.name("vec_of_u32".into()).ty(1))
+                    .field_portable(|f| f.name("second".into()).ty(2)),
+            );
+        assert_eq!(registry.resolve(3).unwrap(), &expected_type);
+    }
 }

src/ty/composite.rs

@@ -76,7 +76,7 @@ pub struct TypeDefComposite<T: Form = MetaForm> {
         feature = "serde",
         serde(skip_serializing_if = "Vec::is_empty", default)
     )]
-    fields: Vec<Field<T>>,
+    pub(crate) fields: Vec<Field<T>>,
 }
 
 impl IntoPortable for TypeDefComposite {

src/ty/fields.rs

@@ -78,22 +78,22 @@ pub struct Field<T: Form = MetaForm> {
         feature = "serde",
         serde(skip_serializing_if = "Option::is_none", default)
     )]
-    name: Option<T::String>,
+    pub(crate) name: Option<T::String>,
     /// The type of the field.
     #[cfg_attr(feature = "serde", serde(rename = "type"))]
-    ty: T::Type,
+    pub(crate) ty: T::Type,
     /// The name of the type of the field as it appears in the source code.
     #[cfg_attr(
         feature = "serde",
         serde(skip_serializing_if = "Option::is_none", default)
     )]
-    type_name: Option<T::String>,
+    pub(crate) type_name: Option<T::String>,
     /// Documentation
     #[cfg_attr(
         feature = "serde",
         serde(skip_serializing_if = "Vec::is_empty", default)
     )]
-    docs: Vec<T::String>,
+    pub(crate) docs: Vec<T::String>,
 }
 
 impl IntoPortable for Field {