Derive TypeInfo for own types

Cargo.toml

@@ -28,11 +28,14 @@ std = [
 derive = [
     "scale-info-derive"
 ]
-# enables decoding and deserialization of portable scale-info type metadata
+# Derive `TypeInfo` for our own types.
+dogfood = ["derive"]
+# Enables decoding and deserialization of portable scale-info type metadata.
 decode = []
 
 [workspace]
 members = [
     "derive",
     "test_suite",
 ]
+# exclude = ["test_suite"]

derive/src/lib.rs

@@ -12,7 +12,7 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
-#![cfg_attr(not(feature = "std"), no_std)]
+// #![cfg_attr(not(feature = "std"), no_std)]
 
 extern crate alloc;
 extern crate proc_macro;
@@ -76,7 +76,29 @@ fn generate(input: TokenStream2) -> Result<TokenStream2> {
 fn generate_type(input: TokenStream2) -> Result<TokenStream2> {
     let mut ast: DeriveInput = syn::parse2(input.clone())?;
 
-    let scale_info = crate_name_ident("scale-info")?;
+    // Find the name given to the `scale-info` crate in the context we run in.
+    // If scale-info is not among the dependencies then we must be deriving
+    // types for the scale-info crate itself, in which case we need to rename
+    // "self" to something, so the object paths keep working.
+    let (scale_info, import_self_as_scale_info) = {
+        let actual_crate_name = proc_macro_crate::crate_name("scale-info");
+        if let Err(e) = actual_crate_name {
+            if e.starts_with("Could not find `scale-info`") {
+                (Ident::new("_scale_info", Span::call_site()), true)
+            } else {
+                return Err(syn::Error::new(Span::call_site(), e))
+            }
+        } else {
+            (
+                Ident::new(
+                    &actual_crate_name.expect("Checked Err above; qed"),
+                    Span::call_site(),
+                ),
+                false,
+            )
+        }
+    };
+
     let parity_scale_codec = crate_name_ident("parity-scale-codec")?;
 
     let ident = &ast.ident;
@@ -97,33 +119,44 @@ fn generate_type(input: TokenStream2) -> Result<TokenStream2> {
     let generic_type_ids = ast.generics.type_params().map(|ty| {
         let ty_ident = &ty.ident;
         quote! {
-            :: #scale_info ::meta_type::<#ty_ident>()
+            #scale_info::meta_type::<#ty_ident>()
         }
     });
 
-    let ast: DeriveInput = syn::parse2(input.clone())?;
+    let mut ast: DeriveInput = syn::parse2(input.clone())?;
     let build_type = match &ast.data {
         Data::Struct(ref s) => generate_composite_type(s, &scale_info),
         Data::Enum(ref e) => generate_variant_type(e, &scale_info),
         Data::Union(_) => return Err(Error::new_spanned(input, "Unions not supported")),
     };
+
+    // Remove any type parameter defaults, we don't want those. E.g. `impl<T: Stuff = WutEven>`
+    ast.generics.type_params_mut().for_each(|type_param| {
+        type_param.default = None;
+    });
     let generic_types = ast.generics.type_params();
     let type_info_impl = quote! {
-        impl <#( #generic_types ),*> :: #scale_info ::TypeInfo for #ident #ty_generics #where_clause {
+        impl <#( #generic_types ),*> #scale_info::TypeInfo for #ident #ty_generics #where_clause {
             type Identity = Self;
-            fn type_info() -> :: #scale_info ::Type {
-                :: #scale_info ::Type::builder()
-                    .path(:: #scale_info ::Path::new(stringify!(#ident), module_path!()))
-                    .type_params(:: #scale_info ::prelude::vec![ #( #generic_type_ids ),* ])
+            fn type_info() -> #scale_info::Type {
+                #scale_info::Type::builder()
+                    .path(#scale_info::Path::new(stringify!(#ident), module_path!()))
+                    .type_params(#scale_info::prelude::vec![ #( #generic_type_ids ),* ])
                     .#build_type
             }
-        }
+        };
+    };
+    let crate_rename = if import_self_as_scale_info {
+        quote! { extern crate self as _scale_info; }
+    } else {
+        quote! {}
     };
-
     Ok(quote! {
-        #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
+        // TODO: are these needed?
+        // #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
         const _: () = {
-            #type_info_impl;
+            #crate_rename
+            #type_info_impl
         };
     })
 }
@@ -222,7 +255,7 @@ fn generate_composite_type(data_struct: &DataStruct, scale_info: &Ident) -> Toke
         }
     };
     quote! {
-        composite(:: #scale_info ::build::Fields::#fields)
+        composite(#scale_info::build::Fields::#fields)
     }
 }
 
@@ -252,7 +285,7 @@ fn generate_c_like_enum_def(variants: &VariantList, scale_info: &Ident) -> Token
     });
     quote! {
         variant(
-            :: #scale_info ::build::Variants::fieldless()
+            #scale_info::build::Variants::fieldless()
                 #( #variants )*
         )
     }
@@ -281,7 +314,7 @@ fn generate_variant_type(data_enum: &DataEnum, scale_info: &Ident) -> TokenStrea
                 quote! {
                     .variant(
                         #v_name,
-                        :: #scale_info ::build::Fields::named()
+                        #scale_info::build::Fields::named()
                             #( #fields)*
                     )
                 }
@@ -291,7 +324,7 @@ fn generate_variant_type(data_enum: &DataEnum, scale_info: &Ident) -> TokenStrea
                 quote! {
                     .variant(
                         #v_name,
-                        :: #scale_info ::build::Fields::unnamed()
+                        #scale_info::build::Fields::unnamed()
                             #( #fields)*
                     )
                 }
@@ -305,7 +338,7 @@ fn generate_variant_type(data_enum: &DataEnum, scale_info: &Ident) -> TokenStrea
     });
     quote! {
         variant(
-            :: #scale_info ::build::Variants::with_fields()
+            #scale_info::build::Variants::with_fields()
                 #( #variants)*
         )
     }

