Do not ignore all serde attributes if there are also schemars attributes

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, U, V, W> {
     t: T,
     u: U,
@@ -36,5 +37,7 @@ struct MySimpleRenamedStruct {}
 
 #[test]
 fn overriden_with_rename_multiple_type_params() -> TestResult {
-    test_default_generated_schema::<MyRenamedStruct<i32, (), bool, Vec<String>>>("schema-name-custom")
+    test_default_generated_schema::<MyRenamedStruct<i32, (), bool, Vec<String>>>(
+        "schema-name-custom",
+    )
 }

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>()?);
         }
     });

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<Item = &'a mut Variant>) {
+fn process_serde_variant_attrs<'a>(ctxt: &Ctxt, variants: impl Iterator<Item = &'a mut Variant>) {
     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<Item = &'a mut Field>) {
+fn process_serde_field_attrs<'a>(ctxt: &Ctxt, fields: impl Iterator<Item = &'a mut Field>) {
     for f in fields {
-        rename_attrs(f.attrs.iter_mut());
+        process_attrs(&ctxt, &mut f.attrs);
     }
 }
 
-fn rename_attrs<'a>(attrs: impl Iterator<Item = &'a mut Attribute>) {
-    let (schemars_attrs, others): (Vec<_>, Vec<_>) =
-        attrs.partition(|a| a.path.is_ident("schemars"));
+fn process_attrs(ctxt: &Ctxt, attrs: &mut Vec<Attribute>) {
+    let mut serde_meta: Vec<NestedMeta> = 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 {
+    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());
     }
-        // 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());
+
+    let schemars_meta_names: BTreeSet<Ident> = 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<Vec<NestedMeta>, ()> {
+    match attr.parse_meta() {
+        Ok(Meta::List(meta)) => Ok(meta.nested.into_iter().collect()),
+        Ok(_) => {
+            ctxt.error("expected #[schemars(...)] or #[serde(...)]");
+            Err(())
+        }
+        Err(err) => {
+            ctxt.error(err);
+            Err(())
+        }
+    }
+}
+
+fn get_meta_ident(ctxt: &Ctxt, meta: &NestedMeta) -> Result<Ident, ()> {
+    match meta {
+        NestedMeta::Meta(m) => Ok(m.name()),
+        NestedMeta::Literal(lit) => {
+            ctxt.error(format!(
+                "unexpected literal in attribute: {}",
+                lit.into_token_stream()
+            ));
+            Err(())
         }
     }
 }