pull_number int64 64 2.85k | test_patch stringlengths 303 98.3k | issue_numbers sequencelengths 1 2 | instance_id stringlengths 18 20 | problem_statement stringlengths 24 6.49k | version stringclasses 19 values | base_commit stringlengths 40 40 | patch stringlengths 372 188k | repo stringclasses 1 value | created_at stringlengths 20 20 | hints_text stringlengths 0 6.32k | environment_setup_commit stringclasses 20 values |
|---|---|---|---|---|---|---|---|---|---|---|---|
1,363 | diff --git a/test_suite/tests/test_unstable.rs b/test_suite/tests/test_unstable.rs
new file mode 100644
index 000000000..ccc68c822
--- /dev/null
+++ b/test_suite/tests/test_unstable.rs
@@ -0,0 +1,27 @@
+// Copyright 2018 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![deny(warnings)]
+#![cfg_attr(feature = "unstable", feature(raw_identifiers))]
+
+#[cfg(feature = "unstable")]
+#[macro_use]
+extern crate serde_derive;
+
+#[cfg(feature = "unstable")]
+extern crate serde;
+#[cfg(feature = "unstable")]
+extern crate serde_test;
+
+// This test target is convoluted with the actual #[test] in a separate file to
+// get it so that the stable compiler does not need to parse the code of the
+// test. If the test were written with #[cfg(feature = "unstable")] #[test]
+// right here, the stable compiler would fail to parse those raw identifiers
+// even if the cfg were not enabled.
+#[cfg(feature = "unstable")]
+mod unstable;
diff --git a/test_suite/tests/unstable/mod.rs b/test_suite/tests/unstable/mod.rs
new file mode 100644
index 000000000..0a8a3330f
--- /dev/null
+++ b/test_suite/tests/unstable/mod.rs
@@ -0,0 +1,30 @@
+// Copyright 2018 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+use serde_test::{assert_tokens, Token};
+
+#[test]
+fn test_raw_identifiers() {
+ #[derive(Debug, PartialEq, Serialize, Deserialize)]
+ #[allow(non_camel_case_types)]
+ enum r#type {
+ r#type {
+ r#type: (),
+ }
+ }
+
+ assert_tokens(
+ &r#type::r#type { r#type: () },
+ &[
+ Token::StructVariant { name: "type", variant: "type", len: 1 },
+ Token::Str("type"),
+ Token::Unit,
+ Token::StructVariantEnd,
+ ],
+ );
+}
| [
"1362"
] | serde-rs__serde-1363 | Raw identifier keywords
Right now, `serde_derive` passes through the `r#` on [raw identifiers](https://rust-lang-nursery.github.io/edition-guide/rust-2018/module-system/raw-identifiers.html) when the identifier is a keyword.
For example ([playground link](https://play.rust-lang.org/?gist=0492ec75839fb4634b7a9ee6e9a1094f&version=nightly&mode=debug&edition=2018))
```rust
#[derive(Serialize)]
struct Foo {
r#type: i32,
r#bar: i32
}
fn main() {
let foo = Foo{ r#type: 3, r#bar: 12 };
println!("{}", serde_json::to_string_pretty(&foo).unwrap());
}
```
prints
```
{
"r#type": 3,
"bar": 12
}
```
That `r#` on the `r#type` seems like it shouldn't be exposed downstream of serde, since the current-list-of-keywords-in-Rust is an implementation detail that serialization probably shouldn't care about. Currently, a bunch of the data format libraries that work with serde (e.g. [ron](https://github.com/ron-rs/ron)) emit invalid data when provided with these raw identifiers, since they assume that field identifiers have a limited set of characters (that doesn't include `#`).
Unfortunately, the root of this issue is probably upstream of serde, and even writing a test case for this in this repo is tricky (since the test code has to be Rust 2018).
| 1.0 | c69a3e083fa865b7801a80db498e4fdc87435aad | diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs
index e2ddfee1e..af5d5b0ca 100644
--- a/serde_derive/src/de.rs
+++ b/serde_derive/src/de.rs
@@ -30,8 +30,9 @@ pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream
let ident = &cont.ident;
let params = Parameters::new(&cont);
let (de_impl_generics, _, ty_generics, where_clause) = split_with_de_lifetime(¶ms);
+ let suffix = ident.to_string().trim_left_matches("r#").to_owned();
let dummy_const = Ident::new(
- &format!("_IMPL_DESERIALIZE_FOR_{}", ident),
+ &format!("_IMPL_DESERIALIZE_FOR_{}", suffix),
Span::call_site(),
);
let body = Stmts(deserialize_body(&cont, ¶ms));
diff --git a/serde_derive/src/internals/attr.rs b/serde_derive/src/internals/attr.rs
index ede409db1..3f399ded9 100644
--- a/serde_derive/src/internals/attr.rs
+++ b/serde_derive/src/internals/attr.rs
@@ -90,6 +90,10 @@ pub struct Name {
deserialize: String,
}
+fn unraw(ident: &Ident) -> String {
+ ident.to_string().trim_left_matches("r#").to_owned()
+}
+
impl Name {
/// Return the container name for the container when serializing.
pub fn serialize_name(&self) -> String {
@@ -380,8 +384,8 @@ impl Container {
Container {
name: Name {
- serialize: ser_name.get().unwrap_or_else(|| item.ident.to_string()),
- deserialize: de_name.get().unwrap_or_else(|| item.ident.to_string()),
+ serialize: ser_name.get().unwrap_or_else(|| unraw(&item.ident)),
+ deserialize: de_name.get().unwrap_or_else(|| unraw(&item.ident)),
},
transparent: transparent.get(),
deny_unknown_fields: deny_unknown_fields.get(),
@@ -697,8 +701,8 @@ impl Variant {
let de_renamed = de_name.is_some();
Variant {
name: Name {
- serialize: ser_name.unwrap_or_else(|| variant.ident.to_string()),
- deserialize: de_name.unwrap_or_else(|| variant.ident.to_string()),
+ serialize: ser_name.unwrap_or_else(|| unraw(&variant.ident)),
+ deserialize: de_name.unwrap_or_else(|| unraw(&variant.ident)),
},
ser_renamed: ser_renamed,
de_renamed: de_renamed,
@@ -822,7 +826,7 @@ impl Field {
let mut flatten = BoolAttr::none(cx, "flatten");
let ident = match field.ident {
- Some(ref ident) => ident.to_string(),
+ Some(ref ident) => unraw(ident),
None => index.to_string(),
};
diff --git a/serde_derive/src/ser.rs b/serde_derive/src/ser.rs
index 30c326d99..d5ae14019 100644
--- a/serde_derive/src/ser.rs
+++ b/serde_derive/src/ser.rs
@@ -26,7 +26,8 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
let ident = &cont.ident;
let params = Parameters::new(&cont);
let (impl_generics, ty_generics, where_clause) = params.generics.split_for_impl();
- let dummy_const = Ident::new(&format!("_IMPL_SERIALIZE_FOR_{}", ident), Span::call_site());
+ let suffix = ident.to_string().trim_left_matches("r#").to_owned();
+ let dummy_const = Ident::new(&format!("_IMPL_SERIALIZE_FOR_{}", suffix), Span::call_site());
let body = Stmts(serialize_body(&cont, ¶ms));
let impl_block = if let Some(remote) = cont.attrs.remote() {
| serde-rs/serde | 2018-08-23T01:10:37Z | Interesting! This is a bug. That program should be printing `"type": 3` instead of `"r#type": 3`.
Would you be interested in tracking down where this is going wrong and sending a PR? Otherwise I should be able to take a look later this week.
As a workaround, at least `serde(rename = "...")` seems to work but this shouldn't be necessary.
```rust
#[derive(Serialize)]
struct Foo {
#[serde(rename = "type")]
r#type: i32,
r#bar: i32
}
``` | 4cea81f93f12473e0ccbdad2ddecff1f7ea85402 |
1,323 | diff --git a/test_suite/tests/test_ser.rs b/test_suite/tests/test_ser.rs
index cd4ce6bf4..eff19069c 100644
--- a/test_suite/tests/test_ser.rs
+++ b/test_suite/tests/test_ser.rs
@@ -462,6 +462,11 @@ declare_tests! {
Token::SeqEnd,
],
}
+ test_fmt_arguments {
+ format_args!("{}{}", 1, 'a') => &[
+ Token::Str("1a"),
+ ],
+ }
}
declare_tests! {
| [
"1319"
] | serde-rs__serde-1323 | impl<'a> Serialize for fmt::Arguments<'a>
Would it make sense to impl<'a> Serialize for fmt::Arguments<'a> ?
It's a very handy type, and available in `core` library. Though I guess for best support, the `Serializer` would have to get a `serialize_fmt` method, so it is possible to write it out without allocating temporary strings, etc. That would probably be a breaking change, though maybe an implementation that serializes into temporary, and calls `serialize_str` or something would do.
| 1.0 | d827b101d9a5896071013bc70f88be172cf0a550 | diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs
index 0b21e5414..cb2739820 100644
--- a/serde/src/ser/impls.rs
+++ b/serde/src/ser/impls.rs
@@ -69,6 +69,15 @@ impl Serialize for String {
}
}
+impl<'a> Serialize for fmt::Arguments<'a> {
+ fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ serializer.collect_str(self)
+ }
+}
+
////////////////////////////////////////////////////////////////////////////////
#[cfg(feature = "std")]
| serde-rs/serde | 2018-06-27T06:31:00Z | Well... We could add an impl of [`std::fmt::Write`](https://doc.rust-lang.org/std/fmt/trait.Write.html) for all `Serializer`s. I guess the `write_str` method could just forward to `serialize_str`:
DISCLAIMER: all the code below is entirely untested and probably will not compile without some adjustments
```rust
impl<S: Serializer> std::fmt::Write for S {
#[inline]
fn write_str(&mut self, s: &str) -> std::fmt::Result {
self.serialize_str(s).map_err(|_| std::fmt::Error)
}
}
```
Although that would be a breaking change, because someone might have implemented `Write` for their serializer already.
We can still do this by adding a wrapper type for `Serializer`s that we then use inside the `Serialize` impl of `fmt::Arguments`
```rust
impl<'a> Serialize for fmt::Arguments<'a> {
fn serialize<S: Serializer>(&self, s: &mut S) -> Result<(), S::Error> {
struct Wrapper<'b, S: Serializer>(&'b mut S, Option<S::Error>);
impl<'b, S: Serializer> std::fmt::Write for Wrapper<'b, S> {
#[inline]
fn write_str(&mut self, s: &str) -> std::fmt::Result {
self.0.serialize_str(s).map_err(|err| {
assert!(self.1.is_none());
self.1 = Some(err);
std::fmt::Error
})
}
}
let mut wrapper = Wrapper(s);
match wrapper.write_fmt(*self) {
Ok(()) => Ok(()),
Err(std::fmt::Error) => Ok(wrapper.1.unwrap()),
}
}
}
```
Unfortunately this means you get a bunch of strings in the output, not sure how useful that is. What's the expected output format? A sequence of strings?
Thanks for response. I don't think serializaing this value to series of `serialize_str` is going to work, but I might be wrong.
> What's the expected output format? A sequence of strings?
In my use-case (`slog` and logging in general) `fmt::Arguments` is just a string that wasn't yet "put together" (lazy-evalution-sort-of). When logging, it's useful to take `&fmt::Arguments` because it's fast, and only if a given logging statement/value reaches logging output make a string out of it/write it out to output. So from my perspective `fmt::Arguments` == lazily evaluated `String`.
I'm toying with some API re-designs where publicly accepted types would be `&dyn serde::Serailize`, and I'm loosing `fmt::Arguments` support because `serde` doesn't support it. I need to be able to do things like `impl<T> Something for T where T : serde:Serialize`, but without `serde` having `impl Serialize for fmt::Arguments`, this can't be done due to coherency conflicts. Well, I could just do impl for each single type that serde supports, but it's not perfect.
In ideal case `Serializer` would get a `serialize_fmt` that would be much like *one* call to `serialize_str`, but serializer would be responsible for either writing it directly to its output, or to temporary string. I am not sure if this is possible, especially without breaking backward compat. Maybe adding a method like that with default impl that writes it out to `String` and calls `write_str` would be OK for non-`no_std`, and in `no_std` it could just return error/do nothing.
| 4cea81f93f12473e0ccbdad2ddecff1f7ea85402 |
1,302 | diff --git a/test_suite/tests/test_de.rs b/test_suite/tests/test_de.rs
index 6c1f3d82f..b4ca2e198 100644
--- a/test_suite/tests/test_de.rs
+++ b/test_suite/tests/test_de.rs
@@ -7,6 +7,7 @@
// except according to those terms.
#![cfg_attr(feature = "cargo-clippy", allow(decimal_literal_representation))]
+#![cfg_attr(feature = "unstable", feature(never_type))]
#[macro_use]
extern crate serde_derive;
@@ -984,6 +985,16 @@ declare_tests! {
}
}
+#[cfg(feature = "unstable")]
+declare_tests! {
+ test_never_result {
+ Ok::<u8, !>(0) => &[
+ Token::NewtypeVariant { name: "Result", variant: "Ok" },
+ Token::U8(0),
+ ],
+ }
+}
+
#[cfg(unix)]
#[test]
fn test_osstring() {
@@ -1051,6 +1062,20 @@ fn test_cstr_internal_null_end() {
);
}
+#[cfg(feature = "unstable")]
+#[test]
+fn test_never_type() {
+ assert_de_tokens_error::<!>(&[], "cannot deserialize `!`");
+
+ assert_de_tokens_error::<Result<u8, !>>(
+ &[Token::NewtypeVariant {
+ name: "Result",
+ variant: "Err",
+ }],
+ "cannot deserialize `!`",
+ );
+}
+
declare_error_tests! {
test_unknown_field<StructDenyUnknown> {
&[
diff --git a/test_suite/tests/test_ser.rs b/test_suite/tests/test_ser.rs
index 21c641a7a..0d4a35de1 100644
--- a/test_suite/tests/test_ser.rs
+++ b/test_suite/tests/test_ser.rs
@@ -6,6 +6,8 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
+#![cfg_attr(feature = "unstable", feature(never_type))]
+
#[macro_use]
extern crate serde_derive;
@@ -548,6 +550,16 @@ declare_tests! {
}
}
+#[cfg(feature = "unstable")]
+declare_tests! {
+ test_never_result {
+ Ok::<u8, !>(0) => &[
+ Token::NewtypeVariant { name: "Result", variant: "Ok" },
+ Token::U8(0),
+ ],
+ }
+}
+
#[test]
#[cfg(unix)]
fn test_cannot_serialize_paths() {
| [
"544"
] | serde-rs__serde-1302 | Impl Serialize/Deserialize for !
`Serialize` is straightforward. As for `Deserialize`, I guess it would just panic? This is useful for me when serializing and deserializing types like `Result<T, !>`.
| 1.0 | 0a71fe329c8898a28d03ddfb746707cf958c21e8 | diff --git a/serde/src/de/impls.rs b/serde/src/de/impls.rs
index 342ca3bea..579ee594e 100644
--- a/serde/src/de/impls.rs
+++ b/serde/src/de/impls.rs
@@ -49,6 +49,16 @@ impl<'de> Deserialize<'de> for () {
}
}
+#[cfg(feature = "unstable")]
+impl<'de> Deserialize<'de> for ! {
+ fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
+ where
+ D: Deserializer<'de>,
+ {
+ Err(Error::custom("cannot deserialize `!`"))
+ }
+}
+
////////////////////////////////////////////////////////////////////////////////
struct BoolVisitor;
diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs
index 104271568..ec1ed5e86 100644
--- a/serde/src/de/mod.rs
+++ b/serde/src/de/mod.rs
@@ -98,6 +98,7 @@
//! - PathBuf
//! - Range\<T\>
//! - num::NonZero*
+//! - `!` *(unstable)*
//! - **Net types**:
//! - IpAddr
//! - Ipv4Addr
diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs
index 56ed7c57f..fe097042b 100644
--- a/serde/src/de/value.rs
+++ b/serde/src/de/value.rs
@@ -176,6 +176,48 @@ where
////////////////////////////////////////////////////////////////////////////////
+/// A deserializer that cannot be instantiated.
+#[cfg(feature = "unstable")]
+pub struct NeverDeserializer<E> {
+ never: !,
+ marker: PhantomData<E>,
+}
+
+#[cfg(feature = "unstable")]
+impl<'de, E> IntoDeserializer<'de, E> for !
+where
+ E: de::Error,
+{
+ type Deserializer = NeverDeserializer<E>;
+
+ fn into_deserializer(self) -> Self::Deserializer {
+ self
+ }
+}
+
+#[cfg(feature = "unstable")]
+impl<'de, E> de::Deserializer<'de> for NeverDeserializer<E>
+where
+ E: de::Error,
+{
+ type Error = E;
+
+ fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: de::Visitor<'de>,
+ {
+ self.never
+ }
+
+ forward_to_deserialize_any! {
+ bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+ bytes byte_buf option unit unit_struct newtype_struct seq tuple
+ tuple_struct map struct enum identifier ignored_any
+ }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
macro_rules! primitive_deserializer {
($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) => {
#[doc = "A deserializer holding"]
diff --git a/serde/src/lib.rs b/serde/src/lib.rs
index 9c1535a31..148e1ac44 100644
--- a/serde/src/lib.rs
+++ b/serde/src/lib.rs
@@ -89,7 +89,7 @@
// discussion of these features please refer to this issue:
//
// https://github.com/serde-rs/serde/issues/812
-#![cfg_attr(feature = "unstable", feature(specialization))]
+#![cfg_attr(feature = "unstable", feature(specialization, never_type))]
#![cfg_attr(feature = "alloc", feature(alloc))]
#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
// Whitelisted clippy lints
diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs
index be07d061c..3a4a4efee 100644
--- a/serde/src/ser/impls.rs
+++ b/serde/src/ser/impls.rs
@@ -247,6 +247,16 @@ impl Serialize for () {
}
}
+#[cfg(feature = "unstable")]
+impl Serialize for ! {
+ fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
+ where
+ S: Serializer,
+ {
+ *self
+ }
+}
+
////////////////////////////////////////////////////////////////////////////////
macro_rules! tuple_impls {
diff --git a/serde/src/ser/mod.rs b/serde/src/ser/mod.rs
index c5c9c423c..d1d4bd7fb 100644
--- a/serde/src/ser/mod.rs
+++ b/serde/src/ser/mod.rs
@@ -93,6 +93,7 @@
//! - PathBuf
//! - Range\<T\>
//! - num::NonZero*
+//! - `!` *(unstable)*
//! - **Net types**:
//! - IpAddr
//! - Ipv4Addr
| serde-rs/serde | 2018-06-03T07:23:07Z | If we do `Deserialize for !` it should error, not panic.
Is `Result<T, !>` the only instance where you need this? Would it make more sense to specialize De/Serialize for `Result<T, !>` instead of implementing them for `!`? `Result<T, !>` is equivalent to T so we might as well serialize it the same way.
The `Result<T, !>` was actually a simplified example. My actual use case involves an error type where one variant is generic: the actual type being deserialized is `Result<T, Error<!>>`. Basically, if a user implements a service that can never return an application error, the application error is `!`, and the framework error is `Error<!>`.
That being said, it could definitely make sense to specialize the `Result<T, !>` case as well!
| 4cea81f93f12473e0ccbdad2ddecff1f7ea85402 |
1,297 | diff --git a/test_suite/tests/compile-fail/borrow/bad_lifetimes.rs b/test_suite/tests/compile-fail/borrow/bad_lifetimes.rs
index a33968f37..f2ab9de07 100644
--- a/test_suite/tests/compile-fail/borrow/bad_lifetimes.rs
+++ b/test_suite/tests/compile-fail/borrow/bad_lifetimes.rs
@@ -9,9 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: failed to parse borrowed lifetimes: "zzz"
struct Test<'a> {
- #[serde(borrow = "zzz")] //~^^ HELP: failed to parse borrowed lifetimes: "zzz"
+ #[serde(borrow = "zzz")]
s: &'a str,
}
diff --git a/test_suite/tests/compile-fail/borrow/duplicate_lifetime.rs b/test_suite/tests/compile-fail/borrow/duplicate_lifetime.rs
index 482a84118..e575e0703 100644
--- a/test_suite/tests/compile-fail/borrow/duplicate_lifetime.rs
+++ b/test_suite/tests/compile-fail/borrow/duplicate_lifetime.rs
@@ -9,9 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: duplicate borrowed lifetime `'a`
struct Test<'a> {
- #[serde(borrow = "'a + 'a")] //~^^ HELP: duplicate borrowed lifetime `'a`
+ #[serde(borrow = "'a + 'a")]
s: &'a str,
}
diff --git a/test_suite/tests/compile-fail/borrow/duplicate_variant.rs b/test_suite/tests/compile-fail/borrow/duplicate_variant.rs
index 5cc3ad3b3..07e286679 100644
--- a/test_suite/tests/compile-fail/borrow/duplicate_variant.rs
+++ b/test_suite/tests/compile-fail/borrow/duplicate_variant.rs
@@ -12,9 +12,9 @@ extern crate serde_derive;
#[derive(Deserialize)]
struct Str<'a>(&'a str);
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 15:10: 15:21: duplicate serde attribute `borrow`
enum Test<'a> {
- #[serde(borrow)] //~^^ HELP: duplicate serde attribute `borrow`
+ #[serde(borrow)]
S(#[serde(borrow)] Str<'a>)
}
diff --git a/test_suite/tests/compile-fail/borrow/empty_lifetimes.rs b/test_suite/tests/compile-fail/borrow/empty_lifetimes.rs
index 0aec052ba..a18c51770 100644
--- a/test_suite/tests/compile-fail/borrow/empty_lifetimes.rs
+++ b/test_suite/tests/compile-fail/borrow/empty_lifetimes.rs
@@ -9,9 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: at least one lifetime must be borrowed
struct Test<'a> {
- #[serde(borrow = "")] //~^^ HELP: at least one lifetime must be borrowed
+ #[serde(borrow = "")]
s: &'a str,
}
diff --git a/test_suite/tests/compile-fail/borrow/no_lifetimes.rs b/test_suite/tests/compile-fail/borrow/no_lifetimes.rs
index ca0f0409b..ee9d5fcd9 100644
--- a/test_suite/tests/compile-fail/borrow/no_lifetimes.rs
+++ b/test_suite/tests/compile-fail/borrow/no_lifetimes.rs
@@ -9,9 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: field `s` has no lifetimes to borrow
struct Test {
- #[serde(borrow)] //~^^ HELP: field `s` has no lifetimes to borrow
+ #[serde(borrow)]
s: String,
}
diff --git a/test_suite/tests/compile-fail/borrow/struct_variant.rs b/test_suite/tests/compile-fail/borrow/struct_variant.rs
index 5bab07171..b4827dec4 100644
--- a/test_suite/tests/compile-fail/borrow/struct_variant.rs
+++ b/test_suite/tests/compile-fail/borrow/struct_variant.rs
@@ -12,9 +12,9 @@ extern crate serde_derive;
#[derive(Deserialize)]
struct Str<'a>(&'a str);
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 15:10: 15:21: #[serde(borrow)] may only be used on newtype variants
enum Test<'a> {
- #[serde(borrow)] //~^^ HELP: #[serde(borrow)] may only be used on newtype variants
+ #[serde(borrow)]
S { s: Str<'a> }
}
diff --git a/test_suite/tests/compile-fail/borrow/wrong_lifetime.rs b/test_suite/tests/compile-fail/borrow/wrong_lifetime.rs
index 707cd1183..a42e90c4a 100644
--- a/test_suite/tests/compile-fail/borrow/wrong_lifetime.rs
+++ b/test_suite/tests/compile-fail/borrow/wrong_lifetime.rs
@@ -9,9 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: field `s` does not have lifetime 'b
struct Test<'a> {
- #[serde(borrow = "'b")] //~^^ HELP: field `s` does not have lifetime 'b
+ #[serde(borrow = "'b")]
s: &'a str,
}
diff --git a/test_suite/tests/compile-fail/conflict/adjacent-tag.rs b/test_suite/tests/compile-fail/conflict/adjacent-tag.rs
index 419afa4c7..c8c6fea1d 100644
--- a/test_suite/tests/compile-fail/conflict/adjacent-tag.rs
+++ b/test_suite/tests/compile-fail/conflict/adjacent-tag.rs
@@ -9,9 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: enum tags `conflict` for type and content conflict with each other
#[serde(tag = "conflict", content = "conflict")]
-//~^^ HELP: enum tags `conflict` for type and content conflict with each other
enum E {
A,
B,
diff --git a/test_suite/tests/compile-fail/conflict/flatten-newtype-struct.rs b/test_suite/tests/compile-fail/conflict/flatten-newtype-struct.rs
index 07566f8c7..bd5089abb 100644
--- a/test_suite/tests/compile-fail/conflict/flatten-newtype-struct.rs
+++ b/test_suite/tests/compile-fail/conflict/flatten-newtype-struct.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: #[serde(flatten)] cannot be used on newtype structs
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: #[serde(flatten)] cannot be used on newtype structs
struct Foo(#[serde(flatten)] HashMap<String, String>);
fn main() {}
diff --git a/test_suite/tests/compile-fail/conflict/flatten-skip-deserializing.rs b/test_suite/tests/compile-fail/conflict/flatten-skip-deserializing.rs
index 3ef4d38f4..0b10ea53b 100644
--- a/test_suite/tests/compile-fail/conflict/flatten-skip-deserializing.rs
+++ b/test_suite/tests/compile-fail/conflict/flatten-skip-deserializing.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: #[serde(flatten] can not be combined with #[serde(skip_deserializing)]
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: #[serde(flatten] can not be combined with #[serde(skip_deserializing)]
struct Foo {
#[serde(flatten, skip_deserializing)]
other: Other,
diff --git a/test_suite/tests/compile-fail/conflict/flatten-skip-serializing-if.rs b/test_suite/tests/compile-fail/conflict/flatten-skip-serializing-if.rs
index 6a5fa9d62..273902e4e 100644
--- a/test_suite/tests/compile-fail/conflict/flatten-skip-serializing-if.rs
+++ b/test_suite/tests/compile-fail/conflict/flatten-skip-serializing-if.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: #[serde(flatten] can not be combined with #[serde(skip_serializing_if = "...")]
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: #[serde(flatten] can not be combined with #[serde(skip_serializing_if = "...")]
struct Foo {
#[serde(flatten, skip_serializing_if="Option::is_none")]
other: Option<Other>,
diff --git a/test_suite/tests/compile-fail/conflict/flatten-skip-serializing.rs b/test_suite/tests/compile-fail/conflict/flatten-skip-serializing.rs
index 204f9bf31..ba6ae7a77 100644
--- a/test_suite/tests/compile-fail/conflict/flatten-skip-serializing.rs
+++ b/test_suite/tests/compile-fail/conflict/flatten-skip-serializing.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: #[serde(flatten] can not be combined with #[serde(skip_serializing)]
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: #[serde(flatten] can not be combined with #[serde(skip_serializing)]
struct Foo {
#[serde(flatten, skip_serializing)]
other: Other,
diff --git a/test_suite/tests/compile-fail/conflict/flatten-tuple-struct.rs b/test_suite/tests/compile-fail/conflict/flatten-tuple-struct.rs
index 167bdbdac..311ea37d3 100644
--- a/test_suite/tests/compile-fail/conflict/flatten-tuple-struct.rs
+++ b/test_suite/tests/compile-fail/conflict/flatten-tuple-struct.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: #[serde(flatten)] cannot be used on tuple structs
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: #[serde(flatten)] cannot be used on tuple structs
struct Foo(u32, #[serde(flatten)] HashMap<String, String>);
fn main() {}
diff --git a/test_suite/tests/compile-fail/conflict/internal-tag.rs b/test_suite/tests/compile-fail/conflict/internal-tag.rs
index 777718bc7..75941922f 100644
--- a/test_suite/tests/compile-fail/conflict/internal-tag.rs
+++ b/test_suite/tests/compile-fail/conflict/internal-tag.rs
@@ -9,9 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: variant field name `conflict` conflicts with internal tag
#[serde(tag = "conflict")]
-//~^^ HELP: variant field name `conflict` conflicts with internal tag
enum E {
A {
#[serde(rename = "conflict")]
diff --git a/test_suite/tests/compile-fail/default-attribute/enum.rs b/test_suite/tests/compile-fail/default-attribute/enum.rs
index 7b0649bbc..989519a0e 100644
--- a/test_suite/tests/compile-fail/default-attribute/enum.rs
+++ b/test_suite/tests/compile-fail/default-attribute/enum.rs
@@ -9,8 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-#[serde(default)] //~^ HELP: #[serde(default)] can only be used on structs
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: #[serde(default)] can only be used on structs with named fields
+#[serde(default)]
enum E {
S { f: u8 },
}
diff --git a/test_suite/tests/compile-fail/default-attribute/nameless_struct_fields.rs b/test_suite/tests/compile-fail/default-attribute/nameless_struct_fields.rs
index 83aec668a..cff48b5c6 100644
--- a/test_suite/tests/compile-fail/default-attribute/nameless_struct_fields.rs
+++ b/test_suite/tests/compile-fail/default-attribute/nameless_struct_fields.rs
@@ -9,8 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-#[serde(default)] //~^ HELP: #[serde(default)] can only be used on structs
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: #[serde(default)] can only be used on structs with named fields
+#[serde(default)]
struct T(u8, u8);
fn main() { }
diff --git a/test_suite/tests/compile-fail/duplicate-attribute/rename-and-ser.rs b/test_suite/tests/compile-fail/duplicate-attribute/rename-and-ser.rs
index cc94685c8..ac34d5cbd 100644
--- a/test_suite/tests/compile-fail/duplicate-attribute/rename-and-ser.rs
+++ b/test_suite/tests/compile-fail/duplicate-attribute/rename-and-ser.rs
@@ -9,9 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: unknown serde field attribute `serialize`
struct S {
- #[serde(rename="x", serialize="y")] //~^^ HELP: unknown serde field attribute `serialize`
+ #[serde(rename="x", serialize="y")]
x: (),
}
diff --git a/test_suite/tests/compile-fail/duplicate-attribute/rename-rename-de.rs b/test_suite/tests/compile-fail/duplicate-attribute/rename-rename-de.rs
index 9b02357ab..039b46ca3 100644
--- a/test_suite/tests/compile-fail/duplicate-attribute/rename-rename-de.rs
+++ b/test_suite/tests/compile-fail/duplicate-attribute/rename-rename-de.rs
@@ -9,10 +9,10 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: duplicate serde attribute `rename`
struct S {
#[serde(rename="x")]
- #[serde(rename(deserialize="y"))] //~^^^ HELP: duplicate serde attribute `rename`
+ #[serde(rename(deserialize="y"))]
x: (),
}
diff --git a/test_suite/tests/compile-fail/duplicate-attribute/rename-ser-rename-ser.rs b/test_suite/tests/compile-fail/duplicate-attribute/rename-ser-rename-ser.rs
index b84344138..08efbe5fd 100644
--- a/test_suite/tests/compile-fail/duplicate-attribute/rename-ser-rename-ser.rs
+++ b/test_suite/tests/compile-fail/duplicate-attribute/rename-ser-rename-ser.rs
@@ -9,9 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: duplicate serde attribute `rename`
struct S {
- #[serde(rename(serialize="x"), rename(serialize="y"))] //~^^ HELP: duplicate serde attribute `rename`
+ #[serde(rename(serialize="x"), rename(serialize="y"))]
x: (),
}
diff --git a/test_suite/tests/compile-fail/duplicate-attribute/rename-ser-rename.rs b/test_suite/tests/compile-fail/duplicate-attribute/rename-ser-rename.rs
index 8aee51312..9e4b32d73 100644
--- a/test_suite/tests/compile-fail/duplicate-attribute/rename-ser-rename.rs
+++ b/test_suite/tests/compile-fail/duplicate-attribute/rename-ser-rename.rs
@@ -9,10 +9,10 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: duplicate serde attribute `rename`
struct S {
#[serde(rename(serialize="x"))]
- #[serde(rename="y")] //~^^^ HELP: duplicate serde attribute `rename`
+ #[serde(rename="y")]
x: (),
}
diff --git a/test_suite/tests/compile-fail/duplicate-attribute/rename-ser-ser.rs b/test_suite/tests/compile-fail/duplicate-attribute/rename-ser-ser.rs
index 25c50fa2a..57d595d17 100644
--- a/test_suite/tests/compile-fail/duplicate-attribute/rename-ser-ser.rs
+++ b/test_suite/tests/compile-fail/duplicate-attribute/rename-ser-ser.rs
@@ -9,9 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: duplicate serde attribute `rename`
struct S {
- #[serde(rename(serialize="x", serialize="y"))] //~^^ HELP: duplicate serde attribute `rename`
+ #[serde(rename(serialize="x", serialize="y"))]
x: (),
}
diff --git a/test_suite/tests/compile-fail/duplicate-attribute/two-rename-ser.rs b/test_suite/tests/compile-fail/duplicate-attribute/two-rename-ser.rs
index 96a657323..313877b39 100644
--- a/test_suite/tests/compile-fail/duplicate-attribute/two-rename-ser.rs
+++ b/test_suite/tests/compile-fail/duplicate-attribute/two-rename-ser.rs
@@ -9,10 +9,10 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: duplicate serde attribute `rename`
struct S {
#[serde(rename(serialize="x"))]
- #[serde(rename(serialize="y"))] //~^^^ HELP: duplicate serde attribute `rename`
+ #[serde(rename(serialize="y"))]
x: (),
}
diff --git a/test_suite/tests/compile-fail/duplicate-attribute/with-and-serialize-with.rs b/test_suite/tests/compile-fail/duplicate-attribute/with-and-serialize-with.rs
index 9ca989954..a6fe4f649 100644
--- a/test_suite/tests/compile-fail/duplicate-attribute/with-and-serialize-with.rs
+++ b/test_suite/tests/compile-fail/duplicate-attribute/with-and-serialize-with.rs
@@ -9,9 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: duplicate serde attribute `serialize_with`
struct S {
- #[serde(with = "w", serialize_with = "s")] //~^^ HELP: duplicate serde attribute `serialize_with`
+ #[serde(with = "w", serialize_with = "s")]
x: (),
}
diff --git a/test_suite/tests/compile-fail/enum-representation/internal-tuple-variant.rs b/test_suite/tests/compile-fail/enum-representation/internal-tuple-variant.rs
index 6b02bfd04..45b4f3d5b 100644
--- a/test_suite/tests/compile-fail/enum-representation/internal-tuple-variant.rs
+++ b/test_suite/tests/compile-fail/enum-representation/internal-tuple-variant.rs
@@ -9,8 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-#[serde(tag = "type")] //~^ HELP: #[serde(tag = "...")] cannot be used with tuple variants
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: #[serde(tag = "...")] cannot be used with tuple variants
+#[serde(tag = "type")]
enum E {
Tuple(u8, u8),
}
diff --git a/test_suite/tests/compile-fail/enum-representation/internally-tagged-struct.rs b/test_suite/tests/compile-fail/enum-representation/internally-tagged-struct.rs
index 31615ff6a..f88a46830 100644
--- a/test_suite/tests/compile-fail/enum-representation/internally-tagged-struct.rs
+++ b/test_suite/tests/compile-fail/enum-representation/internally-tagged-struct.rs
@@ -9,8 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-#[serde(tag = "type")] //~^ HELP: #[serde(tag = "...")] can only be used on enums
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: #[serde(tag = "...")] can only be used on enums
+#[serde(tag = "type")]
struct S;
fn main() {}
diff --git a/test_suite/tests/compile-fail/enum-representation/untagged-and-internal.rs b/test_suite/tests/compile-fail/enum-representation/untagged-and-internal.rs
index 4edbf0043..c7d419923 100644
--- a/test_suite/tests/compile-fail/enum-representation/untagged-and-internal.rs
+++ b/test_suite/tests/compile-fail/enum-representation/untagged-and-internal.rs
@@ -9,9 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: enum cannot be both untagged and internally tagged
#[serde(untagged)]
-#[serde(tag = "type")] //~^^ HELP: enum cannot be both untagged and internally tagged
+#[serde(tag = "type")]
enum E {
A(u8),
B(String),
diff --git a/test_suite/tests/compile-fail/enum-representation/untagged-struct.rs b/test_suite/tests/compile-fail/enum-representation/untagged-struct.rs
index 3546748e2..784d0691a 100644
--- a/test_suite/tests/compile-fail/enum-representation/untagged-struct.rs
+++ b/test_suite/tests/compile-fail/enum-representation/untagged-struct.rs
@@ -9,8 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-#[serde(untagged)] //~^ HELP: #[serde(untagged)] can only be used on enums
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: #[serde(untagged)] can only be used on enums
+#[serde(untagged)]
struct S;
fn main() {}
diff --git a/test_suite/tests/compile-fail/identifier/both.rs b/test_suite/tests/compile-fail/identifier/both.rs
index 13a8d9175..c7b75f84d 100644
--- a/test_suite/tests/compile-fail/identifier/both.rs
+++ b/test_suite/tests/compile-fail/identifier/both.rs
@@ -9,8 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-#[serde(field_identifier, variant_identifier)] //~^ HELP: `field_identifier` and `variant_identifier` cannot both be set
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: `field_identifier` and `variant_identifier` cannot both be set
+#[serde(field_identifier, variant_identifier)]
enum F {
A,
B,
diff --git a/test_suite/tests/compile-fail/identifier/field_struct.rs b/test_suite/tests/compile-fail/identifier/field_struct.rs
index 79b380d94..dddcf1706 100644
--- a/test_suite/tests/compile-fail/identifier/field_struct.rs
+++ b/test_suite/tests/compile-fail/identifier/field_struct.rs
@@ -9,8 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: `field_identifier` can only be used on an enum
#[serde(field_identifier)]
-struct S; //~^^ HELP: `field_identifier` can only be used on an enum
+struct S;
fn main() {}
diff --git a/test_suite/tests/compile-fail/identifier/field_tuple.rs b/test_suite/tests/compile-fail/identifier/field_tuple.rs
index 7b26885d2..b55925a78 100644
--- a/test_suite/tests/compile-fail/identifier/field_tuple.rs
+++ b/test_suite/tests/compile-fail/identifier/field_tuple.rs
@@ -9,11 +9,11 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: field_identifier may only contain unit variants
#[serde(field_identifier)]
enum F {
A,
- B(u8, u8), //~^^^^ HELP: field_identifier may only contain unit variants
+ B(u8, u8),
}
fn main() {}
diff --git a/test_suite/tests/compile-fail/identifier/newtype_not_last.rs b/test_suite/tests/compile-fail/identifier/newtype_not_last.rs
index f601be3e8..71d8ac3e8 100644
--- a/test_suite/tests/compile-fail/identifier/newtype_not_last.rs
+++ b/test_suite/tests/compile-fail/identifier/newtype_not_last.rs
@@ -9,11 +9,11 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: `Other` must be the last variant
#[serde(field_identifier)]
enum F {
A,
- Other(String), //~^^^^ HELP: `Other` must be the last variant
+ Other(String),
B,
}
diff --git a/test_suite/tests/compile-fail/identifier/not_identifier.rs b/test_suite/tests/compile-fail/identifier/not_identifier.rs
index 3dd6d65f9..3bc961750 100644
--- a/test_suite/tests/compile-fail/identifier/not_identifier.rs
+++ b/test_suite/tests/compile-fail/identifier/not_identifier.rs
@@ -9,10 +9,10 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: #[serde(other)] may only be used inside a field_identifier
enum F {
A,
- #[serde(other)] //~^^^ HELP: #[serde(other)] may only be used inside a field_identifier
+ #[serde(other)]
B,
}
diff --git a/test_suite/tests/compile-fail/identifier/not_unit.rs b/test_suite/tests/compile-fail/identifier/not_unit.rs
index dfc65df2a..e94a05921 100644
--- a/test_suite/tests/compile-fail/identifier/not_unit.rs
+++ b/test_suite/tests/compile-fail/identifier/not_unit.rs
@@ -9,11 +9,11 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: #[serde(other)] must be on a unit variant
#[serde(field_identifier)]
enum F {
A,
- #[serde(other)] //~^^^^ HELP: #[serde(other)] must be on a unit variant
+ #[serde(other)]
Other(u8, u8),
}
diff --git a/test_suite/tests/compile-fail/identifier/other_not_last.rs b/test_suite/tests/compile-fail/identifier/other_not_last.rs
index 481f47645..31e2675bf 100644
--- a/test_suite/tests/compile-fail/identifier/other_not_last.rs
+++ b/test_suite/tests/compile-fail/identifier/other_not_last.rs
@@ -9,11 +9,11 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: #[serde(other)] must be the last variant
#[serde(field_identifier)]
enum F {
A,
- #[serde(other)] //~^^^^ HELP: #[serde(other)] must be the last variant
+ #[serde(other)]
Other,
B,
}
diff --git a/test_suite/tests/compile-fail/identifier/serialize.rs b/test_suite/tests/compile-fail/identifier/serialize.rs
index 1c928b3f8..33e7eb759 100644
--- a/test_suite/tests/compile-fail/identifier/serialize.rs
+++ b/test_suite/tests/compile-fail/identifier/serialize.rs
@@ -9,8 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-#[serde(field_identifier)] //~^ HELP: field identifiers cannot be serialized
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: field identifiers cannot be serialized
+#[serde(field_identifier)]
enum F {
A,
B,
diff --git a/test_suite/tests/compile-fail/identifier/variant_struct.rs b/test_suite/tests/compile-fail/identifier/variant_struct.rs
index aeb37f9a5..b14edebd7 100644
--- a/test_suite/tests/compile-fail/identifier/variant_struct.rs
+++ b/test_suite/tests/compile-fail/identifier/variant_struct.rs
@@ -9,8 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: `variant_identifier` can only be used on an enum
#[serde(variant_identifier)]
-struct S; //~^^ HELP: `variant_identifier` can only be used on an enum
+struct S;
fn main() {}
diff --git a/test_suite/tests/compile-fail/identifier/variant_tuple.rs b/test_suite/tests/compile-fail/identifier/variant_tuple.rs
index 9ea2ee2ec..597df1720 100644
--- a/test_suite/tests/compile-fail/identifier/variant_tuple.rs
+++ b/test_suite/tests/compile-fail/identifier/variant_tuple.rs
@@ -9,11 +9,11 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: variant_identifier may only contain unit variants
#[serde(variant_identifier)]
enum F {
A,
- B(u8, u8), //~^^^^ HELP: variant_identifier may only contain unit variants
+ B(u8, u8),
}
fn main() {}
diff --git a/test_suite/tests/compile-fail/precondition/deserialize_de_lifetime.rs b/test_suite/tests/compile-fail/precondition/deserialize_de_lifetime.rs
index 4ab2f6a3b..19ecdbaad 100644
--- a/test_suite/tests/compile-fail/precondition/deserialize_de_lifetime.rs
+++ b/test_suite/tests/compile-fail/precondition/deserialize_de_lifetime.rs
@@ -9,7 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: cannot deserialize when there is a lifetime parameter called 'de
struct S<'de> {
- s: &'de str, //~^^ HELP: cannot deserialize when there is a lifetime parameter called 'de
+ s: &'de str,
}
diff --git a/test_suite/tests/compile-fail/precondition/deserialize_dst.rs b/test_suite/tests/compile-fail/precondition/deserialize_dst.rs
index 243b998d7..ed12a0012 100644
--- a/test_suite/tests/compile-fail/precondition/deserialize_dst.rs
+++ b/test_suite/tests/compile-fail/precondition/deserialize_dst.rs
@@ -9,8 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: cannot deserialize a dynamically sized struct
struct S {
string: String,
- slice: [u8], //~^^^ HELP: cannot deserialize a dynamically sized struct
+ slice: [u8],
}
diff --git a/test_suite/tests/compile-fail/remote/bad_getter.rs b/test_suite/tests/compile-fail/remote/bad_getter.rs
index 7b01c9cfa..3d62d4b4e 100644
--- a/test_suite/tests/compile-fail/remote/bad_getter.rs
+++ b/test_suite/tests/compile-fail/remote/bad_getter.rs
@@ -15,10 +15,10 @@ mod remote {
}
}
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 18:10: 18:19: failed to parse path: "~~~"
#[serde(remote = "remote::S")]
struct S {
- #[serde(getter = "~~~")] //~^^^ HELP: failed to parse path: "~~~"
+ #[serde(getter = "~~~")]
a: u8,
}
diff --git a/test_suite/tests/compile-fail/remote/bad_remote.rs b/test_suite/tests/compile-fail/remote/bad_remote.rs
index a81627dbe..6fca32f85 100644
--- a/test_suite/tests/compile-fail/remote/bad_remote.rs
+++ b/test_suite/tests/compile-fail/remote/bad_remote.rs
@@ -15,8 +15,8 @@ mod remote {
}
}
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-#[serde(remote = "~~~")] //~^ HELP: failed to parse path: "~~~"
+#[derive(Serialize)] //~ ERROR: 18:10: 18:19: failed to parse path: "~~~"
+#[serde(remote = "~~~")]
struct S {
a: u8,
}
diff --git a/test_suite/tests/compile-fail/remote/enum_getter.rs b/test_suite/tests/compile-fail/remote/enum_getter.rs
index 016cfc031..603badce3 100644
--- a/test_suite/tests/compile-fail/remote/enum_getter.rs
+++ b/test_suite/tests/compile-fail/remote/enum_getter.rs
@@ -15,11 +15,11 @@ mod remote {
}
}
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 18:10: 18:19: #[serde(getter = "...")] is not allowed in an enum
#[serde(remote = "remote::E")]
pub enum E {
A {
- #[serde(getter = "get_a")] //~^^^^ HELP: #[serde(getter = "...")] is not allowed in an enum
+ #[serde(getter = "get_a")]
a: u8,
}
}
diff --git a/test_suite/tests/compile-fail/remote/nonremote_getter.rs b/test_suite/tests/compile-fail/remote/nonremote_getter.rs
index ce7539bef..fbd26ad6a 100644
--- a/test_suite/tests/compile-fail/remote/nonremote_getter.rs
+++ b/test_suite/tests/compile-fail/remote/nonremote_getter.rs
@@ -9,9 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: #[serde(getter = "...")] can only be used in structs that have #[serde(remote = "...")]
struct S {
- #[serde(getter = "S::get")] //~^^ HELP: #[serde(getter = "...")] can only be used in structs that have #[serde(remote = "...")]
+ #[serde(getter = "S::get")]
a: u8,
}
diff --git a/test_suite/tests/compile-fail/transparent/at_most_one.rs b/test_suite/tests/compile-fail/transparent/at_most_one.rs
index d5b7dae89..bade8ce8f 100644
--- a/test_suite/tests/compile-fail/transparent/at_most_one.rs
+++ b/test_suite/tests/compile-fail/transparent/at_most_one.rs
@@ -9,10 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: #[serde(transparent)] requires struct to have at most one transparent field
#[serde(transparent)]
struct S {
- //~^^^ HELP: #[serde(transparent)] requires struct to have at most one transparent field
a: u8,
b: u8,
}
diff --git a/test_suite/tests/compile-fail/transparent/de_at_least_one.rs b/test_suite/tests/compile-fail/transparent/de_at_least_one.rs
index a1abe4746..3de299249 100644
--- a/test_suite/tests/compile-fail/transparent/de_at_least_one.rs
+++ b/test_suite/tests/compile-fail/transparent/de_at_least_one.rs
@@ -9,10 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: #[serde(transparent)] requires at least one field that is neither skipped nor has a default
#[serde(transparent)]
struct S {
- //~^^^ HELP: #[serde(transparent)] requires at least one field that is neither skipped nor has a default
#[serde(skip)]
a: u8,
#[serde(default)]
diff --git a/test_suite/tests/compile-fail/transparent/ser_at_least_one.rs b/test_suite/tests/compile-fail/transparent/ser_at_least_one.rs
index 19dd59c17..b13b1ee43 100644
--- a/test_suite/tests/compile-fail/transparent/ser_at_least_one.rs
+++ b/test_suite/tests/compile-fail/transparent/ser_at_least_one.rs
@@ -9,10 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: #[serde(transparent)] requires at least one field that is not skipped
#[serde(transparent)]
struct S {
- //~^^^ HELP: #[serde(transparent)] requires at least one field that is not skipped
#[serde(skip)]
a: u8,
}
diff --git a/test_suite/tests/compile-fail/type-attribute/from.rs b/test_suite/tests/compile-fail/type-attribute/from.rs
index 72e0f1de3..550d0973b 100644
--- a/test_suite/tests/compile-fail/type-attribute/from.rs
+++ b/test_suite/tests/compile-fail/type-attribute/from.rs
@@ -9,8 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-#[serde(from = "Option<T")] //~^ HELP: failed to parse type: from = "Option<T"
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: failed to parse type: from = "Option<T"
+#[serde(from = "Option<T")]
enum TestOne {
Testing,
One,
diff --git a/test_suite/tests/compile-fail/type-attribute/into.rs b/test_suite/tests/compile-fail/type-attribute/into.rs
index 8f6de4d42..f1b2ae577 100644
--- a/test_suite/tests/compile-fail/type-attribute/into.rs
+++ b/test_suite/tests/compile-fail/type-attribute/into.rs
@@ -9,8 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-#[serde(into = "Option<T")] //~^ HELP: failed to parse type: into = "Option<T"
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: failed to parse type: into = "Option<T"
+#[serde(into = "Option<T")]
enum TestOne {
Testing,
One,
diff --git a/test_suite/tests/compile-fail/unknown-attribute/container.rs b/test_suite/tests/compile-fail/unknown-attribute/container.rs
index c60c99c1f..dfce43aab 100644
--- a/test_suite/tests/compile-fail/unknown-attribute/container.rs
+++ b/test_suite/tests/compile-fail/unknown-attribute/container.rs
@@ -9,8 +9,8 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-#[serde(abc="xyz")] //~^ HELP: unknown serde container attribute `abc`
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: unknown serde container attribute `abc`
+#[serde(abc="xyz")]
struct A {
x: u32,
}
diff --git a/test_suite/tests/compile-fail/unknown-attribute/field.rs b/test_suite/tests/compile-fail/unknown-attribute/field.rs
index 66c3a0a80..e4e96cbc8 100644
--- a/test_suite/tests/compile-fail/unknown-attribute/field.rs
+++ b/test_suite/tests/compile-fail/unknown-attribute/field.rs
@@ -9,9 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: unknown serde field attribute `abc`
struct C {
- #[serde(abc="xyz")] //~^^ HELP: unknown serde field attribute `abc`
+ #[serde(abc="xyz")]
x: u32,
}
diff --git a/test_suite/tests/compile-fail/unknown-attribute/variant.rs b/test_suite/tests/compile-fail/unknown-attribute/variant.rs
index 0cfac6275..9d179b205 100644
--- a/test_suite/tests/compile-fail/unknown-attribute/variant.rs
+++ b/test_suite/tests/compile-fail/unknown-attribute/variant.rs
@@ -9,9 +9,9 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: unknown serde variant attribute `abc`
enum E {
- #[serde(abc="xyz")] //~^^ HELP: unknown serde variant attribute `abc`
+ #[serde(abc="xyz")]
V,
}
diff --git a/test_suite/tests/compile-fail/with-variant/skip_de_newtype_field.rs b/test_suite/tests/compile-fail/with-variant/skip_de_newtype_field.rs
index b198f9af3..f783ca8bc 100644
--- a/test_suite/tests/compile-fail/with-variant/skip_de_newtype_field.rs
+++ b/test_suite/tests/compile-fail/with-variant/skip_de_newtype_field.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Newtype` cannot have both #[serde(deserialize_with)] and a field 0 marked with #[serde(skip_deserializing)]
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: variant `Newtype` cannot have both #[serde(deserialize_with)] and a field 0 marked with #[serde(skip_deserializing)]
enum Enum {
#[serde(deserialize_with = "deserialize_some_newtype_variant")]
Newtype(#[serde(skip_deserializing)] String),
diff --git a/test_suite/tests/compile-fail/with-variant/skip_de_struct_field.rs b/test_suite/tests/compile-fail/with-variant/skip_de_struct_field.rs
index 248389c94..eb96456f4 100644
--- a/test_suite/tests/compile-fail/with-variant/skip_de_struct_field.rs
+++ b/test_suite/tests/compile-fail/with-variant/skip_de_struct_field.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Struct` cannot have both #[serde(deserialize_with)] and a field `f1` marked with #[serde(skip_deserializing)]
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: variant `Struct` cannot have both #[serde(deserialize_with)] and a field `f1` marked with #[serde(skip_deserializing)]
enum Enum {
#[serde(deserialize_with = "deserialize_some_other_variant")]
Struct {
diff --git a/test_suite/tests/compile-fail/with-variant/skip_de_tuple_field.rs b/test_suite/tests/compile-fail/with-variant/skip_de_tuple_field.rs
index 7bdeddc45..5b5408d58 100644
--- a/test_suite/tests/compile-fail/with-variant/skip_de_tuple_field.rs
+++ b/test_suite/tests/compile-fail/with-variant/skip_de_tuple_field.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Tuple` cannot have both #[serde(deserialize_with)] and a field 0 marked with #[serde(skip_deserializing)]
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: variant `Tuple` cannot have both #[serde(deserialize_with)] and a field 0 marked with #[serde(skip_deserializing)]
enum Enum {
#[serde(deserialize_with = "deserialize_some_other_variant")]
Tuple(#[serde(skip_deserializing)] String, u8),
diff --git a/test_suite/tests/compile-fail/with-variant/skip_de_whole_variant.rs b/test_suite/tests/compile-fail/with-variant/skip_de_whole_variant.rs
index 2bf2b016c..d70b36a86 100644
--- a/test_suite/tests/compile-fail/with-variant/skip_de_whole_variant.rs
+++ b/test_suite/tests/compile-fail/with-variant/skip_de_whole_variant.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Unit` cannot have both #[serde(deserialize_with)] and #[serde(skip_deserializing)]
+#[derive(Deserialize)] //~ ERROR: 12:10: 12:21: variant `Unit` cannot have both #[serde(deserialize_with)] and #[serde(skip_deserializing)]
enum Enum {
#[serde(deserialize_with = "deserialize_some_unit_variant")]
#[serde(skip_deserializing)]
diff --git a/test_suite/tests/compile-fail/with-variant/skip_ser_newtype_field.rs b/test_suite/tests/compile-fail/with-variant/skip_ser_newtype_field.rs
index 58e4b1b10..fbebcc842 100644
--- a/test_suite/tests/compile-fail/with-variant/skip_ser_newtype_field.rs
+++ b/test_suite/tests/compile-fail/with-variant/skip_ser_newtype_field.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Newtype` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing)]
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: variant `Newtype` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing)]
enum Enum {
#[serde(serialize_with = "serialize_some_newtype_variant")]
Newtype(#[serde(skip_serializing)] String),
diff --git a/test_suite/tests/compile-fail/with-variant/skip_ser_newtype_field_if.rs b/test_suite/tests/compile-fail/with-variant/skip_ser_newtype_field_if.rs
index 61c3112f7..d46d2ccda 100644
--- a/test_suite/tests/compile-fail/with-variant/skip_ser_newtype_field_if.rs
+++ b/test_suite/tests/compile-fail/with-variant/skip_ser_newtype_field_if.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Newtype` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing_if)]
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: variant `Newtype` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing_if)]
enum Enum {
#[serde(serialize_with = "serialize_some_newtype_variant")]
Newtype(#[serde(skip_serializing_if = "always")] String),
diff --git a/test_suite/tests/compile-fail/with-variant/skip_ser_struct_field.rs b/test_suite/tests/compile-fail/with-variant/skip_ser_struct_field.rs
index 0149553cf..29997d052 100644
--- a/test_suite/tests/compile-fail/with-variant/skip_ser_struct_field.rs
+++ b/test_suite/tests/compile-fail/with-variant/skip_ser_struct_field.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Struct` cannot have both #[serde(serialize_with)] and a field `f1` marked with #[serde(skip_serializing)]
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: variant `Struct` cannot have both #[serde(serialize_with)] and a field `f1` marked with #[serde(skip_serializing)]
enum Enum {
#[serde(serialize_with = "serialize_some_other_variant")]
Struct {
diff --git a/test_suite/tests/compile-fail/with-variant/skip_ser_struct_field_if.rs b/test_suite/tests/compile-fail/with-variant/skip_ser_struct_field_if.rs
index 5f94ff83d..6a2a58bce 100644
--- a/test_suite/tests/compile-fail/with-variant/skip_ser_struct_field_if.rs
+++ b/test_suite/tests/compile-fail/with-variant/skip_ser_struct_field_if.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Struct` cannot have both #[serde(serialize_with)] and a field `f1` marked with #[serde(skip_serializing_if)]
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: variant `Struct` cannot have both #[serde(serialize_with)] and a field `f1` marked with #[serde(skip_serializing_if)]
enum Enum {
#[serde(serialize_with = "serialize_some_newtype_variant")]
Struct {
diff --git a/test_suite/tests/compile-fail/with-variant/skip_ser_tuple_field.rs b/test_suite/tests/compile-fail/with-variant/skip_ser_tuple_field.rs
index 51e2ce87e..eaf318ac0 100644
--- a/test_suite/tests/compile-fail/with-variant/skip_ser_tuple_field.rs
+++ b/test_suite/tests/compile-fail/with-variant/skip_ser_tuple_field.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Tuple` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing)]
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: variant `Tuple` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing)]
enum Enum {
#[serde(serialize_with = "serialize_some_other_variant")]
Tuple(#[serde(skip_serializing)] String, u8),
diff --git a/test_suite/tests/compile-fail/with-variant/skip_ser_tuple_field_if.rs b/test_suite/tests/compile-fail/with-variant/skip_ser_tuple_field_if.rs
index efd2e11e7..cae191a58 100644
--- a/test_suite/tests/compile-fail/with-variant/skip_ser_tuple_field_if.rs
+++ b/test_suite/tests/compile-fail/with-variant/skip_ser_tuple_field_if.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Tuple` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing_if)]
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: variant `Tuple` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing_if)]
enum Enum {
#[serde(serialize_with = "serialize_some_other_variant")]
Tuple(#[serde(skip_serializing_if = "always")] String, u8),
diff --git a/test_suite/tests/compile-fail/with-variant/skip_ser_whole_variant.rs b/test_suite/tests/compile-fail/with-variant/skip_ser_whole_variant.rs
index 0446770e8..55c5d27dc 100644
--- a/test_suite/tests/compile-fail/with-variant/skip_ser_whole_variant.rs
+++ b/test_suite/tests/compile-fail/with-variant/skip_ser_whole_variant.rs
@@ -9,8 +9,7 @@
#[macro_use]
extern crate serde_derive;
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Unit` cannot have both #[serde(serialize_with)] and #[serde(skip_serializing)]
+#[derive(Serialize)] //~ ERROR: 12:10: 12:19: variant `Unit` cannot have both #[serde(serialize_with)] and #[serde(skip_serializing)]
enum Enum {
#[serde(serialize_with = "serialize_some_unit_variant")]
#[serde(skip_serializing)]
| [
"1168"
] | serde-rs__serde-1297 | Use compile_error macro to report invalid attribute errors
Currently we use [`Ctxt`](https://github.com/serde-rs/serde/blob/v1.0.27/serde_derive_internals/src/ctxt.rs) in `serde_derive_internals` to batch up errors detected during the attribute parsing step of `serde_derive`, then panic with the resulting message in [`derive_serialize` and `derive_deserialize`](https://github.com/serde-rs/serde/blob/v1.0.27/serde_derive/src/lib.rs).
```rust
#[derive(Serialize)]
struct S {
#[serde(typo, with = 1)]
field: String,
}
```
```
error: proc-macro derive panicked
--> src/main.rs:4:10
|
4 | #[derive(Serialize)]
| ^^^^^^^^^
|
= help: message: 2 errors:
# unknown serde field attribute `typo`
# expected serde with attribute to be a string: `with = "..."`
```
It would be better to use [`std::compile_error!`](https://doc.rust-lang.org/std/macro.compile_error.html) instead of a panic. The resulting user-visible error message can be rendered more nicely.
The `compile_error!` macro was stabilized in Rust 1.20 and we currently support older Rust versions than that, but it would not be a breaking change to begin using `compile_error!` and I am comfortable doing so. In the worst case somebody's code failed to compile before the change and then fails to compile a slightly different way after the change.
| 1.0 | dbaf2893e32a72f9564757b0f95bf9f7869bd900 | diff --git a/serde_derive/src/lib.rs b/serde_derive/src/lib.rs
index 708f3bf46..65886bf1e 100644
--- a/serde_derive/src/lib.rs
+++ b/serde_derive/src/lib.rs
@@ -53,6 +53,7 @@ extern crate proc_macro2;
mod internals;
+use std::str::FromStr;
use proc_macro::TokenStream;
use syn::DeriveInput;
@@ -71,7 +72,7 @@ pub fn derive_serialize(input: TokenStream) -> TokenStream {
let input: DeriveInput = syn::parse(input).unwrap();
match ser::expand_derive_serialize(&input) {
Ok(expanded) => expanded.into(),
- Err(msg) => panic!(msg),
+ Err(msg) => quote! {compile_error!(#msg);}.into(),
}
}
@@ -80,6 +81,6 @@ pub fn derive_deserialize(input: TokenStream) -> TokenStream {
let input: DeriveInput = syn::parse(input).unwrap();
match de::expand_derive_deserialize(&input) {
Ok(expanded) => expanded.into(),
- Err(msg) => panic!(msg),
+ Err(msg) => quote! {compile_error!(#msg);}.into(),
}
}
| serde-rs/serde | 2018-06-01T03:19:31Z | 4cea81f93f12473e0ccbdad2ddecff1f7ea85402 | |
1,288 | diff --git a/test_suite/tests/test_value.rs b/test_suite/tests/test_value.rs
index 80554663c..d2d9e67c0 100644
--- a/test_suite/tests/test_value.rs
+++ b/test_suite/tests/test_value.rs
@@ -32,14 +32,14 @@ fn test_integer128() {
let de_i128 = IntoDeserializer::<value::Error>::into_deserializer(1i128);
// u128 to u128
- assert_eq!(1u128, u128::deserialize(de_u128.clone()).unwrap());
+ assert_eq!(1u128, u128::deserialize(de_u128).unwrap());
// u128 to i128
- assert_eq!(1i128, i128::deserialize(de_u128.clone()).unwrap());
+ assert_eq!(1i128, i128::deserialize(de_u128).unwrap());
// i128 to u128
- assert_eq!(1u128, u128::deserialize(de_i128.clone()).unwrap());
+ assert_eq!(1u128, u128::deserialize(de_i128).unwrap());
// i128 to i128
- assert_eq!(1i128, i128::deserialize(de_i128.clone()).unwrap());
+ assert_eq!(1i128, i128::deserialize(de_i128).unwrap());
}
| [
"1287"
] | serde-rs__serde-1288 | Implement Copy for the primitive value deserializers
https://docs.serde.rs/serde/de/value/index.html
The primitive deserializers (I8Deserializer, I16Deserializer, etc) only wrap only wrap a value of their primitive type and a phantom data for the error type, so it should be fine to allow copying.
| 1.0 | cd0b2d312c00dd9763aa62062180e3fba2a74b9d | diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs
index d08bae3b2..56ed7c57f 100644
--- a/serde/src/de/value.rs
+++ b/serde/src/de/value.rs
@@ -44,6 +44,22 @@ use ser;
////////////////////////////////////////////////////////////////////////////////
+// For structs that contain a PhantomData. We do not want the trait
+// bound `E: Clone` inferred by derive(Clone).
+macro_rules! impl_copy_clone {
+ ($ty:ident $(<$lifetime:tt>)*) => {
+ impl<$($lifetime,)* E> Copy for $ty<$($lifetime,)* E> {}
+
+ impl<$($lifetime,)* E> Clone for $ty<$($lifetime,)* E> {
+ fn clone(&self) -> Self {
+ *self
+ }
+ }
+ };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
/// A minimal representation of all possible errors that can occur using the
/// `IntoDeserializer` trait.
#[derive(Clone, Debug, PartialEq)]
@@ -124,11 +140,13 @@ where
}
/// A deserializer holding a `()`.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
pub struct UnitDeserializer<E> {
marker: PhantomData<E>,
}
+impl_copy_clone!(UnitDeserializer);
+
impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E>
where
E: de::Error,
@@ -162,12 +180,14 @@ macro_rules! primitive_deserializer {
($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) => {
#[doc = "A deserializer holding"]
#[doc = $doc]
- #[derive(Clone, Debug)]
+ #[derive(Debug)]
pub struct $name<E> {
value: $ty,
marker: PhantomData<E>
}
+ impl_copy_clone!($name);
+
impl<'de, E> IntoDeserializer<'de, E> for $ty
where
E: de::Error,
@@ -224,12 +244,14 @@ serde_if_integer128! {
}
/// A deserializer holding a `u32`.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
pub struct U32Deserializer<E> {
value: u32,
marker: PhantomData<E>,
}
+impl_copy_clone!(U32Deserializer);
+
impl<'de, E> IntoDeserializer<'de, E> for u32
where
E: de::Error,
@@ -296,12 +318,14 @@ where
////////////////////////////////////////////////////////////////////////////////
/// A deserializer holding a `&str`.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
pub struct StrDeserializer<'a, E> {
value: &'a str,
marker: PhantomData<E>,
}
+impl_copy_clone!(StrDeserializer<'de>);
+
impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str
where
E: de::Error,
@@ -369,12 +393,14 @@ where
/// A deserializer holding a `&str` with a lifetime tied to another
/// deserializer.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
pub struct BorrowedStrDeserializer<'de, E> {
value: &'de str,
marker: PhantomData<E>,
}
+impl_copy_clone!(BorrowedStrDeserializer<'de>);
+
impl<'de, E> BorrowedStrDeserializer<'de, E> {
/// Create a new borrowed deserializer from the given string.
pub fn new(value: &'de str) -> BorrowedStrDeserializer<'de, E> {
@@ -438,12 +464,22 @@ where
/// A deserializer holding a `String`.
#[cfg(any(feature = "std", feature = "alloc"))]
-#[derive(Clone, Debug)]
+#[derive(Debug)]
pub struct StringDeserializer<E> {
value: String,
marker: PhantomData<E>,
}
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<E> Clone for StringDeserializer<E> {
+ fn clone(&self) -> Self {
+ StringDeserializer {
+ value: self.value.clone(),
+ marker: PhantomData,
+ }
+ }
+}
+
#[cfg(any(feature = "std", feature = "alloc"))]
impl<'de, E> IntoDeserializer<'de, E> for String
where
@@ -514,12 +550,22 @@ where
/// A deserializer holding a `Cow<str>`.
#[cfg(any(feature = "std", feature = "alloc"))]
-#[derive(Clone, Debug)]
+#[derive(Debug)]
pub struct CowStrDeserializer<'a, E> {
value: Cow<'a, str>,
marker: PhantomData<E>,
}
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, E> Clone for CowStrDeserializer<'a, E> {
+ fn clone(&self) -> Self {
+ CowStrDeserializer {
+ value: self.value.clone(),
+ marker: PhantomData,
+ }
+ }
+}
+
#[cfg(any(feature = "std", feature = "alloc"))]
impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str>
where
@@ -593,12 +639,14 @@ where
/// A deserializer holding a `&[u8]` with a lifetime tied to another
/// deserializer.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
pub struct BorrowedBytesDeserializer<'de, E> {
value: &'de [u8],
marker: PhantomData<E>,
}
+impl_copy_clone!(BorrowedBytesDeserializer<'de>);
+
impl<'de, E> BorrowedBytesDeserializer<'de, E> {
/// Create a new borrowed deserializer from the given byte slice.
pub fn new(value: &'de [u8]) -> BorrowedBytesDeserializer<'de, E> {
| serde-rs/serde | 2018-05-26T22:49:24Z | 4cea81f93f12473e0ccbdad2ddecff1f7ea85402 | |
1,286 | diff --git a/test_suite/tests/test_value.rs b/test_suite/tests/test_value.rs
index acd3ddd6c..80554663c 100644
--- a/test_suite/tests/test_value.rs
+++ b/test_suite/tests/test_value.rs
@@ -25,3 +25,21 @@ fn test_u32_to_enum() {
let e: E = E::deserialize(deserializer).unwrap();
assert_eq!(E::B, e);
}
+
+#[test]
+fn test_integer128() {
+ let de_u128 = IntoDeserializer::<value::Error>::into_deserializer(1u128);
+ let de_i128 = IntoDeserializer::<value::Error>::into_deserializer(1i128);
+
+ // u128 to u128
+ assert_eq!(1u128, u128::deserialize(de_u128.clone()).unwrap());
+
+ // u128 to i128
+ assert_eq!(1i128, i128::deserialize(de_u128.clone()).unwrap());
+
+ // i128 to u128
+ assert_eq!(1u128, u128::deserialize(de_i128.clone()).unwrap());
+
+ // i128 to i128
+ assert_eq!(1i128, i128::deserialize(de_i128.clone()).unwrap());
+}
| [
"1280"
] | serde-rs__serde-1286 | Implement IntoDeserializer for i128 and u128
| 1.0 | 7407d71417bc7a72c0a61f2c2f595db517457de9 | diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs
index 101531b3d..d08bae3b2 100644
--- a/serde/src/de/value.rs
+++ b/serde/src/de/value.rs
@@ -218,6 +218,11 @@ primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32);
primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64);
primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char);
+serde_if_integer128! {
+ primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
+ primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
+}
+
/// A deserializer holding a `u32`.
#[derive(Clone, Debug)]
pub struct U32Deserializer<E> {
| serde-rs/serde | 2018-05-26T22:22:38Z | 4cea81f93f12473e0ccbdad2ddecff1f7ea85402 | |
1,270 | diff --git a/test_suite/tests/compile-fail/transparent/at_most_one.rs b/test_suite/tests/compile-fail/transparent/at_most_one.rs
new file mode 100644
index 000000000..d5b7dae89
--- /dev/null
+++ b/test_suite/tests/compile-fail/transparent/at_most_one.rs
@@ -0,0 +1,20 @@
+// Copyright 2018 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[serde(transparent)]
+struct S {
+ //~^^^ HELP: #[serde(transparent)] requires struct to have at most one transparent field
+ a: u8,
+ b: u8,
+}
+
+fn main() {}
diff --git a/test_suite/tests/compile-fail/transparent/de_at_least_one.rs b/test_suite/tests/compile-fail/transparent/de_at_least_one.rs
new file mode 100644
index 000000000..a1abe4746
--- /dev/null
+++ b/test_suite/tests/compile-fail/transparent/de_at_least_one.rs
@@ -0,0 +1,22 @@
+// Copyright 2018 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[serde(transparent)]
+struct S {
+ //~^^^ HELP: #[serde(transparent)] requires at least one field that is neither skipped nor has a default
+ #[serde(skip)]
+ a: u8,
+ #[serde(default)]
+ b: u8,
+}
+
+fn main() {}
diff --git a/test_suite/tests/compile-fail/transparent/ser_at_least_one.rs b/test_suite/tests/compile-fail/transparent/ser_at_least_one.rs
new file mode 100644
index 000000000..19dd59c17
--- /dev/null
+++ b/test_suite/tests/compile-fail/transparent/ser_at_least_one.rs
@@ -0,0 +1,20 @@
+// Copyright 2018 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[serde(transparent)]
+struct S {
+ //~^^^ HELP: #[serde(transparent)] requires at least one field that is not skipped
+ #[serde(skip)]
+ a: u8,
+}
+
+fn main() {}
diff --git a/test_suite/tests/test_annotations.rs b/test_suite/tests/test_annotations.rs
index 5b82ad88d..aea692cba 100644
--- a/test_suite/tests/test_annotations.rs
+++ b/test_suite/tests/test_annotations.rs
@@ -15,6 +15,7 @@ extern crate serde;
use self::serde::de::{self, Unexpected};
use self::serde::{Deserialize, Deserializer, Serialize, Serializer};
use std::collections::HashMap;
+use std::marker::PhantomData;
extern crate serde_test;
use self::serde_test::{
@@ -2161,3 +2162,41 @@ fn test_flatten_option() {
&[Token::Map { len: None }, Token::MapEnd],
);
}
+
+#[test]
+fn test_transparent_struct() {
+ #[derive(Serialize, Deserialize, PartialEq, Debug)]
+ #[serde(transparent)]
+ struct Transparent {
+ #[serde(skip)]
+ a: bool,
+ b: u32,
+ #[serde(skip)]
+ c: bool,
+ d: PhantomData<()>,
+ }
+
+ assert_tokens(
+ &Transparent {
+ a: false,
+ b: 1,
+ c: false,
+ d: PhantomData,
+ },
+ &[Token::U32(1)],
+ );
+}
+
+#[test]
+fn test_transparent_tuple_struct() {
+ #[derive(Serialize, Deserialize, PartialEq, Debug)]
+ #[serde(transparent)]
+ struct Transparent(
+ #[serde(skip)] bool,
+ u32,
+ #[serde(skip)] bool,
+ PhantomData<()>,
+ );
+
+ assert_tokens(&Transparent(false, 1, false, PhantomData), &[Token::U32(1)]);
+}
diff --git a/test_suite/tests/test_gen.rs b/test_suite/tests/test_gen.rs
index ffb73210a..ef301b590 100644
--- a/test_suite/tests/test_gen.rs
+++ b/test_suite/tests/test_gen.rs
@@ -653,6 +653,14 @@ fn test_gen() {
X,
),
}
+
+ #[derive(Serialize, Deserialize)]
+ #[serde(transparent)]
+ struct TransparentWith {
+ #[serde(serialize_with = "ser_x")]
+ #[serde(deserialize_with = "de_x")]
+ x: X,
+ }
}
//////////////////////////////////////////////////////////////////////////
| [
"1054"
] | serde-rs__serde-1270 | Attribute to specify that type representation is the same as its only field
By analogy with [`#[repr(transparent)]`](https://github.com/rust-lang/rfcs/blob/master/text/1758-repr-transparent.md).
```rust
// This should serialize and deserialize directly as String, rather than as newtype.
#[derive(Serialize, Deserialize)]
#[serde(transparent)]
struct Transparent(String);
// Generated code.
impl Serialize for Transparent {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
{
self.0.serialize(serializer)
}
}
impl<'de> Deserialize<'de> for Transparent {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where D: Deserializer<'de>
{
Deserialize::deserialize(deserializer).map(Transparent)
}
}
```
Should also work for structs with one field, and structs and tuple structs with all but one skipped field.
@bluss
| 1.0 | 320897679b3bff07d2e54aa96525422237b6e832 | diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs
index 875c941a7..ad105398d 100644
--- a/serde_derive/src/de.rs
+++ b/serde_derive/src/de.rs
@@ -15,7 +15,7 @@ use syn::{self, Ident, Index, Member};
use bound;
use fragment::{Expr, Fragment, Match, Stmts};
use internals::ast::{Container, Data, Field, Style, Variant};
-use internals::{attr, Ctxt};
+use internals::{attr, Ctxt, Derive};
use pretend;
use try;
@@ -23,7 +23,7 @@ use std::collections::BTreeSet;
pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream, String> {
let ctxt = Ctxt::new();
- let cont = Container::from_ast(&ctxt, input);
+ let cont = Container::from_ast(&ctxt, input, Derive::Deserialize);
precondition(&ctxt, &cont);
try!(ctxt.check());
@@ -269,7 +269,9 @@ fn borrowed_lifetimes(cont: &Container) -> BorrowedLifetimes {
}
fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
- if let Some(type_from) = cont.attrs.type_from() {
+ if cont.attrs.transparent() {
+ deserialize_transparent(cont, params)
+ } else if let Some(type_from) = cont.attrs.type_from() {
deserialize_from(type_from)
} else if let attr::Identifier::No = cont.attrs.identifier() {
match cont.data {
@@ -298,7 +300,9 @@ fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<St
// deserialize_in_place for remote derives.
assert!(!params.has_getter);
- if cont.attrs.type_from().is_some() || cont.attrs.identifier().is_some()
+ if cont.attrs.transparent()
+ || cont.attrs.type_from().is_some()
+ || cont.attrs.identifier().is_some()
|| cont
.data
.all_fields()
@@ -344,6 +348,41 @@ fn deserialize_in_place_body(_cont: &Container, _params: &Parameters) -> Option<
None
}
+fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
+ let fields = match cont.data {
+ Data::Struct(_, ref fields) => fields,
+ Data::Enum(_) => unreachable!(),
+ };
+
+ let this = ¶ms.this;
+ let transparent_field = fields.iter().find(|f| f.attrs.transparent()).unwrap();
+
+ let path = match transparent_field.attrs.deserialize_with() {
+ Some(path) => quote!(#path),
+ None => quote!(_serde::Deserialize::deserialize),
+ };
+
+ let assign = fields.iter().map(|field| {
+ let member = &field.member;
+ if field as *const Field == transparent_field as *const Field {
+ quote!(#member: __transparent)
+ } else {
+ let value = match *field.attrs.default() {
+ attr::Default::Default => quote!(_serde::export::Default::default()),
+ attr::Default::Path(ref path) => quote!(#path()),
+ attr::Default::None => quote!(_serde::export::PhantomData),
+ };
+ quote!(#member: #value)
+ }
+ });
+
+ quote_block! {
+ _serde::export::Result::map(
+ #path(__deserializer),
+ |__transparent| #this { #(#assign),* })
+ }
+}
+
fn deserialize_from(type_from: &syn::Type) -> Fragment {
quote_block! {
_serde::export::Result::map(
diff --git a/serde_derive/src/internals/ast.rs b/serde_derive/src/internals/ast.rs
index 093910d77..ce1d3197f 100644
--- a/serde_derive/src/internals/ast.rs
+++ b/serde_derive/src/internals/ast.rs
@@ -8,7 +8,7 @@
use internals::attr;
use internals::check;
-use internals::Ctxt;
+use internals::{Ctxt, Derive};
use syn;
use syn::punctuated::Punctuated;
@@ -47,7 +47,7 @@ pub enum Style {
}
impl<'a> Container<'a> {
- pub fn from_ast(cx: &Ctxt, item: &'a syn::DeriveInput) -> Container<'a> {
+ pub fn from_ast(cx: &Ctxt, item: &'a syn::DeriveInput, derive: Derive) -> Container<'a> {
let mut attrs = attr::Container::from_ast(cx, item);
let mut data = match item.data {
@@ -86,13 +86,13 @@ impl<'a> Container<'a> {
attrs.mark_has_flatten();
}
- let item = Container {
+ let mut item = Container {
ident: item.ident.clone(),
attrs: attrs,
data: data,
generics: &item.generics,
};
- check::check(cx, &item);
+ check::check(cx, &mut item, derive);
item
}
}
diff --git a/serde_derive/src/internals/attr.rs b/serde_derive/src/internals/attr.rs
index 43c689a0a..abfb005b5 100644
--- a/serde_derive/src/internals/attr.rs
+++ b/serde_derive/src/internals/attr.rs
@@ -105,6 +105,7 @@ impl Name {
/// Represents container (e.g. struct) attribute information
pub struct Container {
name: Name,
+ transparent: bool,
deny_unknown_fields: bool,
default: Default,
rename_all: RenameRule,
@@ -181,6 +182,7 @@ impl Container {
pub fn from_ast(cx: &Ctxt, item: &syn::DeriveInput) -> Self {
let mut ser_name = Attr::none(cx, "rename");
let mut de_name = Attr::none(cx, "rename");
+ let mut transparent = BoolAttr::none(cx, "transparent");
let mut deny_unknown_fields = BoolAttr::none(cx, "deny_unknown_fields");
let mut default = Attr::none(cx, "default");
let mut rename_all = Attr::none(cx, "rename_all");
@@ -228,6 +230,11 @@ impl Container {
}
}
+ // Parse `#[serde(transparent)]`
+ Meta(Word(ref word)) if word == "transparent" => {
+ transparent.set_true();
+ }
+
// Parse `#[serde(deny_unknown_fields)]`
Meta(Word(ref word)) if word == "deny_unknown_fields" => {
deny_unknown_fields.set_true();
@@ -376,6 +383,7 @@ impl Container {
serialize: ser_name.get().unwrap_or_else(|| item.ident.to_string()),
deserialize: de_name.get().unwrap_or_else(|| item.ident.to_string()),
},
+ transparent: transparent.get(),
deny_unknown_fields: deny_unknown_fields.get(),
default: default.get().unwrap_or(Default::None),
rename_all: rename_all.get().unwrap_or(RenameRule::None),
@@ -398,6 +406,10 @@ impl Container {
&self.rename_all
}
+ pub fn transparent(&self) -> bool {
+ self.transparent
+ }
+
pub fn deny_unknown_fields(&self) -> bool {
self.deny_unknown_fields
}
@@ -764,6 +776,7 @@ pub struct Field {
borrowed_lifetimes: BTreeSet<syn::Lifetime>,
getter: Option<syn::ExprPath>,
flatten: bool,
+ transparent: bool,
}
/// Represents the default to use for a field when deserializing.
@@ -777,7 +790,6 @@ pub enum Default {
}
impl Default {
- #[cfg(feature = "deserialize_in_place")]
pub fn is_none(&self) -> bool {
match *self {
Default::None => true,
@@ -1066,6 +1078,7 @@ impl Field {
borrowed_lifetimes: borrowed_lifetimes,
getter: getter.get(),
flatten: flatten.get(),
+ transparent: false,
}
}
@@ -1125,6 +1138,14 @@ impl Field {
pub fn flatten(&self) -> bool {
self.flatten
}
+
+ pub fn transparent(&self) -> bool {
+ self.transparent
+ }
+
+ pub fn mark_transparent(&mut self) {
+ self.transparent = true;
+ }
}
type SerAndDe<T> = (Option<T>, Option<T>);
diff --git a/serde_derive/src/internals/check.rs b/serde_derive/src/internals/check.rs
index eac1c2293..0caa4b502 100644
--- a/serde_derive/src/internals/check.rs
+++ b/serde_derive/src/internals/check.rs
@@ -8,18 +8,19 @@
use internals::ast::{Container, Data, Field, Style};
use internals::attr::{EnumTag, Identifier};
-use internals::Ctxt;
-use syn::Member;
+use internals::{Ctxt, Derive};
+use syn::{Member, Type};
/// Cross-cutting checks that require looking at more than a single attrs
/// object. Simpler checks should happen when parsing and building the attrs.
-pub fn check(cx: &Ctxt, cont: &Container) {
+pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
check_getter(cx, cont);
check_flatten(cx, cont);
check_identifier(cx, cont);
check_variant_skip_attrs(cx, cont);
check_internal_tag_field_name_conflict(cx, cont);
check_adjacent_tag_conflict(cx, cont);
+ check_transparent(cx, cont, derive);
}
/// Getters are only allowed inside structs (not enums) with the `remote`
@@ -278,9 +279,75 @@ fn check_adjacent_tag_conflict(cx: &Ctxt, cont: &Container) {
}
}
+/// Enums and unit structs cannot be transparent.
+fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
+ if !cont.attrs.transparent() {
+ return;
+ }
+
+ if cont.attrs.type_from().is_some() {
+ cx.error("#[serde(transparent)] is not allowed with #[serde(from = \"...\")]");
+ }
+
+ if cont.attrs.type_into().is_some() {
+ cx.error("#[serde(transparent)] is not allowed with #[serde(into = \"...\")]");
+ }
+
+ let fields = match cont.data {
+ Data::Enum(_) => {
+ cx.error("#[serde(transparent)] is not allowed on an enum");
+ return;
+ }
+ Data::Struct(Style::Unit, _) => {
+ cx.error("#[serde(transparent)] is not allowed on a unit struct");
+ return;
+ }
+ Data::Struct(_, ref mut fields) => fields,
+ };
+
+ let mut transparent_field = None;
+
+ for field in fields {
+ if allow_transparent(field, derive) {
+ if transparent_field.is_some() {
+ cx.error("#[serde(transparent)] requires struct to have at most one transparent field");
+ return;
+ }
+ transparent_field = Some(field);
+ }
+ }
+
+ match transparent_field {
+ Some(transparent_field) => transparent_field.attrs.mark_transparent(),
+ None => match derive {
+ Derive::Serialize => {
+ cx.error("#[serde(transparent)] requires at least one field that is not skipped");
+ }
+ Derive::Deserialize => {
+ cx.error("#[serde(transparent)] requires at least one field that is neither skipped nor has a default");
+ }
+ }
+ }
+}
+
fn member_message(member: &Member) -> String {
match *member {
Member::Named(ref ident) => format!("`{}`", ident),
Member::Unnamed(ref i) => i.index.to_string(),
}
}
+
+fn allow_transparent(field: &Field, derive: Derive) -> bool {
+ if let Type::Path(ref ty) = *field.ty {
+ if let Some(seg) = ty.path.segments.last() {
+ if seg.into_value().ident == "PhantomData" {
+ return false;
+ }
+ }
+ }
+
+ match derive {
+ Derive::Serialize => !field.attrs.skip_serializing(),
+ Derive::Deserialize => !field.attrs.skip_deserializing() && field.attrs.default().is_none(),
+ }
+}
diff --git a/serde_derive/src/internals/mod.rs b/serde_derive/src/internals/mod.rs
index f68462c9e..7a39688da 100644
--- a/serde_derive/src/internals/mod.rs
+++ b/serde_derive/src/internals/mod.rs
@@ -14,3 +14,9 @@ pub use self::ctxt::Ctxt;
mod case;
mod check;
+
+#[derive(Copy, Clone)]
+pub enum Derive {
+ Serialize,
+ Deserialize,
+}
diff --git a/serde_derive/src/ser.rs b/serde_derive/src/ser.rs
index 11e5b4835..c78237bf9 100644
--- a/serde_derive/src/ser.rs
+++ b/serde_derive/src/ser.rs
@@ -13,13 +13,13 @@ use syn::{self, Ident, Index, Member};
use bound;
use fragment::{Fragment, Match, Stmts};
use internals::ast::{Container, Data, Field, Style, Variant};
-use internals::{attr, Ctxt};
+use internals::{attr, Ctxt, Derive};
use pretend;
use try;
pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream, String> {
let ctxt = Ctxt::new();
- let cont = Container::from_ast(&ctxt, input);
+ let cont = Container::from_ast(&ctxt, input, Derive::Serialize);
precondition(&ctxt, &cont);
try!(ctxt.check());
@@ -166,7 +166,9 @@ fn needs_serialize_bound(field: &attr::Field, variant: Option<&attr::Variant>) -
}
fn serialize_body(cont: &Container, params: &Parameters) -> Fragment {
- if let Some(type_into) = cont.attrs.type_into() {
+ if cont.attrs.transparent() {
+ serialize_transparent(cont, params)
+ } else if let Some(type_into) = cont.attrs.type_into() {
serialize_into(params, type_into)
} else {
match cont.data {
@@ -185,6 +187,26 @@ fn serialize_body(cont: &Container, params: &Parameters) -> Fragment {
}
}
+fn serialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
+ let fields = match cont.data {
+ Data::Struct(_, ref fields) => fields,
+ Data::Enum(_) => unreachable!(),
+ };
+
+ let self_var = ¶ms.self_var;
+ let transparent_field = fields.iter().find(|f| f.attrs.transparent()).unwrap();
+ let member = &transparent_field.member;
+
+ let path = match transparent_field.attrs.serialize_with() {
+ Some(path) => quote!(#path),
+ None => quote!(_serde::Serialize::serialize),
+ };
+
+ quote_block! {
+ #path(&#self_var.#member, __serializer)
+ }
+}
+
fn serialize_into(params: &Parameters, type_into: &syn::Type) -> Fragment {
let self_var = ¶ms.self_var;
quote_block! {
| serde-rs/serde | 2018-05-20T20:54:37Z | Can this attribute also be used to inline the fields of a struct member type into the parent struct for the purpose of (de)serialization?
Like this:
```rust
#[derive(Serialize, Deserialize)]
struct Common {
a: i32,
}
#[derive(Serialize, Deserialize)]
struct Foo {
#[serde(transparent)]
common: Common,
foo: u8,
}
#[derive(Serialize, Deserialize)]
struct Bar {
#[serde(transparent)]
common: Common,
bar: u64,
}
```
Ah, nvm, I found out that it's `#[serde(flatten)]`.. | 4cea81f93f12473e0ccbdad2ddecff1f7ea85402 |
1,269 | diff --git a/test_suite/tests/test_gen.rs b/test_suite/tests/test_gen.rs
index 7888f2d82..ffb73210a 100644
--- a/test_suite/tests/test_gen.rs
+++ b/test_suite/tests/test_gen.rs
@@ -643,6 +643,16 @@ fn test_gen() {
struct ImpliciltyBorrowedOption<'a> {
option: std::option::Option<&'a str>,
}
+
+ #[derive(Serialize, Deserialize)]
+ #[serde(untagged)]
+ enum UntaggedNewtypeVariantWith {
+ Newtype(
+ #[serde(serialize_with = "ser_x")]
+ #[serde(deserialize_with = "de_x")]
+ X,
+ ),
+ }
}
//////////////////////////////////////////////////////////////////////////
| [
"1268"
] | serde-rs__serde-1269 | serde_derive deserialize_with untagged enum regression
I still need to create a simple reproduction for the issue, and not sure if this is covered by another issue report, but effectively...
```rust
#[derive(Deserialize)]
#[serde(untagged)]
enum E {
Variant(
#[serde(deserialize_with="...")]
Ty
),
}
```
Now fails to compile with a type mismatch error where it used to work properly. Moving the attribute outside of the variant (`#[serde(deserialize_with="...")] Variant(Ty)`) seems to work on both and I believe should be equivalent and a valid workaround for now? Tested with serde_derive v1.0.29 (worked) and v1.0.57 (broken).
| 1.0 | f09320b2932972e55317bf2899f69cab038f4377 | diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs
index 40a5d1050..3cce5f071 100644
--- a/serde_derive/src/de.rs
+++ b/serde_derive/src/de.rs
@@ -1802,10 +1802,8 @@ fn deserialize_untagged_newtype_variant(
}
Some(path) => {
quote_block! {
- let __value: #field_ty = _serde::export::Result::map(
- #path(#deserializer),
- #this::#variant_ident);
- __value
+ let __value: _serde::export::Result<#field_ty, _> = #path(#deserializer);
+ _serde::export::Result::map(__value, #this::#variant_ident)
}
}
}
| serde-rs/serde | 2018-05-20T00:21:09Z | 4cea81f93f12473e0ccbdad2ddecff1f7ea85402 | |
1,256 | diff --git a/test_suite/tests/test_annotations.rs b/test_suite/tests/test_annotations.rs
index 248e42118..7aaa97d5b 100644
--- a/test_suite/tests/test_annotations.rs
+++ b/test_suite/tests/test_annotations.rs
@@ -2095,3 +2095,84 @@ fn test_flatten_untagged_enum() {
],
);
}
+
+#[test]
+fn test_flatten_option() {
+ #[derive(Serialize, Deserialize, PartialEq, Debug)]
+ struct Outer {
+ #[serde(flatten)]
+ inner1: Option<Inner1>,
+ #[serde(flatten)]
+ inner2: Option<Inner2>,
+ }
+
+ #[derive(Serialize, Deserialize, PartialEq, Debug)]
+ struct Inner1 {
+ inner1: i32,
+ }
+
+ #[derive(Serialize, Deserialize, PartialEq, Debug)]
+ struct Inner2 {
+ inner2: i32,
+ }
+
+ assert_tokens(
+ &Outer {
+ inner1: Some(Inner1 {
+ inner1: 1,
+ }),
+ inner2: Some(Inner2 {
+ inner2: 2,
+ }),
+ },
+ &[
+ Token::Map { len: None },
+ Token::Str("inner1"),
+ Token::I32(1),
+ Token::Str("inner2"),
+ Token::I32(2),
+ Token::MapEnd,
+ ],
+ );
+
+ assert_tokens(
+ &Outer {
+ inner1: Some(Inner1 {
+ inner1: 1,
+ }),
+ inner2: None,
+ },
+ &[
+ Token::Map { len: None },
+ Token::Str("inner1"),
+ Token::I32(1),
+ Token::MapEnd,
+ ],
+ );
+
+ assert_tokens(
+ &Outer {
+ inner1: None,
+ inner2: Some(Inner2 {
+ inner2: 2,
+ }),
+ },
+ &[
+ Token::Map { len: None },
+ Token::Str("inner2"),
+ Token::I32(2),
+ Token::MapEnd,
+ ],
+ );
+
+ assert_tokens(
+ &Outer {
+ inner1: None,
+ inner2: None,
+ },
+ &[
+ Token::Map { len: None },
+ Token::MapEnd,
+ ],
+ );
+}
| [
"1255"
] | serde-rs__serde-1256 | Allow flattened untagged Options in struct fields
I have a small use case for `#[serde(flatten)]` that did not work as I expected due to the intermediary presence of an `Option` type. Here's what I mean:
```
#[derive(Serialize, Deserialize)]
enum Quux {
A,
B,
C,
}
#[derive(Serialize, Deserialize)]
struct Bar {
quux: Quux,
}
#[derive(Serialize, Deserialize)]
struct Foo {
baz: i32,
#[serde(flatten)]
bar: Option<Bar>,
}
fn main() {
let f : Foo = serde_json::from_str(r#"{
"baz": 10,
"quux": "A"
}"#).unwrap(); // panics unwrapping 'Error("can only flatten structs and maps", line: 4, column: 5)'
}
```
I'm able to get around this problem by using my own untagged `Option` type.
```
#[derive(Serialize, Deserialize)]
enum Quux {
A,
B,
C,
}
#[derive(Serialize, Deserialize)]
#[serde(untagged)]
enum OptBar {
Some(Bar),
None,
}
#[derive(Serialize, Deserialize)]
struct Bar {
quux: Quux,
}
#[derive(Serialize, Deserialize)]
struct Foo {
baz: i32,
#[serde(flatten)]
bar: OptBar,
}
fn main() {
let f : Foo = serde_json::from_str(r#"{
"n": 10,
"quux": "A"
}"#).unwrap(); // returns a 'Foo { n: 10, bar: Some(Bar { quux: A }) }'
}
```
Is there any way to get around this otherwise? Continuing to use the standard `Option` type allows some more straightforward checking of `Foo.bar`, which is quite useful. Worst case scenario I can change my data representation.
| 1.0 | 35aae92b5609dc0707bea73a890ed0beb5c8cac0 | diff --git a/serde/src/de/impls.rs b/serde/src/de/impls.rs
index b13800dca..59f667ed7 100644
--- a/serde/src/de/impls.rs
+++ b/serde/src/de/impls.rs
@@ -529,6 +529,14 @@ where
{
T::deserialize(deserializer).map(Some)
}
+
+ #[doc(hidden)]
+ fn __private_visit_untagged_option<D>(self, deserializer: D) -> Result<Self::Value, ()>
+ where
+ D: Deserializer<'de>,
+ {
+ Ok(T::deserialize(deserializer).ok())
+ }
}
impl<'de, T> Deserialize<'de> for Option<T>
diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs
index 826662dfa..fbc24016e 100644
--- a/serde/src/de/mod.rs
+++ b/serde/src/de/mod.rs
@@ -1529,6 +1529,15 @@ pub trait Visitor<'de>: Sized {
let _ = data;
Err(Error::invalid_type(Unexpected::Enum, &self))
}
+
+ // Used when deserializing a flattened Option field. Not public API.
+ #[doc(hidden)]
+ fn __private_visit_untagged_option<D>(self, _: D) -> Result<Self::Value, ()>
+ where
+ D: Deserializer<'de>,
+ {
+ Err(())
+ }
}
////////////////////////////////////////////////////////////////////////////////
diff --git a/serde/src/private/de.rs b/serde/src/private/de.rs
index dcf5008f5..fab85534c 100644
--- a/serde/src/private/de.rs
+++ b/serde/src/private/de.rs
@@ -2645,10 +2645,7 @@ impl<'a, 'de, E> FlatMapDeserializer<'a, 'de, E>
where
E: Error,
{
- fn deserialize_other<V>(self, _: V) -> Result<V::Value, E>
- where
- V: Visitor<'de>,
- {
+ fn deserialize_other<V>() -> Result<V, E> {
Err(Error::custom("can only flatten structs and maps"))
}
}
@@ -2657,11 +2654,11 @@ where
macro_rules! forward_to_deserialize_other {
($($func:ident ( $($arg:ty),* ))*) => {
$(
- fn $func<V>(self, $(_: $arg,)* visitor: V) -> Result<V::Value, Self::Error>
+ fn $func<V>(self, $(_: $arg,)* _visitor: V) -> Result<V::Value, Self::Error>
where
V: Visitor<'de>,
{
- self.deserialize_other(visitor)
+ Self::deserialize_other()
}
)*
}
@@ -2741,6 +2738,16 @@ where
visitor.visit_newtype_struct(self)
}
+ fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ match visitor.__private_visit_untagged_option(self) {
+ Ok(value) => Ok(value),
+ Err(()) => Self::deserialize_other(),
+ }
+ }
+
forward_to_deserialize_other! {
deserialize_bool()
deserialize_i8()
@@ -2758,7 +2765,6 @@ where
deserialize_string()
deserialize_bytes()
deserialize_byte_buf()
- deserialize_option()
deserialize_unit()
deserialize_unit_struct(&'static str)
deserialize_seq()
diff --git a/serde/src/private/ser.rs b/serde/src/private/ser.rs
index 54bb4ce02..c21de1635 100644
--- a/serde/src/private/ser.rs
+++ b/serde/src/private/ser.rs
@@ -1122,14 +1122,14 @@ where
}
fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
- Err(self.bad_type(Unsupported::Optional))
+ Ok(())
}
- fn serialize_some<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
+ fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
where
T: Serialize,
{
- Err(self.bad_type(Unsupported::Optional))
+ value.serialize(self)
}
fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
| serde-rs/serde | 2018-05-12T05:14:42Z | 4cea81f93f12473e0ccbdad2ddecff1f7ea85402 | |
1,252 | diff --git a/test_suite/tests/compile-fail/precondition/deserialize_dst.rs b/test_suite/tests/compile-fail/precondition/deserialize_dst.rs
new file mode 100644
index 000000000..243b998d7
--- /dev/null
+++ b/test_suite/tests/compile-fail/precondition/deserialize_dst.rs
@@ -0,0 +1,16 @@
+// Copyright 2018 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+struct S {
+ string: String,
+ slice: [u8], //~^^^ HELP: cannot deserialize a dynamically sized struct
+}
| [
"830"
] | serde-rs__serde-1252 | Deserialize for dynamically sized struct generates invalid code
```rust
extern crate serde;
#[macro_use]
extern crate serde_derive;
#[derive(Deserialize)]
struct S {
last: [u8],
}
```
```
error[E0277]: the trait bound `[u8]: std::marker::Sized` is not satisfied in `S`
--> src/main.rs:6:10
|
6 | #[derive(Deserialize)]
| ^^^^^^^^^^^ within `S`, the trait `std::marker::Sized` is not implemented for `[u8]`
|
= note: `[u8]` does not have a constant size known at compile-time
= note: required because it appears within the type `S`
= note: required by `serde::Deserialize`
```
| 1.0 | 536bdd77a0725fff5ae4e55e1c4905d957c5eb94 | diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs
index 42dbe3860..b0953450b 100644
--- a/serde_derive/src/de.rs
+++ b/serde_derive/src/de.rs
@@ -15,15 +15,16 @@ use syn::{self, Ident, Index, Member};
use bound;
use fragment::{Expr, Fragment, Match, Stmts};
use internals::ast::{Container, Data, Field, Style, Variant};
-use internals::{self, attr};
+use internals::{attr, Ctxt};
use pretend;
use try;
use std::collections::BTreeSet;
pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<Tokens, String> {
- let ctxt = internals::Ctxt::new();
+ let ctxt = Ctxt::new();
let cont = Container::from_ast(&ctxt, input);
+ precondition(&ctxt, &cont);
try!(ctxt.check());
let ident = cont.ident;
@@ -80,6 +81,16 @@ pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<Tokens, Str
Ok(generated)
}
+fn precondition(cx: &Ctxt, cont: &Container) {
+ if let Data::Struct(_, ref fields) = cont.data {
+ if let Some(last) = fields.last() {
+ if let syn::Type::Slice(_) = *last.ty {
+ cx.error("cannot deserialize a dynamically sized struct");
+ }
+ }
+ }
+}
+
struct Parameters {
/// Name of the type the `derive` is on.
local: syn::Ident,
| serde-rs/serde | 2018-05-07T18:28:17Z | There is no way to implement a working Deserialize for this type because Deserialize requires Self: Sized, but it would be nice to at least detect the case of dynamically sized slice as the last field and fail with a message rather than generating broken code. | 4cea81f93f12473e0ccbdad2ddecff1f7ea85402 |
1,961 | diff --git a/test_suite/tests/ui/rename/container_unknown_rename_rule.stderr b/test_suite/tests/ui/rename/container_unknown_rename_rule.stderr
index 728d71ca2..3fd68f3f3 100644
--- a/test_suite/tests/ui/rename/container_unknown_rename_rule.stderr
+++ b/test_suite/tests/ui/rename/container_unknown_rename_rule.stderr
@@ -1,4 +1,4 @@
-error: unknown rename rule for #[serde(rename_all = "abc")]
+error: unknown rename rule `rename_all = "abc"`, expected one of "lowercase", "UPPERCASE", "PascalCase", "camelCase", "snake_case", "SCREAMING_SNAKE_CASE", "kebab-case", "SCREAMING-KEBAB-CASE"
--> $DIR/container_unknown_rename_rule.rs:4:22
|
4 | #[serde(rename_all = "abc")]
diff --git a/test_suite/tests/ui/rename/variant_unknown_rename_rule.stderr b/test_suite/tests/ui/rename/variant_unknown_rename_rule.stderr
index 7a52f37a8..48f53f893 100644
--- a/test_suite/tests/ui/rename/variant_unknown_rename_rule.stderr
+++ b/test_suite/tests/ui/rename/variant_unknown_rename_rule.stderr
@@ -1,4 +1,4 @@
-error: unknown rename rule for #[serde(rename_all = "abc")]
+error: unknown rename rule `rename_all = "abc"`, expected one of "lowercase", "UPPERCASE", "PascalCase", "camelCase", "snake_case", "SCREAMING_SNAKE_CASE", "kebab-case", "SCREAMING-KEBAB-CASE"
--> $DIR/variant_unknown_rename_rule.rs:5:26
|
5 | #[serde(rename_all = "abc")]
| [
"1928"
] | serde-rs__serde-1961 | add a list of possible rename rules upon an error
An implementation of https://github.com/serde-rs/serde/issues/1923
| 1.12 | eaccae2c464eb096c115be38a1930539f5698ce3 | diff --git a/serde_derive/src/internals/case.rs b/serde_derive/src/internals/case.rs
index 199fd4bcb..554505160 100644
--- a/serde_derive/src/internals/case.rs
+++ b/serde_derive/src/internals/case.rs
@@ -5,7 +5,7 @@
#[allow(deprecated, unused_imports)]
use std::ascii::AsciiExt;
-use std::fmt::{self, Display};
+use std::fmt::{self, Debug, Display};
use self::RenameRule::*;
@@ -120,11 +120,16 @@ pub struct ParseError<'a> {
impl<'a> Display for ParseError<'a> {
fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
- write!(
- f,
- "unknown rename rule for #[serde(rename_all = {:?})]",
- self.unknown,
- )
+ f.write_str("unknown rename rule `rename_all = ")?;
+ Debug::fmt(self.unknown, f)?;
+ f.write_str("`, expected one of ")?;
+ for (i, (name, _rule)) in RENAME_RULES.iter().enumerate() {
+ if i > 0 {
+ f.write_str(", ")?;
+ }
+ Debug::fmt(name, f)?;
+ }
+ Ok(())
}
}
| serde-rs/serde | 2021-01-23T22:42:17Z | 55fdbea20bbcb0f0fa7e9545ec0ea10c87a6643d | |
1,958 | diff --git a/test_suite/tests/test_de.rs b/test_suite/tests/test_de.rs
index 025d87b09..a0261bd35 100644
--- a/test_suite/tests/test_de.rs
+++ b/test_suite/tests/test_de.rs
@@ -1452,4 +1452,25 @@ declare_error_tests! {
],
"invalid value: integer `65536`, expected u16",
}
+ test_duration_overflow_seq<Duration> {
+ &[
+ Token::Seq { len: Some(2) },
+ Token::U64(u64::max_value()),
+ Token::U32(1_000_000_000),
+ Token::SeqEnd,
+ ],
+ "overflow deserializing Duration",
+ }
+ test_duration_overflow_struct<Duration> {
+ &[
+ Token::Struct { name: "Duration", len: 2 },
+ Token::Str("secs"),
+ Token::U64(u64::max_value()),
+
+ Token::Str("nanos"),
+ Token::U32(1_000_000_000),
+ Token::StructEnd,
+ ],
+ "overflow deserializing Duration",
+ }
}
| [
"1933"
] | serde-rs__serde-1958 | Serde panics when deserializing malformed Duration
The documentation for `std::time::Duration::new` states that it panics if `nanos` overflows and causes `secs` to overflow.
This should cause a deserialization error instead of causing the application to panic.
| 1.12 | 398fba9b1ee6d27a2e556f8d6cd6d1a82315ee9a | diff --git a/serde/src/de/impls.rs b/serde/src/de/impls.rs
index fd77ddf1f..7f0b5d907 100644
--- a/serde/src/de/impls.rs
+++ b/serde/src/de/impls.rs
@@ -1849,6 +1849,17 @@ impl<'de> Deserialize<'de> for Duration {
}
}
+ fn check_overflow<E>(secs: u64, nanos: u32) -> Result<(), E>
+ where
+ E: Error,
+ {
+ static NANOS_PER_SEC: u32 = 1_000_000_000;
+ match secs.checked_add((nanos / NANOS_PER_SEC) as u64) {
+ Some(_) => Ok(()),
+ None => Err(E::custom("overflow deserializing Duration")),
+ }
+ }
+
struct DurationVisitor;
impl<'de> Visitor<'de> for DurationVisitor {
@@ -1874,6 +1885,7 @@ impl<'de> Deserialize<'de> for Duration {
return Err(Error::invalid_length(1, &self));
}
};
+ try!(check_overflow(secs, nanos));
Ok(Duration::new(secs, nanos))
}
@@ -1907,6 +1919,7 @@ impl<'de> Deserialize<'de> for Duration {
Some(nanos) => nanos,
None => return Err(<A::Error as Error>::missing_field("nanos")),
};
+ try!(check_overflow(secs, nanos));
Ok(Duration::new(secs, nanos))
}
}
| serde-rs/serde | 2021-01-20T19:48:24Z | 55fdbea20bbcb0f0fa7e9545ec0ea10c87a6643d | |
1,916 | diff --git a/serde_test/src/de.rs b/serde_test/src/de.rs
index c9bcee5b3..a1d62758e 100644
--- a/serde_test/src/de.rs
+++ b/serde_test/src/de.rs
@@ -250,9 +250,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
{
visitor.visit_enum(DeserializerEnumVisitor { de: self })
}
- _ => {
- unexpected!(self.next_token());
- }
+ _ => self.deserialize_any(visitor)
}
}
diff --git a/test_suite/tests/test_annotations.rs b/test_suite/tests/test_annotations.rs
index 7604fe031..10d81ad4b 100644
--- a/test_suite/tests/test_annotations.rs
+++ b/test_suite/tests/test_annotations.rs
@@ -2633,3 +2633,200 @@ fn test_flatten_any_after_flatten_struct() {
],
);
}
+
+/// https://github.com/serde-rs/serde/issues/1883
+#[test]
+fn test_expecting_message() {
+ #[derive(Deserialize, PartialEq, Debug)]
+ #[serde(expecting = "something strange...")]
+ struct Unit;
+
+ #[derive(Deserialize)]
+ #[serde(expecting = "something strange...")]
+ struct Newtype(bool);
+
+ #[derive(Deserialize)]
+ #[serde(expecting = "something strange...")]
+ struct Tuple(u32, bool);
+
+ #[derive(Deserialize)]
+ #[serde(expecting = "something strange...")]
+ struct Struct {
+ question: String,
+ answer: u32,
+ }
+
+ assert_de_tokens_error::<Unit>(
+ &[Token::Str("Unit")],
+ r#"invalid type: string "Unit", expected something strange..."#
+ );
+
+ assert_de_tokens_error::<Newtype>(
+ &[Token::Str("Newtype")],
+ r#"invalid type: string "Newtype", expected something strange..."#
+ );
+
+ assert_de_tokens_error::<Tuple>(
+ &[Token::Str("Tuple")],
+ r#"invalid type: string "Tuple", expected something strange..."#
+ );
+
+ assert_de_tokens_error::<Struct>(
+ &[Token::Str("Struct")],
+ r#"invalid type: string "Struct", expected something strange..."#
+ );
+}
+
+#[test]
+fn test_expecting_message_externally_tagged_enum() {
+ #[derive(Deserialize)]
+ #[serde(expecting = "something strange...")]
+ enum Enum {
+ ExternallyTagged,
+ }
+
+ assert_de_tokens_error::<Enum>(
+ &[
+ Token::Str("ExternallyTagged"),
+ ],
+ r#"invalid type: string "ExternallyTagged", expected something strange..."#
+ );
+
+ // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
+ assert_de_tokens_error::<Enum>(
+ &[
+ Token::Enum { name: "Enum" },
+ Token::Unit,
+ ],
+ r#"invalid type: unit value, expected variant identifier"#
+ );
+}
+
+#[test]
+fn test_expecting_message_internally_tagged_enum() {
+ #[derive(Deserialize)]
+ #[serde(tag = "tag")]
+ #[serde(expecting = "something strange...")]
+ enum Enum {
+ InternallyTagged,
+ }
+
+ assert_de_tokens_error::<Enum>(
+ &[
+ Token::Str("InternallyTagged"),
+ ],
+ r#"invalid type: string "InternallyTagged", expected something strange..."#
+ );
+
+ // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
+ assert_de_tokens_error::<Enum>(
+ &[
+ Token::Map { len: None },
+ Token::Str("tag"),
+ Token::Unit,
+ ],
+ r#"invalid type: unit value, expected variant identifier"#
+ );
+}
+
+#[test]
+fn test_expecting_message_adjacently_tagged_enum() {
+ #[derive(Deserialize)]
+ #[serde(tag = "tag", content = "content")]
+ #[serde(expecting = "something strange...")]
+ enum Enum {
+ AdjacentlyTagged,
+ }
+
+ assert_de_tokens_error::<Enum>(
+ &[
+ Token::Str("AdjacentlyTagged"),
+ ],
+ r#"invalid type: string "AdjacentlyTagged", expected something strange..."#
+ );
+
+ assert_de_tokens_error::<Enum>(
+ &[
+ Token::Map { len: None },
+ Token::Unit,
+ ],
+ r#"invalid type: unit value, expected "tag", "content", or other ignored fields"#
+ );
+
+ // Check that #[serde(expecting = "...")] doesn't affect variant identifier error message
+ assert_de_tokens_error::<Enum>(
+ &[
+ Token::Map { len: None },
+ Token::Str("tag"),
+ Token::Unit,
+ ],
+ r#"invalid type: unit value, expected variant identifier"#
+ );
+}
+
+#[test]
+fn test_expecting_message_untagged_tagged_enum() {
+ #[derive(Deserialize)]
+ #[serde(untagged)]
+ #[serde(expecting = "something strange...")]
+ enum Enum {
+ Untagged,
+ }
+
+ assert_de_tokens_error::<Enum>(
+ &[
+ Token::Str("Untagged"),
+ ],
+ r#"something strange..."#
+ );
+}
+
+#[test]
+fn test_expecting_message_identifier_enum() {
+ #[derive(Deserialize)]
+ #[serde(field_identifier)]
+ #[serde(expecting = "something strange...")]
+ enum FieldEnum {
+ Field,
+ }
+
+ #[derive(Deserialize)]
+ #[serde(variant_identifier)]
+ #[serde(expecting = "something strange...")]
+ enum VariantEnum {
+ Variant,
+ }
+
+ assert_de_tokens_error::<FieldEnum>(
+ &[
+ Token::Unit,
+ ],
+ r#"invalid type: unit value, expected something strange..."#
+ );
+
+ assert_de_tokens_error::<FieldEnum>(
+ &[
+ Token::Enum { name: "FieldEnum" },
+ Token::Str("Unknown"),
+ Token::None,
+ ],
+ r#"invalid type: map, expected something strange..."#
+ );
+
+
+ assert_de_tokens_error::<VariantEnum>(
+ &[
+ Token::Unit,
+ ],
+ r#"invalid type: unit value, expected something strange..."#
+ );
+
+ assert_de_tokens_error::<VariantEnum>(
+ &[
+ Token::Enum { name: "VariantEnum" },
+ Token::Str("Unknown"),
+ Token::None,
+ ],
+ r#"invalid type: map, expected something strange..."#
+ );
+}
diff --git a/test_suite/tests/test_gen.rs b/test_suite/tests/test_gen.rs
index d8def742b..b5c12d606 100644
--- a/test_suite/tests/test_gen.rs
+++ b/test_suite/tests/test_gen.rs
@@ -723,6 +723,55 @@ fn test_gen() {
}
deriving!(&'a str);
+
+ // https://github.com/serde-rs/serde/issues/1883
+ #[derive(Deserialize)]
+ #[serde(expecting = "a message")]
+ struct CustomMessageUnit;
+
+ #[derive(Deserialize)]
+ #[serde(expecting = "a message")]
+ struct CustomMessageNewtype(bool);
+
+ #[derive(Deserialize)]
+ #[serde(expecting = "a message")]
+ struct CustomMessageTuple(u32, bool);
+
+ #[derive(Deserialize)]
+ #[serde(expecting = "a message")]
+ struct CustomMessageStruct {
+ question: String,
+ answer: u32,
+ }
+
+ #[derive(Deserialize)]
+ #[serde(expecting = "a message")]
+ enum CustomMessageExternallyTaggedEnum {}
+
+ #[derive(Deserialize)]
+ #[serde(tag = "tag")]
+ #[serde(expecting = "a message")]
+ enum CustomMessageInternallyTaggedEnum {}
+
+ #[derive(Deserialize)]
+ #[serde(tag = "tag", content = "content")]
+ #[serde(expecting = "a message")]
+ enum CustomMessageAdjacentlyTaggedEnum {}
+
+ #[derive(Deserialize)]
+ #[serde(untagged)]
+ #[serde(expecting = "a message")]
+ enum CustomMessageUntaggedEnum {}
+
+ #[derive(Deserialize)]
+ #[serde(field_identifier)]
+ #[serde(expecting = "a message")]
+ enum CustomMessageFieldIdentifierEnum {}
+
+ #[derive(Deserialize)]
+ #[serde(variant_identifier)]
+ #[serde(expecting = "a message")]
+ enum CustomMessageVariantIdentifierEnum {}
}
//////////////////////////////////////////////////////////////////////////
| [
"1883"
] | serde-rs__serde-1916 | Provide an easy way to customize only the error message
**EDIT** After thinking about it some more, I feel it would be better to improve this error message rather than add API surface area. #1544 gets close, but I believe those errors are still too opaque for Cargo's purposes, and it's hidden behind a flag. Anyway, my original post:
-----------------
I have an untagged union:
```rust
#[derive(Serialize, Deserialize)]
#[serde(untagged)]
enum MyEnum {
Foo(Vec<String>),
Bar(usize)
}
```
If all variants fail, you get this error message:
https://github.com/serde-rs/serde/blob/9f331cc25753edd71ad7ab0ea08a430fefaa90e1/serde_derive/src/de.rs#L1648
Is there a good way to customize the error message but keep the default `#[derive(Deserialize)]` implementation? Perhaps a new attribute?:
```rust
#[serde(untagged, expecting = "a number or a list of strings")]
enum MyEnum {
...
}
```
## Advantages:
- You don't have to reimplement `Deserialize`
- Concise
## Disadvantages
- How common is this use-case? We have to do this a couple of times [within Cargo](https://github.com/rust-lang/cargo/commit/cb53e1b2056a02bd1eb83d926e1cc37e56180368).
- Is there a better solution I am overlooking?
| 1.11 | 8084258a3edc1dc4007e8df7f24b022d015b5fb0 | diff --git a/serde/src/private/de.rs b/serde/src/private/de.rs
index bcb964a9c..e3b685e88 100644
--- a/serde/src/private/de.rs
+++ b/serde/src/private/de.rs
@@ -824,15 +824,17 @@ mod content {
/// Not public API.
pub struct TaggedContentVisitor<'de, T> {
tag_name: &'static str,
+ expecting: &'static str,
value: PhantomData<TaggedContent<'de, T>>,
}
impl<'de, T> TaggedContentVisitor<'de, T> {
/// Visitor for the content of an internally tagged enum with the given
/// tag name.
- pub fn new(name: &'static str) -> Self {
+ pub fn new(name: &'static str, expecting: &'static str) -> Self {
TaggedContentVisitor {
tag_name: name,
+ expecting: expecting,
value: PhantomData,
}
}
@@ -861,7 +863,7 @@ mod content {
type Value = TaggedContent<'de, T>;
fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
- fmt.write_str("internally tagged enum")
+ fmt.write_str(self.expecting)
}
fn visit_seq<S>(self, mut seq: S) -> Result<Self::Value, S::Error>
diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs
index 1f5733a6d..071db57bc 100644
--- a/serde_derive/src/de.rs
+++ b/serde_derive/src/de.rs
@@ -399,6 +399,7 @@ fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fra
let type_name = cattrs.name().deserialize_name();
let expecting = format!("unit struct {}", params.type_name());
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
quote_block! {
struct __Visitor;
@@ -456,6 +457,7 @@ fn deserialize_tuple(
Some(variant_ident) => format!("tuple variant {}::{}", params.type_name(), variant_ident),
None => format!("tuple struct {}", params.type_name()),
};
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let nfields = fields.len();
@@ -542,6 +544,7 @@ fn deserialize_tuple_in_place(
Some(variant_ident) => format!("tuple variant {}::{}", params.type_name(), variant_ident),
None => format!("tuple struct {}", params.type_name()),
};
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let nfields = fields.len();
@@ -630,6 +633,7 @@ fn deserialize_seq(
} else {
format!("{} with {} elements", expecting, deserialized_count)
};
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let mut index_in_seq = 0_usize;
let let_values = vars.clone().zip(fields).map(|(var, field)| {
@@ -732,6 +736,7 @@ fn deserialize_seq_in_place(
} else {
format!("{} with {} elements", expecting, deserialized_count)
};
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let mut index_in_seq = 0usize;
let write_values = fields.iter().map(|field| {
@@ -907,6 +912,7 @@ fn deserialize_struct(
Some(variant_ident) => format!("struct variant {}::{}", params.type_name(), variant_ident),
None => format!("struct {}", params.type_name()),
};
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let visit_seq = Stmts(deserialize_seq(
&type_path, params, fields, true, cattrs, &expecting,
@@ -1048,6 +1054,7 @@ fn deserialize_struct_in_place(
Some(variant_ident) => format!("struct variant {}::{}", params.type_name(), variant_ident),
None => format!("struct {}", params.type_name()),
};
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs, &expecting));
@@ -1200,6 +1207,7 @@ fn deserialize_externally_tagged_enum(
let type_name = cattrs.name().deserialize_name();
let expecting = format!("enum {}", params.type_name());
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
@@ -1309,6 +1317,9 @@ fn deserialize_internally_tagged_enum(
}
});
+ let expecting = format!("internally tagged enum {}", params.type_name());
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
+
quote_block! {
#variant_visitor
@@ -1316,7 +1327,7 @@ fn deserialize_internally_tagged_enum(
let __tagged = try!(_serde::Deserializer::deserialize_any(
__deserializer,
- _serde::private::de::TaggedContentVisitor::<__Field>::new(#tag)));
+ _serde::private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting)));
match __tagged.tag {
#(#variant_arms)*
@@ -1359,6 +1370,7 @@ fn deserialize_adjacently_tagged_enum(
.collect();
let expecting = format!("adjacently tagged enum {}", params.type_name());
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let type_name = cattrs.name().deserialize_name();
let deny_unknown_fields = cattrs.deny_unknown_fields();
@@ -1648,6 +1660,7 @@ fn deserialize_untagged_enum(
"data did not match any variant of untagged enum {}",
params.type_name()
);
+ let fallthrough_msg = cattrs.expecting().unwrap_or(&fallthrough_msg);
quote_block! {
let __content = try!(<_serde::private::de::Content as _serde::Deserialize>::deserialize(__deserializer));
@@ -1905,6 +1918,7 @@ fn deserialize_generated_identifier(
is_variant,
fallthrough,
!is_variant && cattrs.has_flatten(),
+ None,
));
let lifetime = if !is_variant && cattrs.has_flatten() {
@@ -2012,6 +2026,7 @@ fn deserialize_custom_identifier(
is_variant,
fallthrough,
false,
+ cattrs.expecting(),
));
quote_block! {
@@ -2042,6 +2057,7 @@ fn deserialize_identifier(
is_variant: bool,
fallthrough: Option<TokenStream>,
collect_other_fields: bool,
+ expecting: Option<&str>,
) -> Fragment {
let mut flat_fields = Vec::new();
for (_, ident, aliases) in fields {
@@ -2066,11 +2082,11 @@ fn deserialize_identifier(
.map(|(_, ident, _)| quote!(#this::#ident))
.collect();
- let expecting = if is_variant {
+ let expecting = expecting.unwrap_or(if is_variant {
"variant identifier"
} else {
"field identifier"
- };
+ });
let index_expecting = if is_variant { "variant" } else { "field" };
diff --git a/serde_derive/src/internals/attr.rs b/serde_derive/src/internals/attr.rs
index e6f72dfe7..fc523d16d 100644
--- a/serde_derive/src/internals/attr.rs
+++ b/serde_derive/src/internals/attr.rs
@@ -223,6 +223,8 @@ pub struct Container {
has_flatten: bool,
serde_path: Option<syn::Path>,
is_packed: bool,
+ /// Error message generated when type can't be deserialized
+ expecting: Option<String>,
}
/// Styles of representing an enum.
@@ -305,6 +307,7 @@ impl Container {
let mut field_identifier = BoolAttr::none(cx, FIELD_IDENTIFIER);
let mut variant_identifier = BoolAttr::none(cx, VARIANT_IDENTIFIER);
let mut serde_path = Attr::none(cx, CRATE);
+ let mut expecting = Attr::none(cx, EXPECTING);
for meta_item in item
.attrs
@@ -575,6 +578,13 @@ impl Container {
}
}
+ // Parse `#[serde(expecting = "a message")]`
+ Meta(NameValue(m)) if m.path == EXPECTING => {
+ if let Ok(s) = get_lit_str(cx, EXPECTING, &m.lit) {
+ expecting.set(&m.path, s.value());
+ }
+ }
+
Meta(meta_item) => {
let path = meta_item
.path()
@@ -627,6 +637,7 @@ impl Container {
has_flatten: false,
serde_path: serde_path.get(),
is_packed,
+ expecting: expecting.get(),
}
}
@@ -702,6 +713,12 @@ impl Container {
self.custom_serde_path()
.map_or_else(|| Cow::Owned(parse_quote!(_serde)), Cow::Borrowed)
}
+
+ /// Error message generated when type can't be deserialized.
+ /// If `None`, default message will be used
+ pub fn expecting(&self) -> Option<&str> {
+ self.expecting.as_ref().map(String::as_ref)
+ }
}
fn decide_tag(
diff --git a/serde_derive/src/internals/symbol.rs b/serde_derive/src/internals/symbol.rs
index 318b81bbb..1fedd2754 100644
--- a/serde_derive/src/internals/symbol.rs
+++ b/serde_derive/src/internals/symbol.rs
@@ -35,6 +35,7 @@ pub const TRY_FROM: Symbol = Symbol("try_from");
pub const UNTAGGED: Symbol = Symbol("untagged");
pub const VARIANT_IDENTIFIER: Symbol = Symbol("variant_identifier");
pub const WITH: Symbol = Symbol("with");
+pub const EXPECTING: Symbol = Symbol("expecting");
impl PartialEq<Symbol> for Ident {
fn eq(&self, word: &Symbol) -> bool {
| serde-rs/serde | 2020-10-22T20:11:56Z | 8084258a3edc1dc4007e8df7f24b022d015b5fb0 | |
1,874 | diff --git a/test_suite/tests/test_annotations.rs b/test_suite/tests/test_annotations.rs
index 06c485dff..7604fe031 100644
--- a/test_suite/tests/test_annotations.rs
+++ b/test_suite/tests/test_annotations.rs
@@ -1967,6 +1967,29 @@ fn test_flatten_map_twice() {
);
}
+#[test]
+fn test_flatten_unit() {
+ #[derive(Debug, PartialEq, Serialize, Deserialize)]
+ struct Response<T> {
+ #[serde(flatten)]
+ data: T,
+ status: usize,
+ }
+
+ assert_tokens(
+ &Response {
+ data: (),
+ status: 0,
+ },
+ &[
+ Token::Map { len: None },
+ Token::Str("status"),
+ Token::U64(0),
+ Token::MapEnd,
+ ],
+ );
+}
+
#[test]
fn test_flatten_unsupported_type() {
#[derive(Debug, PartialEq, Serialize, Deserialize)]
| [
"1873"
] | serde-rs__serde-1874 | Flattening a Unit aka () should produce no extra fields
I'm designing an http api where every response is json and has diffferent fields depending on the api call, but always has a status and code field. I am acomplishing this through the Response struct:
```rust
#[derive(Debug, Serialize)]
pub struct Response<T> {
#[serde(flatten)]
data: T,
status: Status,
}
```
In situations where I just want to return a status, I intended on constructing a `Response<()>`, but that gives me this error:
```thread 'main' panicked at 'called `Result::unwrap()` on an `Err` value: Error("can only flatten structs and maps (got unit)", line: 0, column: 0)', src/libcore/result.rs:1189:5```
I expected that flattening a Unit would just add no fields. I could make a struct with no fields and make a `Response<NoFields>`, but that seems unidiomatic and requires adding an extra type that doesn't do anything. Is there a reason that you can't flatten a Unit?
| 1.11 | 53b9871b172c1c29a16e66138f108bf4155444fe | diff --git a/serde/src/private/de.rs b/serde/src/private/de.rs
index eb5424cc8..bcb964a9c 100644
--- a/serde/src/private/de.rs
+++ b/serde/src/private/de.rs
@@ -2763,6 +2763,13 @@ where
}
}
+ fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+ where
+ V: Visitor<'de>,
+ {
+ visitor.visit_unit()
+ }
+
forward_to_deserialize_other! {
deserialize_bool()
deserialize_i8()
@@ -2780,7 +2787,6 @@ where
deserialize_string()
deserialize_bytes()
deserialize_byte_buf()
- deserialize_unit()
deserialize_unit_struct(&'static str)
deserialize_seq()
deserialize_tuple(usize)
diff --git a/serde/src/private/ser.rs b/serde/src/private/ser.rs
index 70f338181..eb8cfc988 100644
--- a/serde/src/private/ser.rs
+++ b/serde/src/private/ser.rs
@@ -1124,7 +1124,7 @@ where
}
fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
- Err(Self::bad_type(Unsupported::Unit))
+ Ok(())
}
fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
| serde-rs/serde | 2020-08-10T22:07:47Z | 8084258a3edc1dc4007e8df7f24b022d015b5fb0 | |
1,831 | diff --git a/test_suite/tests/test_gen.rs b/test_suite/tests/test_gen.rs
index d8def742b..73f7fa50f 100644
--- a/test_suite/tests/test_gen.rs
+++ b/test_suite/tests/test_gen.rs
@@ -723,6 +723,18 @@ fn test_gen() {
}
deriving!(&'a str);
+
+ macro_rules! mac {
+ ($($tt:tt)*) => {
+ $($tt)*
+ };
+ }
+
+ #[derive(Deserialize)]
+ struct BorrowLifetimeInsideMacro<'a> {
+ #[serde(borrow = "'a")]
+ f: mac!(Cow<'a, str>),
+ }
}
//////////////////////////////////////////////////////////////////////////
| [
"1562"
] | serde-rs__serde-1831 | Error: "field has no lifetimes to borrow" if type is behind a macro
```Rust
use serde::Deserialize;
use std::borrow::Cow;
macro_rules! t {
($t:ty) => { $t }
}
#[derive(Deserialize)]
struct B<'a> {
#[serde(borrow="'a")]
f: t!(Cow<'a , str>)
}
```
This generates error:
```
error: field `f` has no lifetimes to borrow
--> src\main.rs:10:5
|
10 | / #[serde(borrow="'a")]
11 | | f: t!(Cow<'a , str>)
| |________________________^
```
but If I manually substitute type that macro expands to then everything works fine.
| 1.11 | 8084258a3edc1dc4007e8df7f24b022d015b5fb0 | diff --git a/serde_derive/src/internals/attr.rs b/serde_derive/src/internals/attr.rs
index e6f72dfe7..d59e681a0 100644
--- a/serde_derive/src/internals/attr.rs
+++ b/serde_derive/src/internals/attr.rs
@@ -1,6 +1,6 @@
use internals::symbol::*;
use internals::{ungroup, Ctxt};
-use proc_macro2::{Group, Span, TokenStream, TokenTree};
+use proc_macro2::{Group, Spacing, Span, TokenStream, TokenTree};
use quote::ToTokens;
use std::borrow::Cow;
use std::collections::BTreeSet;
@@ -1921,17 +1921,40 @@ fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
syn::Type::Group(ty) => {
collect_lifetimes(&ty.elem, out);
}
+ syn::Type::Macro(ty) => {
+ collect_lifetimes_from_tokens(ty.mac.tokens.clone(), out);
+ }
syn::Type::BareFn(_)
| syn::Type::Never(_)
| syn::Type::TraitObject(_)
| syn::Type::ImplTrait(_)
| syn::Type::Infer(_)
- | syn::Type::Macro(_)
| syn::Type::Verbatim(_)
| _ => {}
}
}
+fn collect_lifetimes_from_tokens(tokens: TokenStream, out: &mut BTreeSet<syn::Lifetime>) {
+ let mut iter = tokens.into_iter();
+ while let Some(tt) = iter.next() {
+ match &tt {
+ TokenTree::Punct(op) if op.as_char() == '\'' && op.spacing() == Spacing::Joint => {
+ if let Some(TokenTree::Ident(ident)) = iter.next() {
+ out.insert(syn::Lifetime {
+ apostrophe: op.span(),
+ ident,
+ });
+ }
+ }
+ TokenTree::Group(group) => {
+ let tokens = group.stream();
+ collect_lifetimes_from_tokens(tokens, out);
+ }
+ _ => {}
+ }
+ }
+}
+
fn parse_lit_str<T>(s: &syn::LitStr) -> parse::Result<T>
where
T: Parse,
| serde-rs/serde | 2020-06-07T11:15:57Z | Thanks! I would accept a PR to fix this. | 8084258a3edc1dc4007e8df7f24b022d015b5fb0 |
1,830 | diff --git a/test_suite/tests/test_self.rs b/test_suite/tests/test_self.rs
new file mode 100644
index 000000000..d2241749c
--- /dev/null
+++ b/test_suite/tests/test_self.rs
@@ -0,0 +1,101 @@
+use serde::{Deserialize, Serialize};
+
+#[test]
+fn test_self() {
+ macro_rules! mac {
+ ($($tt:tt)*) => {
+ $($tt)*
+ };
+ }
+
+ pub trait Trait {
+ type Assoc;
+ }
+
+ #[derive(Deserialize, Serialize)]
+ pub struct Generics<T: Trait<Assoc = Self>>
+ where
+ Self: Trait<Assoc = Self>,
+ <Self as Trait>::Assoc: Sized,
+ mac!(Self): Trait<Assoc = mac!(Self)>,
+ {
+ _f: T,
+ }
+
+ impl<T: Trait<Assoc = Self>> Trait for Generics<T> {
+ type Assoc = Self;
+ }
+
+ #[derive(Deserialize, Serialize)]
+ pub struct Struct {
+ _f1: Box<Self>,
+ _f2: Box<<Self as Trait>::Assoc>,
+ _f3: Box<mac!(Self)>,
+ _f4: [(); Self::ASSOC],
+ _f5: [(); Self::assoc()],
+ _f6: [(); mac!(Self::assoc())],
+ }
+
+ impl Struct {
+ const ASSOC: usize = 1;
+ const fn assoc() -> usize {
+ 0
+ }
+ }
+
+ impl Trait for Struct {
+ type Assoc = Self;
+ }
+
+ #[derive(Deserialize, Serialize)]
+ struct Tuple(
+ Box<Self>,
+ Box<<Self as Trait>::Assoc>,
+ Box<mac!(Self)>,
+ [(); Self::ASSOC],
+ [(); Self::assoc()],
+ [(); mac!(Self::assoc())],
+ );
+
+ impl Tuple {
+ const ASSOC: usize = 1;
+ const fn assoc() -> usize {
+ 0
+ }
+ }
+
+ impl Trait for Tuple {
+ type Assoc = Self;
+ }
+
+ #[derive(Deserialize, Serialize)]
+ enum Enum {
+ Struct {
+ _f1: Box<Self>,
+ _f2: Box<<Self as Trait>::Assoc>,
+ _f3: Box<mac!(Self)>,
+ _f4: [(); Self::ASSOC],
+ _f5: [(); Self::assoc()],
+ _f6: [(); mac!(Self::assoc())],
+ },
+ Tuple(
+ Box<Self>,
+ Box<<Self as Trait>::Assoc>,
+ Box<mac!(Self)>,
+ [(); Self::ASSOC],
+ [(); Self::assoc()],
+ [(); mac!(Self::assoc())],
+ ),
+ }
+
+ impl Enum {
+ const ASSOC: usize = 1;
+ const fn assoc() -> usize {
+ 0
+ }
+ }
+
+ impl Trait for Enum {
+ type Assoc = Self;
+ }
+}
| [
"1565"
] | serde-rs__serde-1830 | Derive Deserialize: Self in recursive type is not supported
As the code and errors below show, deriving `Deserialize` on a recursive enum with a `Self` reference does not work.
Note: `Serialize` works fine.
```rust
// Works fine:
#[derive(serde_derive::Deserialize)]
enum E {
Nested(Vec<E>),
}
// Fails with ERROR:
#[derive(serde_derive::Deserialize)]
enum E {
Nested(Vec<Self>),
}
```
```
Compiling playground v0.0.1 (/playground)
error[E0277]: the trait bound `_IMPL_DESERIALIZE_FOR_E::<impl _IMPL_DESERIALIZE_FOR_E::_serde::Deserialize<'de> for E>::deserialize::__Visitor<'de>: _IMPL_DESERIALIZE_FOR_E::_serde::Deserialize<'_>` is not satisfied
--> src/lib.rs:5:12
|
5 | Nested(Vec<Self>),
| ^^^ the trait `_IMPL_DESERIALIZE_FOR_E::_serde::Deserialize<'_>` is not implemented for `_IMPL_DESERIALIZE_FOR_E::<impl _IMPL_DESERIALIZE_FOR_E::_serde::Deserialize<'de> for E>::deserialize::__Visitor<'de>`
|
= note: required because of the requirements on the impl of `_IMPL_DESERIALIZE_FOR_E::_serde::Deserialize<'_>` for `std::vec::Vec<_IMPL_DESERIALIZE_FOR_E::<impl _IMPL_DESERIALIZE_FOR_E::_serde::Deserialize<'de> for E>::deserialize::__Visitor<'de>>`
= note: required by `_IMPL_DESERIALIZE_FOR_E::_serde::de::VariantAccess::newtype_variant`
error[E0631]: type mismatch in function arguments
--> src/lib.rs:3:10
|
3 | #[derive(serde_derive::Deserialize)]
| ^^^^^^^^^^^^^^^^^^^^^^^^^ expected signature of `fn(std::vec::Vec<_IMPL_DESERIALIZE_FOR_E::<impl _IMPL_DESERIALIZE_FOR_E::_serde::Deserialize<'de> for E>::deserialize::__Visitor<'_>>) -> _`
4 | enum E {
5 | Nested(Vec<Self>),
| ----------------- found signature of `fn(std::vec::Vec<E>) -> _`
|
= note: required by `std::result::Result::<T, E>::map`
error: aborting due to 2 previous errors
For more information about this error, try `rustc --explain E0277`.
error: Could not compile `playground`.
```
| 1.12 | f6e7366b46f767c427ca0423ae4cc69531213498 | diff --git a/serde_derive/Cargo.toml b/serde_derive/Cargo.toml
index 185fe9787..5b6fa4344 100644
--- a/serde_derive/Cargo.toml
+++ b/serde_derive/Cargo.toml
@@ -22,7 +22,7 @@ proc-macro = true
[dependencies]
proc-macro2 = "1.0"
quote = "1.0"
-syn = { version = "1.0.58", features = ["visit"] }
+syn = { version = "1.0.58", features = ["visit", "visit-mut"] }
[dev-dependencies]
serde = { version = "1.0", path = "../serde" }
diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs
index 90d0ab7c1..3daa9d1e6 100644
--- a/serde_derive/src/de.rs
+++ b/serde_derive/src/de.rs
@@ -8,13 +8,17 @@ use bound;
use dummy;
use fragment::{Expr, Fragment, Match, Stmts};
use internals::ast::{Container, Data, Field, Style, Variant};
-use internals::{attr, ungroup, Ctxt, Derive};
+use internals::{attr, replace_receiver, ungroup, Ctxt, Derive};
use pretend;
use std::collections::BTreeSet;
use std::ptr;
-pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream, Vec<syn::Error>> {
+pub fn expand_derive_deserialize(
+ input: &mut syn::DeriveInput,
+) -> Result<TokenStream, Vec<syn::Error>> {
+ replace_receiver(input);
+
let ctxt = Ctxt::new();
let cont = match Container::from_ast(&ctxt, input, Derive::Deserialize) {
Some(cont) => cont,
diff --git a/serde_derive/src/internals/mod.rs b/serde_derive/src/internals/mod.rs
index d36b6e45c..5e9f416c4 100644
--- a/serde_derive/src/internals/mod.rs
+++ b/serde_derive/src/internals/mod.rs
@@ -4,8 +4,12 @@ pub mod attr;
mod ctxt;
pub use self::ctxt::Ctxt;
+mod receiver;
+pub use self::receiver::replace_receiver;
+
mod case;
mod check;
+mod respan;
mod symbol;
use syn::Type;
diff --git a/serde_derive/src/internals/receiver.rs b/serde_derive/src/internals/receiver.rs
new file mode 100644
index 000000000..1aaddb8bd
--- /dev/null
+++ b/serde_derive/src/internals/receiver.rs
@@ -0,0 +1,190 @@
+use super::respan::respan;
+use proc_macro2::{Group, Spacing, Span, TokenStream, TokenTree};
+use quote::{quote, quote_spanned};
+use std::{iter::FromIterator, mem};
+use syn::{
+ parse_quote,
+ punctuated::Punctuated,
+ visit_mut::{self, VisitMut},
+ DeriveInput, ExprPath, Macro, Path, PathArguments, QSelf, Type, TypePath,
+};
+
+pub fn replace_receiver(input: &mut DeriveInput) {
+ let self_ty = {
+ let ident = &input.ident;
+ let ty_generics = input.generics.split_for_impl().1;
+ parse_quote!(#ident #ty_generics)
+ };
+ let mut visitor = ReplaceReceiver(&self_ty);
+ visitor.visit_generics_mut(&mut input.generics);
+ visitor.visit_data_mut(&mut input.data);
+}
+
+struct ReplaceReceiver<'a>(&'a TypePath);
+
+impl ReplaceReceiver<'_> {
+ fn self_ty(&self, span: Span) -> TypePath {
+ respan(self.0, span)
+ }
+
+ fn self_to_qself(&self, qself: &mut Option<QSelf>, path: &mut Path) {
+ if path.leading_colon.is_some() {
+ return;
+ }
+
+ // Make borrow checker happy
+ {
+ let first = &path.segments[0];
+ if first.ident != "Self" || !first.arguments.is_empty() {
+ return;
+ }
+ }
+
+ if path.segments.len() == 1 {
+ self.self_to_expr_path(path);
+ return;
+ }
+
+ let span = path.segments[0].ident.span();
+ *qself = Some(QSelf {
+ lt_token: Token,
+ ty: Box::new(self.self_ty(span).into()),
+ position: 0,
+ as_token: None,
+ gt_token: Token,
+ });
+
+ path.leading_colon = Some(**path.segments.pairs().next().unwrap().punct().unwrap());
+
+ let segments = mem::replace(&mut path.segments, Punctuated::new());
+ path.segments = segments.into_pairs().skip(1).collect();
+ }
+
+ fn self_to_expr_path(&self, path: &mut Path) {
+ if path.leading_colon.is_some() {
+ return;
+ }
+
+ // Make borrow checker happy
+ {
+ let first = &path.segments[0];
+ if first.ident != "Self" || !first.arguments.is_empty() {
+ return;
+ }
+ }
+
+ let self_ty = self.self_ty(path.segments[0].ident.span());
+ let variant = mem::replace(path, self_ty.path);
+ for segment in &mut path.segments {
+ if let PathArguments::AngleBracketed(bracketed) = &mut segment.arguments {
+ if bracketed.colon2_token.is_none() && !bracketed.args.is_empty() {
+ bracketed.colon2_token = Some(<Token![::]>::default());
+ }
+ }
+ }
+ if variant.segments.len() > 1 {
+ path.segments.push_punct(<Token![::]>::default());
+ path.segments.extend(variant.segments.into_pairs().skip(1));
+ }
+ }
+
+ fn visit_token_stream(&self, tokens: &mut TokenStream) -> bool {
+ let mut out = Vec::new();
+ let mut modified = false;
+ let mut iter = tokens.clone().into_iter().peekable();
+ while let Some(tt) = iter.next() {
+ match tt {
+ TokenTree::Ident(ident) => {
+ if ident == "Self" {
+ modified = true;
+ let self_ty = self.self_ty(ident.span());
+ match iter.peek() {
+ Some(TokenTree::Punct(p))
+ if p.as_char() == ':' && p.spacing() == Spacing::Joint => {}
+ _ => {
+ out.extend(quote!(#self_ty));
+ continue;
+ }
+ }
+ let next = iter.next().unwrap();
+ match iter.peek() {
+ Some(TokenTree::Punct(p)) if p.as_char() == ':' => {
+ let span = ident.span();
+ out.extend(quote_spanned!(span=> <#self_ty>));
+ }
+ _ => out.extend(quote!(#self_ty)),
+ }
+ out.push(next);
+ } else {
+ out.push(TokenTree::Ident(ident));
+ }
+ }
+ TokenTree::Group(group) => {
+ let mut content = group.stream();
+ modified |= self.visit_token_stream(&mut content);
+ let mut new = Group::new(group.delimiter(), content);
+ new.set_span(group.span());
+ out.push(TokenTree::Group(new));
+ }
+ other => out.push(other),
+ }
+ }
+ if modified {
+ *tokens = TokenStream::from_iter(out);
+ }
+ modified
+ }
+}
+
+impl VisitMut for ReplaceReceiver<'_> {
+ // `Self` -> `Receiver`
+ fn visit_type_mut(&mut self, ty: &mut Type) {
+ let span = if let Type::Path(node) = ty {
+ if node.qself.is_none() && node.path.is_ident("Self") {
+ node.path.segments[0].ident.span()
+ } else {
+ self.visit_type_path_mut(node);
+ return;
+ }
+ } else {
+ visit_mut::visit_type_mut(self, ty);
+ return;
+ };
+ *ty = self.self_ty(span).into();
+ }
+
+ // `Self::Assoc` -> `<Receiver>::Assoc`
+ fn visit_type_path_mut(&mut self, ty: &mut TypePath) {
+ if ty.qself.is_none() {
+ self.self_to_qself(&mut ty.qself, &mut ty.path);
+ }
+ visit_mut::visit_type_path_mut(self, ty);
+ }
+
+ // `Self::method` -> `<Receiver>::method`
+ fn visit_expr_path_mut(&mut self, expr: &mut ExprPath) {
+ if expr.qself.is_none() {
+ self.self_to_qself(&mut expr.qself, &mut expr.path);
+ }
+ visit_mut::visit_expr_path_mut(self, expr);
+ }
+
+ fn visit_macro_mut(&mut self, mac: &mut Macro) {
+ // We can't tell in general whether `self` inside a macro invocation
+ // refers to the self in the argument list or a different self
+ // introduced within the macro. Heuristic: if the macro input contains
+ // `fn`, then `self` is more likely to refer to something other than the
+ // outer function's self argument.
+ if !contains_fn(mac.tokens.clone()) {
+ self.visit_token_stream(&mut mac.tokens);
+ }
+ }
+}
+
+fn contains_fn(tokens: TokenStream) -> bool {
+ tokens.into_iter().any(|tt| match tt {
+ TokenTree::Ident(ident) => ident == "fn",
+ TokenTree::Group(group) => contains_fn(group.stream()),
+ _ => false,
+ })
+}
diff --git a/serde_derive/src/internals/respan.rs b/serde_derive/src/internals/respan.rs
new file mode 100644
index 000000000..38f6612c4
--- /dev/null
+++ b/serde_derive/src/internals/respan.rs
@@ -0,0 +1,22 @@
+use proc_macro2::{Span, TokenStream};
+use quote::ToTokens;
+use syn::parse::Parse;
+
+pub(crate) fn respan<T>(node: &T, span: Span) -> T
+where
+ T: ToTokens + Parse,
+{
+ let tokens = node.to_token_stream();
+ let respanned = respan_tokens(tokens, span);
+ syn::parse2(respanned).unwrap()
+}
+
+fn respan_tokens(tokens: TokenStream, span: Span) -> TokenStream {
+ tokens
+ .into_iter()
+ .map(|mut token| {
+ token.set_span(span);
+ token
+ })
+ .collect()
+}
diff --git a/serde_derive/src/lib.rs b/serde_derive/src/lib.rs
index 3b4f28817..c34f00722 100644
--- a/serde_derive/src/lib.rs
+++ b/serde_derive/src/lib.rs
@@ -86,8 +86,8 @@ pub fn derive_serialize(input: TokenStream) -> TokenStream {
#[proc_macro_derive(Deserialize, attributes(serde))]
pub fn derive_deserialize(input: TokenStream) -> TokenStream {
- let input = parse_macro_input!(input as DeriveInput);
- de::expand_derive_deserialize(&input)
+ let mut input = parse_macro_input!(input as DeriveInput);
+ de::expand_derive_deserialize(&mut input)
.unwrap_or_else(to_compile_errors)
.into()
}
diff --git a/serde_derive_internals/Cargo.toml b/serde_derive_internals/Cargo.toml
index 64ee1c629..6e9214558 100644
--- a/serde_derive_internals/Cargo.toml
+++ b/serde_derive_internals/Cargo.toml
@@ -16,7 +16,7 @@ path = "lib.rs"
[dependencies]
proc-macro2 = "1.0"
quote = "1.0"
-syn = { version = "1.0.33", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }
+syn = { version = "1.0.33", default-features = false, features = ["derive", "parsing", "printing", "clone-impls", "visit-mut"] }
[package.metadata.docs.rs]
targets = ["x86_64-unknown-linux-gnu"]
| serde-rs/serde | 2020-06-07T09:37:23Z | Thanks! This is a bug. I would accept a PR to fix this.
I assume this just boils down to special casing `Self` in the derive code?
I'll take a look.
Yeah, I imagine what happens is that the field type is referred to from somewhere outside of the Deserialize impl itself, such as from a Visitor impl where Self would refer to the visitor struct and not the output type. Check `cargo expand` to identify where that happens. In that code, we will need to replace `Self` with either the type name (`E` in this case, but making sure to fill in generic parameters if there are any) or a convenient associated type like `Self::Value` if there is already one available that means the right thing. I believe there already is some code for recursively replacing `Self` in types, but if not, the easiest way would be with a syn Fold or VisitMut impl that walks the type and performs the replacement. | 55fdbea20bbcb0f0fa7e9545ec0ea10c87a6643d |
1,827 | diff --git a/test_suite/tests/expand/de_enum.expanded.rs b/test_suite/tests/expand/de_enum.expanded.rs
index 58d40459b..a4ba24911 100644
--- a/test_suite/tests/expand/de_enum.expanded.rs
+++ b/test_suite/tests/expand/de_enum.expanded.rs
@@ -9,7 +9,7 @@ enum DeEnum<B, C, D> {
}
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_DeEnum: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
@@ -261,7 +261,7 @@ const _IMPL_SERIALIZE_FOR_DeEnum: () = {
};
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_DeEnum: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
diff --git a/test_suite/tests/expand/default_ty_param.expanded.rs b/test_suite/tests/expand/default_ty_param.expanded.rs
index 23c243bc0..8aaa3ab43 100644
--- a/test_suite/tests/expand/default_ty_param.expanded.rs
+++ b/test_suite/tests/expand/default_ty_param.expanded.rs
@@ -10,7 +10,7 @@ struct DefaultTyParam<T: AssociatedType<X = i32> = i32> {
}
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_DefaultTyParam: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
@@ -45,7 +45,7 @@ const _IMPL_SERIALIZE_FOR_DefaultTyParam: () = {
};
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_DefaultTyParam: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
diff --git a/test_suite/tests/expand/generic_enum.expanded.rs b/test_suite/tests/expand/generic_enum.expanded.rs
index 899e4fea2..add7c510d 100644
--- a/test_suite/tests/expand/generic_enum.expanded.rs
+++ b/test_suite/tests/expand/generic_enum.expanded.rs
@@ -7,7 +7,7 @@ pub enum GenericEnum<T, U> {
}
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_GenericEnum: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
@@ -110,7 +110,7 @@ const _IMPL_SERIALIZE_FOR_GenericEnum: () = {
};
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
diff --git a/test_suite/tests/expand/generic_struct.expanded.rs b/test_suite/tests/expand/generic_struct.expanded.rs
index 1331e7e96..59d2e51d7 100644
--- a/test_suite/tests/expand/generic_struct.expanded.rs
+++ b/test_suite/tests/expand/generic_struct.expanded.rs
@@ -4,7 +4,7 @@ pub struct GenericStruct<T> {
}
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_GenericStruct: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
@@ -38,7 +38,7 @@ const _IMPL_SERIALIZE_FOR_GenericStruct: () = {
};
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_GenericStruct: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
@@ -400,7 +400,7 @@ const _IMPL_DESERIALIZE_FOR_GenericStruct: () = {
pub struct GenericNewTypeStruct<T>(T);
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_GenericNewTypeStruct: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
@@ -422,7 +422,7 @@ const _IMPL_SERIALIZE_FOR_GenericNewTypeStruct: () = {
};
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_GenericNewTypeStruct: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
diff --git a/test_suite/tests/expand/generic_tuple_struct.expanded.rs b/test_suite/tests/expand/generic_tuple_struct.expanded.rs
index 508667387..8eaf0e7ef 100644
--- a/test_suite/tests/expand/generic_tuple_struct.expanded.rs
+++ b/test_suite/tests/expand/generic_tuple_struct.expanded.rs
@@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize};
pub struct GenericTupleStruct<T, U>(T, U);
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_GenericTupleStruct: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
diff --git a/test_suite/tests/expand/lifetimes.expanded.rs b/test_suite/tests/expand/lifetimes.expanded.rs
index 6916ac905..9840d4401 100644
--- a/test_suite/tests/expand/lifetimes.expanded.rs
+++ b/test_suite/tests/expand/lifetimes.expanded.rs
@@ -7,7 +7,7 @@ enum Lifetimes<'a> {
}
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_Lifetimes: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
@@ -91,7 +91,7 @@ const _IMPL_SERIALIZE_FOR_Lifetimes: () = {
};
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
diff --git a/test_suite/tests/expand/named_map.expanded.rs b/test_suite/tests/expand/named_map.expanded.rs
index 5283993ec..ce43b6634 100644
--- a/test_suite/tests/expand/named_map.expanded.rs
+++ b/test_suite/tests/expand/named_map.expanded.rs
@@ -6,7 +6,7 @@ struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> {
}
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_SerNamedMap: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
@@ -59,7 +59,7 @@ struct DeNamedMap<A, B, C> {
}
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
diff --git a/test_suite/tests/expand/named_tuple.expanded.rs b/test_suite/tests/expand/named_tuple.expanded.rs
index 2966c295e..8b5e4eee0 100644
--- a/test_suite/tests/expand/named_tuple.expanded.rs
+++ b/test_suite/tests/expand/named_tuple.expanded.rs
@@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize};
struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C);
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_SerNamedTuple: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
@@ -51,7 +51,7 @@ const _IMPL_SERIALIZE_FOR_SerNamedTuple: () = {
struct DeNamedTuple<A, B, C>(A, B, C);
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_DeNamedTuple: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
diff --git a/test_suite/tests/expand/named_unit.expanded.rs b/test_suite/tests/expand/named_unit.expanded.rs
index f100688a2..dfe44ddd0 100644
--- a/test_suite/tests/expand/named_unit.expanded.rs
+++ b/test_suite/tests/expand/named_unit.expanded.rs
@@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize};
struct NamedUnit;
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_NamedUnit: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
@@ -17,7 +17,7 @@ const _IMPL_SERIALIZE_FOR_NamedUnit: () = {
};
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_NamedUnit: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
diff --git a/test_suite/tests/expand/ser_enum.expanded.rs b/test_suite/tests/expand/ser_enum.expanded.rs
index cd2723fae..3f4db97d9 100644
--- a/test_suite/tests/expand/ser_enum.expanded.rs
+++ b/test_suite/tests/expand/ser_enum.expanded.rs
@@ -12,7 +12,7 @@ where
}
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_SerEnum: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
diff --git a/test_suite/tests/expand/void.expanded.rs b/test_suite/tests/expand/void.expanded.rs
index e7db4ac2f..fb98c321a 100644
--- a/test_suite/tests/expand/void.expanded.rs
+++ b/test_suite/tests/expand/void.expanded.rs
@@ -2,7 +2,7 @@ use serde::{Deserialize, Serialize};
enum Void {}
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_Void: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
@@ -17,7 +17,7 @@ const _IMPL_SERIALIZE_FOR_Void: () = {
};
#[doc(hidden)]
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_Void: () = {
+const _: () = {
#[allow(rust_2018_idioms, clippy::useless_attribute)]
extern crate serde as _serde;
#[automatically_derived]
| [
"1683"
] | serde-rs__serde-1827 | Use underscore consts on rustc 1.37+
https://blog.rust-lang.org/2019/08/15/Rust-1.37.0.html#using-unnamed-const-items-for-macros
This would tend to produce more readable error messages, because the paths currently emitted by rustc in error messages are silly (https://github.com/rust-lang/rust/issues/46991).
It will require adding a build.rs script to serde_derive similar to the one that exists in serde.
| 1.11 | 6980727d74e1b4fd0f2bff85e824e2c47ca08ba3 | diff --git a/serde_derive/Cargo.toml b/serde_derive/Cargo.toml
index 879a65199..2e90c0b91 100644
--- a/serde_derive/Cargo.toml
+++ b/serde_derive/Cargo.toml
@@ -9,7 +9,7 @@ repository = "https://github.com/serde-rs/serde"
documentation = "https://serde.rs/derive.html"
keywords = ["serde", "serialization", "no_std"]
readme = "crates-io.md"
-include = ["src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
[features]
default = []
diff --git a/serde_derive/build.rs b/serde_derive/build.rs
new file mode 100644
index 000000000..a2c481a4a
--- /dev/null
+++ b/serde_derive/build.rs
@@ -0,0 +1,30 @@
+use std::env;
+use std::process::Command;
+use std::str;
+
+// The rustc-cfg strings below are *not* public API. Please let us know by
+// opening a GitHub issue if your build environment requires some way to enable
+// these cfgs other than by executing our build script.
+fn main() {
+ let minor = match rustc_minor_version() {
+ Some(minor) => minor,
+ None => return,
+ };
+
+ // Underscore const names stabilized in Rust 1.37:
+ // https://github.com/rust-lang/rust/pull/61347
+ if minor >= 37 {
+ println!("cargo:rustc-cfg=underscore_consts");
+ }
+}
+
+fn rustc_minor_version() -> Option<u32> {
+ let rustc = env::var_os("RUSTC")?;
+ let output = Command::new(rustc).arg("--version").output().ok()?;
+ let version = str::from_utf8(&output.stdout).ok()?;
+ let mut pieces = version.split('.');
+ if pieces.next() != Some("rustc 1") {
+ return None;
+ }
+ pieces.next()?.parse().ok()
+}
diff --git a/serde_derive/src/dummy.rs b/serde_derive/src/dummy.rs
index d55baf29c..9a4e5f085 100644
--- a/serde_derive/src/dummy.rs
+++ b/serde_derive/src/dummy.rs
@@ -1,4 +1,5 @@
-use proc_macro2::{Ident, Span, TokenStream};
+use proc_macro2::{Ident, TokenStream};
+use quote::format_ident;
use syn;
use try;
@@ -11,10 +12,11 @@ pub fn wrap_in_const(
) -> TokenStream {
let try_replacement = try::replacement();
- let dummy_const = Ident::new(
- &format!("_IMPL_{}_FOR_{}", trait_, unraw(ty)),
- Span::call_site(),
- );
+ let dummy_const = if cfg!(underscore_consts) {
+ format_ident!("_")
+ } else {
+ format_ident!("_IMPL_{}_FOR_{}", trait_, unraw(ty))
+ };
let use_serde = match serde_path {
Some(path) => quote! {
| serde-rs/serde | 2020-06-07T00:17:10Z | 8084258a3edc1dc4007e8df7f24b022d015b5fb0 | |
1,805 | diff --git a/test_suite/tests/test_gen.rs b/test_suite/tests/test_gen.rs
index 92bb0ae1f..c429500c1 100644
--- a/test_suite/tests/test_gen.rs
+++ b/test_suite/tests/test_gen.rs
@@ -691,6 +691,16 @@ fn test_gen() {
#[serde(flatten, skip_deserializing)]
flat: T,
}
+
+ // https://github.com/serde-rs/serde/issues/1804
+ #[derive(Serialize, Deserialize)]
+ enum Message {
+ #[serde(skip)]
+ #[allow(dead_code)]
+ String(String),
+ #[serde(other)]
+ Unknown,
+ }
}
//////////////////////////////////////////////////////////////////////////
| [
"1804"
] | serde-rs__serde-1805 | derive(Deserialize) panics with index out of bounds for `#[serde(skip)]`
Observed in this commit
https://github.com/matklad/cargo_metadata/commit/0b1c8d85c860fe9fb3488fea5990d659780065fc
```
Compiling cargo_metadata v0.9.1 (/home/matklad/projects/cargo_metadata)
error: proc-macro derive panicked
--> src/messages.rs:99:35
|
99 | #[derive(Debug, Clone, Serialize, Deserialize)]
| ^^^^^^^^^^^
|
= help: message: index out of bounds: the len is 5 but the index is 5
error: aborting due to previous error
error: could not compile `cargo_metadata`.
```
I think I am doing something very stupid with this skip, which is a bug in my code, *but* I think serde still should not panic, but rather explain me that I am holding it wrong?
serde_derive version = "1.0.106"
| 1.10 | 099fa25b86524f07d86852ea2de071e8dd2a653f | diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs
index 5ccd38a8f..74df11df7 100644
--- a/serde_derive/src/de.rs
+++ b/serde_derive/src/de.rs
@@ -1153,10 +1153,13 @@ fn prepare_enum_variant_enum(
variants: &[Variant],
cattrs: &attr::Container,
) -> (TokenStream, Stmts) {
- let variant_names_idents: Vec<_> = variants
+ let mut deserialized_variants = variants
.iter()
.enumerate()
- .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
+ .filter(|&(_, variant)| !variant.attrs.skip_deserializing());
+
+ let variant_names_idents: Vec<_> = deserialized_variants
+ .clone()
.map(|(i, variant)| {
(
variant.attrs.name().deserialize_name(),
@@ -1166,7 +1169,7 @@ fn prepare_enum_variant_enum(
})
.collect();
- let other_idx = variants.iter().position(|variant| variant.attrs.other());
+ let other_idx = deserialized_variants.position(|(_, variant)| variant.attrs.other());
let variants_stmt = {
let variant_names = variant_names_idents.iter().map(|(name, _, _)| name);
| serde-rs/serde | 2020-05-08T22:40:13Z | 099fa25b86524f07d86852ea2de071e8dd2a653f | |
1,706 | diff --git a/test_suite/tests/test_macros.rs b/test_suite/tests/test_macros.rs
index d4456bed7..c0c807ec7 100644
--- a/test_suite/tests/test_macros.rs
+++ b/test_suite/tests/test_macros.rs
@@ -1145,6 +1145,20 @@ fn test_adjacently_tagged_enum() {
],
);
+ // optional newtype with no content field
+ assert_de_tokens(
+ &AdjacentlyTagged::Newtype::<Option<u8>>(None),
+ &[
+ Token::Struct {
+ name: "AdjacentlyTagged",
+ len: 1,
+ },
+ Token::Str("t"),
+ Token::Str("Newtype"),
+ Token::StructEnd,
+ ],
+ );
+
// tuple with tag first
assert_tokens(
&AdjacentlyTagged::Tuple::<u8>(1, 1),
| [
"1553"
] | serde-rs__serde-1706 | Optional content for enum variants?
Hi!
I need to de/serialize JSON messages such as the following:
```javascript
{ ..., "command": "cmd1", "arguments": { <command-dependent> } }
```
So far so good, this fits the adjacently tagged enum representation.
The wrinkle is that for some commands the `arguments` field may be optional. I tried modelling this as
```rust
#[serde(tag = "command", content = "arguments")]
enum Command {
cmd1(Option<Cmd1Arguments>)
...
}
```
but Serde is not liking it and complains about "missing field \`arguments\`".
Any suggestions? (besides custom serialization)
| 1.10 | a81968af3caea9528e8e935a9a19ccad19a16778 | diff --git a/serde_derive/src/de.rs b/serde_derive/src/de.rs
index 64113a603..c3b779bf9 100644
--- a/serde_derive/src/de.rs
+++ b/serde_derive/src/de.rs
@@ -1379,42 +1379,37 @@ fn deserialize_adjacently_tagged_enum(
}
};
- fn is_unit(variant: &Variant) -> bool {
- match variant.style {
- Style::Unit => true,
- Style::Struct | Style::Tuple | Style::Newtype => false,
- }
- }
+ let arms = variants
+ .iter()
+ .enumerate()
+ .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
+ .filter_map(|(i, variant)| {
+ let variant_index = field_i(i);
+ let variant_ident = &variant.ident;
- let mut missing_content = quote! {
- _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#content))
- };
- if variants.iter().any(is_unit) {
- let fallthrough = if variants.iter().all(is_unit) {
- None
- } else {
+ let arm = match variant.style {
+ Style::Unit => quote! {
+ _serde::export::Ok(#this::#variant_ident)
+ },
+ Style::Newtype if variant.attrs.deserialize_with().is_none() => {
+ let span = variant.original.span();
+ let func = quote_spanned!(span=> _serde::private::de::missing_field);
+ quote! {
+ #func(#content).map(#this::#variant_ident)
+ }
+ }
+ _ => return None,
+ };
Some(quote! {
- _ => #missing_content
+ __Field::#variant_index => #arm,
})
- };
- let arms = variants
- .iter()
- .enumerate()
- .filter(|&(_, variant)| !variant.attrs.skip_deserializing() && is_unit(variant))
- .map(|(i, variant)| {
- let variant_index = field_i(i);
- let variant_ident = &variant.ident;
- quote! {
- __Field::#variant_index => _serde::export::Ok(#this::#variant_ident),
- }
- });
- missing_content = quote! {
- match __field {
- #(#arms)*
- #fallthrough
- }
- };
- }
+ });
+ let missing_content = quote! {
+ match __field {
+ #(#arms)*
+ _ => _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#content))
+ }
+ };
// Advance the map by one key, returning early in case of error.
let next_key = quote! {
| serde-rs/serde | 2020-01-06T21:07:44Z | 099fa25b86524f07d86852ea2de071e8dd2a653f | |
1,695 | diff --git a/test_suite/tests/test_macros.rs b/test_suite/tests/test_macros.rs
index 0594d8d45..d95fa928f 100644
--- a/test_suite/tests/test_macros.rs
+++ b/test_suite/tests/test_macros.rs
@@ -1924,6 +1924,62 @@ fn test_rename_all() {
);
}
+#[test]
+fn test_rename_all_fields() {
+ #[derive(Serialize, Deserialize, Debug, PartialEq)]
+ #[serde(rename_all_fields = "kebab-case")]
+ enum E {
+ V1,
+ V2(bool),
+ V3 {
+ a_field: bool,
+ another_field: bool,
+ #[serde(rename = "last-field")]
+ yet_another_field: bool,
+ },
+ #[serde(rename_all = "snake_case")]
+ V4 {
+ a_field: bool,
+ },
+ }
+
+ assert_tokens(
+ &E::V3 {
+ a_field: true,
+ another_field: true,
+ yet_another_field: true,
+ },
+ &[
+ Token::StructVariant {
+ name: "E",
+ variant: "V3",
+ len: 3,
+ },
+ Token::Str("a-field"),
+ Token::Bool(true),
+ Token::Str("another-field"),
+ Token::Bool(true),
+ Token::Str("last-field"),
+ Token::Bool(true),
+ Token::StructVariantEnd,
+ ],
+ );
+
+ assert_tokens(
+ &E::V4 { a_field: true },
+ &[
+ Token::StructVariant {
+ name: "E",
+ variant: "V4",
+ len: 1,
+ },
+ Token::Str("a_field"),
+ Token::Bool(true),
+ Token::StructVariantEnd,
+ ],
+ );
+}
+
#[test]
fn test_untagged_newtype_variant_containing_unit_struct_not_map() {
#[derive(Debug, PartialEq, Serialize, Deserialize)]
| [
"1061"
] | serde-rs__serde-1695 | Apply rename_all to enum member "fields"
When using enums with struct-like members it would be useful if `rename_all` on the enclosing enum could apply to the members, too. For example:
```rust
#[serde(untagged, rename_all = "camelCase" )]
pub enum Value {
Null { null_value: () },
String { string_value: String },
Boolean { boolean_value: bool },
}
```
could do
```json
Value::String("foo".to_string())
=>
{ "stringValue": "foo" }
------^-----
|
This here is what I want
```
Currently the annotation has to be placed on the fields in addition:
```rust
#[serde(untagged)]
pub enum Value {
Null {
#[serde(rename = "nullValue")]
null_value: ()
},
String {
#[serde(rename = "stringValue")]
string_value: String
},
/* etc. */
}
```
(If you're wondering what is going on with this type, it's [Google Datastore](https://cloud.google.com/datastore/docs/reference/rest/v1/projects/runQuery#Value)).
| 1.17 | ad94aed75398d43d174368aa8c4869332bb94e33 | diff --git a/serde_derive/src/internals/ast.rs b/serde_derive/src/internals/ast.rs
index 8bcb0ecd1..75b28c969 100644
--- a/serde_derive/src/internals/ast.rs
+++ b/serde_derive/src/internals/ast.rs
@@ -88,9 +88,12 @@ impl<'a> Container<'a> {
if field.attrs.flatten() {
has_flatten = true;
}
- field
- .attrs
- .rename_by_rules(variant.attrs.rename_all_rules());
+ field.attrs.rename_by_rules(
+ variant
+ .attrs
+ .rename_all_rules()
+ .or(attrs.rename_all_fields_rules()),
+ );
}
}
}
diff --git a/serde_derive/src/internals/attr.rs b/serde_derive/src/internals/attr.rs
index 42212a64d..133299564 100644
--- a/serde_derive/src/internals/attr.rs
+++ b/serde_derive/src/internals/attr.rs
@@ -193,11 +193,23 @@ impl Name {
}
}
+#[derive(Copy, Clone)]
pub struct RenameAllRules {
serialize: RenameRule,
deserialize: RenameRule,
}
+impl RenameAllRules {
+ /// Returns a new `RenameAllRules` with the individual rules of `self` and
+ /// `other_rules` joined by `RenameRules::or`.
+ pub fn or(self, other_rules: Self) -> Self {
+ Self {
+ serialize: self.serialize.or(other_rules.serialize),
+ deserialize: self.deserialize.or(other_rules.deserialize),
+ }
+ }
+}
+
/// Represents struct or enum attribute information.
pub struct Container {
name: Name,
@@ -205,6 +217,7 @@ pub struct Container {
deny_unknown_fields: bool,
default: Default,
rename_all_rules: RenameAllRules,
+ rename_all_fields_rules: RenameAllRules,
ser_bound: Option<Vec<syn::WherePredicate>>,
de_bound: Option<Vec<syn::WherePredicate>>,
tag: TagType,
@@ -288,6 +301,8 @@ impl Container {
let mut default = Attr::none(cx, DEFAULT);
let mut rename_all_ser_rule = Attr::none(cx, RENAME_ALL);
let mut rename_all_de_rule = Attr::none(cx, RENAME_ALL);
+ let mut rename_all_fields_ser_rule = Attr::none(cx, RENAME_ALL_FIELDS);
+ let mut rename_all_fields_de_rule = Attr::none(cx, RENAME_ALL_FIELDS);
let mut ser_bound = Attr::none(cx, BOUND);
let mut de_bound = Attr::none(cx, BOUND);
let mut untagged = BoolAttr::none(cx, UNTAGGED);
@@ -341,6 +356,44 @@ impl Container {
}
}
}
+ } else if meta.path == RENAME_ALL_FIELDS {
+ // #[serde(rename_all_fields = "foo")]
+ // #[serde(rename_all_fields(serialize = "foo", deserialize = "bar"))]
+ let one_name = meta.input.peek(Token![=]);
+ let (ser, de) = get_renames(cx, RENAME_ALL_FIELDS, &meta)?;
+
+ match item.data {
+ syn::Data::Enum(_) => {
+ if let Some(ser) = ser {
+ match RenameRule::from_str(&ser.value()) {
+ Ok(rename_rule) => {
+ rename_all_fields_ser_rule.set(&meta.path, rename_rule);
+ }
+ Err(err) => cx.error_spanned_by(ser, err),
+ }
+ }
+ if let Some(de) = de {
+ match RenameRule::from_str(&de.value()) {
+ Ok(rename_rule) => {
+ rename_all_fields_de_rule.set(&meta.path, rename_rule);
+ }
+ Err(err) => {
+ if !one_name {
+ cx.error_spanned_by(de, err);
+ }
+ }
+ }
+ }
+ }
+ syn::Data::Struct(_) => {
+ let msg = "#[serde(rename_all_fields)] can only be used on enums";
+ cx.error_spanned_by(&meta.path, msg);
+ }
+ syn::Data::Union(_) => {
+ let msg = "#[serde(rename_all_fields)] can only be used on enums";
+ cx.error_spanned_by(&meta.path, msg);
+ }
+ }
} else if meta.path == TRANSPARENT {
// #[serde(transparent)]
transparent.set_true(meta.path);
@@ -528,6 +581,10 @@ impl Container {
serialize: rename_all_ser_rule.get().unwrap_or(RenameRule::None),
deserialize: rename_all_de_rule.get().unwrap_or(RenameRule::None),
},
+ rename_all_fields_rules: RenameAllRules {
+ serialize: rename_all_fields_ser_rule.get().unwrap_or(RenameRule::None),
+ deserialize: rename_all_fields_de_rule.get().unwrap_or(RenameRule::None),
+ },
ser_bound: ser_bound.get(),
de_bound: de_bound.get(),
tag: decide_tag(cx, item, untagged, internal_tag, content),
@@ -547,8 +604,12 @@ impl Container {
&self.name
}
- pub fn rename_all_rules(&self) -> &RenameAllRules {
- &self.rename_all_rules
+ pub fn rename_all_rules(&self) -> RenameAllRules {
+ self.rename_all_rules
+ }
+
+ pub fn rename_all_fields_rules(&self) -> RenameAllRules {
+ self.rename_all_fields_rules
}
pub fn transparent(&self) -> bool {
@@ -921,7 +982,7 @@ impl Variant {
self.name.deserialize_aliases()
}
- pub fn rename_by_rules(&mut self, rules: &RenameAllRules) {
+ pub fn rename_by_rules(&mut self, rules: RenameAllRules) {
if !self.name.serialize_renamed {
self.name.serialize = rules.serialize.apply_to_variant(&self.name.serialize);
}
@@ -930,8 +991,8 @@ impl Variant {
}
}
- pub fn rename_all_rules(&self) -> &RenameAllRules {
- &self.rename_all_rules
+ pub fn rename_all_rules(&self) -> RenameAllRules {
+ self.rename_all_rules
}
pub fn ser_bound(&self) -> Option<&[syn::WherePredicate]> {
@@ -1260,7 +1321,7 @@ impl Field {
self.name.deserialize_aliases()
}
- pub fn rename_by_rules(&mut self, rules: &RenameAllRules) {
+ pub fn rename_by_rules(&mut self, rules: RenameAllRules) {
if !self.name.serialize_renamed {
self.name.serialize = rules.serialize.apply_to_field(&self.name.serialize);
}
diff --git a/serde_derive/src/internals/case.rs b/serde_derive/src/internals/case.rs
index 554505160..e769462cd 100644
--- a/serde_derive/src/internals/case.rs
+++ b/serde_derive/src/internals/case.rs
@@ -59,8 +59,8 @@ impl RenameRule {
}
/// Apply a renaming rule to an enum variant, returning the version expected in the source.
- pub fn apply_to_variant(&self, variant: &str) -> String {
- match *self {
+ pub fn apply_to_variant(self, variant: &str) -> String {
+ match self {
None | PascalCase => variant.to_owned(),
LowerCase => variant.to_ascii_lowercase(),
UpperCase => variant.to_ascii_uppercase(),
@@ -84,8 +84,8 @@ impl RenameRule {
}
/// Apply a renaming rule to a struct field, returning the version expected in the source.
- pub fn apply_to_field(&self, field: &str) -> String {
- match *self {
+ pub fn apply_to_field(self, field: &str) -> String {
+ match self {
None | LowerCase | SnakeCase => field.to_owned(),
UpperCase => field.to_ascii_uppercase(),
PascalCase => {
@@ -112,6 +112,14 @@ impl RenameRule {
ScreamingKebabCase => ScreamingSnakeCase.apply_to_field(field).replace('_', "-"),
}
}
+
+ /// Returns the `RenameRule` if it is not `None`, `rule_b` otherwise.
+ pub fn or(self, rule_b: Self) -> Self {
+ match self {
+ None => rule_b,
+ _ => self,
+ }
+ }
}
pub struct ParseError<'a> {
diff --git a/serde_derive/src/internals/symbol.rs b/serde_derive/src/internals/symbol.rs
index 9606edb5f..68091fb85 100644
--- a/serde_derive/src/internals/symbol.rs
+++ b/serde_derive/src/internals/symbol.rs
@@ -23,6 +23,7 @@ pub const OTHER: Symbol = Symbol("other");
pub const REMOTE: Symbol = Symbol("remote");
pub const RENAME: Symbol = Symbol("rename");
pub const RENAME_ALL: Symbol = Symbol("rename_all");
+pub const RENAME_ALL_FIELDS: Symbol = Symbol("rename_all_fields");
pub const REPR: Symbol = Symbol("repr");
pub const SERDE: Symbol = Symbol("serde");
pub const SERIALIZE: Symbol = Symbol("serialize");
| serde-rs/serde | 2019-12-15T18:14:14Z | Seems reasonable. Do you have a suggestion for how this should work? Simplify changing the meaning of `rename_all` would be a breaking change.
Side note: representing the datastore value the following way may be more convenient. This avoids restating the type twice in Rust code -- <code>Value::<b>Boolean</b>(true)</code> instead of <code>Value::<b>Boolean</b> { <b>boolean</b>_value: true }</code>.
```rust
#[derive(Serialize, Deserialize)]
enum Value {
#[serde(rename = "nullValue", with = "null")]
Null,
#[serde(rename = "stringValue")]
String(String),
#[serde(rename = "booleanValue")]
Boolean(bool),
}
// Serialize the unit variant `Value::Null` as `{"nullValue":null}` rather
// than the default `"nullValue"`.
mod null {
use serde::{Serialize, Serializer, Deserialize, Deserializer};
pub fn serialize<S>(serializer: S) -> Result<S::Ok, S::Error>
where S: Serializer
{
().serialize(serializer)
}
pub fn deserialize<'de, D>(deserializer: D) -> Result<(), D::Error>
where D: Deserializer<'de>
{
<()>::deserialize(deserializer)
}
}
```
Thanks for a quick reply! I'm really enjoying `serde` btw, easily the most pleasant serialisation lib I've worked with so far :-)
----------------
> Do you have a suggestion for how this should work? Simplify changing the meaning of rename_all would be a breaking change.
Agreed, maybe it's sensible to have a separate `rename_fields` for this that would both apply to `struct` and `enum`-member fields?
---------------
> Side note: representing the datastore value the following way may be more convenient
The problem is that the enum is "key-tagged", i.e. it's adjacent to other keys inside of a different struct and the *key* that contains the `Value` determines its type.
I haven't found a better way than the current `untagged` solution, but I also really need to stop thinking about this for today and find a nearby bed! ;-)
Maybe instead of `rename_all` we should have had distinct `rename_fields` and `rename_variants` attributes, so that you can write both to get the desired effect.
It may be confusing to add those now and *not* have `rename_all` mean rename both fields and variants.
I would be willing to consider a pull request that adds a `serde(rename_all_fields = "...")` attribute for enums that applies a rename rule to every field of every variant. | ad94aed75398d43d174368aa8c4869332bb94e33 |
End of preview. Expand
in Data Studio
README.md exists but content is empty.
- Downloads last month
- 5