pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-04-30 23:38:02 +00:00
Code Issues Packages Projects Releases Wiki Activity

Touch up PR 2553

Browse Source
This commit is contained in:
David Tolnay
2023-08-05 22:12:38 -07:00
parent 73931692b2
commit bd7b0e257e
8 changed files with 62 additions and 66 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde_derive/src/internals/attr.rs
+6 -6
View File
@@ -400,16 +400,16 @@ impl Container {
default.set(&meta.path, Default::Path(path)); default.set(&meta.path, Default::Path(path));
} }
syn::Fields::Unit => { syn::Fields::Unit => {
let msg = "#[serde(default = \"...\")] can only be used on structs with fields"; let msg = "#[serde(default = \"...\")] can only be used on structs that have fields";
cx.syn_error(meta.error(msg)); cx.syn_error(meta.error(msg));
} }
}, },
syn::Data::Enum(_) => { syn::Data::Enum(_) => {
let msg = "#[serde(default = \"...\")] can only be used on structs with fields"; let msg = "#[serde(default = \"...\")] can only be used on structs";
cx.syn_error(meta.error(msg)); cx.syn_error(meta.error(msg));
} }
syn::Data::Union(_) => { syn::Data::Union(_) => {
let msg = "#[serde(default = \"...\")] can only be used on structs with fields"; let msg = "#[serde(default = \"...\")] can only be used on structs";
cx.syn_error(meta.error(msg)); cx.syn_error(meta.error(msg));
} }
} }
@@ -422,16 +422,16 @@ impl Container {
default.set(meta.path, Default::Default); default.set(meta.path, Default::Default);
} }
syn::Fields::Unit => { syn::Fields::Unit => {
let msg = "#[serde(default)] can only be used on structs with fields"; let msg = "#[serde(default)] can only be used on structs that have fields";
cx.error_spanned_by(fields, msg); cx.error_spanned_by(fields, msg);
} }
}, },
syn::Data::Enum(_) => { syn::Data::Enum(_) => {
let msg = "#[serde(default)] can only be used on structs with fields"; let msg = "#[serde(default)] can only be used on structs";
cx.syn_error(meta.error(msg)); cx.syn_error(meta.error(msg));
} }
syn::Data::Union(_) => { syn::Data::Union(_) => {
let msg = "#[serde(default)] can only be used on structs with fields"; let msg = "#[serde(default)] can only be used on structs";
cx.syn_error(meta.error(msg)); cx.syn_error(meta.error(msg));
} }
} }
serde_derive/src/internals/check.rs
+10 -12
View File
@@ -18,19 +18,19 @@ pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
check_from_and_try_from(cx, cont); check_from_and_try_from(cx, cont);
} }
/// If some field of tuple is marked as `#[serde(default)]` then all subsequent // If some field of a tuple struct is marked #[serde(default)] then all fields
/// fields also should be marked with that attribute or the struct itself should // after it must also be marked with that attribute, or the struct must have a
/// have this attribute. This is because using default value for a field is // container-level serde(default) attribute. A field's default value is only
/// possible only if the sequence is exhausted that means that all subsequent // used for tuple fields if the sequence is exhausted at that point; that means
/// fields will fail to deserialize and should provide a default value if we want // all subsequent fields will fail to deserialize if they don't have their own
/// the successful deserialization. // default.
fn check_default_on_tuple(cx: &Ctxt, cont: &Container) { fn check_default_on_tuple(cx: &Ctxt, cont: &Container) {
if let Default::None = cont.attrs.default() { if let Default::None = cont.attrs.default() {
if let Data::Struct(Style::Tuple, fields) = &cont.data { if let Data::Struct(Style::Tuple, fields) = &cont.data {
let mut first_default_index = None; let mut first_default_index = None;
for (i, field) in fields.iter().enumerate() { for (i, field) in fields.iter().enumerate() {
// Skipped fields automatically get the #[serde(default)] attribute // Skipped fields automatically get the #[serde(default)]
// We interested only on non-skipped fields here // attribute. We are interested only on non-skipped fields here.
if field.attrs.skip_deserializing() { if field.attrs.skip_deserializing() {
continue; continue;
} }
@@ -38,19 +38,17 @@ fn check_default_on_tuple(cx: &Ctxt, cont: &Container) {
if let Some(first) = first_default_index { if let Some(first) = first_default_index {
cx.error_spanned_by( cx.error_spanned_by(
field.ty, field.ty,
format!("struct or field must have #[serde(default)] because previous field {} have #[serde(default)]", first), format!("field must have #[serde(default)] because previous field {} has #[serde(default)]", first),
); );
} }
continue; continue;
} }
if let None = first_default_index { if first_default_index.is_none() {
first_default_index = Some(i); first_default_index = Some(i);
} }
} }
} }
} }
// TODO: Warn if container has default and all fields also marked with default
// when warnings in proc-macro become available
} }
// Remote derive definition type must have either all of the generics of the // Remote derive definition type must have either all of the generics of the
test_suite/tests/ui/default-attribute/enum.stderr
+1 -1
View File
@@ -1,4 +1,4 @@
error: #[serde(default)] can only be used on structs with fields error: #[serde(default)] can only be used on structs
--> tests/ui/default-attribute/enum.rs:4:9 --> tests/ui/default-attribute/enum.rs:4:9
| |
4 | #[serde(default)] 4 | #[serde(default)]
test_suite/tests/ui/default-attribute/enum_path.stderr
+1 -1
View File
@@ -1,4 +1,4 @@
error: #[serde(default = "...")] can only be used on structs with fields error: #[serde(default = "...")] can only be used on structs
--> tests/ui/default-attribute/enum_path.rs:4:9 --> tests/ui/default-attribute/enum_path.rs:4:9
| |
4 | #[serde(default = "default_e")] 4 | #[serde(default = "default_e")]
test_suite/tests/ui/default-attribute/tuple_struct.rs
+14 -15
View File
@@ -1,46 +1,45 @@
use serde_derive::Deserialize; use serde_derive::Deserialize;
/// No errors expected // No errors expected.
#[derive(Deserialize)] #[derive(Deserialize)]
struct T0(u8, u8); struct T0(u8, u8);
/// No errors expected: // No errors expected:
/// - if both fields are provided, both gets value from data // - If both fields are provided, both get value from data.
/// - if only one field is provided, the second gets default value // - If only one field is provided, the second gets default value.
#[derive(Deserialize)] #[derive(Deserialize)]
struct T1(u8, #[serde(default)] u8); struct T1(u8, #[serde(default)] u8);
/// Errors expected -- the first field can get default value only if sequence is // ERROR: The first field can get default value only if sequence is empty, but
/// empty, but that mean that all other fields cannot be deserialized without // that mean that all other fields cannot be deserialized without errors.
/// errors, so the `#[serde(default)]` attribute is superfluous
#[derive(Deserialize)] #[derive(Deserialize)]
struct T2(#[serde(default)] u8, u8, u8); struct T2(#[serde(default)] u8, u8, u8);
/// No errors expected: // No errors expected:
/// - if both fields are provided, both gets value from data // - If both fields are provided, both get value from data.
/// - if only one field is provided, the second gets default value // - If only one field is provided, the second gets default value.
/// - if none fields are provided, both gets default value // - If no fields are provided, both get default value.
#[derive(Deserialize)] #[derive(Deserialize)]
struct T3(#[serde(default)] u8, #[serde(default)] u8); struct T3(#[serde(default)] u8, #[serde(default)] u8);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// No errors expected -- missing fields gets default values // No errors expected -- missing fields get default values.
#[derive(Deserialize, Default)] #[derive(Deserialize, Default)]
#[serde(default)] #[serde(default)]
struct T4(u8, u8); struct T4(u8, u8);
/// No errors expected -- missing fields gets default values // No errors expected -- missing fields get default values.
#[derive(Deserialize, Default)] #[derive(Deserialize, Default)]
#[serde(default)] #[serde(default)]
struct T5(#[serde(default)] u8, u8); struct T5(#[serde(default)] u8, u8);
/// No errors expected -- missing fields gets default values // No errors expected -- missing fields get default values.
#[derive(Deserialize, Default)] #[derive(Deserialize, Default)]
#[serde(default)] #[serde(default)]
struct T6(u8, #[serde(default)] u8); struct T6(u8, #[serde(default)] u8);
/// No errors expected -- missing fields gets default values // No errors expected -- missing fields get default values.
#[derive(Deserialize, Default)] #[derive(Deserialize, Default)]
#[serde(default)] #[serde(default)]
struct T7(#[serde(default)] u8, #[serde(default)] u8); struct T7(#[serde(default)] u8, #[serde(default)] u8);
test_suite/tests/ui/default-attribute/tuple_struct.stderr
+6 -6
View File
@@ -1,11 +1,11 @@
error: struct or field must have #[serde(default)] because previous field 0 have #[serde(default)] error: field must have #[serde(default)] because previous field 0 has #[serde(default)]
--> tests/ui/default-attribute/tuple_struct.rs:17:33 --> tests/ui/default-attribute/tuple_struct.rs:16:33
| |
17 | struct T2(#[serde(default)] u8, u8, u8); 16 | struct T2(#[serde(default)] u8, u8, u8);
| ^^ | ^^
error: struct or field must have #[serde(default)] because previous field 0 have #[serde(default)] error: field must have #[serde(default)] because previous field 0 has #[serde(default)]
--> tests/ui/default-attribute/tuple_struct.rs:17:37 --> tests/ui/default-attribute/tuple_struct.rs:16:37
| |
17 | struct T2(#[serde(default)] u8, u8, u8); 16 | struct T2(#[serde(default)] u8, u8, u8);
| ^^ | ^^
test_suite/tests/ui/default-attribute/tuple_struct_path.rs
+18 -19
View File
@@ -4,72 +4,71 @@ fn d<T>() -> T {
unimplemented!() unimplemented!()
} }
/// No errors expected: // No errors expected:
/// - if both fields are provided, both gets value from data // - If both fields are provided, both get value from data.
/// - if only one field is provided, the second gets default value // - If only one field is provided, the second gets default value.
#[derive(Deserialize)] #[derive(Deserialize)]
struct T1(u8, #[serde(default = "d")] u8); struct T1(u8, #[serde(default = "d")] u8);
/// Errors expected -- the first field can get default value only if sequence is // ERROR: The first field can get default value only if sequence is empty, but
/// empty, but that mean that all other fields cannot be deserialized without // that mean that all other fields cannot be deserialized without errors.
/// errors, so the `#[serde(default)]` attribute is superfluous
#[derive(Deserialize)] #[derive(Deserialize)]
struct T2(#[serde(default = "d")] u8, u8, u8); struct T2(#[serde(default = "d")] u8, u8, u8);
/// No errors expected: // No errors expected:
/// - if both fields are provided, both gets value from data // - If both fields are provided, both get value from data.
/// - if only one field is provided, the second gets default value // - If only one field is provided, the second gets default value.
/// - if none fields are provided, both gets default value // - If no fields are provided, both get default value.
#[derive(Deserialize)] #[derive(Deserialize)]
struct T3(#[serde(default = "d")] u8, #[serde(default = "d")] u8); struct T3(#[serde(default = "d")] u8, #[serde(default = "d")] u8);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// No errors expected -- missing fields gets default values // No errors expected -- missing fields get default values.
#[derive(Deserialize, Default)] #[derive(Deserialize, Default)]
#[serde(default)] #[serde(default)]
struct T1D(#[serde(default = "d")] u8, u8); struct T1D(#[serde(default = "d")] u8, u8);
/// No errors expected -- missing fields gets default values // No errors expected -- missing fields get default values.
#[derive(Deserialize, Default)] #[derive(Deserialize, Default)]
#[serde(default)] #[serde(default)]
struct T2D(u8, #[serde(default = "d")] u8); struct T2D(u8, #[serde(default = "d")] u8);
/// No errors expected -- missing fields gets default values // No errors expected -- missing fields get default values.
#[derive(Deserialize, Default)] #[derive(Deserialize, Default)]
#[serde(default)] #[serde(default)]
struct T3D(#[serde(default = "d")] u8, #[serde(default = "d")] u8); struct T3D(#[serde(default = "d")] u8, #[serde(default = "d")] u8);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// No errors expected -- missing fields gets default values // No errors expected -- missing fields get default values.
#[derive(Deserialize)] #[derive(Deserialize)]
#[serde(default = "d")] #[serde(default = "d")]
struct T1Path(#[serde(default)] u8, u8); struct T1Path(#[serde(default)] u8, u8);
/// No errors expected -- missing fields gets default values // No errors expected -- missing fields get default values.
#[derive(Deserialize)] #[derive(Deserialize)]
#[serde(default = "d")] #[serde(default = "d")]
struct T2Path(u8, #[serde(default)] u8); struct T2Path(u8, #[serde(default)] u8);
/// No errors expected -- missing fields gets default values // No errors expected -- missing fields get default values.
#[derive(Deserialize)] #[derive(Deserialize)]
#[serde(default = "d")] #[serde(default = "d")]
struct T3Path(#[serde(default)] u8, #[serde(default)] u8); struct T3Path(#[serde(default)] u8, #[serde(default)] u8);
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
/// No errors expected -- missing fields gets default values // No errors expected -- missing fields get default values.
#[derive(Deserialize)] #[derive(Deserialize)]
#[serde(default = "d")] #[serde(default = "d")]
struct T1PathD(#[serde(default = "d")] u8, u8); struct T1PathD(#[serde(default = "d")] u8, u8);
/// No errors expected -- missing fields gets default values // No errors expected -- missing fields get default values.
#[derive(Deserialize)] #[derive(Deserialize)]
#[serde(default = "d")] #[serde(default = "d")]
struct T2PathD(u8, #[serde(default = "d")] u8); struct T2PathD(u8, #[serde(default = "d")] u8);
/// No errors expected -- missing fields gets default values // No errors expected -- missing fields get default values.
#[derive(Deserialize)] #[derive(Deserialize)]
#[serde(default = "d")] #[serde(default = "d")]
struct T3PathD(#[serde(default = "d")] u8, #[serde(default = "d")] u8); struct T3PathD(#[serde(default = "d")] u8, #[serde(default = "d")] u8);
test_suite/tests/ui/default-attribute/tuple_struct_path.stderr
+6 -6
View File
@@ -1,11 +1,11 @@
error: struct or field must have #[serde(default)] because previous field 0 have #[serde(default)] error: field must have #[serde(default)] because previous field 0 has #[serde(default)]
--> tests/ui/default-attribute/tuple_struct_path.rs:17:39 --> tests/ui/default-attribute/tuple_struct_path.rs:16:39
| |
17 | struct T2(#[serde(default = "d")] u8, u8, u8); 16 | struct T2(#[serde(default = "d")] u8, u8, u8);
| ^^ | ^^
error: struct or field must have #[serde(default)] because previous field 0 have #[serde(default)] error: field must have #[serde(default)] because previous field 0 has #[serde(default)]
--> tests/ui/default-attribute/tuple_struct_path.rs:17:43 --> tests/ui/default-attribute/tuple_struct_path.rs:16:43
| |
17 | struct T2(#[serde(default = "d")] u8, u8, u8); 16 | struct T2(#[serde(default = "d")] u8, u8, u8);
| ^^ | ^^