pezkuwichain/pezkuwi-subxt
1
0
Fork 0
mirror of https://github.com/pezkuwichain/pezkuwi-subxt.git synced 2026-04-27 11:38:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

update DefaultNoBound derive macro (#12723)

Browse Source 
fix derive for empty enums

Update derive & ui tests

clean up

Apply suggestions from code review

Co-authored-by: Bastian Köcher <git@kchr.de>

rename variable

formatting & clippy

formatting

Co-authored-by: parity-processbot <>
This commit is contained in:
benluelo
2022-11-25 05:11:19 -05:00
committed by GitHub
parent 08657f14b7
commit 50f338e1ea
13 changed files with 235 additions and 61 deletions
Download Patch File Download Diff File Expand all files Collapse all files
substrate/frame/support/procedural/src/default_no_bound.rs
+115 -55
View File
@@ -15,82 +15,142 @@
// See the License for the specific language governing permissions and
// limitations under the License.
use syn::spanned::Spanned;
use proc_macro2::Span;
use quote::{quote, quote_spanned};
use syn::{spanned::Spanned, Data, DeriveInput, Fields};
/// Derive Clone but do not bound any generic.
/// Derive Default but do not bound any generic.
pub fn derive_default_no_bound(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
let input: syn::DeriveInput = match syn::parse(input) {
Ok(input) => input,
Err(e) => return e.to_compile_error().into(),
};
let input = syn::parse_macro_input!(input as DeriveInput);
let name = &input.ident;
let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
let impl_ = match input.data {
syn::Data::Struct(struct_) => match struct_.fields {
syn::Fields::Named(named) => {
let fields = named.named.iter().map(|i| &i.ident).map(|i| {
quote::quote_spanned!(i.span() =>
#i: core::default::Default::default()
)
Data::Struct(struct_) => match struct_.fields {
Fields::Named(named) => {
let fields = named.named.iter().map(|field| &field.ident).map(|ident| {
quote_spanned! {ident.span() =>
#ident: core::default::Default::default()
}
});
quote::quote!( Self { #( #fields, )* } )
quote!(Self { #( #fields, )* })
},
syn::Fields::Unnamed(unnamed) => {
let fields =
unnamed.unnamed.iter().enumerate().map(|(i, _)| syn::Index::from(i)).map(|i| {
quote::quote_spanned!(i.span() =>
core::default::Default::default()
)
});
Fields::Unnamed(unnamed) => {
let fields = unnamed.unnamed.iter().map(|field| {
quote_spanned! {field.span()=>
core::default::Default::default()
}
});
quote::quote!( Self ( #( #fields, )* ) )
quote!(Self( #( #fields, )* ))
},
syn::Fields::Unit => {
quote::quote!(Self)
Fields::Unit => {
quote!(Self)
},
},
syn::Data::Enum(enum_) =>
if let Some(first_variant) = enum_.variants.first() {
let variant_ident = &first_variant.ident;
match &first_variant.fields {
syn::Fields::Named(named) => {
let fields = named.named.iter().map(|i| &i.ident).map(|i| {
quote::quote_spanned!(i.span() =>
#i: core::default::Default::default()
)
});
Data::Enum(enum_) => {
if enum_.variants.is_empty() {
return syn::Error::new_spanned(name, "cannot derive Default for an empty enum")
.to_compile_error()
.into()
}
quote::quote!( #name :: #ty_generics :: #variant_ident { #( #fields, )* } )
},
syn::Fields::Unnamed(unnamed) => {
let fields = unnamed
.unnamed
.iter()
.enumerate()
.map(|(i, _)| syn::Index::from(i))
.map(|i| {
quote::quote_spanned!(i.span() =>
// all #[default] attrs with the variant they're on; i.e. a var
let default_variants = enum_
.variants
.into_iter()
.filter(|variant| variant.attrs.iter().any(|attr| attr.path.is_ident("default")))
.collect::<Vec<_>>();
match &*default_variants {
[] => {
return syn::Error::new(
name.clone().span(),
// writing this as a regular string breaks rustfmt for some reason
r#"no default declared, make a variant default by placing `#[default]` above it"#,
)
.into_compile_error()
.into()
},
// only one variant with the #[default] attribute set
[default_variant] => {
let variant_attrs = default_variant
.attrs
.iter()
.filter(|a| a.path.is_ident("default"))
.collect::<Vec<_>>();
// check that there is only one #[default] attribute on the variant
if let [first_attr, second_attr, additional_attrs @ ..] = &*variant_attrs {
let mut err =
syn::Error::new(Span::call_site(), "multiple `#[default]` attributes");
err.combine(syn::Error::new_spanned(first_attr, "`#[default]` used here"));
err.extend([second_attr].into_iter().chain(additional_attrs).map(
|variant| {
syn::Error::new_spanned(variant, "`#[default]` used again here")
},
));
return err.into_compile_error().into()
}
let variant_ident = &default_variant.ident;
let fully_qualified_variant_path = quote!(Self::#variant_ident);
match &default_variant.fields {
Fields::Named(named) => {
let fields =
named.named.iter().map(|field| &field.ident).map(|ident| {
quote_spanned! {ident.span()=>
#ident: core::default::Default::default()
}
});
quote!(#fully_qualified_variant_path { #( #fields, )* })
},
Fields::Unnamed(unnamed) => {
let fields = unnamed.unnamed.iter().map(|field| {
quote_spanned! {field.span()=>
core::default::Default::default()
)
}
});
quote::quote!( #name :: #ty_generics :: #variant_ident ( #( #fields, )* ) )
},
syn::Fields::Unit => quote::quote!( #name :: #ty_generics :: #variant_ident ),
}
} else {
quote::quote!(Self)
},
syn::Data::Union(_) => {
let msg = "Union type not supported by `derive(CloneNoBound)`";
return syn::Error::new(input.span(), msg).to_compile_error().into()
quote!(#fully_qualified_variant_path( #( #fields, )* ))
},
Fields::Unit => fully_qualified_variant_path,
}
},
[first, additional @ ..] => {
let mut err = syn::Error::new(Span::call_site(), "multiple declared defaults");
err.combine(syn::Error::new_spanned(first, "first default"));
err.extend(
additional
.into_iter()
.map(|variant| syn::Error::new_spanned(variant, "additional default")),
);
return err.into_compile_error().into()
},
}
},
Data::Union(union_) =>
return syn::Error::new_spanned(
union_.union_token,
"Union type not supported by `derive(DefaultNoBound)`",
)
.to_compile_error()
.into(),
};
quote::quote!(
quote!(
const _: () = {
impl #impl_generics core::default::Default for #name #ty_generics #where_clause {
fn default() -> Self {
substrate/frame/support/procedural/src/lib.rs
+1 -1
View File
@@ -582,7 +582,7 @@ pub fn derive_eq_no_bound(input: TokenStream) -> TokenStream {
}
/// derive `Default` but do no bound any generic. Docs are at `frame_support::DefaultNoBound`.
#[proc_macro_derive(DefaultNoBound)]
#[proc_macro_derive(DefaultNoBound, attributes(default))]
pub fn derive_default_no_bound(input: TokenStream) -> TokenStream {
default_no_bound::derive_default_no_bound(input)
}