Add skip_type_params attribute

derive/src/lib.rs

@@ -18,13 +18,6 @@ extern crate proc_macro;
 mod trait_bounds;
 mod utils;
 
-use alloc::{
-    string::{
-        String,
-        ToString,
-    },
-    vec::Vec,
-};
 use proc_macro::TokenStream;
 use proc_macro2::{
     Span,
@@ -51,7 +44,7 @@ use syn::{
     Variant,
 };
 
-#[proc_macro_derive(TypeInfo)]
+#[proc_macro_derive(TypeInfo, attributes(scale_info))]
 pub fn type_info(input: TokenStream) -> TokenStream {
     match generate(input.into()) {
         Ok(output) => output.into(),
@@ -68,21 +61,36 @@ fn generate(input: TokenStream2) -> Result<TokenStream2> {
 fn generate_type(input: TokenStream2) -> Result<TokenStream2> {
     let ast: DeriveInput = syn::parse2(input.clone())?;
 
+    utils::check_attributes(&ast)?;
+
     let scale_info = crate_name_ident("scale-info")?;
     let parity_scale_codec = crate_name_ident("parity-scale-codec")?;
 
     let ident = &ast.ident;
 
-    let (impl_generics, ty_generics, _) = ast.generics.split_for_impl();
+    let type_params: Vec<_> =
+        if let Some(skip_type_params) = utils::skipped_type_params(&ast.attrs) {
+            ast.generics
+                .type_params()
+                .filter(|tp| !skip_type_params.iter().any(|skip| *skip == **tp))
+                .cloned()
+                .collect()
+        } else {
+            ast.generics.type_params().into_iter().cloned().collect()
+        };
+
     let where_clause = trait_bounds::make_where_clause(
         ident,
         &ast.generics,
+        &type_params,
         &ast.data,
         &scale_info,
         &parity_scale_codec,
     )?;
 
-    let generic_type_ids = ast.generics.type_params().map(|ty| {
+    let (impl_generics, ty_generics, _) = ast.generics.split_for_impl();
+
+    let type_params_meta_types = type_params.iter().map(|ty| {
         let ty_ident = &ty.ident;
         quote! {
             :: #scale_info ::meta_type::<#ty_ident>()
@@ -102,7 +110,7 @@ fn generate_type(input: TokenStream2) -> Result<TokenStream2> {
             fn type_info() -> :: #scale_info ::Type {
                 :: #scale_info ::Type::builder()
                     .path(:: #scale_info ::Path::new(::core::stringify!(#ident), ::core::module_path!()))
-                    .type_params(:: #scale_info ::prelude::vec![ #( #generic_type_ids ),* ])
+                    .type_params(:: #scale_info ::prelude::vec![ #( #type_params_meta_types ),* ])
                     .docs(&[ #( #docs ),* ])
                     .#build_type
             }

derive/src/trait_bounds.rs

@@ -25,6 +25,7 @@ use syn::{
     Generics,
     Result,
     Type,
+    TypeParam,
     TypePath,
     WhereClause,
 };
@@ -34,9 +35,12 @@ use crate::utils;
 /// Generates a where clause for a `TypeInfo` impl, adding `TypeInfo + 'static` bounds to all
 /// relevant generic types including associated types (e.g. `T::A: TypeInfo`), correctly dealing
 /// with self-referential types.
+///
+/// Ignores any type parameters not included in `type_params`.
 pub fn make_where_clause<'a>(
     input_ident: &'a Ident,
     generics: &'a Generics,
+    type_params: &[TypeParam],
     data: &'a syn::Data,
     scale_info: &Ident,
     parity_scale_codec: &Ident,
@@ -53,8 +57,8 @@ pub fn make_where_clause<'a>(
             .push(parse_quote!(#lifetime: 'static))
     }
 
-    let type_params = generics.type_params();
-    let ty_params_ids = type_params
+    let ty_params_ids = generics
+        .type_params()
         .map(|type_param| type_param.ident.clone())
         .collect::<Vec<Ident>>();
 
@@ -84,7 +88,9 @@ pub fn make_where_clause<'a>(
     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));
+        if type_params.iter().any(|tp| *tp == *type_param) {
+            bounds.push(parse_quote!(:: #scale_info ::TypeInfo));
+        }
         bounds.push(parse_quote!('static));
         where_clause
             .predicates

derive/src/utils.rs

@@ -23,10 +23,14 @@ use alloc::{
 use proc_macro2::TokenStream;
 use quote::quote;
 use syn::{
+    parse::Parse,
     parse_quote,
+    punctuated::Punctuated,
     spanned::Spanned,
+    token,
     AttrStyle,
     Attribute,
+    DeriveInput,
     Lit,
     Meta,
     NestedMeta,
@@ -55,6 +59,41 @@ pub fn get_doc_literals(attrs: &[syn::Attribute]) -> Vec<syn::Lit> {
         .collect()
 }
 
+/// Trait bounds.
+pub type TypeParams = Punctuated<syn::TypeParam, token::Comma>;
+
+/// Parse `name(T, N)` as a custom trait bound.
+struct SkipTypeParams<N> {
+    _name: N,
+    _paren_token: token::Paren,
+    params: TypeParams,
+}
+
+impl<N: Parse> Parse for SkipTypeParams<N> {
+    fn parse(input: syn::parse::ParseStream) -> syn::Result<Self> {
+        let content;
+        let _name = input.parse()?;
+        let _paren_token = syn::parenthesized!(content in input);
+        let params = content.parse_terminated(syn::TypeParam::parse)?;
+        Ok(Self {
+            _name,
+            _paren_token,
+            params,
+        })
+    }
+}
+
+syn::custom_keyword!(skip_type_params);
+
+/// Look for a `#[scale_info(skip_type_params(…))]`in the given attributes.
+///
+/// If found, do not register the given type params or require `TypeInfo` bounds for them.
+pub fn skipped_type_params(attrs: &[Attribute]) -> Option<TypeParams> {
+    scale_info_meta_item(attrs.iter(), |meta: SkipTypeParams<skip_type_params>| {
+        Some(meta.params)
+    })
+}
+
 /// Look for a `#[codec(index = $int)]` attribute on a variant. If no attribute
 /// is found, fall back to the discriminant or just the variant index.
 pub fn variant_index(v: &Variant, i: usize) -> TokenStream {
@@ -77,7 +116,7 @@ pub fn maybe_index(variant: &Variant) -> Option<u8> {
         .iter()
         .filter(|attr| attr.style == AttrStyle::Outer);
 
-    find_meta_item(outer_attrs, |meta| {
+    codec_meta_item(outer_attrs, |meta| {
         if let NestedMeta::Meta(Meta::NameValue(ref nv)) = meta {
             if nv.path.is_ident("index") {
                 if let Lit::Int(ref v) = nv.lit {
@@ -99,7 +138,7 @@ pub fn is_compact(field: &syn::Field) -> bool {
         .attrs
         .iter()
         .filter(|attr| attr.style == AttrStyle::Outer);
-    find_meta_item(outer_attrs, |meta| {
+    codec_meta_item(outer_attrs, |meta| {
         if let NestedMeta::Meta(Meta::Path(ref path)) = meta {
             if path.is_ident("compact") {
                 return Some(())
@@ -113,7 +152,7 @@ pub fn is_compact(field: &syn::Field) -> bool {
 
 /// Look for a `#[codec(skip)]` in the given attributes.
 pub fn should_skip(attrs: &[Attribute]) -> bool {
-    find_meta_item(attrs.iter(), |meta| {
+    codec_meta_item(attrs.iter(), |meta| {
         if let NestedMeta::Meta(Meta::Path(ref path)) = meta {
             if path.is_ident("skip") {
                 return Some(path.span())
@@ -125,22 +164,57 @@ pub fn should_skip(attrs: &[Attribute]) -> bool {
     .is_some()
 }
 
-fn find_meta_item<'a, F, R, I>(itr: I, pred: F) -> Option<R>
+fn codec_meta_item<'a, F, R, I, M>(itr: I, pred: F) -> Option<R>
 where
-    F: Fn(&NestedMeta) -> Option<R> + Clone,
+    F: FnMut(M) -> Option<R> + Clone,
     I: Iterator<Item = &'a Attribute>,
+    M: Parse,
 {
-    itr.filter_map(|attr| {
-        if attr.path.is_ident("codec") {
-            if let Meta::List(ref meta_list) = attr
-                .parse_meta()
-                .expect("scale-info: Bad index in `#[codec(index = …)]`, see `parity-scale-codec` error")
-            {
-                return meta_list.nested.iter().filter_map(pred.clone()).next()
-            }
-        }
+    find_meta_item("codec", itr, pred)
+}
 
-        None
+fn scale_info_meta_item<'a, F, R, I, M>(itr: I, pred: F) -> Option<R>
+where
+    F: FnMut(M) -> Option<R> + Clone,
+    I: Iterator<Item = &'a Attribute>,
+    M: Parse,
+{
+    find_meta_item("scale_info", itr, pred)
+}
+
+fn find_meta_item<'a, F, R, I, M>(kind: &str, mut itr: I, mut pred: F) -> Option<R>
+where
+    F: FnMut(M) -> Option<R> + Clone,
+    I: Iterator<Item = &'a Attribute>,
+    M: Parse,
+{
+    itr.find_map(|attr| {
+        attr.path
+            .is_ident(kind)
+            .then(|| pred(attr.parse_args().ok()?))
+            .flatten()
     })
-    .next()
+}
+
+/// Ensure attributes are correctly applied. This *must* be called before using
+/// any of the attribute finder methods or the macro may panic if it encounters
+/// misapplied attributes.
+/// `#[scale_info(bounds())]` is the only accepted attribute.
+pub fn check_attributes(input: &DeriveInput) -> syn::Result<()> {
+    for attr in &input.attrs {
+        check_top_attribute(attr)?;
+    }
+    Ok(())
+}
+
+// Only `#[scale_info(bounds())]` is a valid top attribute.
+fn check_top_attribute(attr: &Attribute) -> syn::Result<()> {
+    if attr.path.is_ident("scale_info") {
+        match attr.parse_args::<SkipTypeParams<skip_type_params>>() {
+            Ok(_) => Ok(()),
+            Err(e) => Err(syn::Error::new(attr.span(), format!("Invalid attribute: {:?}. Only `#[scale_info(bounds(…))]` is a valid top attribute", e)))
+        }
+    } else {
+        Ok(())
+    }
 }

src/impls.rs

@@ -266,14 +266,11 @@ impl TypeInfo for String {
     }
 }
 
-impl<T> TypeInfo for PhantomData<T>
-where
-    T: TypeInfo + ?Sized + 'static,
-{
-    type Identity = Self;
+impl<T> TypeInfo for PhantomData<T> {
+    type Identity = PhantomData<()>;
 
     fn type_info() -> Type {
-        TypeDefPhantom::new(MetaType::new::<T>()).into()
+        TypeDefPhantom.into()
     }
 }
 

src/tests.rs

@@ -82,7 +82,7 @@ fn prelude_items() {
                     )
             )
     );
-    assert_type!(PhantomData<i32>, TypeDefPhantom::new(meta_type::<i32>()));
+    assert_type!(PhantomData<i32>, TypeDefPhantom);
     assert_type!(
         Cow<u128>,
         Type::builder()

src/ty/mod.rs

@@ -196,7 +196,7 @@ pub enum TypeDef<T: Form = MetaForm> {
     /// A type using the [`Compact`] encoding
     Compact(TypeDefCompact<T>),
     /// A PhantomData type.
-    Phantom(TypeDefPhantom<T>),
+    Phantom(TypeDefPhantom),
 }
 
 impl IntoPortable for TypeDef {
@@ -211,7 +211,7 @@ impl IntoPortable for TypeDef {
             TypeDef::Tuple(tuple) => tuple.into_portable(registry).into(),
             TypeDef::Primitive(primitive) => primitive.into(),
             TypeDef::Compact(compact) => compact.into_portable(registry).into(),
-            TypeDef::Phantom(phantom) => phantom.into_portable(registry).into(),
+            TypeDef::Phantom(phantom) => phantom.into(),
         }
     }
 }
@@ -453,35 +453,4 @@ where
 #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
 #[cfg_attr(any(feature = "std", feature = "decode"), derive(scale::Decode))]
 #[derive(PartialEq, Eq, PartialOrd, Ord, Clone, Encode, Debug)]
-pub struct TypeDefPhantom<T: Form = MetaForm> {
-    /// The PhantomData type parameter
-    #[cfg_attr(feature = "serde", serde(rename = "type"))]
-    type_param: T::Type,
-}
-
-impl IntoPortable for TypeDefPhantom {
-    type Output = TypeDefPhantom<PortableForm>;
-
-    fn into_portable(self, registry: &mut Registry) -> Self::Output {
-        TypeDefPhantom {
-            type_param: registry.register_type(&self.type_param),
-        }
-    }
-}
-
-impl TypeDefPhantom {
-    /// Creates a new phantom type definition.
-    pub fn new(type_param: MetaType) -> Self {
-        Self { type_param }
-    }
-}
-
-impl<T> TypeDefPhantom<T>
-where
-    T: Form,
-{
-    /// Returns the type parameter type of the phantom type.
-    pub fn type_param(&self) -> &T::Type {
-        &self.type_param
-    }
-}
+pub struct TypeDefPhantom;

test_suite/tests/derive.rs

@@ -609,6 +609,36 @@ fn doc_capture_works() {
     assert_type!(S, ty);
 }
 
+#[test]
+fn skip_type_params() {
+    #[allow(unused)]
+    #[derive(TypeInfo)]
+    #[scale_info(skip_type_params(T))]
+    struct Hey<T, N> {
+        ciao: Greet<T>,
+        ho: N,
+    }
+
+    #[derive(TypeInfo)]
+    #[scale_info(skip_type_params(T))]
+    struct Greet<T> {
+        marker: PhantomData<T>,
+    }
+
+    struct SomeType;
+
+    let ty = Type::builder()
+        .path(Path::new("Hey", "derive"))
+        .type_params(tuple_meta_type!(u16))
+        .composite(
+            Fields::named()
+                .field(|f| f.ty::<Greet<SomeType>>().name("ciao").type_name("Greet<T>"))
+                .field(|f| f.ty::<u16>().name("ho").type_name("N")),
+        );
+
+    assert_type!(Hey<SomeType, u16>, ty);
+}
+
 #[rustversion::nightly]
 #[test]
 fn ui_tests() {

test_suite/tests/json.rs

@@ -135,9 +135,7 @@ fn test_builtins() {
     assert_json_for_type::<String>(json!({ "def": { "primitive": "str" } }));
     assert_json_for_type::<str>(json!({ "def": { "primitive": "str" } }));
     // PhantomData
-    assert_json_for_type::<PhantomData<bool>>(
-        json!({ "def": { "phantom": { "type": 0 } }, }),
-    )
+    assert_json_for_type::<PhantomData<bool>>(json!({ "def": { "phantom": null }, }))
 }
 
 #[test]