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
     }
 }
@@ -336,10 +353,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 +381,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 +410,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 +441,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 +526,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 +563,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 +615,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
     }
 }

src/form.rs

@@ -62,11 +62,6 @@ pub trait Form {
 #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Debug)]
 pub enum MetaForm {}
 
-impl Form for MetaForm {
-    type Type = MetaType;
-    type String = &'static str;
-}
-
 /// Portable form that has its lifetime untracked in association to its interner.
 ///
 /// # Note
@@ -80,12 +75,22 @@ pub enum PortableForm {}
 
 cfg_if::cfg_if! {
     if #[cfg(any(feature = "std", feature = "decode"))] {
+        impl Form for MetaForm {
+            type Type = MetaType;
+            type String = crate::prelude::string::String;
+        }
+
         impl Form for PortableForm {
             type Type = UntrackedSymbol<TypeId>;
             // Owned string required for decoding/deserialization
             type String = crate::prelude::string::String;
         }
     } else {
+        impl Form for MetaForm {
+            type Type = MetaType;
+            type String = &'static str;
+        }
+
         impl Form for PortableForm {
             type Type = UntrackedSymbol<TypeId>;
             type String = &'static str;

src/impls.rs

@@ -337,7 +337,7 @@ impl<T> TypeInfo for PhantomData<T> {
         // Fields of this type should be filtered out and never appear in the type graph.
         Type::builder()
             .path(Path::prelude("PhantomData"))
-            .docs(&["PhantomData placeholder, this type should be filtered out"])
+            .docs(["PhantomData placeholder, this type should be filtered out"])
             .composite(Fields::unit())
     }
 }

src/interner.rs

@@ -61,6 +61,15 @@ impl<T> UntrackedSymbol<T> {
     }
 }
 
+impl<T> From<u32> for UntrackedSymbol<T> {
+    fn from(id: u32) -> Self {
+        Self {
+            id,
+            marker: Default::default(),
+        }
+    }
+}
+
 /// A symbol from an interner.
 ///
 /// Can be used to resolve to the associated instance.

src/lib.rs

@@ -335,7 +335,7 @@ pub mod form;
 mod impls;
 pub mod interner;
 mod meta_type;
-mod registry;
+pub mod registry;
 mod ty;
 mod utils;