Remove clear_docs

src/registry.rs

@@ -188,27 +188,14 @@ impl PortableRegistry {
             (id, ty)
         })
     }
-
-    /// Clears all docs from types.
-    ///
-    /// Use when the docs are not required to produce smaller encoded metadata.
-    pub fn clear_docs(&mut self) {
-        for ty in &mut self.types {
-            ty.clear_docs()
-        }
-    }
 }
 
 #[cfg(test)]
 mod tests {
     use super::*;
     use crate::{
-        build::{
-            Fields,
-            Variants,
-        },
+        build::Fields,
         meta_type,
-        ty::Variant,
         Path,
         TypeDef,
         TypeInfo,
@@ -280,134 +267,4 @@ mod tests {
             panic!("Should be a composite type definition")
         }
     }
-
-    #[test]
-    fn clear_docs() {
-        #[allow(unused)]
-        /// docs
-        struct S {
-            /// docs
-            pub t: bool,
-            pub u: u8,
-        }
-
-        impl TypeInfo for S {
-            type Identity = Self;
-
-            fn type_info() -> Type {
-                Type::builder()
-                    .path(Path::new("S", module_path!()))
-                    .docs(&[" docs"])
-                    .composite(
-                        Fields::named()
-                            .field(|f| {
-                                f.ty::<bool>()
-                                    .name("t")
-                                    .type_name("bool")
-                                    .docs(&[" docs"])
-                            })
-                            .field(|f| f.ty::<u8>().name("u").type_name("u8")),
-                    )
-            }
-        }
-
-        #[allow(unused)]
-        struct T(
-            /// docs
-            u32,
-        );
-
-        impl TypeInfo for T {
-            type Identity = Self;
-
-            fn type_info() -> Type {
-                Type::builder()
-                    .path(Path::new("T", module_path!()))
-                    .docs(&[" docs"])
-                    .composite(
-                        Fields::unnamed()
-                            .field(|f| f.ty::<u32>().type_name("u32").docs(&[" docs"])),
-                    )
-            }
-        }
-
-        #[allow(unused)]
-        /// docs
-        enum E {
-            /// docs
-            A(
-                /// docs
-                bool,
-            ),
-            /// docs
-            B {
-                /// docs
-                b: u8,
-            },
-            /// docs
-            C,
-        }
-
-        impl TypeInfo for E {
-            type Identity = Self;
-
-            fn type_info() -> Type {
-                Type::builder()
-                    .path(Path::new("E", "derive"))
-                    .type_params(tuple_meta_type!(bool))
-                    .docs(&[" Enum docs."])
-                    .variant(
-                        Variants::new()
-                            .variant(
-                                Variant::builder("A")
-                                    .fields(Fields::unnamed().field(|f| {
-                                        f.ty::<bool>().type_name("bool").docs(&[" docs"])
-                                    }))
-                                    .docs(&[" Unnamed fields variant."]),
-                            )
-                            .variant(
-                                Variant::builder("B")
-                                    .fields(Fields::named().field(|f| {
-                                        f.ty::<u8>()
-                                            .name("b")
-                                            .type_name("u8")
-                                            .docs(&[" docs"])
-                                    }))
-                                    .docs(&[" docs"]),
-                            )
-                            .variant(Variant::builder("C").docs(&[" docs"])),
-                    )
-            }
-        }
-
-        let mut registry = Registry::new();
-        registry.register_type(&meta_type::<S>());
-        registry.register_type(&meta_type::<T>());
-        registry.register_type(&meta_type::<E>());
-
-        let mut registry: PortableRegistry = registry.into();
-
-        registry.clear_docs();
-
-        for ty in registry.types {
-            assert!(ty.docs().is_empty());
-            match ty.type_def() {
-                TypeDef::Composite(c) => {
-                    for f in c.fields() {
-                        assert!(f.docs().is_empty())
-                    }
-                }
-                TypeDef::Variant(v) => {
-                    for var in v.variants() {
-                        assert!(var.docs().is_empty());
-
-                        for f in var.fields() {
-                            assert!(f.docs().is_empty())
-                        }
-                    }
-                }
-                _ => {}
-            }
-        }
-    }
 }

src/ty/composite.rs

@@ -109,11 +109,4 @@ where
     pub fn fields(&self) -> &[Field<T>] {
         &self.fields
     }
-
-    /// Clear the docs of the field.
-    pub fn clear_docs(&mut self) {
-        for field in &mut self.fields {
-            field.clear_docs()
-        }
-    }
 }

src/ty/fields.rs

@@ -161,9 +161,4 @@ where
     pub fn docs(&self) -> &[T::String] {
         &self.docs
     }
-
-    /// Clear the docs of the field.
-    pub fn clear_docs(&mut self) {
-        self.docs.clear()
-    }
 }

src/ty/mod.rs

@@ -86,23 +86,6 @@ pub struct Type<T: Form = MetaForm> {
     docs: Vec<T::String>,
 }
 
-impl Type<PortableForm> {
-    /// Clear docs from this type.
-    pub fn clear_docs(&mut self) {
-        self.docs.clear();
-        match &mut self.type_def {
-            TypeDef::Composite(composite) => composite.clear_docs(),
-            TypeDef::Variant(variant) => variant.clear_docs(),
-            TypeDef::Sequence(_) => {}
-            TypeDef::Array(_) => {}
-            TypeDef::Tuple(_) => {}
-            TypeDef::Primitive(_) => {}
-            TypeDef::Compact(_) => {}
-            TypeDef::Phantom(_) => {}
-        }
-    }
-}
-
 impl IntoPortable for Type {
     type Output = Type<PortableForm>;
 

src/ty/variant.rs

@@ -122,13 +122,6 @@ where
     pub fn variants(&self) -> &[Variant<T>] {
         &self.variants
     }
-
-    /// Clear docs for all variants.
-    pub fn clear_docs(&mut self) {
-        for variant in &mut self.variants {
-            variant.clear_docs()
-        }
-    }
 }
 
 /// A struct enum variant with either named (struct) or unnamed (tuple struct)
@@ -244,12 +237,4 @@ where
     pub fn docs(&self) -> &[T::String] {
         &self.docs
     }
-
-    /// Clear the docs for this variant.
-    pub fn clear_docs(&mut self) {
-        self.docs.clear();
-        for field in &mut self.fields {
-            field.clear_docs()
-        }
-    }
 }