From af1fa5fe9ed54a75bee48292e3fd5c8ea0bf7ce2 Mon Sep 17 00:00:00 2001 From: Graham Esau Date: Sun, 8 Sep 2019 22:46:18 +0100 Subject: [PATCH] Do not ignore all serde attributes if there are also schemars attributes --- schemars/tests/property_name.rs | 2 +- schemars/tests/schema_name.rs | 5 +- schemars_derive/src/lib.rs | 14 ++-- schemars_derive/src/preprocess.rs | 121 +++++++++++++++++++++++------- 4 files changed, 105 insertions(+), 37 deletions(-) diff --git a/schemars/tests/property_name.rs b/schemars/tests/property_name.rs index 2bd61c8..3356146 100644 --- a/schemars/tests/property_name.rs +++ b/schemars/tests/property_name.rs @@ -16,4 +16,4 @@ struct MyStruct { #[test] fn set_struct_property_names() -> TestResult { test_default_generated_schema::("property-name-struct") -} \ No newline at end of file +} diff --git a/schemars/tests/schema_name.rs b/schemars/tests/schema_name.rs index e29265d..8b34318 100644 --- a/schemars/tests/schema_name.rs +++ b/schemars/tests/schema_name.rs @@ -21,6 +21,7 @@ fn default_name_multiple_type_params() -> TestResult { #[derive(Debug, JsonSchema)] #[serde(rename = "a-new-name-{W}-{T}-{T}")] +#[schemars(rename_all = "camelCase")] struct MyRenamedStruct { t: T, u: U, @@ -36,5 +37,7 @@ struct MySimpleRenamedStruct {} #[test] fn overriden_with_rename_multiple_type_params() -> TestResult { - test_default_generated_schema::>>("schema-name-custom") + test_default_generated_schema::>>( + "schema-name-custom", + ) } diff --git a/schemars_derive/src/lib.rs b/schemars_derive/src/lib.rs index 37a24ed..b0d6178 100644 --- a/schemars_derive/src/lib.rs +++ b/schemars_derive/src/lib.rs @@ -19,7 +19,9 @@ pub fn derive_json_schema(input: proc_macro::TokenStream) -> proc_macro::TokenSt let mut input = parse_macro_input!(input as DeriveInput); preprocess::add_trait_bounds(&mut input.generics); - preprocess::rename_schemars_attrs(&mut input); + if let Err(e) = preprocess::process_serde_attrs(&mut input) { + return e.into(); + } let ctxt = Ctxt::new(); let cont = Container::from_ast(&ctxt, &input, Derive::Deserialize); @@ -237,13 +239,13 @@ fn schema_for_struct(fields: &[Field], cattrs: &attr::Container) -> TokenStream let (nested, flat): (Vec<_>, Vec<_>) = fields.iter().partition(|f| !f.attrs.flatten()); let container_has_default = has_default(cattrs.default()); let mut required = Vec::new(); - let recurse = nested.iter().map(|f| { - let name = f.attrs.name().deserialize_name(); - if !container_has_default && !has_default(f.attrs.default()) { + let recurse = nested.iter().map(|field| { + let name = field.attrs.name().deserialize_name(); + if !container_has_default && !has_default(field.attrs.default()) { required.push(name.clone()); } - let ty = f.ty; - quote_spanned! {f.original.span()=> + let ty = field.ty; + quote_spanned! {field.original.span()=> props.insert(#name.to_owned(), gen.subschema_for::<#ty>()?); } }); diff --git a/schemars_derive/src/preprocess.rs b/schemars_derive/src/preprocess.rs index 72d801b..bd0b32d 100644 --- a/schemars_derive/src/preprocess.rs +++ b/schemars_derive/src/preprocess.rs @@ -1,5 +1,12 @@ -use proc_macro2::Span; -use syn::{Attribute, Data, DeriveInput, Field, GenericParam, Generics, Ident, Variant}; +use proc_macro2::TokenStream; +use quote::ToTokens; +use serde_derive_internals::Ctxt; +use std::collections::BTreeSet; +use syn::parse::Parser; +use syn::spanned::Spanned; +use syn::{ + Attribute, Data, DeriveInput, Field, GenericParam, Generics, Ident, Meta, NestedMeta, Variant, +}; pub fn add_trait_bounds(generics: &mut Generics) { for param in &mut generics.params { @@ -11,47 +18,103 @@ pub fn add_trait_bounds(generics: &mut Generics) { // If a struct/variant/field has any #[schemars] attributes, then rename them // to #[serde] so that serde_derive_internals will parse them for us. -pub fn rename_schemars_attrs(input: &mut DeriveInput) { - rename_attrs(input.attrs.iter_mut()); +pub fn process_serde_attrs(input: &mut DeriveInput) -> Result<(), TokenStream> { + let ctxt = Ctxt::new(); + process_attrs(&ctxt, &mut input.attrs); match input.data { - Data::Struct(ref mut s) => rename_field_attrs(s.fields.iter_mut()), - Data::Enum(ref mut e) => rename_variant_attrs(e.variants.iter_mut()), - Data::Union(ref mut u) => rename_field_attrs(u.fields.named.iter_mut()), + Data::Struct(ref mut s) => process_serde_field_attrs(&ctxt, s.fields.iter_mut()), + Data::Enum(ref mut e) => process_serde_variant_attrs(&ctxt, e.variants.iter_mut()), + Data::Union(ref mut u) => process_serde_field_attrs(&ctxt, u.fields.named.iter_mut()), }; + + ctxt.check().map_err(|message| { + quote_spanned! {input.span()=> + compile_error!(#message); + } + }) } -fn rename_variant_attrs<'a>(variants: impl Iterator) { +fn process_serde_variant_attrs<'a>(ctxt: &Ctxt, variants: impl Iterator) { for v in variants { - rename_attrs(v.attrs.iter_mut()); - rename_field_attrs(v.fields.iter_mut()); + process_attrs(&ctxt, &mut v.attrs); + process_serde_field_attrs(&ctxt, v.fields.iter_mut()); } } -fn rename_field_attrs<'a>(fields: impl Iterator) { +fn process_serde_field_attrs<'a>(ctxt: &Ctxt, fields: impl Iterator) { for f in fields { - rename_attrs(f.attrs.iter_mut()); + process_attrs(&ctxt, &mut f.attrs); } } -fn rename_attrs<'a>(attrs: impl Iterator) { - let (schemars_attrs, others): (Vec<_>, Vec<_>) = - attrs.partition(|a| a.path.is_ident("schemars")); +fn process_attrs(ctxt: &Ctxt, attrs: &mut Vec) { + let mut serde_meta: Vec = attrs + .iter() + .filter(|a| a.path.is_ident("serde")) + .flat_map(|attr| get_meta_items(&ctxt, attr)) + .flatten() + .collect(); - if !schemars_attrs.is_empty() { - for attr in schemars_attrs { - let schemars_ident = attr.path.segments.pop().unwrap().into_value().ident; - attr.path - .segments - .push(Ident::new("serde", schemars_ident.span()).into()); + attrs.retain(|a| a.path.is_ident("schemars")); + + for attr in attrs.iter_mut() { + let schemars_ident = attr.path.segments.pop().unwrap().into_value().ident; + attr.path + .segments + .push(Ident::new("serde", schemars_ident.span()).into()); + } + + let schemars_meta_names: BTreeSet = attrs + .iter() + .flat_map(|attr| get_meta_items(&ctxt, attr)) + .flatten() + .flat_map(|m| get_meta_ident(&ctxt, &m)) + .collect(); + + serde_meta.retain(|m| { + get_meta_ident(&ctxt, m) + .map(|i| !schemars_meta_names.contains(&i)) + .unwrap_or(false) + }); + + if serde_meta.is_empty() { + return; + } + + let new_serde_attr = quote! { + #[serde(#(#serde_meta),*)] + }; + + let parser = Attribute::parse_outer; + match parser.parse2(new_serde_attr) { + Ok(ref mut parsed) => attrs.append(parsed), + Err(e) => ctxt.error(e), + } +} + +fn get_meta_items(ctxt: &Ctxt, attr: &Attribute) -> Result, ()> { + match attr.parse_meta() { + Ok(Meta::List(meta)) => Ok(meta.nested.into_iter().collect()), + Ok(_) => { + ctxt.error("expected #[schemars(...)] or #[serde(...)]"); + Err(()) } - // Give any other attributes a new name so that serde doesn't process them - // and complain about duplicate attributes. - // TODO we shouldn't need to remove all attributes - it should be possible - // to just remove duplicated parts of the attributes. - for attr in others { - attr.path - .segments - .push(Ident::new("dummy", Span::call_site()).into()); + Err(err) => { + ctxt.error(err); + Err(()) + } + } +} + +fn get_meta_ident(ctxt: &Ctxt, meta: &NestedMeta) -> Result { + match meta { + NestedMeta::Meta(m) => Ok(m.name()), + NestedMeta::Literal(lit) => { + ctxt.error(format!( + "unexpected literal in attribute: {}", + lit.into_token_stream() + )); + Err(()) } } }