Allow type parameter bounds in skip.

Signed-off-by: Toralf Wittner <[email protected]>

Author: twittner

minicbor-derive/src/attrs.rs

@@ -124,15 +124,17 @@ impl Attributes {
                 return Err(syn::Error::new(*s, "`tag` and `transparent` are mutually exclusive"))
             }
         }
-        if let Some(Value::Skip(s)) = this.get(Kind::Skip) {
-            if this.attrs.len() > 1 {
-                return Err(syn::Error::new(*s, "`skip` does not allow other attributes"))
-            }
+        if this.contains_key(Kind::Skip)
+            && let Some((_, a)) = this.attrs
+                .iter()
+                .find(|(k, _)| !matches!(k, Kind::Skip | Kind::TypeParam))
+        {
+            return Err(syn::Error::new(a.span(), "`skip` can not be used with this attribute"))
         }
-        if let Some(Value::Flat(_)) = this.get(Kind::Flat) {
-            if let Some(Value::Encoding(Encoding::Map, s)) = this.get(Kind::Encoding) {
-                return Err(syn::Error::new(*s, "flat enum does not support map encoding"))
-            }
+        if this.contains_key(Kind::Flat)
+            && let Some(Value::Encoding(Encoding::Map, s)) = this.get(Kind::Encoding)
+        {
+            return Err(syn::Error::new(*s, "flat enum does not support map encoding"))
         }
         // `skip_if` triggers the creation of a custom codec where `encode` and `decode`
         // correspond the the default routines, `is_nil` is defined via `skip_if`'s
@@ -662,17 +664,13 @@ impl Attributes {
                 }
             }
             Value::CborLen(_, s) => {
-                if let Some(Value::Codec(c, _)) = self.get(Kind::Codec) {
-                    if c.is_module() {
-                        return Err(syn::Error::new(*s, "`cbor_len` and `with` are mutually exclusive"))
-                    }
+                if let Some(Value::Codec(c, _)) = self.get(Kind::Codec) && c.is_module() {
+                    return Err(syn::Error::new(*s, "`cbor_len` and `with` are mutually exclusive"))
                 }
             }
             Value::Borrow(_, s) => {
-                if let Some(idx) = self.index() {
-                    if idx.is_b() {
-                        return Err(syn::Error::new(*s, "`borrow` and `b` are mutually exclusive"))
-                    }
+                if let Some(idx) = self.index() && idx.is_b() {
+                    return Err(syn::Error::new(*s, "`borrow` and `b` are mutually exclusive"))
                 }
             }
             Value::Index(idx, s) if idx.is_b() => {

minicbor-derive/src/blacklist.rs

@@ -4,19 +4,28 @@ use std::ops::Deref;
 use crate::{collect_type_params, is_phantom_data, Mode};
 use crate::{attrs::CustomCodec, fields::Fields};
 
-#[derive(Default)]
 pub(crate) struct Blacklist(HashSet<syn::Ident>);
 
 impl Blacklist {
+    pub(crate) fn empty() -> Self {
+        Self(HashSet::new())
+    }
+
     /// Generate a blacklist of type parameters that should not have bounds attached.
     ///
     /// This includes:
     ///
     /// - Type parameters of fields with a custom encode, decode or cbor_len function.
     /// - Fields that are skipped over.
     /// - Fields with a `PhantomData` type.
-    pub(crate) fn new(mode: Mode, fields: &Fields, g: &syn::Generics) -> Blacklist {
-        // Start with custom encode/decode/cbor_len functions.
+    pub(crate) fn new(mode: Mode, fields: &Fields, g: &syn::Generics) -> Self {
+        Self::empty()
+            .with_mode(mode, fields, g)
+            .with_skipped(fields, g)
+            .with_phantoms(fields, g)
+    }
+
+    pub(crate) fn with_mode(mut self, mode: Mode, fields: &Fields, g: &syn::Generics) -> Self {
         let mut blacklist = collect_type_params(g, fields.fields().filter(|f| {
             match mode {
                 Mode::Encode => f.attrs.codec().map(|c| !c.require_encode_bound()).unwrap_or(false),
@@ -41,43 +50,49 @@ impl Blacklist {
             }));
             blacklist.retain(|ident| !others.contains(ident));
         }
+        self.0.extend(blacklist);
+        self
+    }
 
-        // Extend the blacklist by type parameters only appearing in skipped fields.
+    /// Extend the blacklist by type parameters only appearing in skipped fields.
+    pub(crate) fn with_skipped(mut self, fields: &Fields, g: &syn::Generics) -> Self {
         let skipped = collect_type_params(g, fields.skipped());
         if !skipped.is_empty() {
             let regular = collect_type_params(g, fields.fields());
-            blacklist.extend(skipped.difference(&regular).cloned())
+            self.0.extend(skipped.difference(&regular).cloned())
         }
+        self
+    }
 
-        // And finally also by type parameters only appearing in `PhantomData`.
+    pub(crate) fn with_phantoms(mut self, fields: &Fields, g: &syn::Generics) -> Self {
         let phantoms = collect_type_params(g, fields.fields().chain(fields.skipped()).filter(|f| {
             is_phantom_data(&f.typ)
         }));
         if !phantoms.is_empty() {
             let non_phantom = collect_type_params(g, fields.fields().chain(fields.skipped()).filter(|f| {
                 !is_phantom_data(&f.typ)
             }));
-            blacklist.extend(phantoms.difference(&non_phantom).cloned());
+            self.0.extend(phantoms.difference(&non_phantom).cloned());
         }
-
-        Self(blacklist)
+        self
     }
 
+
     /// Merge in another set of fields.
     ///
     /// Any types in positive position, i.e. not blacklisted in the given
     /// fields argument will be removed from the blacklist.
     ///
     /// Any types in negative position, i.e. blacklisted in the given fields
     /// argument will be add to the blacklist.
-    pub(crate) fn merge(&mut self, m: Mode, f: &Fields, g: &syn::Generics) {
-        let b = Blacklist::new(m, f, g);
+    pub(crate) fn merge(&mut self, f: &Fields, g: &syn::Generics, b: Self) -> &mut Self {
         for t in collect_type_params(g, f.fields()).difference(&b) {
             self.0.remove(t);
         }
         for t in b.0 {
             self.0.insert(t);
         }
+        self
     }
 
     pub(crate) fn add<I>(&mut self, it: I)

minicbor-derive/src/cbor_len.rs

@@ -39,12 +39,12 @@ fn on_struct(inp: &mut syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream
     let blacklist      = Blacklist::new(Mode::Length, &fields, &inp.generics);
     let cbor_len_bound = gen_cbor_len_bound()?;
     let params         = inp.generics.type_params_mut();
-    add_bound_to_type_params(cbor_len_bound, params, &blacklist, fields.fields().attributes(), Mode::Length);
+    add_bound_to_type_params(Mode::Length, cbor_len_bound, params, &blacklist, fields.fields().attributes());
 
     let blacklist    = blacklist_is_nil_params(&inp.generics, &fields);
     let encode_bound = gen_encode_bound()?;
     let params       = inp.generics.type_params_mut();
-    add_bound_to_type_params(encode_bound, params, &blacklist, fields.fields().attributes(), Mode::Length);
+    add_bound_to_type_params(Mode::Length, encode_bound, params, &blacklist, fields.fields().attributes());
 
     let generics = add_typeparam(&inp.generics, gen_ctx_param()?, attrs.context_bound());
     let impl_generics = generics.split_for_impl().0;
@@ -90,13 +90,13 @@ fn on_enum(inp: &mut syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream>
     let flat          = enum_attrs.flat();
     let variants      = Variants::try_from(name.span(), data.variants.iter(), &enum_attrs)?;
 
-    let mut blacklist_len = Blacklist::default();
-    let mut blacklist_enc = Blacklist::default();
+    let mut blacklist_len = Blacklist::empty();
+    let mut blacklist_enc = Blacklist::empty();
     let mut field_attrs = Vec::new();
     let mut rows = Vec::new();
     for ((var, idx), attrs) in data.variants.iter().zip(variants.indices.iter()).zip(&variants.attrs) {
         let fields = Fields::try_from(var.ident.span(), var.fields.iter(), &[attrs, &enum_attrs])?;
-        blacklist_len.merge(Mode::Length, &fields, &inp.generics);
+        blacklist_len.merge(&fields, &inp.generics, Blacklist::new(Mode::Length, &fields, &inp.generics));
         blacklist_enc.add(HashSet::from(blacklist_is_nil_params(&inp.generics, &fields)));
         let con      = &var.ident;
         let encoding = attrs.encoding().unwrap_or(enum_encoding);
@@ -158,11 +158,11 @@ fn on_enum(inp: &mut syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream>
 
     let cbor_len_bound = gen_cbor_len_bound()?;
     let params         = inp.generics.type_params_mut();
-    add_bound_to_type_params(cbor_len_bound, params, &blacklist_len, &field_attrs, Mode::Length);
+    add_bound_to_type_params(Mode::Length, cbor_len_bound, params, &blacklist_len, &field_attrs);
 
     let encode_bound   = gen_encode_bound()?;
     let params         = inp.generics.type_params_mut();
-    add_bound_to_type_params(encode_bound, params, &blacklist_enc, &field_attrs, Mode::Length);
+    add_bound_to_type_params(Mode::Length, encode_bound, params, &blacklist_enc, &field_attrs);
 
     let generics = add_typeparam(&inp.generics, gen_ctx_param()?, enum_attrs.context_bound());
     let impl_generics = generics.split_for_impl().0;
@@ -296,10 +296,8 @@ fn cbor_len(custom: Option<&syn::ExprPath>, codec: Option<&CustomCodec>) -> proc
     if let Some(cu) = custom {
         return cu.to_token_stream()
     }
-    if let Some(ce) = codec {
-        if let Some(p) = ce.to_cbor_len_path() {
-            return p.to_token_stream()
-        }
+    if let Some(ce) = codec && let Some(p) = ce.to_cbor_len_path() {
+        return p.to_token_stream()
     }
     quote!(minicbor::CborLen::<Ctx>::cbor_len)
 }
@@ -349,7 +347,7 @@ fn on_tag(a: &Attributes) -> proc_macro2::TokenStream {
 }
 
 fn blacklist_is_nil_params(generics: &syn::Generics, fields: &Fields) -> Blacklist {
-    let mut blacklist = Blacklist::default();
+    let mut blacklist = Blacklist::empty();
     blacklist.add({
         let mut with_is_nil = collect_type_params(generics, fields.fields().filter(|f| {
             f.attrs.codec().map(|c| c.is_is_nil()).unwrap_or(false)

minicbor-derive/src/decode.rs

@@ -1,11 +1,12 @@
-use quote::quote;
 use std::collections::HashSet;
+
+use quote::quote;
 use syn::spanned::Spanned;
 
 use crate::blacklist::Blacklist;
-use crate::{is_phantom_data, Mode};
-use crate::{add_bound_to_type_params, collect_type_params, is_cow, is_option, is_str, is_byte_slice};
-use crate::{add_typeparam, gen_ctx_param, add_bound_to_matching_type_params};
+use crate::{collect_type_params, Mode};
+use crate::{add_bound_to_type_params, is_cow, is_option, is_str, is_byte_slice};
+use crate::{add_typeparam, gen_ctx_param};
 use crate::attrs::{Attributes, CustomCodec, Encoding, Level};
 use crate::fields::{Field, Fields};
 use crate::variants::Variants;
@@ -34,33 +35,39 @@ fn on_struct(inp: &mut syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream
             unreachable!("`derive_from` matched against `syn::Data::Struct`")
         };
 
-    let name      = &inp.ident;
-    let attrs     = Attributes::try_from_iter(Level::Struct, inp.attrs.iter())?;
-    let fields    = Fields::try_from(name.span(), data.fields.iter(), &[&attrs])?;
-    let blacklist = Blacklist::new(Mode::Decode, &fields, &inp.generics);
+    let name   = &inp.ident;
+    let attrs  = Attributes::try_from_iter(Level::Struct, inp.attrs.iter())?;
+    let fields = Fields::try_from(name.span(), data.fields.iter(), &[&attrs])?;
 
-    let mut lifetime = gen_lifetime()?;
+    let mut lifetime = gen_lifetime();
     for l in lifetimes_to_constrain(fields.fields().map(|f| (&f.index, f.attrs.borrow(), &f.typ))) {
         if !lifetime.bounds.iter().any(|b| *b == l) {
             lifetime.bounds.push(l.clone())
         }
     }
 
-    // Collect type parameters which require a `Default` bound.
-    let default_types =
-        collect_type_params(&inp.generics, fields.fields().chain(fields.skipped()).filter(|f| {
-            (f.attrs.default() || f.attrs.skip() || f.attrs.skip_if_codec()) && !is_phantom_data(&f.typ)
-        }))
-        .into_iter()
-        .collect();
-
-    let bound  = gen_decode_bound()?;
+    let blacklist = Blacklist::new(Mode::Decode, &fields, &inp.generics);
+    let bound  = gen_decode_bound();
     let params = inp.generics.type_params_mut();
-    add_bound_to_type_params(bound, params, &blacklist, fields.fields().attributes(), Mode::Decode);
+    add_bound_to_type_params(Mode::Decode, bound, params, &blacklist, fields.fields().attributes());
 
-    let bound  = gen_default_bound()?;
-    let params = inp.generics.type_params_mut();
-    add_bound_to_matching_type_params(bound, params, &default_types);
+    // Collect type parameters which require a `Default` bound.
+    let default_types: HashSet<syn::Ident> =
+        collect_type_params(&inp.generics, fields.fields().chain(fields.skipped()).filter(|f| {
+            f.attrs.default() || f.attrs.skip() || f.attrs.skip_if_codec()
+        }));
+
+    let blacklist = Blacklist::empty()
+        .with_mode(Mode::Decode, &fields, &inp.generics)
+        .with_phantoms(&fields, &inp.generics);
+
+    let bound  = gen_default_bound();
+    let params = inp.generics.type_params_mut().filter(|p| default_types.contains(&p.ident));
+    add_bound_to_type_params(Mode::Decode, bound, params, &blacklist,
+        fields.fields().chain(fields.skipped()).filter_map(|f| {
+            (f.attrs.default() || f.attrs.skip() || f.attrs.skip_if_codec()).then_some(&f.attrs)
+        })
+    );
 
     let generics = add_lifetime(&inp.generics, lifetime);
     let generics = add_typeparam(&generics, gen_ctx_param()?, attrs.context_bound());
@@ -140,10 +147,12 @@ fn on_enum(inp: &mut syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream>
     let flat          = enum_attrs.flat();
     let variants      = Variants::try_from(name.span(), data.variants.iter(), &enum_attrs)?;
 
-    let mut blacklist = Blacklist::default();
-    let mut defaults = HashSet::new();
+    let mut decode_blacklist = Blacklist::empty();
     let mut field_attrs = Vec::new();
-    let mut lifetime = gen_lifetime()?;
+    let mut default_blacklist = Blacklist::empty();
+    let mut defaults = HashSet::new();
+    let mut default_attrs = Vec::new();
+    let mut lifetime = gen_lifetime();
     let mut rows = Vec::new();
     for ((var, idx), attrs) in data.variants.iter().zip(variants.indices.iter()).zip(&variants.attrs) {
         let fields = Fields::try_from(var.ident.span(), var.fields.iter(), &[attrs, &enum_attrs])?;
@@ -166,13 +175,14 @@ fn on_enum(inp: &mut syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream>
                     lifetime.bounds.push(l.clone())
                 }
             }
-            blacklist.merge(Mode::Decode, &fields, &inp.generics);
-            // Collect type parameters which require a `Default` bound.
+            decode_blacklist.merge(&fields, &inp.generics, Blacklist::new(Mode::Decode, &fields, &inp.generics));
+            default_blacklist.merge(&fields, &inp.generics, Blacklist::empty()
+                .with_mode(Mode::Decode, &fields, &inp.generics)
+                .with_phantoms(&fields, &inp.generics));
             defaults.extend(
                 collect_type_params(&inp.generics, fields.fields().chain(fields.skipped()).filter(|f| {
-                    (f.attrs.default() || f.attrs.skip() || f.attrs.skip_if_codec()) && !is_phantom_data(&f.typ)
+                    f.attrs.default() || f.attrs.skip() || f.attrs.skip_if_codec()
                 }))
-                .into_iter()
             );
             let statements = gen_statements(&fields, encoding, flat)?;
             if let syn::Fields::Named(_) = var.fields {
@@ -213,16 +223,21 @@ fn on_enum(inp: &mut syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream>
             }
         };
         field_attrs.extend(fields.fields().attributes().cloned());
+        default_attrs.extend(fields.fields().attributes().chain(fields.skipped().attributes()).cloned());
         rows.push(row)
     }
 
-    let bound  = gen_decode_bound()?;
+    let bound  = gen_decode_bound();
     let params = inp.generics.type_params_mut();
-    add_bound_to_type_params(bound, params, &blacklist, &field_attrs, Mode::Decode);
+    add_bound_to_type_params(Mode::Decode, bound, params, &decode_blacklist, &field_attrs);
 
-    let bound  = gen_default_bound()?;
-    let params = inp.generics.type_params_mut();
-    add_bound_to_matching_type_params(bound, params, &defaults);
+    let bound  = gen_default_bound();
+    let params = inp.generics.type_params_mut().filter(|p| defaults.contains(&p.ident));
+    add_bound_to_type_params(Mode::Decode, bound, params, &default_blacklist,
+        default_attrs.iter().filter(|a| {
+            a.default() || a.skip() || a.skip_if_codec()
+        })
+    );
 
     let generics = add_lifetime(&inp.generics, lifetime);
     let generics = add_typeparam(&generics, gen_ctx_param()?, enum_attrs.context_bound());
@@ -527,12 +542,12 @@ fn make_transparent_impl
     })
 }
 
-fn gen_decode_bound() -> syn::Result<syn::TypeParamBound> {
-    syn::parse_str("minicbor::Decode<'bytes, Ctx>")
+fn gen_decode_bound() -> syn::TypeParamBound {
+    syn::parse_quote!(minicbor::Decode<'bytes, Ctx>)
 }
 
-fn gen_default_bound() -> syn::Result<syn::TypeParamBound> {
-    syn::parse_str("Default")
+fn gen_default_bound() -> syn::TypeParamBound {
+    syn::parse_quote!(Default)
 }
 
 fn defs<'a, T>(fields: T) -> Vec<proc_macro2::TokenStream>

minicbor-derive/src/encode.rs

@@ -40,7 +40,7 @@ fn on_struct(inp: &mut syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream
 
     let bound  = gen_encode_bound()?;
     let params = inp.generics.type_params_mut();
-    add_bound_to_type_params(bound, params, &blacklist, fields.fields().attributes(), Mode::Encode);
+    add_bound_to_type_params(Mode::Encode, bound, params, &blacklist, fields.fields().attributes());
 
     let generics = add_typeparam(&inp.generics, gen_ctx_param()?, attrs.context_bound());
     let impl_generics = generics.split_for_impl().0;
@@ -90,13 +90,13 @@ fn on_enum(inp: &mut syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream>
     let flat          = enum_attrs.flat();
     let variants      = Variants::try_from(name.span(), data.variants.iter(), &enum_attrs)?;
 
-    let mut blacklist = Blacklist::default();
+    let mut blacklist = Blacklist::empty();
     let mut field_attrs = Vec::new();
     let mut rows = Vec::new();
 
     for ((var, idx), attrs) in data.variants.iter().zip(variants.indices.iter()).zip(&variants.attrs) {
         let fields = Fields::try_from(var.ident.span(), var.fields.iter(), &[attrs, &enum_attrs])?;
-        blacklist.merge(Mode::Encode, &fields, &inp.generics);
+        blacklist.merge(&fields, &inp.generics, Blacklist::new(Mode::Encode, &fields, &inp.generics));
         let con = &var.ident;
         let encoding = attrs.encoding().unwrap_or(enum_encoding);
         let tag = encode_tag(attrs);
@@ -207,7 +207,7 @@ fn on_enum(inp: &mut syn::DeriveInput) -> syn::Result<proc_macro2::TokenStream>
     {
         let bound  = gen_encode_bound()?;
         let params = inp.generics.type_params_mut();
-        add_bound_to_type_params(bound, params, &blacklist, &field_attrs, Mode::Encode);
+        add_bound_to_type_params(Mode::Encode, bound, params, &blacklist, &field_attrs);
     }
 
     let generics = add_typeparam(&inp.generics, gen_ctx_param()?, enum_attrs.context_bound());