derive/src/trait_bounds.rs

@@ -66,14 +66,14 @@ pub fn make_where_clause<'a>(
         } else {
             where_clause
                 .predicates
-                .push(parse_quote!(#ty : :: #scale_info ::TypeInfo + 'static));
+                .push(parse_quote!(#ty : #scale_info ::TypeInfo + 'static));
         }
     });
 
     generics.type_params().into_iter().for_each(|type_param| {
         let ident = type_param.ident.clone();
         let mut bounds = type_param.bounds.clone();
-        bounds.push(parse_quote!(:: #scale_info ::TypeInfo));
+        bounds.push(parse_quote!(#scale_info ::TypeInfo));
         bounds.push(parse_quote!('static));
         where_clause
             .predicates

src/form.rs

@@ -60,6 +60,7 @@ pub trait Form {
 /// through the registry and `IntoPortable`.
 #[cfg_attr(feature = "serde", derive(Serialize))]
 #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Copy, Debug)]
+#[cfg_attr(feature = "dogfood", derive(scale_info_derive::TypeInfo))]
 pub enum MetaForm {}
 
 impl Form for MetaForm {

src/impls.rs

@@ -33,6 +33,18 @@ use crate::{
     TypeDefTuple,
     TypeInfo,
 };
+use core::num::{
+    NonZeroI128,
+    NonZeroI16,
+    NonZeroI32,
+    NonZeroI64,
+    NonZeroI8,
+    NonZeroU128,
+    NonZeroU16,
+    NonZeroU32,
+    NonZeroU64,
+    NonZeroU8,
+};
 
 macro_rules! impl_metadata_for_primitives {
     ( $( $t:ty => $ident_kind:expr, )* ) => { $(
@@ -119,6 +131,34 @@ impl_metadata_for_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M, N);
 impl_metadata_for_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O);
 impl_metadata_for_tuple!(A, B, C, D, E, F, G, H, I, J, K, L, M, N, O, P);
 
+macro_rules! impl_for_non_zero {
+    ( $( $t: ty ),* $(,)? ) => {
+        $(
+            impl TypeInfo for $t {
+                type Identity = Self;
+                fn type_info() -> Type {
+                    Type::builder()
+                        .path(Path::prelude(stringify!($t)))
+                        .composite(Fields::unnamed().field_of::<$t>(stringify!($t)))
+                }
+            }
+        )*
+    };
+}
+
+impl_for_non_zero!(
+    NonZeroI8,
+    NonZeroI16,
+    NonZeroI32,
+    NonZeroI64,
+    NonZeroI128,
+    NonZeroU8,
+    NonZeroU16,
+    NonZeroU32,
+    NonZeroU64,
+    NonZeroU128
+);
+
 impl<T> TypeInfo for Vec<T>
 where
     T: TypeInfo + 'static,

src/interner.rs

@@ -32,6 +32,14 @@ use crate::prelude::{
     vec::Vec,
 };
 
+use crate::{
+    build::Fields,
+    form::MetaForm,
+    Path,
+    Type,
+    TypeInfo,
+};
+
 #[cfg(feature = "serde")]
 use serde::{
     Deserialize,
@@ -72,6 +80,19 @@ impl<T> scale::Decode for UntrackedSymbol<T> {
     }
 }
 
+// TODO: we should be able to derive this.
+impl<T> TypeInfo for UntrackedSymbol<T>
+where
+    T: TypeInfo + 'static,
+{
+    type Identity = Self;
+    fn type_info() -> Type<MetaForm> {
+        Type::builder()
+            .path(Path::prelude("Path"))
+            .composite(Fields::named().field_of::<NonZeroU32>("id", "NonZeroU32"))
+    }
+}
+
 impl<T> UntrackedSymbol<T> {
     /// Returns the index to the symbol in the interner table.
     pub fn id(&self) -> NonZeroU32 {

src/meta_type.rs

@@ -27,7 +27,9 @@ use crate::prelude::{
 };
 
 use crate::{
+    build::Fields,
     form::MetaForm,
+    Path,
     Type,
     TypeInfo,
 };
@@ -49,6 +51,18 @@ pub struct MetaType {
     type_id: TypeId,
 }
 
+// TODO: this is a total hack. Not sure what we can do here.
+impl TypeInfo for MetaType {
+    type Identity = Self;
+    fn type_info() -> Type<MetaForm> {
+        Type::builder()
+            .path(Path::new("MetaType", "meta_type"))
+            .composite(
+                Fields::named().field_of::<core::num::NonZeroU64>("type_id", "TypeId"),
+            )
+    }
+}
+
 impl PartialEq for MetaType {
     fn eq(&self, other: &Self) -> bool {
         self.type_id == other.type_id

src/registry.rs

@@ -46,6 +46,7 @@ use crate::{
 use scale::Encode;
 #[cfg(feature = "serde")]
 use serde::{
+    de::DeserializeOwned,
     Deserialize,
     Serialize,
 };
@@ -166,6 +167,15 @@ impl Registry {
 
 /// A read-only registry containing types in their portable form for serialization.
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+// #[cfg_attr(feature = "serde", derive(Serialize))]
+// serialize = "T::Type: Serialize, T::String: Serialize",
+// TODO: do we need this?
+#[cfg_attr(
+    feature = "serde",
+    serde(bound(
+        deserialize = "<PortableForm as Form>::Type: DeserializeOwned, <PortableForm as Form>::String: DeserializeOwned",
+    ))
+)]
 #[cfg_attr(any(feature = "std", feature = "decode"), derive(scale::Decode))]
 #[derive(Clone, Debug, PartialEq, Eq, Encode)]
 pub struct PortableRegistry {

src/ty/composite.rs

@@ -70,6 +70,7 @@ use serde::{
 #[cfg_attr(feature = "serde", serde(rename_all = "lowercase"))]
 #[cfg_attr(any(feature = "std", feature = "decode"), derive(scale::Decode))]
 #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Debug, From, Encode)]
+#[cfg_attr(feature = "dogfood", derive(scale_info_derive::TypeInfo))]
 pub struct TypeDefComposite<T: Form = MetaForm> {
     /// The fields of the composite type.
     #[cfg_attr(

src/ty/fields.rs

@@ -67,6 +67,7 @@ use serde::{
 #[cfg_attr(feature = "serde", serde(rename_all = "camelCase"))]
 #[cfg_attr(any(feature = "std", feature = "decode"), derive(scale::Decode))]
 #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Debug, Encode)]
+#[cfg_attr(feature = "dogfood", derive(scale_info_derive::TypeInfo))]
 pub struct Field<T: Form = MetaForm> {
     /// The name of the field. None for unnamed fields.
     #[cfg_attr(