Construct PortableRegistry dynamically at runtime

.rustfmt.toml

@@ -9,7 +9,6 @@ format_code_in_doc_comments = false
 comment_width = 80
 normalize_comments = true # changed
 normalize_doc_attributes = false
-license_template_path = "FILE_TEMPLATE" # changed
 format_strings = false
 format_macro_matchers = false
 format_macro_bodies = true
@@ -57,8 +56,6 @@ skip_children = false
 hide_parse_errors = false
 error_on_line_overflow = false
 error_on_unformatted = false
-report_todo = "Always"
-report_fixme = "Always"
 ignore = []
 
 # Below are `rustfmt` internal settings

derive/src/lib.rs

@@ -288,9 +288,13 @@ impl TypeInfoImpl {
             })
             .collect::<Vec<_>>();
 
-        Some(quote! {
-            .#docs_builder_fn(&[ #( #docs ),* ])
-        })
+        if !docs.is_empty() {
+            Some(quote! {
+                .#docs_builder_fn([ #( #docs ),* ])
+            })
+        } else {
+            None
+        }
     }
 }
 

src/build.rs

@@ -128,7 +128,10 @@ use crate::prelude::{
 };
 
 use crate::{
-    form::MetaForm,
+    form::{
+        Form,
+        MetaForm,
+    },
     Field,
     MetaType,
     Path,
@@ -141,6 +144,8 @@ use crate::{
     Variant,
 };
 
+type MetaFormStr = <MetaForm as Form>::String;
+
 /// State types for type builders which require a Path.
 pub mod state {
     /// State where the builder has not assigned a Path to the type
@@ -154,7 +159,7 @@ pub mod state {
 pub struct TypeBuilder<S = state::PathNotAssigned> {
     path: Option<Path>,
     type_params: Vec<TypeParameter>,
-    docs: Vec<&'static str>,
+    docs: Vec<MetaFormStr>,
     marker: PhantomData<fn() -> S>,
 }
 
@@ -213,21 +218,33 @@ impl<S> TypeBuilder<S> {
 
     #[cfg(feature = "docs")]
     /// Set the type documentation
-    pub fn docs(mut self, docs: &[&'static str]) -> Self {
-        self.docs = docs.to_vec();
+    pub fn docs<I, Str>(mut self, docs: I) -> Self
+    where
+        I: IntoIterator<Item = Str>,
+        Str: Into<MetaFormStr>,
+    {
+        self.docs = docs.into_iter().map(Into::into).collect();
         self
     }
 
     #[cfg(not(feature = "docs"))]
     #[inline]
     /// Doc capture is not enabled via the "docs" feature so this is a no-op.
-    pub fn docs(self, _docs: &'static [&'static str]) -> Self {
+    pub fn docs<I, Str>(self, _docs: I) -> Self
+    where
+        I: IntoIterator<Item = Str>,
+        Str: Into<MetaFormStr>,
+    {
         self
     }
 
     /// Set the type documentation, always captured even if the "docs" feature is not enabled.
-    pub fn docs_always(mut self, docs: &[&'static str]) -> Self {
-        self.docs = docs.to_vec();
+    pub fn docs_always<I, Str>(mut self, docs: I) -> Self
+    where
+        I: IntoIterator<Item = Str>,
+        Str: Into<MetaFormStr>,
+    {
+        self.docs = docs.into_iter().map(Into::into).collect();
         self
     }
 }
@@ -281,12 +298,11 @@ impl<T> FieldsBuilder<T> {
         self.fields
     }
 
-    fn push_field(mut self, field: Field) -> Self {
+    fn push_field(&mut self, field: Field) {
         // filter out fields of PhantomData
         if !field.ty().is_phantom() {
             self.fields.push(field);
         }
-        self
     }
 }
 
@@ -300,7 +316,21 @@ impl FieldsBuilder<NamedFields> {
             -> FieldBuilder<field_state::NameAssigned, field_state::TypeAssigned>,
     {
         let builder = builder(FieldBuilder::new());
-        self.push_field(builder.finalize())
+        let mut this = self;
+        this.push_field(builder.finalize());
+        this
+    }
+
+    /// Add a named field constructed using the builder.
+    pub fn field_mut<F>(&mut self, builder: F)
+    where
+        F: Fn(
+            FieldBuilder,
+        )
+            -> FieldBuilder<field_state::NameAssigned, field_state::TypeAssigned>,
+    {
+        let builder = builder(FieldBuilder::new());
+        self.push_field(builder.finalize());
     }
 }
 
@@ -314,7 +344,9 @@ impl FieldsBuilder<UnnamedFields> {
             -> FieldBuilder<field_state::NameNotAssigned, field_state::TypeAssigned>,
     {
         let builder = builder(FieldBuilder::new());
-        self.push_field(builder.finalize())
+        let mut this = self;
+        this.push_field(builder.finalize());
+        this
     }
 }
 
@@ -336,10 +368,10 @@ pub struct FieldBuilder<
     N = field_state::NameNotAssigned,
     T = field_state::TypeNotAssigned,
 > {
-    name: Option<&'static str>,
+    name: Option<MetaFormStr>,
     ty: Option<MetaType>,
-    type_name: Option<&'static str>,
-    docs: &'static [&'static str],
+    type_name: Option<MetaFormStr>,
+    docs: Vec<MetaFormStr>,
     marker: PhantomData<fn() -> (N, T)>,
 }
 
@@ -364,9 +396,12 @@ impl FieldBuilder {
 
 impl<T> FieldBuilder<field_state::NameNotAssigned, T> {
     /// Initialize the field name.
-    pub fn name(self, name: &'static str) -> FieldBuilder<field_state::NameAssigned, T> {
+    pub fn name<S>(self, name: S) -> FieldBuilder<field_state::NameAssigned, T>
+    where
+        S: Into<MetaFormStr>,
+    {
         FieldBuilder {
-            name: Some(name),
+            name: Some(name.into()),
             ty: self.ty,
             type_name: self.type_name,
             docs: self.docs,
@@ -390,6 +425,20 @@ impl<N> FieldBuilder<N, field_state::TypeNotAssigned> {
         }
     }
 
+    /// Initialize the type of the field.
+    pub fn ty_meta(
+        self,
+        meta_type: MetaType,
+    ) -> FieldBuilder<N, field_state::TypeAssigned> {
+        FieldBuilder {
+            name: self.name,
+            ty: Some(meta_type),
+            type_name: self.type_name,
+            docs: self.docs,
+            marker: PhantomData,
+        }
+    }
+
     /// Initializes the type of the field as a compact type.
     pub fn compact<TY>(self) -> FieldBuilder<N, field_state::TypeAssigned>
     where
@@ -407,43 +456,58 @@ impl<N> FieldBuilder<N, field_state::TypeNotAssigned> {
 
 impl<N, T> FieldBuilder<N, T> {
     /// Initialize the type name of a field (optional).
-    pub fn type_name(self, type_name: &'static str) -> FieldBuilder<N, T> {
+    pub fn type_name<S>(self, type_name: S) -> FieldBuilder<N, T>
+    where
+        S: Into<MetaFormStr>,
+    {
         FieldBuilder {
             name: self.name,
             ty: self.ty,
-            type_name: Some(type_name),
+            type_name: Some(type_name.into()),
             docs: self.docs,
             marker: PhantomData,
         }
     }
 
     #[cfg(feature = "docs")]
     /// Initialize the documentation of a field (optional).
-    pub fn docs(self, docs: &'static [&'static str]) -> FieldBuilder<N, T> {
+    pub fn docs<I, Str>(self, docs: I) -> FieldBuilder<N, T>
+    where
+        I: IntoIterator<Item = Str>,
+        Str: Into<MetaFormStr>,
+    {
         FieldBuilder {
             name: self.name,
             ty: self.ty,
             type_name: self.type_name,
-            docs,
+            docs: docs.into_iter().map(Into::into).collect(),
             marker: PhantomData,
         }
     }
 
     #[cfg(not(feature = "docs"))]
     #[inline]
     /// Doc capture is not enabled via the "docs" feature so this is a no-op.
-    pub fn docs(self, _docs: &'static [&'static str]) -> FieldBuilder<N, T> {
+    pub fn docs<I, Str>(self, _docs: I) -> FieldBuilder<N, T>
+    where
+        I: IntoIterator<Item = Str>,
+        Str: Into<MetaFormStr>,
+    {
         self
     }
 
     /// Initialize the documentation of a field, always captured even if the "docs" feature is not
     /// enabled.
-    pub fn docs_always(self, docs: &'static [&'static str]) -> Self {
+    pub fn docs_always<I, Str>(self, docs: I) -> Self
+    where
+        I: IntoIterator<Item = Str>,
+        Str: Into<MetaFormStr>,
+    {
         FieldBuilder {
             name: self.name,
             ty: self.ty,
             type_name: self.type_name,
-            docs,
+            docs: docs.into_iter().map(Into::into).collect(),
             marker: PhantomData,
         }
     }
@@ -477,17 +541,21 @@ impl Variants {
     }
 
     /// Add a variant
-    pub fn variant<F>(mut self, name: &'static str, builder: F) -> Self
+    pub fn variant<F, S>(mut self, name: S, builder: F) -> Self
     where
         F: Fn(VariantBuilder) -> VariantBuilder<variant_state::IndexAssigned>,
+        S: Into<MetaFormStr>,
     {
         let builder = builder(VariantBuilder::new(name));
         self.variants.push(builder.finalize());
         self
     }
 
     /// Add a unit variant (without fields).
-    pub fn variant_unit(mut self, name: &'static str, index: u8) -> Self {
+    pub fn variant_unit<S>(mut self, name: S, index: u8) -> Self
+    where
+        S: Into<MetaFormStr>,
+    {
         let builder = VariantBuilder::new(name).index(index);
         self.variants.push(builder.finalize());
         self
@@ -510,19 +578,22 @@ pub mod variant_state {
 /// Build a [`Variant`].
 #[must_use]
 pub struct VariantBuilder<S = variant_state::IndexNotAssigned> {
-    name: &'static str,
+    name: MetaFormStr,
     index: Option<u8>,
     fields: Vec<Field<MetaForm>>,
     discriminant: Option<u64>,
-    docs: Vec<&'static str>,
+    docs: Vec<MetaFormStr>,
     marker: PhantomData<S>,
 }
 
 impl VariantBuilder<variant_state::IndexNotAssigned> {
     /// Create a new [`VariantBuilder`].
-    pub fn new(name: &'static str) -> Self {
+    pub fn new<S>(name: S) -> Self
+    where
+        S: Into<MetaFormStr>,
+    {
         Self {
-            name,
+            name: name.into(),
             fields: Vec::new(),
             discriminant: None,
             index: None,
@@ -559,22 +630,34 @@ impl<S> VariantBuilder<S> {
 
     #[cfg(feature = "docs")]
     /// Initialize the variant's documentation.
-    pub fn docs(mut self, docs: &[&'static str]) -> Self {
-        self.docs = docs.to_vec();
+    pub fn docs<I, Str>(mut self, docs: I) -> Self
+    where
+        I: IntoIterator<Item = Str>,
+        Str: Into<MetaFormStr>,
+    {
+        self.docs = docs.into_iter().map(Into::into).collect();
         self
     }
 
     #[cfg(not(feature = "docs"))]
     #[inline]
     /// Doc capture is not enabled via the "docs" feature so this is a no-op.
-    pub fn docs(self, _docs: &[&'static str]) -> Self {
+    pub fn docs<I, Str>(self, _docs: I) -> Self
+    where
+        I: IntoIterator<Item = Str>,
+        Str: Into<MetaFormStr>,
+    {
         self
     }
 
     /// Initialize the variant's documentation, always captured even if the "docs" feature is not
     /// enabled.
-    pub fn docs_always(mut self, docs: &[&'static str]) -> Self {
-        self.docs = docs.to_vec();
+    pub fn docs_always<I, Str>(mut self, docs: I) -> Self
+    where
+        I: IntoIterator<Item = Str>,
+        Str: Into<MetaFormStr>,
+    {
+        self.docs = docs.into_iter().map(Into::into).collect();
         self
     }
 }