├── .github ├── FUNDING.yml ├── ISSUE_TEMPLATE │ ├── 1-problem.md │ ├── 2-suggestion.md │ ├── 3-documentation.md │ └── 4-other.md └── workflows │ └── ci.yml ├── .gitignore ├── CONTRIBUTING.md ├── Cargo.toml ├── LICENSE-APACHE ├── LICENSE-MIT ├── README.md ├── crates-io.md ├── serde ├── Cargo.toml ├── LICENSE-APACHE ├── LICENSE-MIT ├── README.md ├── build.rs ├── crates-io.md └── src │ ├── de │ ├── ignored_any.rs │ ├── impls.rs │ ├── mod.rs │ ├── seed.rs │ ├── size_hint.rs │ └── value.rs │ ├── format.rs │ ├── integer128.rs │ ├── lib.rs │ ├── macros.rs │ ├── private │ ├── de.rs │ ├── doc.rs │ ├── mod.rs │ └── ser.rs │ ├── ser │ ├── fmt.rs │ ├── impls.rs │ ├── impossible.rs │ └── mod.rs │ └── std_error.rs ├── serde_derive ├── Cargo.toml ├── LICENSE-APACHE ├── LICENSE-MIT ├── README.md ├── build.rs ├── crates-io.md └── src │ ├── bound.rs │ ├── de.rs │ ├── dummy.rs │ ├── fragment.rs │ ├── internals │ ├── ast.rs │ ├── attr.rs │ ├── case.rs │ ├── check.rs │ ├── ctxt.rs │ ├── mod.rs │ ├── name.rs │ ├── receiver.rs │ ├── respan.rs │ └── symbol.rs │ ├── lib.rs │ ├── pretend.rs │ ├── ser.rs │ └── this.rs ├── serde_derive_internals ├── Cargo.toml ├── LICENSE-APACHE ├── LICENSE-MIT ├── build.rs ├── lib.rs └── src └── test_suite ├── Cargo.toml ├── no_std ├── .gitignore ├── Cargo.toml └── src │ └── main.rs └── tests ├── bytes └── mod.rs ├── compiletest.rs ├── macros └── mod.rs ├── regression.rs ├── regression ├── issue1904.rs ├── issue2371.rs ├── issue2409.rs ├── issue2415.rs ├── issue2565.rs ├── issue2792.rs ├── issue2844.rs └── issue2846.rs ├── test_annotations.rs ├── test_borrow.rs ├── test_de.rs ├── test_de_error.rs ├── test_enum_adjacently_tagged.rs ├── test_enum_internally_tagged.rs ├── test_enum_untagged.rs ├── test_gen.rs ├── test_identifier.rs ├── test_ignored_any.rs ├── test_macros.rs ├── test_remote.rs ├── test_roundtrip.rs ├── test_self.rs ├── test_ser.rs ├── test_serde_path.rs ├── test_unstable.rs ├── test_value.rs ├── ui ├── borrow │ ├── bad_lifetimes.rs │ ├── bad_lifetimes.stderr │ ├── duplicate_lifetime.rs │ ├── duplicate_lifetime.stderr │ ├── duplicate_variant.rs │ ├── duplicate_variant.stderr │ ├── empty_lifetimes.rs │ ├── empty_lifetimes.stderr │ ├── no_lifetimes.rs │ ├── no_lifetimes.stderr │ ├── struct_variant.rs │ ├── struct_variant.stderr │ ├── wrong_lifetime.rs │ └── wrong_lifetime.stderr ├── conflict │ ├── adjacent-tag.rs │ ├── adjacent-tag.stderr │ ├── alias-enum.rs │ ├── alias-enum.stderr │ ├── alias.rs │ ├── alias.stderr │ ├── flatten-newtype-struct.rs │ ├── flatten-newtype-struct.stderr │ ├── flatten-tuple-struct.rs │ ├── flatten-tuple-struct.stderr │ ├── from-try-from.rs │ ├── from-try-from.stderr │ ├── internal-tag-alias.rs │ ├── internal-tag-alias.stderr │ ├── internal-tag.rs │ └── internal-tag.stderr ├── default-attribute │ ├── enum.rs │ ├── enum.stderr │ ├── enum_path.rs │ ├── enum_path.stderr │ ├── incorrect_type_enum_adjacently_tagged.rs │ ├── incorrect_type_enum_adjacently_tagged.stderr │ ├── incorrect_type_enum_externally_tagged.rs │ ├── incorrect_type_enum_externally_tagged.stderr │ ├── incorrect_type_enum_internally_tagged.rs │ ├── incorrect_type_enum_internally_tagged.stderr │ ├── incorrect_type_enum_untagged.rs │ ├── incorrect_type_enum_untagged.stderr │ ├── incorrect_type_newtype.rs │ ├── incorrect_type_newtype.stderr │ ├── incorrect_type_struct.rs │ ├── incorrect_type_struct.stderr │ ├── incorrect_type_tuple.rs │ ├── incorrect_type_tuple.stderr │ ├── tuple_struct.rs │ ├── tuple_struct.stderr │ ├── tuple_struct_path.rs │ ├── tuple_struct_path.stderr │ ├── union.rs │ ├── union.stderr │ ├── union_path.rs │ ├── union_path.stderr │ ├── unit.rs │ ├── unit.stderr │ ├── unit_path.rs │ └── unit_path.stderr ├── duplicate-attribute │ ├── rename-and-ser.rs │ ├── rename-and-ser.stderr │ ├── rename-ser-rename-ser.rs │ ├── rename-ser-rename-ser.stderr │ ├── rename-ser-rename.rs │ ├── rename-ser-rename.stderr │ ├── rename-ser-ser.rs │ ├── rename-ser-ser.stderr │ ├── two-rename-ser.rs │ ├── two-rename-ser.stderr │ ├── with-and-serialize-with.rs │ └── with-and-serialize-with.stderr ├── enum-representation │ ├── content-no-tag.rs │ ├── content-no-tag.stderr │ ├── internal-tuple-variant.rs │ ├── internal-tuple-variant.stderr │ ├── partially_tagged_wrong_order.rs │ ├── partially_tagged_wrong_order.stderr │ ├── untagged-and-adjacent.rs │ ├── untagged-and-adjacent.stderr │ ├── untagged-and-content.rs │ ├── untagged-and-content.stderr │ ├── untagged-and-internal.rs │ ├── untagged-and-internal.stderr │ ├── untagged-struct.rs │ └── untagged-struct.stderr ├── expected-string │ ├── boolean.rs │ ├── boolean.stderr │ ├── byte_character.rs │ ├── byte_character.stderr │ ├── byte_string.rs │ ├── byte_string.stderr │ ├── character.rs │ ├── character.stderr │ ├── float.rs │ ├── float.stderr │ ├── integer.rs │ └── integer.stderr ├── identifier │ ├── both.rs │ ├── both.stderr │ ├── field_struct.rs │ ├── field_struct.stderr │ ├── field_tuple.rs │ ├── field_tuple.stderr │ ├── newtype_not_last.rs │ ├── newtype_not_last.stderr │ ├── not_unit.rs │ ├── not_unit.stderr │ ├── other_not_last.rs │ ├── other_not_last.stderr │ ├── other_untagged.rs │ ├── other_untagged.stderr │ ├── other_variant.rs │ ├── other_variant.stderr │ ├── variant_struct.rs │ ├── variant_struct.stderr │ ├── variant_tuple.rs │ └── variant_tuple.stderr ├── malformed │ ├── bound.rs │ ├── bound.stderr │ ├── cut_off.rs │ ├── cut_off.stderr │ ├── not_list.rs │ ├── not_list.stderr │ ├── rename.rs │ ├── rename.stderr │ ├── str_suffix.rs │ ├── str_suffix.stderr │ ├── trailing_expr.rs │ └── trailing_expr.stderr ├── on_unimplemented.rs ├── on_unimplemented.stderr ├── precondition │ ├── deserialize_de_lifetime.rs │ ├── deserialize_de_lifetime.stderr │ ├── deserialize_dst.rs │ ├── deserialize_dst.stderr │ ├── serialize_field_identifier.rs │ ├── serialize_field_identifier.stderr │ ├── serialize_variant_identifier.rs │ └── serialize_variant_identifier.stderr ├── remote │ ├── bad_getter.rs │ ├── bad_getter.stderr │ ├── bad_remote.rs │ ├── bad_remote.stderr │ ├── double_generic.rs │ ├── double_generic.stderr │ ├── enum_getter.rs │ ├── enum_getter.stderr │ ├── missing_field.rs │ ├── missing_field.stderr │ ├── nonremote_getter.rs │ ├── nonremote_getter.stderr │ ├── unknown_field.rs │ ├── unknown_field.stderr │ ├── wrong_de.rs │ ├── wrong_de.stderr │ ├── wrong_getter.rs │ ├── wrong_getter.stderr │ ├── wrong_ser.rs │ └── wrong_ser.stderr ├── rename │ ├── container_unknown_rename_rule.rs │ ├── container_unknown_rename_rule.stderr │ ├── variant_unknown_rename_rule.rs │ └── variant_unknown_rename_rule.stderr ├── struct-representation │ ├── internally-tagged-tuple.rs │ ├── internally-tagged-tuple.stderr │ ├── internally-tagged-unit.rs │ └── internally-tagged-unit.stderr ├── transparent │ ├── at_most_one.rs │ ├── at_most_one.stderr │ ├── de_at_least_one.rs │ ├── de_at_least_one.stderr │ ├── enum.rs │ ├── enum.stderr │ ├── ser_at_least_one.rs │ ├── ser_at_least_one.stderr │ ├── unit_struct.rs │ ├── unit_struct.stderr │ ├── with_from.rs │ ├── with_from.stderr │ ├── with_into.rs │ ├── with_into.stderr │ ├── with_try_from.rs │ └── with_try_from.stderr ├── type-attribute │ ├── from.rs │ ├── from.stderr │ ├── into.rs │ ├── into.stderr │ ├── try_from.rs │ └── try_from.stderr ├── unexpected-literal │ ├── container.rs │ ├── container.stderr │ ├── field.rs │ ├── field.stderr │ ├── variant.rs │ └── variant.stderr ├── unknown-attribute │ ├── container.rs │ ├── container.stderr │ ├── field.rs │ ├── field.stderr │ ├── variant.rs │ └── variant.stderr ├── unsupported │ ├── union_de.rs │ ├── union_de.stderr │ ├── union_ser.rs │ └── union_ser.stderr ├── with-variant │ ├── skip_de_newtype_field.rs │ ├── skip_de_newtype_field.stderr │ ├── skip_de_struct_field.rs │ ├── skip_de_struct_field.stderr │ ├── skip_de_tuple_field.rs │ ├── skip_de_tuple_field.stderr │ ├── skip_de_whole_variant.rs │ ├── skip_de_whole_variant.stderr │ ├── skip_ser_newtype_field.rs │ ├── skip_ser_newtype_field.stderr │ ├── skip_ser_newtype_field_if.rs │ ├── skip_ser_newtype_field_if.stderr │ ├── skip_ser_struct_field.rs │ ├── skip_ser_struct_field.stderr │ ├── skip_ser_struct_field_if.rs │ ├── skip_ser_struct_field_if.stderr │ ├── skip_ser_tuple_field.rs │ ├── skip_ser_tuple_field.stderr │ ├── skip_ser_tuple_field_if.rs │ ├── skip_ser_tuple_field_if.stderr │ ├── skip_ser_whole_variant.rs │ └── skip_ser_whole_variant.stderr └── with │ ├── incorrect_type.rs │ └── incorrect_type.stderr └── unstable └── mod.rs /.github/FUNDING.yml: -------------------------------------------------------------------------------- 1 | github: dtolnay 2 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/1-problem.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Problem 3 | about: Something does not seem right 4 | 5 | --- 6 | 7 | 8 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/2-suggestion.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Suggestion 3 | about: Share how Serde could support your use case better 4 | 5 | --- 6 | 7 | 8 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/3-documentation.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Documentation 3 | about: Certainly there is room for improvement 4 | 5 | --- 6 | 7 | 8 | -------------------------------------------------------------------------------- /.github/ISSUE_TEMPLATE/4-other.md: -------------------------------------------------------------------------------- 1 | --- 2 | name: Anything else! 3 | about: Whatever is on your mind 4 | 5 | --- 6 | 7 | 8 | -------------------------------------------------------------------------------- /.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | /Cargo.lock 3 | -------------------------------------------------------------------------------- /CONTRIBUTING.md: -------------------------------------------------------------------------------- 1 | # Contributing to Serde 2 | 3 | Serde welcomes contribution from everyone in the form of suggestions, bug 4 | reports, pull requests, and feedback. This document gives some guidance if you 5 | are thinking of helping us. 6 | 7 | ## Submitting bug reports and feature requests 8 | 9 | Serde development is spread across lots of repositories, but this serde-rs/serde 10 | repository is always a safe choice for opening any issues related to Serde. 11 | 12 | When reporting a bug or asking for help, please include enough details so that 13 | the people helping you can reproduce the behavior you are seeing. For some tips 14 | on how to approach this, read about how to produce a [Minimal, Complete, and 15 | Verifiable example]. 16 | 17 | [Minimal, Complete, and Verifiable example]: https://stackoverflow.com/help/mcve 18 | 19 | When making a feature request, please make it clear what problem you intend to 20 | solve with the feature, any ideas for how Serde could support solving that 21 | problem, any possible alternatives, and any disadvantages. 22 | 23 | ## Running the test suite 24 | 25 | We encourage you to check that the test suite passes locally before submitting a 26 | pull request with your changes. If anything does not pass, typically it will be 27 | easier to iterate and fix it locally than waiting for the CI servers to run 28 | tests for you. 29 | 30 | ##### In the [`serde`] directory 31 | 32 | ```sh 33 | # Test all the example code in Serde documentation 34 | cargo test --features derive 35 | ``` 36 | 37 | ##### In the [`test_suite`] directory 38 | 39 | ```sh 40 | # Run the full test suite, including tests of unstable functionality 41 | cargo +nightly test --features unstable 42 | ``` 43 | 44 | Note that this test suite currently only supports running on a nightly compiler. 45 | 46 | [`serde`]: https://github.com/serde-rs/serde/tree/master/serde 47 | [`test_suite`]: https://github.com/serde-rs/serde/tree/master/test_suite 48 | 49 | ## Conduct 50 | 51 | In all Serde-related forums, we follow the [Rust Code of Conduct]. For 52 | escalation or moderation issues please contact Erick (erick.tryzelaar@gmail.com) 53 | instead of the Rust moderation team. 54 | 55 | [Rust Code of Conduct]: https://www.rust-lang.org/policies/code-of-conduct 56 | -------------------------------------------------------------------------------- /Cargo.toml: -------------------------------------------------------------------------------- 1 | [workspace] 2 | members = [ 3 | "serde", 4 | "serde_derive", 5 | "serde_derive_internals", 6 | "test_suite", 7 | ] 8 | resolver = "2" 9 | 10 | [patch.crates-io] 11 | serde = { path = "serde" } 12 | 13 | [workspace.dependencies] 14 | proc-macro2 = { version = "1.0.74", default-features = false } 15 | quote = { version = "1.0.35", default-features = false } 16 | syn = { version = "2.0.81", default-features = false } 17 | -------------------------------------------------------------------------------- /LICENSE-MIT: -------------------------------------------------------------------------------- 1 | Permission is hereby granted, free of charge, to any 2 | person obtaining a copy of this software and associated 3 | documentation files (the "Software"), to deal in the 4 | Software without restriction, including without 5 | limitation the rights to use, copy, modify, merge, 6 | publish, distribute, sublicense, and/or sell copies of 7 | the Software, and to permit persons to whom the Software 8 | is furnished to do so, subject to the following 9 | conditions: 10 | 11 | The above copyright notice and this permission notice 12 | shall be included in all copies or substantial portions 13 | of the Software. 14 | 15 | THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF 16 | ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED 17 | TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A 18 | PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT 19 | SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY 20 | CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION 21 | OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR 22 | IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 23 | DEALINGS IN THE SOFTWARE. 24 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Serde   [![Build Status]][actions] [![Latest Version]][crates.io] [![serde msrv]][Rust 1.56] [![serde_derive msrv]][Rust 1.61] 2 | 3 | [Build Status]: https://img.shields.io/github/actions/workflow/status/serde-rs/serde/ci.yml?branch=master 4 | [actions]: https://github.com/serde-rs/serde/actions?query=branch%3Amaster 5 | [Latest Version]: https://img.shields.io/crates/v/serde.svg 6 | [crates.io]: https://crates.io/crates/serde 7 | [serde msrv]: https://img.shields.io/crates/msrv/serde.svg?label=serde%20msrv&color=lightgray 8 | [serde_derive msrv]: https://img.shields.io/crates/msrv/serde_derive.svg?label=serde_derive%20msrv&color=lightgray 9 | [Rust 1.56]: https://blog.rust-lang.org/2021/10/21/Rust-1.56.0.html 10 | [Rust 1.61]: https://blog.rust-lang.org/2022/05/19/Rust-1.61.0.html 11 | 12 | **Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.** 13 | 14 | --- 15 | 16 | You may be looking for: 17 | 18 | - [An overview of Serde](https://serde.rs/) 19 | - [Data formats supported by Serde](https://serde.rs/#data-formats) 20 | - [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/derive.html) 21 | - [Examples](https://serde.rs/examples.html) 22 | - [API documentation](https://docs.rs/serde) 23 | - [Release notes](https://github.com/serde-rs/serde/releases) 24 | 25 | ## Serde in action 26 | 27 |
28 | 29 | Click to show Cargo.toml. 30 | Run this code in the playground. 31 | 32 | 33 | ```toml 34 | [dependencies] 35 | 36 | # The core APIs, including the Serialize and Deserialize traits. Always 37 | # required when using Serde. The "derive" feature is only required when 38 | # using #[derive(Serialize, Deserialize)] to make Serde work with structs 39 | # and enums defined in your crate. 40 | serde = { version = "1.0", features = ["derive"] } 41 | 42 | # Each data format lives in its own crate; the sample code below uses JSON 43 | # but you may be using a different one. 44 | serde_json = "1.0" 45 | ``` 46 | 47 |
48 |

49 | 50 | ```rust 51 | use serde::{Deserialize, Serialize}; 52 | 53 | #[derive(Serialize, Deserialize, Debug)] 54 | struct Point { 55 | x: i32, 56 | y: i32, 57 | } 58 | 59 | fn main() { 60 | let point = Point { x: 1, y: 2 }; 61 | 62 | // Convert the Point to a JSON string. 63 | let serialized = serde_json::to_string(&point).unwrap(); 64 | 65 | // Prints serialized = {"x":1,"y":2} 66 | println!("serialized = {}", serialized); 67 | 68 | // Convert the JSON string back to a Point. 69 | let deserialized: Point = serde_json::from_str(&serialized).unwrap(); 70 | 71 | // Prints deserialized = Point { x: 1, y: 2 } 72 | println!("deserialized = {:?}", deserialized); 73 | } 74 | ``` 75 | 76 | ## Getting help 77 | 78 | Serde is one of the most widely used Rust libraries so any place that Rustaceans 79 | congregate will be able to help you out. For chat, consider trying the 80 | [#rust-questions] or [#rust-beginners] channels of the unofficial community 81 | Discord (invite: ), the [#rust-usage] or 82 | [#beginners] channels of the official Rust Project Discord (invite: 83 | ), or the [#general][zulip] stream in Zulip. For 84 | asynchronous, consider the [\[rust\] tag on StackOverflow][stackoverflow], the 85 | [/r/rust] subreddit which has a pinned weekly easy questions post, or the Rust 86 | [Discourse forum][discourse]. It's acceptable to file a support issue in this 87 | repo but they tend not to get as many eyes as any of the above and may get 88 | closed without a response after some time. 89 | 90 | [#rust-questions]: https://discord.com/channels/273534239310479360/274215136414400513 91 | [#rust-beginners]: https://discord.com/channels/273534239310479360/273541522815713281 92 | [#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848 93 | [#beginners]: https://discord.com/channels/442252698964721669/448238009733742612 94 | [zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general 95 | [stackoverflow]: https://stackoverflow.com/questions/tagged/rust 96 | [/r/rust]: https://www.reddit.com/r/rust 97 | [discourse]: https://users.rust-lang.org 98 | 99 |
100 | 101 | #### License 102 | 103 | 104 | Licensed under either of Apache License, Version 105 | 2.0 or MIT license at your option. 106 | 107 | 108 |
109 | 110 | 111 | Unless you explicitly state otherwise, any contribution intentionally submitted 112 | for inclusion in Serde by you, as defined in the Apache-2.0 license, shall be 113 | dual licensed as above, without any additional terms or conditions. 114 | 115 | -------------------------------------------------------------------------------- /crates-io.md: -------------------------------------------------------------------------------- 1 | 2 | 3 | **Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.** 4 | 5 | --- 6 | 7 | You may be looking for: 8 | 9 | - [An overview of Serde](https://serde.rs/) 10 | - [Data formats supported by Serde](https://serde.rs/#data-formats) 11 | - [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/derive.html) 12 | - [Examples](https://serde.rs/examples.html) 13 | - [API documentation](https://docs.rs/serde) 14 | - [Release notes](https://github.com/serde-rs/serde/releases) 15 | 16 | ## Serde in action 17 | 18 | ```rust 19 | use serde::{Deserialize, Serialize}; 20 | 21 | #[derive(Serialize, Deserialize, Debug)] 22 | struct Point { 23 | x: i32, 24 | y: i32, 25 | } 26 | 27 | fn main() { 28 | let point = Point { x: 1, y: 2 }; 29 | 30 | // Convert the Point to a JSON string. 31 | let serialized = serde_json::to_string(&point).unwrap(); 32 | 33 | // Prints serialized = {"x":1,"y":2} 34 | println!("serialized = {}", serialized); 35 | 36 | // Convert the JSON string back to a Point. 37 | let deserialized: Point = serde_json::from_str(&serialized).unwrap(); 38 | 39 | // Prints deserialized = Point { x: 1, y: 2 } 40 | println!("deserialized = {:?}", deserialized); 41 | } 42 | ``` 43 | 44 | ## Getting help 45 | 46 | Serde is one of the most widely used Rust libraries so any place that Rustaceans 47 | congregate will be able to help you out. For chat, consider trying the 48 | [#rust-questions] or [#rust-beginners] channels of the unofficial community 49 | Discord (invite: ), the [#rust-usage] 50 | or [#beginners] channels of the official Rust Project Discord (invite: 51 | ), or the [#general][zulip] stream in Zulip. For 52 | asynchronous, consider the [\[rust\] tag on StackOverflow][stackoverflow], the 53 | [/r/rust] subreddit which has a pinned weekly easy questions post, or the Rust 54 | [Discourse forum][discourse]. It's acceptable to file a support issue in this 55 | repo but they tend not to get as many eyes as any of the above and may get 56 | closed without a response after some time. 57 | 58 | [#rust-questions]: https://discord.com/channels/273534239310479360/274215136414400513 59 | [#rust-beginners]: https://discord.com/channels/273534239310479360/273541522815713281 60 | [#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848 61 | [#beginners]: https://discord.com/channels/442252698964721669/448238009733742612 62 | [zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general 63 | [stackoverflow]: https://stackoverflow.com/questions/tagged/rust 64 | [/r/rust]: https://www.reddit.com/r/rust 65 | [discourse]: https://users.rust-lang.org 66 | -------------------------------------------------------------------------------- /serde/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "serde" 3 | version = "1.0.219" 4 | authors = ["Erick Tryzelaar ", "David Tolnay "] 5 | build = "build.rs" 6 | categories = ["encoding", "no-std", "no-std::no-alloc"] 7 | description = "A generic serialization/deserialization framework" 8 | documentation = "https://docs.rs/serde" 9 | edition = "2021" 10 | homepage = "https://serde.rs" 11 | keywords = ["serde", "serialization", "no_std"] 12 | license = "MIT OR Apache-2.0" 13 | readme = "crates-io.md" 14 | repository = "https://github.com/serde-rs/serde" 15 | rust-version = "1.56" 16 | 17 | [dependencies] 18 | serde_derive = { version = "1", optional = true, path = "../serde_derive" } 19 | 20 | [dev-dependencies] 21 | serde_derive = { version = "1", path = "../serde_derive" } 22 | 23 | [package.metadata.playground] 24 | features = ["derive", "rc"] 25 | 26 | [package.metadata.docs.rs] 27 | features = ["derive", "rc", "unstable"] 28 | targets = ["x86_64-unknown-linux-gnu"] 29 | rustdoc-args = [ 30 | "--generate-link-to-definition", 31 | "--extern-html-root-url=core=https://doc.rust-lang.org", 32 | "--extern-html-root-url=alloc=https://doc.rust-lang.org", 33 | "--extern-html-root-url=std=https://doc.rust-lang.org", 34 | ] 35 | 36 | # This cfg cannot be enabled, but it still forces Cargo to keep serde_derive's 37 | # version in lockstep with serde's, even if someone depends on the two crates 38 | # separately with serde's "derive" feature disabled. Every serde_derive release 39 | # is compatible with exactly one serde release because the generated code 40 | # involves nonpublic APIs which are not bound by semver. 41 | [target.'cfg(any())'.dependencies] 42 | serde_derive = { version = "=1.0.219", path = "../serde_derive" } 43 | 44 | 45 | ### FEATURES ################################################################# 46 | 47 | [features] 48 | default = ["std"] 49 | 50 | # Provide derive(Serialize, Deserialize) macros. 51 | derive = ["serde_derive"] 52 | 53 | # Provide impls for common standard library types like Vec and HashMap. 54 | # Requires a dependency on the Rust standard library. 55 | std = [] 56 | 57 | # Provide impls for types that require unstable functionality. For tracking and 58 | # discussion of unstable functionality please refer to this issue: 59 | # 60 | # https://github.com/serde-rs/serde/issues/812 61 | unstable = [] 62 | 63 | # Provide impls for types in the Rust core allocation and collections library 64 | # including String, Box, Vec, and Cow. This is a subset of std but may 65 | # be enabled without depending on all of std. 66 | alloc = [] 67 | 68 | # Opt into impls for Rc and Arc. Serializing and deserializing these types 69 | # does not preserve identity and may result in multiple copies of the same data. 70 | # Be sure that this is what you want before enabling this feature. 71 | rc = [] 72 | -------------------------------------------------------------------------------- /serde/LICENSE-APACHE: -------------------------------------------------------------------------------- 1 | ../LICENSE-APACHE -------------------------------------------------------------------------------- /serde/LICENSE-MIT: -------------------------------------------------------------------------------- 1 | ../LICENSE-MIT -------------------------------------------------------------------------------- /serde/README.md: -------------------------------------------------------------------------------- 1 | ../README.md -------------------------------------------------------------------------------- /serde/build.rs: -------------------------------------------------------------------------------- 1 | use std::env; 2 | use std::process::Command; 3 | use std::str; 4 | 5 | // The rustc-cfg strings below are *not* public API. Please let us know by 6 | // opening a GitHub issue if your build environment requires some way to enable 7 | // these cfgs other than by executing our build script. 8 | fn main() { 9 | println!("cargo:rerun-if-changed=build.rs"); 10 | 11 | let minor = match rustc_minor_version() { 12 | Some(minor) => minor, 13 | None => return, 14 | }; 15 | 16 | if minor >= 77 { 17 | println!("cargo:rustc-check-cfg=cfg(no_core_cstr)"); 18 | println!("cargo:rustc-check-cfg=cfg(no_core_error)"); 19 | println!("cargo:rustc-check-cfg=cfg(no_core_net)"); 20 | println!("cargo:rustc-check-cfg=cfg(no_core_num_saturating)"); 21 | println!("cargo:rustc-check-cfg=cfg(no_diagnostic_namespace)"); 22 | println!("cargo:rustc-check-cfg=cfg(no_serde_derive)"); 23 | println!("cargo:rustc-check-cfg=cfg(no_std_atomic)"); 24 | println!("cargo:rustc-check-cfg=cfg(no_std_atomic64)"); 25 | println!("cargo:rustc-check-cfg=cfg(no_target_has_atomic)"); 26 | } 27 | 28 | let target = env::var("TARGET").unwrap(); 29 | let emscripten = target == "asmjs-unknown-emscripten" || target == "wasm32-unknown-emscripten"; 30 | 31 | // Support for #[cfg(target_has_atomic = "...")] stabilized in Rust 1.60. 32 | if minor < 60 { 33 | println!("cargo:rustc-cfg=no_target_has_atomic"); 34 | // Allowlist of archs that support std::sync::atomic module. This is 35 | // based on rustc's compiler/rustc_target/src/spec/*.rs. 36 | let has_atomic64 = target.starts_with("x86_64") 37 | || target.starts_with("i686") 38 | || target.starts_with("aarch64") 39 | || target.starts_with("powerpc64") 40 | || target.starts_with("sparc64") 41 | || target.starts_with("mips64el") 42 | || target.starts_with("riscv64"); 43 | let has_atomic32 = has_atomic64 || emscripten; 44 | if minor < 34 || !has_atomic64 { 45 | println!("cargo:rustc-cfg=no_std_atomic64"); 46 | } 47 | if minor < 34 || !has_atomic32 { 48 | println!("cargo:rustc-cfg=no_std_atomic"); 49 | } 50 | } 51 | 52 | // Current minimum supported version of serde_derive crate is Rust 1.61. 53 | if minor < 61 { 54 | println!("cargo:rustc-cfg=no_serde_derive"); 55 | } 56 | 57 | // Support for core::ffi::CStr and alloc::ffi::CString stabilized in Rust 1.64. 58 | // https://blog.rust-lang.org/2022/09/22/Rust-1.64.0.html#c-compatible-ffi-types-in-core-and-alloc 59 | if minor < 64 { 60 | println!("cargo:rustc-cfg=no_core_cstr"); 61 | } 62 | 63 | // Support for core::num::Saturating and std::num::Saturating stabilized in Rust 1.74 64 | // https://blog.rust-lang.org/2023/11/16/Rust-1.74.0.html#stabilized-apis 65 | if minor < 74 { 66 | println!("cargo:rustc-cfg=no_core_num_saturating"); 67 | } 68 | 69 | // Support for core::net stabilized in Rust 1.77. 70 | // https://blog.rust-lang.org/2024/03/21/Rust-1.77.0.html 71 | if minor < 77 { 72 | println!("cargo:rustc-cfg=no_core_net"); 73 | } 74 | 75 | // Support for the `#[diagnostic]` tool attribute namespace 76 | // https://blog.rust-lang.org/2024/05/02/Rust-1.78.0.html#diagnostic-attributes 77 | if minor < 78 { 78 | println!("cargo:rustc-cfg=no_diagnostic_namespace"); 79 | } 80 | 81 | // The Error trait became available in core in 1.81. 82 | // https://blog.rust-lang.org/2024/09/05/Rust-1.81.0.html#coreerrorerror 83 | if minor < 81 { 84 | println!("cargo:rustc-cfg=no_core_error"); 85 | } 86 | } 87 | 88 | fn rustc_minor_version() -> Option { 89 | let rustc = env::var_os("RUSTC")?; 90 | let output = Command::new(rustc).arg("--version").output().ok()?; 91 | let version = str::from_utf8(&output.stdout).ok()?; 92 | let mut pieces = version.split('.'); 93 | if pieces.next() != Some("rustc 1") { 94 | return None; 95 | } 96 | pieces.next()?.parse().ok() 97 | } 98 | -------------------------------------------------------------------------------- /serde/crates-io.md: -------------------------------------------------------------------------------- 1 | ../crates-io.md -------------------------------------------------------------------------------- /serde/src/de/seed.rs: -------------------------------------------------------------------------------- 1 | use crate::de::{Deserialize, DeserializeSeed, Deserializer}; 2 | 3 | /// A DeserializeSeed helper for implementing deserialize_in_place Visitors. 4 | /// 5 | /// Wraps a mutable reference and calls deserialize_in_place on it. 6 | pub struct InPlaceSeed<'a, T: 'a>(pub &'a mut T); 7 | 8 | impl<'a, 'de, T> DeserializeSeed<'de> for InPlaceSeed<'a, T> 9 | where 10 | T: Deserialize<'de>, 11 | { 12 | type Value = (); 13 | fn deserialize(self, deserializer: D) -> Result 14 | where 15 | D: Deserializer<'de>, 16 | { 17 | T::deserialize_in_place(deserializer, self.0) 18 | } 19 | } 20 | -------------------------------------------------------------------------------- /serde/src/de/size_hint.rs: -------------------------------------------------------------------------------- 1 | #[cfg(any(feature = "std", feature = "alloc"))] 2 | use crate::lib::*; 3 | 4 | pub fn from_bounds(iter: &I) -> Option 5 | where 6 | I: Iterator, 7 | { 8 | helper(iter.size_hint()) 9 | } 10 | 11 | #[cfg(any(feature = "std", feature = "alloc"))] 12 | pub fn cautious(hint: Option) -> usize { 13 | const MAX_PREALLOC_BYTES: usize = 1024 * 1024; 14 | 15 | if mem::size_of::() == 0 { 16 | 0 17 | } else { 18 | cmp::min( 19 | hint.unwrap_or(0), 20 | MAX_PREALLOC_BYTES / mem::size_of::(), 21 | ) 22 | } 23 | } 24 | 25 | fn helper(bounds: (usize, Option)) -> Option { 26 | match bounds { 27 | (lower, Some(upper)) if lower == upper => Some(upper), 28 | _ => None, 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /serde/src/format.rs: -------------------------------------------------------------------------------- 1 | use crate::lib::fmt::{self, Write}; 2 | use crate::lib::str; 3 | 4 | pub(super) struct Buf<'a> { 5 | bytes: &'a mut [u8], 6 | offset: usize, 7 | } 8 | 9 | impl<'a> Buf<'a> { 10 | pub fn new(bytes: &'a mut [u8]) -> Self { 11 | Buf { bytes, offset: 0 } 12 | } 13 | 14 | pub fn as_str(&self) -> &str { 15 | let slice = &self.bytes[..self.offset]; 16 | unsafe { str::from_utf8_unchecked(slice) } 17 | } 18 | } 19 | 20 | impl<'a> Write for Buf<'a> { 21 | fn write_str(&mut self, s: &str) -> fmt::Result { 22 | if self.offset + s.len() > self.bytes.len() { 23 | Err(fmt::Error) 24 | } else { 25 | self.bytes[self.offset..self.offset + s.len()].copy_from_slice(s.as_bytes()); 26 | self.offset += s.len(); 27 | Ok(()) 28 | } 29 | } 30 | } 31 | -------------------------------------------------------------------------------- /serde/src/integer128.rs: -------------------------------------------------------------------------------- 1 | // No longer used. Old versions of serde used this macro for supporting targets 2 | // that did not yet have 128-bit integer support. 3 | #[macro_export] 4 | #[doc(hidden)] 5 | macro_rules! serde_if_integer128 { 6 | ($($tt:tt)*) => { 7 | $($tt)* 8 | }; 9 | } 10 | -------------------------------------------------------------------------------- /serde/src/private/doc.rs: -------------------------------------------------------------------------------- 1 | // Used only by Serde doc tests. Not public API. 2 | 3 | use crate::lib::*; 4 | 5 | use crate::ser; 6 | 7 | #[doc(hidden)] 8 | #[derive(Debug)] 9 | pub struct Error; 10 | 11 | impl ser::Error for Error { 12 | fn custom(_: T) -> Self 13 | where 14 | T: Display, 15 | { 16 | unimplemented!() 17 | } 18 | } 19 | 20 | #[cfg(feature = "std")] 21 | impl error::Error for Error { 22 | fn description(&self) -> &str { 23 | unimplemented!() 24 | } 25 | } 26 | 27 | impl Display for Error { 28 | fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result { 29 | unimplemented!() 30 | } 31 | } 32 | 33 | #[doc(hidden)] 34 | #[macro_export] 35 | macro_rules! __private_serialize { 36 | () => { 37 | trait Serialize { 38 | fn serialize(&self, serializer: S) -> Result 39 | where 40 | S: $crate::Serializer; 41 | } 42 | }; 43 | } 44 | 45 | #[doc(hidden)] 46 | #[macro_export(local_inner_macros)] 47 | macro_rules! __serialize_unimplemented { 48 | ($($func:ident)*) => { 49 | $( 50 | __serialize_unimplemented_helper!($func); 51 | )* 52 | }; 53 | } 54 | 55 | #[doc(hidden)] 56 | #[macro_export] 57 | macro_rules! __serialize_unimplemented_method { 58 | ($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) => { 59 | fn $func $(<$t>)* (self $(, _: $arg)*) -> $crate::__private::Result 60 | where 61 | $($t: ?Sized + $crate::Serialize,)* 62 | { 63 | unimplemented!() 64 | } 65 | }; 66 | } 67 | 68 | #[doc(hidden)] 69 | #[macro_export(local_inner_macros)] 70 | macro_rules! __serialize_unimplemented_helper { 71 | (bool) => { 72 | __serialize_unimplemented_method!(serialize_bool(bool) -> Ok); 73 | }; 74 | (i8) => { 75 | __serialize_unimplemented_method!(serialize_i8(i8) -> Ok); 76 | }; 77 | (i16) => { 78 | __serialize_unimplemented_method!(serialize_i16(i16) -> Ok); 79 | }; 80 | (i32) => { 81 | __serialize_unimplemented_method!(serialize_i32(i32) -> Ok); 82 | }; 83 | (i64) => { 84 | __serialize_unimplemented_method!(serialize_i64(i64) -> Ok); 85 | }; 86 | (u8) => { 87 | __serialize_unimplemented_method!(serialize_u8(u8) -> Ok); 88 | }; 89 | (u16) => { 90 | __serialize_unimplemented_method!(serialize_u16(u16) -> Ok); 91 | }; 92 | (u32) => { 93 | __serialize_unimplemented_method!(serialize_u32(u32) -> Ok); 94 | }; 95 | (u64) => { 96 | __serialize_unimplemented_method!(serialize_u64(u64) -> Ok); 97 | }; 98 | (f32) => { 99 | __serialize_unimplemented_method!(serialize_f32(f32) -> Ok); 100 | }; 101 | (f64) => { 102 | __serialize_unimplemented_method!(serialize_f64(f64) -> Ok); 103 | }; 104 | (char) => { 105 | __serialize_unimplemented_method!(serialize_char(char) -> Ok); 106 | }; 107 | (str) => { 108 | __serialize_unimplemented_method!(serialize_str(&str) -> Ok); 109 | }; 110 | (bytes) => { 111 | __serialize_unimplemented_method!(serialize_bytes(&[u8]) -> Ok); 112 | }; 113 | (none) => { 114 | __serialize_unimplemented_method!(serialize_none() -> Ok); 115 | }; 116 | (some) => { 117 | __serialize_unimplemented_method!(serialize_some(&T) -> Ok); 118 | }; 119 | (unit) => { 120 | __serialize_unimplemented_method!(serialize_unit() -> Ok); 121 | }; 122 | (unit_struct) => { 123 | __serialize_unimplemented_method!(serialize_unit_struct(&str) -> Ok); 124 | }; 125 | (unit_variant) => { 126 | __serialize_unimplemented_method!(serialize_unit_variant(&str, u32, &str) -> Ok); 127 | }; 128 | (newtype_struct) => { 129 | __serialize_unimplemented_method!(serialize_newtype_struct(&str, &T) -> Ok); 130 | }; 131 | (newtype_variant) => { 132 | __serialize_unimplemented_method!(serialize_newtype_variant(&str, u32, &str, &T) -> Ok); 133 | }; 134 | (seq) => { 135 | type SerializeSeq = $crate::ser::Impossible; 136 | __serialize_unimplemented_method!(serialize_seq(Option) -> SerializeSeq); 137 | }; 138 | (tuple) => { 139 | type SerializeTuple = $crate::ser::Impossible; 140 | __serialize_unimplemented_method!(serialize_tuple(usize) -> SerializeTuple); 141 | }; 142 | (tuple_struct) => { 143 | type SerializeTupleStruct = $crate::ser::Impossible; 144 | __serialize_unimplemented_method!(serialize_tuple_struct(&str, usize) -> SerializeTupleStruct); 145 | }; 146 | (tuple_variant) => { 147 | type SerializeTupleVariant = $crate::ser::Impossible; 148 | __serialize_unimplemented_method!(serialize_tuple_variant(&str, u32, &str, usize) -> SerializeTupleVariant); 149 | }; 150 | (map) => { 151 | type SerializeMap = $crate::ser::Impossible; 152 | __serialize_unimplemented_method!(serialize_map(Option) -> SerializeMap); 153 | }; 154 | (struct) => { 155 | type SerializeStruct = $crate::ser::Impossible; 156 | __serialize_unimplemented_method!(serialize_struct(&str, usize) -> SerializeStruct); 157 | }; 158 | (struct_variant) => { 159 | type SerializeStructVariant = $crate::ser::Impossible; 160 | __serialize_unimplemented_method!(serialize_struct_variant(&str, u32, &str, usize) -> SerializeStructVariant); 161 | }; 162 | } 163 | -------------------------------------------------------------------------------- /serde/src/private/mod.rs: -------------------------------------------------------------------------------- 1 | #[cfg(not(no_serde_derive))] 2 | pub mod de; 3 | #[cfg(not(no_serde_derive))] 4 | pub mod ser; 5 | 6 | // FIXME: #[cfg(doctest)] once https://github.com/rust-lang/rust/issues/67295 is fixed. 7 | pub mod doc; 8 | 9 | pub use crate::lib::clone::Clone; 10 | pub use crate::lib::convert::{From, Into, TryFrom}; 11 | pub use crate::lib::default::Default; 12 | pub use crate::lib::fmt::{self, Formatter}; 13 | pub use crate::lib::marker::PhantomData; 14 | pub use crate::lib::option::Option::{self, None, Some}; 15 | pub use crate::lib::ptr; 16 | pub use crate::lib::result::Result::{self, Err, Ok}; 17 | 18 | pub use self::string::from_utf8_lossy; 19 | 20 | #[cfg(any(feature = "alloc", feature = "std"))] 21 | pub use crate::lib::{ToString, Vec}; 22 | 23 | mod string { 24 | use crate::lib::*; 25 | 26 | #[cfg(any(feature = "std", feature = "alloc"))] 27 | pub fn from_utf8_lossy(bytes: &[u8]) -> Cow { 28 | String::from_utf8_lossy(bytes) 29 | } 30 | 31 | // The generated code calls this like: 32 | // 33 | // let value = &_serde::__private::from_utf8_lossy(bytes); 34 | // Err(_serde::de::Error::unknown_variant(value, VARIANTS)) 35 | // 36 | // so it is okay for the return type to be different from the std case as long 37 | // as the above works. 38 | #[cfg(not(any(feature = "std", feature = "alloc")))] 39 | pub fn from_utf8_lossy(bytes: &[u8]) -> &str { 40 | // Three unicode replacement characters if it fails. They look like a 41 | // white-on-black question mark. The user will recognize it as invalid 42 | // UTF-8. 43 | str::from_utf8(bytes).unwrap_or("\u{fffd}\u{fffd}\u{fffd}") 44 | } 45 | } 46 | -------------------------------------------------------------------------------- /serde/src/ser/fmt.rs: -------------------------------------------------------------------------------- 1 | use crate::lib::*; 2 | use crate::ser::{Error, Impossible, Serialize, Serializer}; 3 | 4 | impl Error for fmt::Error { 5 | fn custom(_msg: T) -> Self { 6 | fmt::Error 7 | } 8 | } 9 | 10 | macro_rules! fmt_primitives { 11 | ($($f:ident: $t:ty,)*) => { 12 | $( 13 | fn $f(self, v: $t) -> fmt::Result { 14 | Display::fmt(&v, self) 15 | } 16 | )* 17 | }; 18 | } 19 | 20 | /// ```edition2021 21 | /// use serde::ser::Serialize; 22 | /// use serde_derive::Serialize; 23 | /// use std::fmt::{self, Display}; 24 | /// 25 | /// #[derive(Serialize)] 26 | /// #[serde(rename_all = "kebab-case")] 27 | /// pub enum MessageType { 28 | /// StartRequest, 29 | /// EndRequest, 30 | /// } 31 | /// 32 | /// impl Display for MessageType { 33 | /// fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result { 34 | /// self.serialize(f) 35 | /// } 36 | /// } 37 | /// ``` 38 | impl<'a> Serializer for &mut fmt::Formatter<'a> { 39 | type Ok = (); 40 | type Error = fmt::Error; 41 | type SerializeSeq = Impossible<(), fmt::Error>; 42 | type SerializeTuple = Impossible<(), fmt::Error>; 43 | type SerializeTupleStruct = Impossible<(), fmt::Error>; 44 | type SerializeTupleVariant = Impossible<(), fmt::Error>; 45 | type SerializeMap = Impossible<(), fmt::Error>; 46 | type SerializeStruct = Impossible<(), fmt::Error>; 47 | type SerializeStructVariant = Impossible<(), fmt::Error>; 48 | 49 | fmt_primitives! { 50 | serialize_bool: bool, 51 | serialize_i8: i8, 52 | serialize_i16: i16, 53 | serialize_i32: i32, 54 | serialize_i64: i64, 55 | serialize_i128: i128, 56 | serialize_u8: u8, 57 | serialize_u16: u16, 58 | serialize_u32: u32, 59 | serialize_u64: u64, 60 | serialize_u128: u128, 61 | serialize_f32: f32, 62 | serialize_f64: f64, 63 | serialize_char: char, 64 | serialize_str: &str, 65 | serialize_unit_struct: &'static str, 66 | } 67 | 68 | fn serialize_unit_variant( 69 | self, 70 | _name: &'static str, 71 | _variant_index: u32, 72 | variant: &'static str, 73 | ) -> fmt::Result { 74 | Display::fmt(variant, self) 75 | } 76 | 77 | fn serialize_newtype_struct(self, _name: &'static str, value: &T) -> fmt::Result 78 | where 79 | T: ?Sized + Serialize, 80 | { 81 | Serialize::serialize(value, self) 82 | } 83 | 84 | fn serialize_bytes(self, _v: &[u8]) -> fmt::Result { 85 | Err(fmt::Error) 86 | } 87 | 88 | fn serialize_none(self) -> fmt::Result { 89 | Err(fmt::Error) 90 | } 91 | 92 | fn serialize_some(self, _value: &T) -> fmt::Result 93 | where 94 | T: ?Sized + Serialize, 95 | { 96 | Err(fmt::Error) 97 | } 98 | 99 | fn serialize_unit(self) -> fmt::Result { 100 | Err(fmt::Error) 101 | } 102 | 103 | fn serialize_newtype_variant( 104 | self, 105 | _name: &'static str, 106 | _variant_index: u32, 107 | _variant: &'static str, 108 | _value: &T, 109 | ) -> fmt::Result 110 | where 111 | T: ?Sized + Serialize, 112 | { 113 | Err(fmt::Error) 114 | } 115 | 116 | fn serialize_seq(self, _len: Option) -> Result { 117 | Err(fmt::Error) 118 | } 119 | 120 | fn serialize_tuple(self, _len: usize) -> Result { 121 | Err(fmt::Error) 122 | } 123 | 124 | fn serialize_tuple_struct( 125 | self, 126 | _name: &'static str, 127 | _len: usize, 128 | ) -> Result { 129 | Err(fmt::Error) 130 | } 131 | 132 | fn serialize_tuple_variant( 133 | self, 134 | _name: &'static str, 135 | _variant_index: u32, 136 | _variant: &'static str, 137 | _len: usize, 138 | ) -> Result { 139 | Err(fmt::Error) 140 | } 141 | 142 | fn serialize_map(self, _len: Option) -> Result { 143 | Err(fmt::Error) 144 | } 145 | 146 | fn serialize_struct( 147 | self, 148 | _name: &'static str, 149 | _len: usize, 150 | ) -> Result { 151 | Err(fmt::Error) 152 | } 153 | 154 | fn serialize_struct_variant( 155 | self, 156 | _name: &'static str, 157 | _variant_index: u32, 158 | _variant: &'static str, 159 | _len: usize, 160 | ) -> Result { 161 | Err(fmt::Error) 162 | } 163 | 164 | fn collect_str(self, value: &T) -> fmt::Result 165 | where 166 | T: ?Sized + Display, 167 | { 168 | Display::fmt(value, self) 169 | } 170 | } 171 | -------------------------------------------------------------------------------- /serde/src/ser/impossible.rs: -------------------------------------------------------------------------------- 1 | //! This module contains `Impossible` serializer and its implementations. 2 | 3 | use crate::lib::*; 4 | 5 | use crate::ser::{ 6 | self, Serialize, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, 7 | SerializeTuple, SerializeTupleStruct, SerializeTupleVariant, 8 | }; 9 | 10 | /// Helper type for implementing a `Serializer` that does not support 11 | /// serializing one of the compound types. 12 | /// 13 | /// This type cannot be instantiated, but implements every one of the traits 14 | /// corresponding to the [`Serializer`] compound types: [`SerializeSeq`], 15 | /// [`SerializeTuple`], [`SerializeTupleStruct`], [`SerializeTupleVariant`], 16 | /// [`SerializeMap`], [`SerializeStruct`], and [`SerializeStructVariant`]. 17 | /// 18 | /// ```edition2021 19 | /// # use serde::ser::{Serializer, Impossible}; 20 | /// # use serde::__private::doc::Error; 21 | /// # 22 | /// # struct MySerializer; 23 | /// # 24 | /// impl Serializer for MySerializer { 25 | /// type Ok = (); 26 | /// type Error = Error; 27 | /// 28 | /// type SerializeSeq = Impossible<(), Error>; 29 | /// /* other associated types */ 30 | /// 31 | /// /// This data format does not support serializing sequences. 32 | /// fn serialize_seq(self, 33 | /// len: Option) 34 | /// -> Result { 35 | /// // Given Impossible cannot be instantiated, the only 36 | /// // thing we can do here is to return an error. 37 | /// # stringify! { 38 | /// Err(...) 39 | /// # }; 40 | /// # unimplemented!() 41 | /// } 42 | /// 43 | /// /* other Serializer methods */ 44 | /// # serde::__serialize_unimplemented! { 45 | /// # bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str bytes none some 46 | /// # unit unit_struct unit_variant newtype_struct newtype_variant 47 | /// # tuple tuple_struct tuple_variant map struct struct_variant 48 | /// # } 49 | /// } 50 | /// ``` 51 | /// 52 | /// [`Serializer`]: crate::Serializer 53 | /// [`SerializeSeq`]: crate::ser::SerializeSeq 54 | /// [`SerializeTuple`]: crate::ser::SerializeTuple 55 | /// [`SerializeTupleStruct`]: crate::ser::SerializeTupleStruct 56 | /// [`SerializeTupleVariant`]: crate::ser::SerializeTupleVariant 57 | /// [`SerializeMap`]: crate::ser::SerializeMap 58 | /// [`SerializeStruct`]: crate::ser::SerializeStruct 59 | /// [`SerializeStructVariant`]: crate::ser::SerializeStructVariant 60 | pub struct Impossible { 61 | void: Void, 62 | ok: PhantomData, 63 | error: PhantomData, 64 | } 65 | 66 | enum Void {} 67 | 68 | impl SerializeSeq for Impossible 69 | where 70 | Error: ser::Error, 71 | { 72 | type Ok = Ok; 73 | type Error = Error; 74 | 75 | fn serialize_element(&mut self, value: &T) -> Result<(), Error> 76 | where 77 | T: ?Sized + Serialize, 78 | { 79 | let _ = value; 80 | match self.void {} 81 | } 82 | 83 | fn end(self) -> Result { 84 | match self.void {} 85 | } 86 | } 87 | 88 | impl SerializeTuple for Impossible 89 | where 90 | Error: ser::Error, 91 | { 92 | type Ok = Ok; 93 | type Error = Error; 94 | 95 | fn serialize_element(&mut self, value: &T) -> Result<(), Error> 96 | where 97 | T: ?Sized + Serialize, 98 | { 99 | let _ = value; 100 | match self.void {} 101 | } 102 | 103 | fn end(self) -> Result { 104 | match self.void {} 105 | } 106 | } 107 | 108 | impl SerializeTupleStruct for Impossible 109 | where 110 | Error: ser::Error, 111 | { 112 | type Ok = Ok; 113 | type Error = Error; 114 | 115 | fn serialize_field(&mut self, value: &T) -> Result<(), Error> 116 | where 117 | T: ?Sized + Serialize, 118 | { 119 | let _ = value; 120 | match self.void {} 121 | } 122 | 123 | fn end(self) -> Result { 124 | match self.void {} 125 | } 126 | } 127 | 128 | impl SerializeTupleVariant for Impossible 129 | where 130 | Error: ser::Error, 131 | { 132 | type Ok = Ok; 133 | type Error = Error; 134 | 135 | fn serialize_field(&mut self, value: &T) -> Result<(), Error> 136 | where 137 | T: ?Sized + Serialize, 138 | { 139 | let _ = value; 140 | match self.void {} 141 | } 142 | 143 | fn end(self) -> Result { 144 | match self.void {} 145 | } 146 | } 147 | 148 | impl SerializeMap for Impossible 149 | where 150 | Error: ser::Error, 151 | { 152 | type Ok = Ok; 153 | type Error = Error; 154 | 155 | fn serialize_key(&mut self, key: &T) -> Result<(), Error> 156 | where 157 | T: ?Sized + Serialize, 158 | { 159 | let _ = key; 160 | match self.void {} 161 | } 162 | 163 | fn serialize_value(&mut self, value: &T) -> Result<(), Error> 164 | where 165 | T: ?Sized + Serialize, 166 | { 167 | let _ = value; 168 | match self.void {} 169 | } 170 | 171 | fn end(self) -> Result { 172 | match self.void {} 173 | } 174 | } 175 | 176 | impl SerializeStruct for Impossible 177 | where 178 | Error: ser::Error, 179 | { 180 | type Ok = Ok; 181 | type Error = Error; 182 | 183 | fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<(), Error> 184 | where 185 | T: ?Sized + Serialize, 186 | { 187 | let _ = key; 188 | let _ = value; 189 | match self.void {} 190 | } 191 | 192 | fn end(self) -> Result { 193 | match self.void {} 194 | } 195 | } 196 | 197 | impl SerializeStructVariant for Impossible 198 | where 199 | Error: ser::Error, 200 | { 201 | type Ok = Ok; 202 | type Error = Error; 203 | 204 | fn serialize_field(&mut self, key: &'static str, value: &T) -> Result<(), Error> 205 | where 206 | T: ?Sized + Serialize, 207 | { 208 | let _ = key; 209 | let _ = value; 210 | match self.void {} 211 | } 212 | 213 | fn end(self) -> Result { 214 | match self.void {} 215 | } 216 | } 217 | -------------------------------------------------------------------------------- /serde/src/std_error.rs: -------------------------------------------------------------------------------- 1 | use crate::lib::{Debug, Display}; 2 | 3 | /// Either a re-export of std::error::Error or a new identical trait, depending 4 | /// on whether Serde's "std" feature is enabled. 5 | /// 6 | /// Serde's error traits [`serde::ser::Error`] and [`serde::de::Error`] require 7 | /// [`std::error::Error`] as a supertrait, but only when Serde is built with 8 | /// "std" enabled. Data formats that don't care about no\_std support should 9 | /// generally provide their error types with a `std::error::Error` impl 10 | /// directly: 11 | /// 12 | /// ```edition2021 13 | /// #[derive(Debug)] 14 | /// struct MySerError {...} 15 | /// 16 | /// impl serde::ser::Error for MySerError {...} 17 | /// 18 | /// impl std::fmt::Display for MySerError {...} 19 | /// 20 | /// // We don't support no_std! 21 | /// impl std::error::Error for MySerError {} 22 | /// ``` 23 | /// 24 | /// Data formats that *do* support no\_std may either have a "std" feature of 25 | /// their own: 26 | /// 27 | /// ```toml 28 | /// [features] 29 | /// std = ["serde/std"] 30 | /// ``` 31 | /// 32 | /// ```edition2021 33 | /// #[cfg(feature = "std")] 34 | /// impl std::error::Error for MySerError {} 35 | /// ``` 36 | /// 37 | /// ... or else provide the std Error impl unconditionally via Serde's 38 | /// re-export: 39 | /// 40 | /// ```edition2021 41 | /// impl serde::ser::StdError for MySerError {} 42 | /// ``` 43 | pub trait Error: Debug + Display { 44 | /// The underlying cause of this error, if any. 45 | fn source(&self) -> Option<&(dyn Error + 'static)> { 46 | None 47 | } 48 | } 49 | -------------------------------------------------------------------------------- /serde_derive/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "serde_derive" 3 | version = "1.0.219" 4 | authors = ["Erick Tryzelaar ", "David Tolnay "] 5 | categories = ["no-std", "no-std::no-alloc"] 6 | description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]" 7 | documentation = "https://serde.rs/derive.html" 8 | edition = "2021" 9 | exclude = ["build.rs"] 10 | homepage = "https://serde.rs" 11 | keywords = ["serde", "serialization", "no_std", "derive"] 12 | license = "MIT OR Apache-2.0" 13 | readme = "crates-io.md" 14 | repository = "https://github.com/serde-rs/serde" 15 | rust-version = "1.61" 16 | 17 | [features] 18 | default = [] 19 | deserialize_in_place = [] 20 | 21 | [lib] 22 | name = "serde_derive" 23 | proc-macro = true 24 | 25 | [dependencies] 26 | proc-macro2 = { workspace = true, features = ["proc-macro"] } 27 | quote = { workspace = true, features = ["proc-macro"] } 28 | syn = { workspace = true, features = ["clone-impls", "derive", "parsing", "printing", "proc-macro"] } 29 | 30 | [dev-dependencies] 31 | serde = { version = "1", path = "../serde" } 32 | 33 | [package.metadata.docs.rs] 34 | targets = ["x86_64-unknown-linux-gnu"] 35 | rustdoc-args = [ 36 | "--generate-link-to-definition", 37 | "--extern-html-root-url=core=https://doc.rust-lang.org", 38 | "--extern-html-root-url=alloc=https://doc.rust-lang.org", 39 | "--extern-html-root-url=std=https://doc.rust-lang.org", 40 | "--extern-html-root-url=proc_macro=https://doc.rust-lang.org", 41 | ] 42 | -------------------------------------------------------------------------------- /serde_derive/LICENSE-APACHE: -------------------------------------------------------------------------------- 1 | ../LICENSE-APACHE -------------------------------------------------------------------------------- /serde_derive/LICENSE-MIT: -------------------------------------------------------------------------------- 1 | ../LICENSE-MIT -------------------------------------------------------------------------------- /serde_derive/README.md: -------------------------------------------------------------------------------- 1 | ../README.md -------------------------------------------------------------------------------- /serde_derive/build.rs: -------------------------------------------------------------------------------- 1 | fn main() { 2 | // Warning: build.rs is not published to crates.io. 3 | 4 | println!("cargo:rerun-if-changed=build.rs"); 5 | println!("cargo:rustc-cfg=check_cfg"); 6 | println!("cargo:rustc-check-cfg=cfg(check_cfg)"); 7 | println!("cargo:rustc-check-cfg=cfg(exhaustive)"); 8 | } 9 | -------------------------------------------------------------------------------- /serde_derive/crates-io.md: -------------------------------------------------------------------------------- 1 | ../crates-io.md -------------------------------------------------------------------------------- /serde_derive/src/dummy.rs: -------------------------------------------------------------------------------- 1 | use proc_macro2::TokenStream; 2 | use quote::quote; 3 | 4 | pub fn wrap_in_const(serde_path: Option<&syn::Path>, code: TokenStream) -> TokenStream { 5 | let use_serde = match serde_path { 6 | Some(path) => quote! { 7 | use #path as _serde; 8 | }, 9 | None => quote! { 10 | #[allow(unused_extern_crates, clippy::useless_attribute)] 11 | extern crate serde as _serde; 12 | }, 13 | }; 14 | 15 | quote! { 16 | #[doc(hidden)] 17 | #[allow( 18 | non_upper_case_globals, 19 | unused_attributes, 20 | unused_qualifications, 21 | clippy::absolute_paths, 22 | )] 23 | const _: () = { 24 | #use_serde 25 | #code 26 | }; 27 | } 28 | } 29 | -------------------------------------------------------------------------------- /serde_derive/src/fragment.rs: -------------------------------------------------------------------------------- 1 | use proc_macro2::TokenStream; 2 | use quote::ToTokens; 3 | use syn::{token, Token}; 4 | 5 | pub enum Fragment { 6 | /// Tokens that can be used as an expression. 7 | Expr(TokenStream), 8 | /// Tokens that can be used inside a block. The surrounding curly braces are 9 | /// not part of these tokens. 10 | Block(TokenStream), 11 | } 12 | 13 | macro_rules! quote_expr { 14 | ($($tt:tt)*) => { 15 | $crate::fragment::Fragment::Expr(quote!($($tt)*)) 16 | } 17 | } 18 | 19 | macro_rules! quote_block { 20 | ($($tt:tt)*) => { 21 | $crate::fragment::Fragment::Block(quote!($($tt)*)) 22 | } 23 | } 24 | 25 | /// Interpolate a fragment in place of an expression. This involves surrounding 26 | /// Block fragments in curly braces. 27 | pub struct Expr(pub Fragment); 28 | impl ToTokens for Expr { 29 | fn to_tokens(&self, out: &mut TokenStream) { 30 | match &self.0 { 31 | Fragment::Expr(expr) => expr.to_tokens(out), 32 | Fragment::Block(block) => { 33 | token::Brace::default().surround(out, |out| block.to_tokens(out)); 34 | } 35 | } 36 | } 37 | } 38 | 39 | /// Interpolate a fragment as the statements of a block. 40 | pub struct Stmts(pub Fragment); 41 | impl ToTokens for Stmts { 42 | fn to_tokens(&self, out: &mut TokenStream) { 43 | match &self.0 { 44 | Fragment::Expr(expr) => expr.to_tokens(out), 45 | Fragment::Block(block) => block.to_tokens(out), 46 | } 47 | } 48 | } 49 | 50 | /// Interpolate a fragment as the value part of a `match` expression. This 51 | /// involves putting a comma after expressions and curly braces around blocks. 52 | pub struct Match(pub Fragment); 53 | impl ToTokens for Match { 54 | fn to_tokens(&self, out: &mut TokenStream) { 55 | match &self.0 { 56 | Fragment::Expr(expr) => { 57 | expr.to_tokens(out); 58 | ::default().to_tokens(out); 59 | } 60 | Fragment::Block(block) => { 61 | token::Brace::default().surround(out, |out| block.to_tokens(out)); 62 | } 63 | } 64 | } 65 | } 66 | 67 | impl AsRef for Fragment { 68 | fn as_ref(&self) -> &TokenStream { 69 | match self { 70 | Fragment::Expr(expr) => expr, 71 | Fragment::Block(block) => block, 72 | } 73 | } 74 | } 75 | -------------------------------------------------------------------------------- /serde_derive/src/internals/ctxt.rs: -------------------------------------------------------------------------------- 1 | use quote::ToTokens; 2 | use std::cell::RefCell; 3 | use std::fmt::Display; 4 | use std::thread; 5 | 6 | /// A type to collect errors together and format them. 7 | /// 8 | /// Dropping this object will cause a panic. It must be consumed using `check`. 9 | /// 10 | /// References can be shared since this type uses run-time exclusive mut checking. 11 | #[derive(Default)] 12 | pub struct Ctxt { 13 | // The contents will be set to `None` during checking. This is so that checking can be 14 | // enforced. 15 | errors: RefCell>>, 16 | } 17 | 18 | impl Ctxt { 19 | /// Create a new context object. 20 | /// 21 | /// This object contains no errors, but will still trigger a panic if it is not `check`ed. 22 | pub fn new() -> Self { 23 | Ctxt { 24 | errors: RefCell::new(Some(Vec::new())), 25 | } 26 | } 27 | 28 | /// Add an error to the context object with a tokenenizable object. 29 | /// 30 | /// The object is used for spanning in error messages. 31 | pub fn error_spanned_by(&self, obj: A, msg: T) { 32 | self.errors 33 | .borrow_mut() 34 | .as_mut() 35 | .unwrap() 36 | // Curb monomorphization from generating too many identical methods. 37 | .push(syn::Error::new_spanned(obj.into_token_stream(), msg)); 38 | } 39 | 40 | /// Add one of Syn's parse errors. 41 | pub fn syn_error(&self, err: syn::Error) { 42 | self.errors.borrow_mut().as_mut().unwrap().push(err); 43 | } 44 | 45 | /// Consume this object, producing a formatted error string if there are errors. 46 | pub fn check(self) -> syn::Result<()> { 47 | let mut errors = self.errors.borrow_mut().take().unwrap().into_iter(); 48 | 49 | let mut combined = match errors.next() { 50 | Some(first) => first, 51 | None => return Ok(()), 52 | }; 53 | 54 | for rest in errors { 55 | combined.combine(rest); 56 | } 57 | 58 | Err(combined) 59 | } 60 | } 61 | 62 | impl Drop for Ctxt { 63 | fn drop(&mut self) { 64 | if !thread::panicking() && self.errors.borrow().is_some() { 65 | panic!("forgot to check for errors"); 66 | } 67 | } 68 | } 69 | -------------------------------------------------------------------------------- /serde_derive/src/internals/mod.rs: -------------------------------------------------------------------------------- 1 | pub mod ast; 2 | pub mod attr; 3 | pub mod name; 4 | 5 | mod case; 6 | mod check; 7 | mod ctxt; 8 | mod receiver; 9 | mod respan; 10 | mod symbol; 11 | 12 | use syn::Type; 13 | 14 | pub use self::ctxt::Ctxt; 15 | pub use self::receiver::replace_receiver; 16 | 17 | #[derive(Copy, Clone)] 18 | pub enum Derive { 19 | Serialize, 20 | Deserialize, 21 | } 22 | 23 | pub fn ungroup(mut ty: &Type) -> &Type { 24 | while let Type::Group(group) = ty { 25 | ty = &group.elem; 26 | } 27 | ty 28 | } 29 | -------------------------------------------------------------------------------- /serde_derive/src/internals/name.rs: -------------------------------------------------------------------------------- 1 | use crate::internals::attr::{Attr, VecAttr}; 2 | use proc_macro2::{Ident, Span, TokenStream}; 3 | use quote::ToTokens; 4 | use std::cmp::Ordering; 5 | use std::collections::BTreeSet; 6 | use std::fmt::{self, Display}; 7 | use syn::LitStr; 8 | 9 | pub struct MultiName { 10 | pub(crate) serialize: Name, 11 | pub(crate) serialize_renamed: bool, 12 | pub(crate) deserialize: Name, 13 | pub(crate) deserialize_renamed: bool, 14 | pub(crate) deserialize_aliases: BTreeSet, 15 | } 16 | 17 | impl MultiName { 18 | pub(crate) fn from_attrs( 19 | source_name: Name, 20 | ser_name: Attr, 21 | de_name: Attr, 22 | de_aliases: Option>, 23 | ) -> Self { 24 | let mut alias_set = BTreeSet::new(); 25 | if let Some(de_aliases) = de_aliases { 26 | for alias_name in de_aliases.get() { 27 | alias_set.insert(alias_name); 28 | } 29 | } 30 | 31 | let ser_name = ser_name.get(); 32 | let ser_renamed = ser_name.is_some(); 33 | let de_name = de_name.get(); 34 | let de_renamed = de_name.is_some(); 35 | MultiName { 36 | serialize: ser_name.unwrap_or_else(|| source_name.clone()), 37 | serialize_renamed: ser_renamed, 38 | deserialize: de_name.unwrap_or(source_name), 39 | deserialize_renamed: de_renamed, 40 | deserialize_aliases: alias_set, 41 | } 42 | } 43 | 44 | /// Return the container name for the container when serializing. 45 | pub fn serialize_name(&self) -> &Name { 46 | &self.serialize 47 | } 48 | 49 | /// Return the container name for the container when deserializing. 50 | pub fn deserialize_name(&self) -> &Name { 51 | &self.deserialize 52 | } 53 | 54 | pub(crate) fn deserialize_aliases(&self) -> &BTreeSet { 55 | &self.deserialize_aliases 56 | } 57 | } 58 | 59 | #[derive(Clone)] 60 | pub struct Name { 61 | pub value: String, 62 | pub span: Span, 63 | } 64 | 65 | impl ToTokens for Name { 66 | fn to_tokens(&self, tokens: &mut TokenStream) { 67 | LitStr::new(&self.value, self.span).to_tokens(tokens); 68 | } 69 | } 70 | 71 | impl Ord for Name { 72 | fn cmp(&self, other: &Self) -> Ordering { 73 | Ord::cmp(&self.value, &other.value) 74 | } 75 | } 76 | 77 | impl PartialOrd for Name { 78 | fn partial_cmp(&self, other: &Self) -> Option { 79 | Some(Ord::cmp(self, other)) 80 | } 81 | } 82 | 83 | impl Eq for Name {} 84 | 85 | impl PartialEq for Name { 86 | fn eq(&self, other: &Self) -> bool { 87 | self.value == other.value 88 | } 89 | } 90 | 91 | impl From<&Ident> for Name { 92 | fn from(ident: &Ident) -> Self { 93 | Name { 94 | value: ident.to_string(), 95 | span: ident.span(), 96 | } 97 | } 98 | } 99 | 100 | impl From<&LitStr> for Name { 101 | fn from(lit: &LitStr) -> Self { 102 | Name { 103 | value: lit.value(), 104 | span: lit.span(), 105 | } 106 | } 107 | } 108 | 109 | impl Display for Name { 110 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 111 | Display::fmt(&self.value, formatter) 112 | } 113 | } 114 | -------------------------------------------------------------------------------- /serde_derive/src/internals/respan.rs: -------------------------------------------------------------------------------- 1 | use proc_macro2::{Group, Span, TokenStream, TokenTree}; 2 | 3 | pub(crate) fn respan(stream: TokenStream, span: Span) -> TokenStream { 4 | stream 5 | .into_iter() 6 | .map(|token| respan_token(token, span)) 7 | .collect() 8 | } 9 | 10 | fn respan_token(mut token: TokenTree, span: Span) -> TokenTree { 11 | if let TokenTree::Group(g) = &mut token { 12 | *g = Group::new(g.delimiter(), respan(g.stream(), span)); 13 | } 14 | token.set_span(span); 15 | token 16 | } 17 | -------------------------------------------------------------------------------- /serde_derive/src/internals/symbol.rs: -------------------------------------------------------------------------------- 1 | use std::fmt::{self, Display}; 2 | use syn::{Ident, Path}; 3 | 4 | #[derive(Copy, Clone)] 5 | pub struct Symbol(&'static str); 6 | 7 | pub const ALIAS: Symbol = Symbol("alias"); 8 | pub const BORROW: Symbol = Symbol("borrow"); 9 | pub const BOUND: Symbol = Symbol("bound"); 10 | pub const CONTENT: Symbol = Symbol("content"); 11 | pub const CRATE: Symbol = Symbol("crate"); 12 | pub const DEFAULT: Symbol = Symbol("default"); 13 | pub const DENY_UNKNOWN_FIELDS: Symbol = Symbol("deny_unknown_fields"); 14 | pub const DESERIALIZE: Symbol = Symbol("deserialize"); 15 | pub const DESERIALIZE_WITH: Symbol = Symbol("deserialize_with"); 16 | pub const EXPECTING: Symbol = Symbol("expecting"); 17 | pub const FIELD_IDENTIFIER: Symbol = Symbol("field_identifier"); 18 | pub const FLATTEN: Symbol = Symbol("flatten"); 19 | pub const FROM: Symbol = Symbol("from"); 20 | pub const GETTER: Symbol = Symbol("getter"); 21 | pub const INTO: Symbol = Symbol("into"); 22 | pub const NON_EXHAUSTIVE: Symbol = Symbol("non_exhaustive"); 23 | pub const OTHER: Symbol = Symbol("other"); 24 | pub const REMOTE: Symbol = Symbol("remote"); 25 | pub const RENAME: Symbol = Symbol("rename"); 26 | pub const RENAME_ALL: Symbol = Symbol("rename_all"); 27 | pub const RENAME_ALL_FIELDS: Symbol = Symbol("rename_all_fields"); 28 | pub const REPR: Symbol = Symbol("repr"); 29 | pub const SERDE: Symbol = Symbol("serde"); 30 | pub const SERIALIZE: Symbol = Symbol("serialize"); 31 | pub const SERIALIZE_WITH: Symbol = Symbol("serialize_with"); 32 | pub const SKIP: Symbol = Symbol("skip"); 33 | pub const SKIP_DESERIALIZING: Symbol = Symbol("skip_deserializing"); 34 | pub const SKIP_SERIALIZING: Symbol = Symbol("skip_serializing"); 35 | pub const SKIP_SERIALIZING_IF: Symbol = Symbol("skip_serializing_if"); 36 | pub const TAG: Symbol = Symbol("tag"); 37 | pub const TRANSPARENT: Symbol = Symbol("transparent"); 38 | pub const TRY_FROM: Symbol = Symbol("try_from"); 39 | pub const UNTAGGED: Symbol = Symbol("untagged"); 40 | pub const VARIANT_IDENTIFIER: Symbol = Symbol("variant_identifier"); 41 | pub const WITH: Symbol = Symbol("with"); 42 | 43 | impl PartialEq for Ident { 44 | fn eq(&self, word: &Symbol) -> bool { 45 | self == word.0 46 | } 47 | } 48 | 49 | impl PartialEq for &Ident { 50 | fn eq(&self, word: &Symbol) -> bool { 51 | *self == word.0 52 | } 53 | } 54 | 55 | impl PartialEq for Path { 56 | fn eq(&self, word: &Symbol) -> bool { 57 | self.is_ident(word.0) 58 | } 59 | } 60 | 61 | impl PartialEq for &Path { 62 | fn eq(&self, word: &Symbol) -> bool { 63 | self.is_ident(word.0) 64 | } 65 | } 66 | 67 | impl Display for Symbol { 68 | fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 69 | formatter.write_str(self.0) 70 | } 71 | } 72 | -------------------------------------------------------------------------------- /serde_derive/src/lib.rs: -------------------------------------------------------------------------------- 1 | //! This crate provides Serde's two derive macros. 2 | //! 3 | //! ```edition2021 4 | //! # use serde_derive::{Deserialize, Serialize}; 5 | //! # 6 | //! #[derive(Serialize, Deserialize)] 7 | //! # struct S; 8 | //! # 9 | //! # fn main() {} 10 | //! ``` 11 | //! 12 | //! Please refer to [https://serde.rs/derive.html] for how to set this up. 13 | //! 14 | //! [https://serde.rs/derive.html]: https://serde.rs/derive.html 15 | 16 | #![doc(html_root_url = "https://docs.rs/serde_derive/1.0.219")] 17 | #![cfg_attr(not(check_cfg), allow(unexpected_cfgs))] 18 | // Ignored clippy lints 19 | #![allow( 20 | // clippy false positive: https://github.com/rust-lang/rust-clippy/issues/7054 21 | clippy::branches_sharing_code, 22 | clippy::cognitive_complexity, 23 | // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7575 24 | clippy::collapsible_match, 25 | clippy::derive_partial_eq_without_eq, 26 | clippy::enum_variant_names, 27 | // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6797 28 | clippy::manual_map, 29 | clippy::match_like_matches_macro, 30 | clippy::needless_lifetimes, 31 | clippy::needless_pass_by_value, 32 | clippy::too_many_arguments, 33 | clippy::trivially_copy_pass_by_ref, 34 | clippy::used_underscore_binding, 35 | clippy::wildcard_in_or_patterns, 36 | // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704 37 | clippy::unnested_or_patterns, 38 | )] 39 | // Ignored clippy_pedantic lints 40 | #![allow( 41 | clippy::cast_possible_truncation, 42 | clippy::checked_conversions, 43 | clippy::doc_markdown, 44 | clippy::elidable_lifetime_names, 45 | clippy::enum_glob_use, 46 | clippy::indexing_slicing, 47 | clippy::items_after_statements, 48 | clippy::let_underscore_untyped, 49 | clippy::manual_assert, 50 | clippy::map_err_ignore, 51 | clippy::match_same_arms, 52 | // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984 53 | clippy::match_wildcard_for_single_variants, 54 | clippy::module_name_repetitions, 55 | clippy::must_use_candidate, 56 | clippy::similar_names, 57 | clippy::single_match_else, 58 | clippy::struct_excessive_bools, 59 | clippy::too_many_lines, 60 | clippy::uninlined_format_args, 61 | clippy::unseparated_literal_suffix, 62 | clippy::unused_self, 63 | clippy::use_self, 64 | clippy::wildcard_imports 65 | )] 66 | #![cfg_attr(all(test, exhaustive), feature(non_exhaustive_omitted_patterns_lint))] 67 | 68 | extern crate proc_macro2; 69 | extern crate quote; 70 | extern crate syn; 71 | 72 | extern crate proc_macro; 73 | 74 | mod internals; 75 | 76 | use proc_macro::TokenStream; 77 | use syn::parse_macro_input; 78 | use syn::DeriveInput; 79 | 80 | #[macro_use] 81 | mod bound; 82 | #[macro_use] 83 | mod fragment; 84 | 85 | mod de; 86 | mod dummy; 87 | mod pretend; 88 | mod ser; 89 | mod this; 90 | 91 | #[proc_macro_derive(Serialize, attributes(serde))] 92 | pub fn derive_serialize(input: TokenStream) -> TokenStream { 93 | let mut input = parse_macro_input!(input as DeriveInput); 94 | ser::expand_derive_serialize(&mut input) 95 | .unwrap_or_else(syn::Error::into_compile_error) 96 | .into() 97 | } 98 | 99 | #[proc_macro_derive(Deserialize, attributes(serde))] 100 | pub fn derive_deserialize(input: TokenStream) -> TokenStream { 101 | let mut input = parse_macro_input!(input as DeriveInput); 102 | de::expand_derive_deserialize(&mut input) 103 | .unwrap_or_else(syn::Error::into_compile_error) 104 | .into() 105 | } 106 | -------------------------------------------------------------------------------- /serde_derive/src/this.rs: -------------------------------------------------------------------------------- 1 | use crate::internals::ast::Container; 2 | use syn::{Path, PathArguments, Token}; 3 | 4 | pub fn this_type(cont: &Container) -> Path { 5 | if let Some(remote) = cont.attrs.remote() { 6 | let mut this = remote.clone(); 7 | for segment in &mut this.segments { 8 | if let PathArguments::AngleBracketed(arguments) = &mut segment.arguments { 9 | arguments.colon2_token = None; 10 | } 11 | } 12 | this 13 | } else { 14 | Path::from(cont.ident.clone()) 15 | } 16 | } 17 | 18 | pub fn this_value(cont: &Container) -> Path { 19 | if let Some(remote) = cont.attrs.remote() { 20 | let mut this = remote.clone(); 21 | for segment in &mut this.segments { 22 | if let PathArguments::AngleBracketed(arguments) = &mut segment.arguments { 23 | if arguments.colon2_token.is_none() { 24 | arguments.colon2_token = Some(Token![::](arguments.lt_token.span)); 25 | } 26 | } 27 | } 28 | this 29 | } else { 30 | Path::from(cont.ident.clone()) 31 | } 32 | } 33 | -------------------------------------------------------------------------------- /serde_derive_internals/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "serde_derive_internals" 3 | version = "0.29.1" 4 | authors = ["Erick Tryzelaar ", "David Tolnay "] 5 | description = "AST representation used by Serde derive macros. Unstable." 6 | documentation = "https://docs.rs/serde_derive_internals" 7 | edition = "2021" 8 | exclude = ["build.rs"] 9 | homepage = "https://serde.rs" 10 | keywords = ["serde", "serialization"] 11 | license = "MIT OR Apache-2.0" 12 | repository = "https://github.com/serde-rs/serde" 13 | rust-version = "1.61" 14 | 15 | [lib] 16 | path = "lib.rs" 17 | 18 | [dependencies] 19 | proc-macro2 = { workspace = true } 20 | quote = { workspace = true } 21 | syn = { workspace = true, features = ["clone-impls", "derive", "parsing", "printing"] } 22 | 23 | [package.metadata.docs.rs] 24 | targets = ["x86_64-unknown-linux-gnu"] 25 | rustdoc-args = [ 26 | "--generate-link-to-definition", 27 | "--extern-html-root-url=core=https://doc.rust-lang.org", 28 | "--extern-html-root-url=alloc=https://doc.rust-lang.org", 29 | "--extern-html-root-url=std=https://doc.rust-lang.org", 30 | "--extern-html-root-url=proc_macro=https://doc.rust-lang.org", 31 | ] 32 | -------------------------------------------------------------------------------- /serde_derive_internals/LICENSE-APACHE: -------------------------------------------------------------------------------- 1 | ../LICENSE-APACHE -------------------------------------------------------------------------------- /serde_derive_internals/LICENSE-MIT: -------------------------------------------------------------------------------- 1 | ../LICENSE-MIT -------------------------------------------------------------------------------- /serde_derive_internals/build.rs: -------------------------------------------------------------------------------- 1 | use std::path::Path; 2 | 3 | fn main() { 4 | // Warning: build.rs is not published to crates.io. 5 | 6 | println!("cargo:rerun-if-changed=build.rs"); 7 | println!("cargo:rerun-if-changed=src/mod.rs"); 8 | 9 | println!("cargo:rustc-cfg=check_cfg"); 10 | println!("cargo:rustc-check-cfg=cfg(check_cfg)"); 11 | println!("cargo:rustc-check-cfg=cfg(exhaustive)"); 12 | println!("cargo:rustc-check-cfg=cfg(serde_build_from_git)"); 13 | println!("cargo:rustc-check-cfg=cfg(feature, values(\"deserialize_in_place\"))"); 14 | 15 | // Sometimes on Windows the git checkout does not correctly wire up the 16 | // symlink from serde_derive_internals/src to serde_derive/src/internals. 17 | // When this happens we'll just build based on relative paths within the git 18 | // repo. 19 | let mod_behind_symlink = Path::new("src/mod.rs"); 20 | if !mod_behind_symlink.exists() { 21 | println!("cargo:rustc-cfg=serde_build_from_git"); 22 | } 23 | } 24 | -------------------------------------------------------------------------------- /serde_derive_internals/lib.rs: -------------------------------------------------------------------------------- 1 | #![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.29.1")] 2 | #![cfg_attr(not(check_cfg), allow(unexpected_cfgs))] 3 | // Ignored clippy lints 4 | #![allow( 5 | clippy::cognitive_complexity, 6 | // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7575 7 | clippy::collapsible_match, 8 | clippy::derive_partial_eq_without_eq, 9 | // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6797 10 | clippy::manual_map, 11 | clippy::missing_panics_doc, 12 | clippy::needless_lifetimes, 13 | clippy::redundant_field_names, 14 | clippy::result_unit_err, 15 | clippy::should_implement_trait, 16 | clippy::trivially_copy_pass_by_ref, 17 | clippy::wildcard_in_or_patterns, 18 | // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704 19 | clippy::unnested_or_patterns, 20 | )] 21 | // Ignored clippy_pedantic lints 22 | #![allow( 23 | clippy::doc_markdown, 24 | clippy::elidable_lifetime_names, 25 | clippy::enum_glob_use, 26 | clippy::items_after_statements, 27 | clippy::let_underscore_untyped, 28 | clippy::manual_assert, 29 | clippy::match_same_arms, 30 | // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984 31 | clippy::match_wildcard_for_single_variants, 32 | clippy::missing_errors_doc, 33 | clippy::module_name_repetitions, 34 | clippy::must_use_candidate, 35 | clippy::return_self_not_must_use, 36 | clippy::similar_names, 37 | clippy::single_match_else, 38 | clippy::struct_excessive_bools, 39 | clippy::too_many_lines, 40 | clippy::uninlined_format_args, 41 | clippy::unused_self, 42 | clippy::wildcard_imports 43 | )] 44 | 45 | extern crate proc_macro2; 46 | extern crate quote; 47 | extern crate syn; 48 | 49 | #[cfg_attr(serde_build_from_git, path = "../serde_derive/src/internals/mod.rs")] 50 | #[cfg_attr(not(serde_build_from_git), path = "src/mod.rs")] 51 | mod internals; 52 | 53 | pub use internals::*; 54 | -------------------------------------------------------------------------------- /serde_derive_internals/src: -------------------------------------------------------------------------------- 1 | ../serde_derive/src/internals/ -------------------------------------------------------------------------------- /test_suite/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "serde_test_suite" 3 | version = "0.0.0" 4 | authors = ["Erick Tryzelaar ", "David Tolnay "] 5 | edition = "2021" 6 | publish = false 7 | 8 | [features] 9 | unstable = ["serde/unstable"] 10 | 11 | [dependencies] 12 | serde = { path = "../serde" } 13 | 14 | [dev-dependencies] 15 | automod = "1.0.1" 16 | foldhash = "0.1" 17 | rustversion = "1.0" 18 | serde = { path = "../serde", features = ["rc"] } 19 | serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] } 20 | serde_test = "1.0.176" 21 | trybuild = { version = "1.0.97", features = ["diff"] } 22 | -------------------------------------------------------------------------------- /test_suite/no_std/.gitignore: -------------------------------------------------------------------------------- 1 | /target/ 2 | /Cargo.lock 3 | -------------------------------------------------------------------------------- /test_suite/no_std/Cargo.toml: -------------------------------------------------------------------------------- 1 | [package] 2 | name = "serde_derive_tests_no_std" 3 | version = "0.0.0" 4 | authors = ["David Tolnay "] 5 | edition = "2021" 6 | publish = false 7 | 8 | [dependencies] 9 | libc = { version = "0.2", default-features = false } 10 | serde = { path = "../../serde", default-features = false } 11 | serde_derive = { path = "../../serde_derive" } 12 | 13 | [profile.dev] 14 | panic = "abort" 15 | 16 | [profile.release] 17 | panic = "abort" 18 | 19 | [workspace] 20 | -------------------------------------------------------------------------------- /test_suite/no_std/src/main.rs: -------------------------------------------------------------------------------- 1 | #![no_std] 2 | #![no_main] 3 | 4 | use core::ffi::c_int; 5 | 6 | #[no_mangle] 7 | extern "C" fn main(_argc: c_int, _argv: *const *const u8) -> c_int { 8 | 0 9 | } 10 | 11 | #[panic_handler] 12 | fn panic(_info: &core::panic::PanicInfo) -> ! { 13 | unsafe { 14 | libc::abort(); 15 | } 16 | } 17 | 18 | ////////////////////////////////////////////////////////////////////////////// 19 | 20 | use serde_derive::{Deserialize, Serialize}; 21 | 22 | #[derive(Serialize, Deserialize)] 23 | pub struct Unit; 24 | 25 | #[derive(Serialize, Deserialize)] 26 | pub struct Newtype(u8); 27 | 28 | #[derive(Serialize, Deserialize)] 29 | pub struct Tuple(u8, u8); 30 | 31 | #[derive(Serialize, Deserialize)] 32 | pub struct Struct { 33 | f: u8, 34 | } 35 | 36 | #[derive(Serialize, Deserialize)] 37 | pub enum Enum { 38 | Unit, 39 | Newtype(u8), 40 | Tuple(u8, u8), 41 | Struct { f: u8 }, 42 | } 43 | -------------------------------------------------------------------------------- /test_suite/tests/bytes/mod.rs: -------------------------------------------------------------------------------- 1 | use serde::de::{Deserializer, Error, SeqAccess, Visitor}; 2 | use std::fmt; 3 | 4 | pub fn deserialize<'de, D>(deserializer: D) -> Result, D::Error> 5 | where 6 | D: Deserializer<'de>, 7 | { 8 | deserializer.deserialize_byte_buf(ByteBufVisitor) 9 | } 10 | 11 | struct ByteBufVisitor; 12 | 13 | impl<'de> Visitor<'de> for ByteBufVisitor { 14 | type Value = Vec; 15 | 16 | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 17 | formatter.write_str("byte array") 18 | } 19 | 20 | fn visit_seq(self, mut visitor: V) -> Result 21 | where 22 | V: SeqAccess<'de>, 23 | { 24 | let mut values = Vec::new(); 25 | while let Some(value) = visitor.next_element()? { 26 | values.push(value); 27 | } 28 | Ok(values) 29 | } 30 | 31 | fn visit_bytes(self, v: &[u8]) -> Result 32 | where 33 | E: Error, 34 | { 35 | Ok(v.to_vec()) 36 | } 37 | 38 | fn visit_byte_buf(self, v: Vec) -> Result 39 | where 40 | E: Error, 41 | { 42 | Ok(v) 43 | } 44 | 45 | fn visit_str(self, v: &str) -> Result 46 | where 47 | E: Error, 48 | { 49 | Ok(v.as_bytes().to_vec()) 50 | } 51 | 52 | fn visit_string(self, v: String) -> Result 53 | where 54 | E: Error, 55 | { 56 | Ok(v.into_bytes()) 57 | } 58 | } 59 | -------------------------------------------------------------------------------- /test_suite/tests/compiletest.rs: -------------------------------------------------------------------------------- 1 | #[cfg_attr(target_os = "emscripten", ignore = "disabled on Emscripten")] 2 | #[rustversion::attr(not(nightly), ignore = "requires nightly")] 3 | #[cfg_attr(miri, ignore = "incompatible with miri")] 4 | #[allow(unused_attributes)] 5 | #[test] 6 | fn ui() { 7 | let t = trybuild::TestCases::new(); 8 | t.compile_fail("tests/ui/**/*.rs"); 9 | } 10 | -------------------------------------------------------------------------------- /test_suite/tests/macros/mod.rs: -------------------------------------------------------------------------------- 1 | #![allow(unused_macro_rules)] 2 | 3 | use serde_test::Token; 4 | use std::iter; 5 | 6 | macro_rules! btreeset { 7 | () => { 8 | BTreeSet::new() 9 | }; 10 | ($($value:expr),+) => {{ 11 | let mut set = BTreeSet::new(); 12 | $(set.insert($value);)+ 13 | set 14 | }}; 15 | } 16 | 17 | macro_rules! btreemap { 18 | () => { 19 | BTreeMap::new() 20 | }; 21 | ($($key:expr => $value:expr),+) => {{ 22 | let mut map = BTreeMap::new(); 23 | $(map.insert($key, $value);)+ 24 | map 25 | }}; 26 | } 27 | 28 | macro_rules! hashset { 29 | () => { 30 | HashSet::new() 31 | }; 32 | ($($value:expr),+) => {{ 33 | let mut set = HashSet::new(); 34 | $(set.insert($value);)+ 35 | set 36 | }}; 37 | ($hasher:ty; $($value:expr),+) => {{ 38 | let mut set = HashSet::<_, $hasher>::default(); 39 | $(set.insert($value);)+ 40 | set 41 | }}; 42 | } 43 | 44 | macro_rules! hashmap { 45 | () => { 46 | HashMap::new() 47 | }; 48 | ($($key:expr => $value:expr),+) => {{ 49 | let mut map = HashMap::new(); 50 | $(map.insert($key, $value);)+ 51 | map 52 | }}; 53 | ($hasher:ty; $($key:expr => $value:expr),+) => {{ 54 | let mut map = HashMap::<_, _, $hasher>::default(); 55 | $(map.insert($key, $value);)+ 56 | map 57 | }}; 58 | } 59 | 60 | pub trait SingleTokenIntoIterator { 61 | fn into_iter(self) -> iter::Once; 62 | } 63 | 64 | impl SingleTokenIntoIterator for Token { 65 | fn into_iter(self) -> iter::Once { 66 | iter::once(self) 67 | } 68 | } 69 | 70 | macro_rules! seq { 71 | ($($elem:expr),* $(,)?) => {{ 72 | use crate::macros::SingleTokenIntoIterator; 73 | let mut vec = Vec::new(); 74 | $( as Extend>::extend(&mut vec, $elem.into_iter());)* 75 | vec 76 | }}; 77 | } 78 | -------------------------------------------------------------------------------- /test_suite/tests/regression.rs: -------------------------------------------------------------------------------- 1 | mod regression { 2 | automod::dir!("tests/regression"); 3 | } 4 | -------------------------------------------------------------------------------- /test_suite/tests/regression/issue1904.rs: -------------------------------------------------------------------------------- 1 | #![allow(dead_code)] // we do not read enum fields 2 | 3 | use serde_derive::Deserialize; 4 | 5 | #[derive(Deserialize)] 6 | pub struct Nested; 7 | 8 | #[derive(Deserialize)] 9 | pub enum ExternallyTagged1 { 10 | Tuple(f64, String), 11 | Flatten { 12 | #[serde(flatten)] 13 | nested: Nested, 14 | }, 15 | } 16 | 17 | #[derive(Deserialize)] 18 | pub enum ExternallyTagged2 { 19 | Flatten { 20 | #[serde(flatten)] 21 | nested: Nested, 22 | }, 23 | Tuple(f64, String), 24 | } 25 | 26 | // Internally tagged enums cannot contain tuple variants so not tested here 27 | 28 | #[derive(Deserialize)] 29 | #[serde(tag = "tag", content = "content")] 30 | pub enum AdjacentlyTagged1 { 31 | Tuple(f64, String), 32 | Flatten { 33 | #[serde(flatten)] 34 | nested: Nested, 35 | }, 36 | } 37 | 38 | #[derive(Deserialize)] 39 | #[serde(tag = "tag", content = "content")] 40 | pub enum AdjacentlyTagged2 { 41 | Flatten { 42 | #[serde(flatten)] 43 | nested: Nested, 44 | }, 45 | Tuple(f64, String), 46 | } 47 | 48 | #[derive(Deserialize)] 49 | #[serde(untagged)] 50 | pub enum Untagged1 { 51 | Tuple(f64, String), 52 | Flatten { 53 | #[serde(flatten)] 54 | nested: Nested, 55 | }, 56 | } 57 | 58 | #[derive(Deserialize)] 59 | #[serde(untagged)] 60 | pub enum Untagged2 { 61 | Flatten { 62 | #[serde(flatten)] 63 | nested: Nested, 64 | }, 65 | Tuple(f64, String), 66 | } 67 | -------------------------------------------------------------------------------- /test_suite/tests/regression/issue2371.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | pub struct Nested; 5 | 6 | #[derive(Deserialize)] 7 | pub enum ExternallyTagged { 8 | Flatten { 9 | #[serde(flatten)] 10 | #[allow(dead_code)] 11 | nested: Nested, 12 | #[allow(dead_code)] 13 | string: &'static str, 14 | }, 15 | } 16 | 17 | #[derive(Deserialize)] 18 | #[serde(tag = "tag")] 19 | pub enum InternallyTagged { 20 | Flatten { 21 | #[serde(flatten)] 22 | #[allow(dead_code)] 23 | nested: Nested, 24 | #[allow(dead_code)] 25 | string: &'static str, 26 | }, 27 | } 28 | 29 | #[derive(Deserialize)] 30 | #[serde(tag = "tag", content = "content")] 31 | pub enum AdjacentlyTagged { 32 | Flatten { 33 | #[serde(flatten)] 34 | #[allow(dead_code)] 35 | nested: Nested, 36 | #[allow(dead_code)] 37 | string: &'static str, 38 | }, 39 | } 40 | 41 | #[derive(Deserialize)] 42 | #[serde(untagged)] 43 | pub enum UntaggedWorkaround { 44 | Flatten { 45 | #[serde(flatten)] 46 | #[allow(dead_code)] 47 | nested: Nested, 48 | #[allow(dead_code)] 49 | string: &'static str, 50 | }, 51 | } 52 | -------------------------------------------------------------------------------- /test_suite/tests/regression/issue2409.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | macro_rules! bug { 4 | ($serde_path:literal) => { 5 | #[derive(Deserialize)] 6 | #[serde(crate = $serde_path)] 7 | pub struct Struct; 8 | }; 9 | } 10 | 11 | bug!("serde"); 12 | -------------------------------------------------------------------------------- /test_suite/tests/regression/issue2415.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde()] 5 | #[allow(dead_code)] 6 | pub struct S; 7 | -------------------------------------------------------------------------------- /test_suite/tests/regression/issue2565.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::{Deserialize, Serialize}; 2 | use serde_test::{assert_tokens, Token}; 3 | 4 | #[derive(Serialize, Deserialize, Debug, PartialEq)] 5 | enum Enum { 6 | Simple { 7 | a: i32, 8 | }, 9 | Flatten { 10 | #[serde(flatten)] 11 | flatten: (), 12 | a: i32, 13 | }, 14 | } 15 | 16 | #[test] 17 | fn simple_variant() { 18 | assert_tokens( 19 | &Enum::Simple { a: 42 }, 20 | &[ 21 | Token::StructVariant { 22 | name: "Enum", 23 | variant: "Simple", 24 | len: 1, 25 | }, 26 | Token::Str("a"), 27 | Token::I32(42), 28 | Token::StructVariantEnd, 29 | ], 30 | ); 31 | } 32 | 33 | #[test] 34 | fn flatten_variant() { 35 | assert_tokens( 36 | &Enum::Flatten { flatten: (), a: 42 }, 37 | &[ 38 | Token::NewtypeVariant { 39 | name: "Enum", 40 | variant: "Flatten", 41 | }, 42 | Token::Map { len: None }, 43 | Token::Str("a"), 44 | Token::I32(42), 45 | Token::MapEnd, 46 | ], 47 | ); 48 | } 49 | -------------------------------------------------------------------------------- /test_suite/tests/regression/issue2792.rs: -------------------------------------------------------------------------------- 1 | #![allow(dead_code)] // we do not read enum fields 2 | 3 | use serde_derive::Deserialize; 4 | 5 | #[derive(Deserialize)] 6 | #[serde(deny_unknown_fields)] 7 | pub enum A { 8 | B { 9 | c: String, 10 | }, 11 | D { 12 | #[serde(flatten)] 13 | e: E, 14 | }, 15 | } 16 | 17 | #[derive(Deserialize)] 18 | pub struct E {} 19 | -------------------------------------------------------------------------------- /test_suite/tests/regression/issue2844.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::trivially_copy_pass_by_ref)] 2 | 3 | use serde_derive::{Deserialize, Serialize}; 4 | 5 | macro_rules! declare_in_macro { 6 | ($with:literal) => { 7 | #[derive(Serialize, Deserialize)] 8 | pub struct S { 9 | #[serde(with = $with)] 10 | f: i32, 11 | } 12 | }; 13 | } 14 | 15 | declare_in_macro!("with"); 16 | 17 | mod with { 18 | use serde::{Deserializer, Serializer}; 19 | 20 | pub fn serialize(_: &i32, _: S) -> Result 21 | where 22 | S: Serializer, 23 | { 24 | unimplemented!() 25 | } 26 | 27 | pub fn deserialize<'de, D>(_: D) -> Result 28 | where 29 | D: Deserializer<'de>, 30 | { 31 | unimplemented!() 32 | } 33 | } 34 | -------------------------------------------------------------------------------- /test_suite/tests/regression/issue2846.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::trivially_copy_pass_by_ref)] 2 | 3 | use serde_derive::Deserialize; 4 | 5 | macro_rules! declare_in_macro { 6 | ($with:literal) => { 7 | #[derive(Deserialize)] 8 | pub struct S( 9 | #[serde(with = $with)] 10 | #[allow(dead_code)] 11 | i32, 12 | ); 13 | }; 14 | } 15 | 16 | declare_in_macro!("with"); 17 | 18 | mod with { 19 | use serde::Deserializer; 20 | 21 | pub fn deserialize<'de, D>(_: D) -> Result 22 | where 23 | D: Deserializer<'de>, 24 | { 25 | unimplemented!() 26 | } 27 | } 28 | -------------------------------------------------------------------------------- /test_suite/tests/test_borrow.rs: -------------------------------------------------------------------------------- 1 | #![allow( 2 | clippy::derive_partial_eq_without_eq, 3 | clippy::items_after_statements, 4 | clippy::used_underscore_binding 5 | )] 6 | 7 | use serde::de::value::{BorrowedStrDeserializer, MapDeserializer}; 8 | use serde::de::{Deserialize, Deserializer, IntoDeserializer}; 9 | use serde_derive::Deserialize; 10 | use serde_test::{assert_de_tokens, assert_de_tokens_error, Token}; 11 | use std::borrow::Cow; 12 | 13 | #[test] 14 | fn test_borrowed_str() { 15 | assert_de_tokens(&"borrowed", &[Token::BorrowedStr("borrowed")]); 16 | } 17 | 18 | #[test] 19 | fn test_borrowed_str_from_string() { 20 | assert_de_tokens_error::<&str>( 21 | &[Token::String("borrowed")], 22 | "invalid type: string \"borrowed\", expected a borrowed string", 23 | ); 24 | } 25 | 26 | #[test] 27 | fn test_borrowed_str_from_str() { 28 | assert_de_tokens_error::<&str>( 29 | &[Token::Str("borrowed")], 30 | "invalid type: string \"borrowed\", expected a borrowed string", 31 | ); 32 | } 33 | 34 | #[test] 35 | fn test_string_from_borrowed_str() { 36 | assert_de_tokens(&"owned".to_owned(), &[Token::BorrowedStr("owned")]); 37 | } 38 | 39 | #[test] 40 | fn test_borrowed_bytes() { 41 | assert_de_tokens(&&b"borrowed"[..], &[Token::BorrowedBytes(b"borrowed")]); 42 | } 43 | 44 | #[test] 45 | fn test_borrowed_bytes_from_bytebuf() { 46 | assert_de_tokens_error::<&[u8]>( 47 | &[Token::ByteBuf(b"borrowed")], 48 | "invalid type: byte array, expected a borrowed byte array", 49 | ); 50 | } 51 | 52 | #[test] 53 | fn test_borrowed_bytes_from_bytes() { 54 | assert_de_tokens_error::<&[u8]>( 55 | &[Token::Bytes(b"borrowed")], 56 | "invalid type: byte array, expected a borrowed byte array", 57 | ); 58 | } 59 | 60 | #[test] 61 | fn test_tuple() { 62 | assert_de_tokens( 63 | &("str", &b"bytes"[..]), 64 | &[ 65 | Token::Tuple { len: 2 }, 66 | Token::BorrowedStr("str"), 67 | Token::BorrowedBytes(b"bytes"), 68 | Token::TupleEnd, 69 | ], 70 | ); 71 | } 72 | 73 | #[test] 74 | fn test_struct() { 75 | #[derive(Deserialize, Debug, PartialEq)] 76 | struct Borrowing<'a, 'b> { 77 | bs: &'a str, 78 | bb: &'b [u8], 79 | } 80 | 81 | assert_de_tokens( 82 | &Borrowing { 83 | bs: "str", 84 | bb: b"bytes", 85 | }, 86 | &[ 87 | Token::Struct { 88 | name: "Borrowing", 89 | len: 2, 90 | }, 91 | Token::BorrowedStr("bs"), 92 | Token::BorrowedStr("str"), 93 | Token::BorrowedStr("bb"), 94 | Token::BorrowedBytes(b"bytes"), 95 | Token::StructEnd, 96 | ], 97 | ); 98 | } 99 | 100 | #[test] 101 | fn test_field_identifier() { 102 | #[derive(Deserialize, Debug, PartialEq)] 103 | #[serde(field_identifier)] 104 | enum FieldStr<'a> { 105 | #[serde(borrow)] 106 | Str(&'a str), 107 | } 108 | 109 | assert_de_tokens(&FieldStr::Str("value"), &[Token::BorrowedStr("value")]); 110 | 111 | #[derive(Deserialize, Debug, PartialEq)] 112 | #[serde(field_identifier)] 113 | enum FieldBytes<'a> { 114 | #[serde(borrow)] 115 | Bytes(&'a [u8]), 116 | } 117 | 118 | assert_de_tokens( 119 | &FieldBytes::Bytes(b"value"), 120 | &[Token::BorrowedBytes(b"value")], 121 | ); 122 | } 123 | 124 | #[test] 125 | fn test_cow() { 126 | #[derive(Deserialize)] 127 | struct Cows<'a, 'b> { 128 | copied: Cow<'a, str>, 129 | 130 | #[serde(borrow)] 131 | borrowed: Cow<'b, str>, 132 | } 133 | 134 | struct BorrowedStr(&'static str); 135 | 136 | impl<'de> IntoDeserializer<'de> for BorrowedStr { 137 | type Deserializer = BorrowedStrDeserializer<'de, serde::de::value::Error>; 138 | 139 | fn into_deserializer(self) -> Self::Deserializer { 140 | BorrowedStrDeserializer::new(self.0) 141 | } 142 | } 143 | 144 | let de = MapDeserializer::new(IntoIterator::into_iter([ 145 | ("copied", BorrowedStr("copied")), 146 | ("borrowed", BorrowedStr("borrowed")), 147 | ])); 148 | 149 | let cows = Cows::deserialize(de).unwrap(); 150 | 151 | match cows.copied { 152 | Cow::Owned(ref s) if s == "copied" => {} 153 | _ => panic!("expected a copied string"), 154 | } 155 | 156 | match cows.borrowed { 157 | Cow::Borrowed("borrowed") => {} 158 | _ => panic!("expected a borrowed string"), 159 | } 160 | } 161 | 162 | #[test] 163 | fn test_lifetimes() { 164 | #[derive(Deserialize)] 165 | pub struct Cows<'a, 'b> { 166 | _copied: Cow<'a, str>, 167 | 168 | #[serde(borrow)] 169 | _borrowed: Cow<'b, str>, 170 | } 171 | 172 | // Tests that `'de: 'a` is not required by the Deserialize impl. 173 | fn _cows_lifetimes<'de: 'b, 'a, 'b, D>(deserializer: D) -> Cows<'a, 'b> 174 | where 175 | D: Deserializer<'de>, 176 | { 177 | Deserialize::deserialize(deserializer).unwrap() 178 | } 179 | 180 | #[derive(Deserialize)] 181 | pub struct Wrap<'a, 'b> { 182 | #[serde(borrow = "'b")] 183 | _cows: Cows<'a, 'b>, 184 | } 185 | 186 | // Tests that `'de: 'a` is not required by the Deserialize impl. 187 | fn _wrap_lifetimes<'de: 'b, 'a, 'b, D>(deserializer: D) -> Wrap<'a, 'b> 188 | where 189 | D: Deserializer<'de>, 190 | { 191 | Deserialize::deserialize(deserializer).unwrap() 192 | } 193 | } 194 | -------------------------------------------------------------------------------- /test_suite/tests/test_ignored_any.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::derive_partial_eq_without_eq)] 2 | 3 | use serde::de::value::{Error, MapDeserializer, SeqDeserializer}; 4 | use serde::de::{ 5 | Deserialize, DeserializeSeed, Deserializer, EnumAccess, IgnoredAny, IntoDeserializer, 6 | VariantAccess, Visitor, 7 | }; 8 | use serde::forward_to_deserialize_any; 9 | use serde_derive::Deserialize; 10 | 11 | #[derive(PartialEq, Debug, Deserialize)] 12 | enum Target { 13 | Unit, 14 | Newtype(i32), 15 | Tuple(i32, i32), 16 | Struct { a: i32 }, 17 | } 18 | 19 | struct Enum(&'static str); 20 | 21 | impl<'de> Deserializer<'de> for Enum { 22 | type Error = Error; 23 | 24 | fn deserialize_any(self, visitor: V) -> Result 25 | where 26 | V: Visitor<'de>, 27 | { 28 | visitor.visit_enum(self) 29 | } 30 | 31 | forward_to_deserialize_any! { 32 | bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string 33 | bytes byte_buf option unit unit_struct newtype_struct seq tuple 34 | tuple_struct map struct enum identifier ignored_any 35 | } 36 | } 37 | 38 | impl<'de> EnumAccess<'de> for Enum { 39 | type Error = Error; 40 | type Variant = Self; 41 | 42 | fn variant_seed(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error> 43 | where 44 | V: DeserializeSeed<'de>, 45 | { 46 | let v = seed.deserialize(self.0.into_deserializer())?; 47 | Ok((v, self)) 48 | } 49 | } 50 | 51 | impl<'de> VariantAccess<'de> for Enum { 52 | type Error = Error; 53 | 54 | fn unit_variant(self) -> Result<(), Self::Error> { 55 | Ok(()) 56 | } 57 | 58 | fn newtype_variant_seed(self, seed: T) -> Result 59 | where 60 | T: DeserializeSeed<'de>, 61 | { 62 | seed.deserialize(10i32.into_deserializer()) 63 | } 64 | 65 | fn tuple_variant(self, _len: usize, visitor: V) -> Result 66 | where 67 | V: Visitor<'de>, 68 | { 69 | let seq = SeqDeserializer::new(vec![1i32, 2].into_iter()); 70 | visitor.visit_seq(seq) 71 | } 72 | 73 | fn struct_variant( 74 | self, 75 | _fields: &'static [&'static str], 76 | visitor: V, 77 | ) -> Result 78 | where 79 | V: Visitor<'de>, 80 | { 81 | let map = MapDeserializer::new(vec![("a", 10i32)].into_iter()); 82 | visitor.visit_map(map) 83 | } 84 | } 85 | 86 | #[test] 87 | fn test_deserialize_enum() { 88 | // First just make sure the Deserializer impl works 89 | assert_eq!(Target::Unit, Target::deserialize(Enum("Unit")).unwrap()); 90 | assert_eq!( 91 | Target::Newtype(10), 92 | Target::deserialize(Enum("Newtype")).unwrap() 93 | ); 94 | assert_eq!( 95 | Target::Tuple(1, 2), 96 | Target::deserialize(Enum("Tuple")).unwrap() 97 | ); 98 | assert_eq!( 99 | Target::Struct { a: 10 }, 100 | Target::deserialize(Enum("Struct")).unwrap() 101 | ); 102 | 103 | // Now try IgnoredAny 104 | IgnoredAny::deserialize(Enum("Unit")).unwrap(); 105 | IgnoredAny::deserialize(Enum("Newtype")).unwrap(); 106 | IgnoredAny::deserialize(Enum("Tuple")).unwrap(); 107 | IgnoredAny::deserialize(Enum("Struct")).unwrap(); 108 | } 109 | -------------------------------------------------------------------------------- /test_suite/tests/test_roundtrip.rs: -------------------------------------------------------------------------------- 1 | use serde_test::{assert_tokens, Configure, Token}; 2 | use std::net; 3 | 4 | #[macro_use] 5 | #[allow(unused_macros)] 6 | mod macros; 7 | 8 | #[test] 9 | fn ip_addr_roundtrip() { 10 | assert_tokens( 11 | &net::IpAddr::from(*b"1234").compact(), 12 | &seq![ 13 | Token::NewtypeVariant { 14 | name: "IpAddr", 15 | variant: "V4" 16 | }, 17 | Token::Tuple { len: 4 }, 18 | b"1234".iter().copied().map(Token::U8), 19 | Token::TupleEnd, 20 | ], 21 | ); 22 | } 23 | 24 | #[test] 25 | fn socket_addr_roundtrip() { 26 | assert_tokens( 27 | &net::SocketAddr::from((*b"1234567890123456", 1234)).compact(), 28 | &seq![ 29 | Token::NewtypeVariant { 30 | name: "SocketAddr", 31 | variant: "V6" 32 | }, 33 | Token::Tuple { len: 2 }, 34 | Token::Tuple { len: 16 }, 35 | b"1234567890123456".iter().copied().map(Token::U8), 36 | Token::TupleEnd, 37 | Token::U16(1234), 38 | Token::TupleEnd, 39 | ], 40 | ); 41 | } 42 | -------------------------------------------------------------------------------- /test_suite/tests/test_self.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::used_underscore_binding)] 2 | 3 | use serde_derive::{Deserialize, Serialize}; 4 | 5 | #[test] 6 | fn test_self() { 7 | pub trait Trait { 8 | type Assoc; 9 | } 10 | 11 | #[derive(Deserialize, Serialize)] 12 | pub struct Generics> 13 | where 14 | Self: Trait, 15 | ::Assoc: Sized, 16 | { 17 | _f: T, 18 | } 19 | 20 | impl> Trait for Generics { 21 | type Assoc = Self; 22 | } 23 | 24 | #[derive(Deserialize, Serialize)] 25 | pub struct Struct { 26 | _f1: Box, 27 | _f2: Box<::Assoc>, 28 | _f4: [(); Self::ASSOC], 29 | _f5: [(); Self::assoc()], 30 | } 31 | 32 | impl Struct { 33 | const ASSOC: usize = 1; 34 | const fn assoc() -> usize { 35 | 0 36 | } 37 | } 38 | 39 | impl Trait for Struct { 40 | type Assoc = Self; 41 | } 42 | 43 | #[derive(Deserialize, Serialize)] 44 | pub struct Tuple( 45 | Box, 46 | Box<::Assoc>, 47 | [(); Self::ASSOC], 48 | [(); Self::assoc()], 49 | ); 50 | 51 | impl Tuple { 52 | const ASSOC: usize = 1; 53 | const fn assoc() -> usize { 54 | 0 55 | } 56 | } 57 | 58 | impl Trait for Tuple { 59 | type Assoc = Self; 60 | } 61 | 62 | #[derive(Deserialize, Serialize)] 63 | pub enum Enum { 64 | Struct { 65 | _f1: Box, 66 | _f2: Box<::Assoc>, 67 | _f4: [(); Self::ASSOC], 68 | _f5: [(); Self::assoc()], 69 | }, 70 | Tuple( 71 | Box, 72 | Box<::Assoc>, 73 | [(); Self::ASSOC], 74 | [(); Self::assoc()], 75 | ), 76 | } 77 | 78 | impl Enum { 79 | const ASSOC: usize = 1; 80 | const fn assoc() -> usize { 81 | 0 82 | } 83 | } 84 | 85 | impl Trait for Enum { 86 | type Assoc = Self; 87 | } 88 | } 89 | -------------------------------------------------------------------------------- /test_suite/tests/test_serde_path.rs: -------------------------------------------------------------------------------- 1 | #![allow( 2 | clippy::elidable_lifetime_names, 3 | clippy::extra_unused_type_parameters, 4 | clippy::needless_lifetimes, 5 | clippy::type_repetition_in_bounds 6 | )] 7 | 8 | #[test] 9 | fn test_gen_custom_serde() { 10 | #[derive(serde_derive::Serialize, serde_derive::Deserialize)] 11 | #[serde(crate = "fake_serde")] 12 | struct Foo; 13 | 14 | // Would be overlapping if serde::Serialize were implemented 15 | impl AssertNotSerdeSerialize for Foo {} 16 | // Would be overlapping if serde::Deserialize were implemented 17 | impl<'a> AssertNotSerdeDeserialize<'a> for Foo {} 18 | 19 | fake_serde::assert::(); 20 | } 21 | 22 | mod fake_serde { 23 | pub use serde::*; 24 | 25 | pub fn assert() 26 | where 27 | T: Serialize, 28 | T: for<'a> Deserialize<'a>, 29 | { 30 | } 31 | 32 | #[allow(dead_code)] 33 | pub trait Serialize { 34 | fn serialize(&self, serializer: S) -> Result; 35 | } 36 | 37 | #[allow(dead_code)] 38 | pub trait Deserialize<'a>: Sized { 39 | fn deserialize>(deserializer: D) -> Result; 40 | } 41 | } 42 | 43 | pub trait AssertNotSerdeSerialize {} 44 | 45 | impl AssertNotSerdeSerialize for T {} 46 | 47 | pub trait AssertNotSerdeDeserialize<'a> {} 48 | 49 | impl<'a, T: serde::Deserialize<'a>> AssertNotSerdeDeserialize<'a> for T {} 50 | -------------------------------------------------------------------------------- /test_suite/tests/test_unstable.rs: -------------------------------------------------------------------------------- 1 | #![deny(warnings)] 2 | #![allow(clippy::derive_partial_eq_without_eq)] 3 | 4 | // This test target is convoluted with the actual #[test] in a separate file to 5 | // get it so that the stable compiler does not need to parse the code of the 6 | // test. If the test were written with #[cfg(feature = "unstable")] #[test] 7 | // right here, the stable compiler would fail to parse those raw identifiers 8 | // even if the cfg were not enabled. 9 | #[cfg(feature = "unstable")] 10 | mod unstable; 11 | -------------------------------------------------------------------------------- /test_suite/tests/test_value.rs: -------------------------------------------------------------------------------- 1 | #![allow(clippy::derive_partial_eq_without_eq, clippy::similar_names)] 2 | 3 | use serde::de::value::{self, MapAccessDeserializer}; 4 | use serde::de::{Deserialize, Deserializer, IntoDeserializer, MapAccess, Visitor}; 5 | use serde_derive::Deserialize; 6 | use serde_test::{assert_de_tokens, Token}; 7 | use std::fmt; 8 | 9 | #[test] 10 | fn test_u32_to_enum() { 11 | #[derive(Deserialize, Debug, PartialEq)] 12 | enum E { 13 | A, 14 | B, 15 | } 16 | 17 | let deserializer = IntoDeserializer::::into_deserializer(1u32); 18 | let e: E = E::deserialize(deserializer).unwrap(); 19 | assert_eq!(E::B, e); 20 | } 21 | 22 | #[test] 23 | fn test_integer128() { 24 | let de_u128 = IntoDeserializer::::into_deserializer(1u128); 25 | let de_i128 = IntoDeserializer::::into_deserializer(1i128); 26 | 27 | // u128 to u128 28 | assert_eq!(1u128, u128::deserialize(de_u128).unwrap()); 29 | 30 | // u128 to i128 31 | assert_eq!(1i128, i128::deserialize(de_u128).unwrap()); 32 | 33 | // i128 to u128 34 | assert_eq!(1u128, u128::deserialize(de_i128).unwrap()); 35 | 36 | // i128 to i128 37 | assert_eq!(1i128, i128::deserialize(de_i128).unwrap()); 38 | } 39 | 40 | #[test] 41 | fn test_map_access_to_enum() { 42 | #[derive(PartialEq, Debug)] 43 | struct Potential(PotentialKind); 44 | 45 | #[derive(PartialEq, Debug, Deserialize)] 46 | enum PotentialKind { 47 | Airebo(Airebo), 48 | } 49 | 50 | #[derive(PartialEq, Debug, Deserialize)] 51 | struct Airebo { 52 | lj_sigma: f64, 53 | } 54 | 55 | impl<'de> Deserialize<'de> for Potential { 56 | fn deserialize(deserializer: D) -> Result 57 | where 58 | D: Deserializer<'de>, 59 | { 60 | struct PotentialVisitor; 61 | 62 | impl<'de> Visitor<'de> for PotentialVisitor { 63 | type Value = Potential; 64 | 65 | fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { 66 | formatter.write_str("a map") 67 | } 68 | 69 | fn visit_map(self, map: A) -> Result 70 | where 71 | A: MapAccess<'de>, 72 | { 73 | Deserialize::deserialize(MapAccessDeserializer::new(map)).map(Potential) 74 | } 75 | } 76 | 77 | deserializer.deserialize_any(PotentialVisitor) 78 | } 79 | } 80 | 81 | let expected = Potential(PotentialKind::Airebo(Airebo { lj_sigma: 14.0 })); 82 | 83 | assert_de_tokens( 84 | &expected, 85 | &[ 86 | Token::Map { len: Some(1) }, 87 | Token::Str("Airebo"), 88 | Token::Map { len: Some(1) }, 89 | Token::Str("lj_sigma"), 90 | Token::F64(14.0), 91 | Token::MapEnd, 92 | Token::MapEnd, 93 | ], 94 | ); 95 | } 96 | -------------------------------------------------------------------------------- /test_suite/tests/ui/borrow/bad_lifetimes.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | struct Test<'a> { 5 | #[serde(borrow = "zzz")] 6 | s: &'a str, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/borrow/bad_lifetimes.stderr: -------------------------------------------------------------------------------- 1 | error: failed to parse borrowed lifetimes: "zzz" 2 | --> tests/ui/borrow/bad_lifetimes.rs:5:22 3 | | 4 | 5 | #[serde(borrow = "zzz")] 5 | | ^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/borrow/duplicate_lifetime.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | struct Test<'a> { 5 | #[serde(borrow = "'a + 'a")] 6 | s: &'a str, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/borrow/duplicate_lifetime.stderr: -------------------------------------------------------------------------------- 1 | error: duplicate borrowed lifetime `'a` 2 | --> tests/ui/borrow/duplicate_lifetime.rs:5:22 3 | | 4 | 5 | #[serde(borrow = "'a + 'a")] 5 | | ^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/borrow/duplicate_variant.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | struct Str<'a>(&'a str); 5 | 6 | #[derive(Deserialize)] 7 | enum Test<'a> { 8 | #[serde(borrow)] 9 | S(#[serde(borrow)] Str<'a>), 10 | } 11 | 12 | fn main() {} 13 | -------------------------------------------------------------------------------- /test_suite/tests/ui/borrow/duplicate_variant.stderr: -------------------------------------------------------------------------------- 1 | error: duplicate serde attribute `borrow` 2 | --> tests/ui/borrow/duplicate_variant.rs:9:15 3 | | 4 | 9 | S(#[serde(borrow)] Str<'a>), 5 | | ^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/borrow/empty_lifetimes.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | struct Test<'a> { 5 | #[serde(borrow = "")] 6 | r: &'a str, 7 | #[serde(borrow = " ")] 8 | s: &'a str, 9 | } 10 | 11 | fn main() {} 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/borrow/empty_lifetimes.stderr: -------------------------------------------------------------------------------- 1 | error: at least one lifetime must be borrowed 2 | --> tests/ui/borrow/empty_lifetimes.rs:5:22 3 | | 4 | 5 | #[serde(borrow = "")] 5 | | ^^ 6 | 7 | error: at least one lifetime must be borrowed 8 | --> tests/ui/borrow/empty_lifetimes.rs:7:22 9 | | 10 | 7 | #[serde(borrow = " ")] 11 | | ^^^^ 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/borrow/no_lifetimes.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | struct Test { 5 | #[serde(borrow)] 6 | s: String, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/borrow/no_lifetimes.stderr: -------------------------------------------------------------------------------- 1 | error: field `s` has no lifetimes to borrow 2 | --> tests/ui/borrow/no_lifetimes.rs:5:5 3 | | 4 | 5 | / #[serde(borrow)] 5 | 6 | | s: String, 6 | | |_____________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/borrow/struct_variant.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | struct Str<'a>(&'a str); 5 | 6 | #[derive(Deserialize)] 7 | enum Test<'a> { 8 | #[serde(borrow)] 9 | S { s: Str<'a> }, 10 | } 11 | 12 | fn main() {} 13 | -------------------------------------------------------------------------------- /test_suite/tests/ui/borrow/struct_variant.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(borrow)] may only be used on newtype variants 2 | --> tests/ui/borrow/struct_variant.rs:8:5 3 | | 4 | 8 | / #[serde(borrow)] 5 | 9 | | S { s: Str<'a> }, 6 | | |____________________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/borrow/wrong_lifetime.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | struct Test<'a> { 5 | #[serde(borrow = "'b")] 6 | s: &'a str, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/borrow/wrong_lifetime.stderr: -------------------------------------------------------------------------------- 1 | error: field `s` does not have lifetime 'b 2 | --> tests/ui/borrow/wrong_lifetime.rs:5:5 3 | | 4 | 5 | / #[serde(borrow = "'b")] 5 | 6 | | s: &'a str, 6 | | |______________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/adjacent-tag.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(tag = "conflict", content = "conflict")] 5 | enum E { 6 | A, 7 | B, 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/adjacent-tag.stderr: -------------------------------------------------------------------------------- 1 | error: enum tags `conflict` for type and content conflict with each other 2 | --> tests/ui/conflict/adjacent-tag.rs:4:1 3 | | 4 | 4 | / #[serde(tag = "conflict", content = "conflict")] 5 | 5 | | enum E { 6 | 6 | | A, 7 | 7 | | B, 8 | 8 | | } 9 | | |_^ 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/alias-enum.rs: -------------------------------------------------------------------------------- 1 | #![allow(non_camel_case_types)] 2 | 3 | use serde_derive::Deserialize; 4 | 5 | #[derive(Deserialize)] 6 | enum E { 7 | S1 { 8 | #[serde(alias = "a", alias = "b", alias = "c")] 9 | a: (), 10 | 11 | // Warning on "c" and "b" 12 | #[serde(alias = "c")] 13 | b: (), 14 | 15 | #[serde(skip_deserializing)] 16 | c: (), 17 | }, 18 | 19 | S2 { 20 | #[serde(alias = "b", alias = "c")] 21 | a: (), 22 | 23 | // Warning on "c" 24 | #[serde(rename = "c")] 25 | b: (), 26 | }, 27 | 28 | #[serde(rename_all = "UPPERCASE")] 29 | S3 { 30 | #[serde(alias = "B", alias = "c")] 31 | a: (), 32 | 33 | // Warning on "b" because this collides with the "B" above after 34 | // applying rename rules 35 | b: (), 36 | }, 37 | } 38 | 39 | #[derive(Deserialize)] 40 | enum E1 { 41 | #[serde(alias = "a", alias = "b", alias = "c")] 42 | a, 43 | 44 | // Warning on "c" and "b" 45 | #[serde(alias = "c")] 46 | b, 47 | 48 | #[serde(skip_deserializing)] 49 | c, 50 | } 51 | 52 | #[derive(Deserialize)] 53 | enum E2 { 54 | #[serde(alias = "b", alias = "c")] 55 | a, 56 | 57 | // Warning on "c" 58 | #[serde(rename = "c")] 59 | b, 60 | } 61 | 62 | #[derive(Deserialize)] 63 | #[serde(rename_all = "UPPERCASE")] 64 | enum E3 { 65 | #[serde(alias = "B", alias = "c")] 66 | a, 67 | 68 | // Warning on "b" because this collides with the "B" above after applying 69 | // rename rules 70 | b, 71 | } 72 | 73 | fn main() { 74 | __FAIL__; 75 | } 76 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/alias-enum.stderr: -------------------------------------------------------------------------------- 1 | error[E0425]: cannot find value `__FAIL__` in this scope 2 | --> tests/ui/conflict/alias-enum.rs:74:5 3 | | 4 | 74 | __FAIL__; 5 | | ^^^^^^^^ not found in this scope 6 | 7 | warning: unreachable pattern 8 | --> tests/ui/conflict/alias-enum.rs:13:9 9 | | 10 | 8 | #[serde(alias = "a", alias = "b", alias = "c")] 11 | | --- matches all the relevant values 12 | ... 13 | 13 | b: (), 14 | | ^ no value can reach this 15 | | 16 | = note: `#[warn(unreachable_patterns)]` on by default 17 | 18 | warning: unreachable pattern 19 | --> tests/ui/conflict/alias-enum.rs:12:25 20 | | 21 | 8 | #[serde(alias = "a", alias = "b", alias = "c")] 22 | | --- matches all the relevant values 23 | ... 24 | 12 | #[serde(alias = "c")] 25 | | ^^^ no value can reach this 26 | 27 | warning: unreachable pattern 28 | --> tests/ui/conflict/alias-enum.rs:24:26 29 | | 30 | 20 | #[serde(alias = "b", alias = "c")] 31 | | --- matches all the relevant values 32 | ... 33 | 24 | #[serde(rename = "c")] 34 | | ^^^ no value can reach this 35 | 36 | warning: unreachable pattern 37 | --> tests/ui/conflict/alias-enum.rs:35:9 38 | | 39 | 30 | #[serde(alias = "B", alias = "c")] 40 | | --- matches all the relevant values 41 | ... 42 | 35 | b: (), 43 | | ^ no value can reach this 44 | 45 | warning: unreachable pattern 46 | --> tests/ui/conflict/alias-enum.rs:46:5 47 | | 48 | 41 | #[serde(alias = "a", alias = "b", alias = "c")] 49 | | --- matches all the relevant values 50 | ... 51 | 46 | b, 52 | | ^ no value can reach this 53 | 54 | warning: unreachable pattern 55 | --> tests/ui/conflict/alias-enum.rs:45:21 56 | | 57 | 41 | #[serde(alias = "a", alias = "b", alias = "c")] 58 | | --- matches all the relevant values 59 | ... 60 | 45 | #[serde(alias = "c")] 61 | | ^^^ no value can reach this 62 | 63 | warning: unreachable pattern 64 | --> tests/ui/conflict/alias-enum.rs:58:22 65 | | 66 | 54 | #[serde(alias = "b", alias = "c")] 67 | | --- matches all the relevant values 68 | ... 69 | 58 | #[serde(rename = "c")] 70 | | ^^^ no value can reach this 71 | 72 | warning: unreachable pattern 73 | --> tests/ui/conflict/alias-enum.rs:70:5 74 | | 75 | 65 | #[serde(alias = "B", alias = "c")] 76 | | --- matches all the relevant values 77 | ... 78 | 70 | b, 79 | | ^ no value can reach this 80 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/alias.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | struct S1 { 5 | #[serde(alias = "a", alias = "b", alias = "c")] 6 | a: (), 7 | 8 | // Warning on "c" and "b" 9 | #[serde(alias = "c")] 10 | b: (), 11 | 12 | #[serde(skip_deserializing)] 13 | c: (), 14 | } 15 | 16 | #[derive(Deserialize)] 17 | struct S2 { 18 | #[serde(alias = "b", alias = "c")] 19 | a: (), 20 | 21 | // Warning on "c" 22 | #[serde(rename = "c")] 23 | b: (), 24 | } 25 | 26 | #[derive(Deserialize)] 27 | #[serde(rename_all = "UPPERCASE")] 28 | struct S3 { 29 | #[serde(alias = "B", alias = "c")] 30 | a: (), 31 | 32 | // Warning on "b" because this collides with the "B" above after applying 33 | // rename rules 34 | b: (), 35 | } 36 | 37 | fn main() { 38 | __FAIL__; 39 | } 40 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/alias.stderr: -------------------------------------------------------------------------------- 1 | error[E0425]: cannot find value `__FAIL__` in this scope 2 | --> tests/ui/conflict/alias.rs:38:5 3 | | 4 | 38 | __FAIL__; 5 | | ^^^^^^^^ not found in this scope 6 | 7 | warning: unreachable pattern 8 | --> tests/ui/conflict/alias.rs:10:5 9 | | 10 | 5 | #[serde(alias = "a", alias = "b", alias = "c")] 11 | | --- matches all the relevant values 12 | ... 13 | 10 | b: (), 14 | | ^ no value can reach this 15 | | 16 | = note: `#[warn(unreachable_patterns)]` on by default 17 | 18 | warning: unreachable pattern 19 | --> tests/ui/conflict/alias.rs:9:21 20 | | 21 | 5 | #[serde(alias = "a", alias = "b", alias = "c")] 22 | | --- matches all the relevant values 23 | ... 24 | 9 | #[serde(alias = "c")] 25 | | ^^^ no value can reach this 26 | 27 | warning: unreachable pattern 28 | --> tests/ui/conflict/alias.rs:22:22 29 | | 30 | 18 | #[serde(alias = "b", alias = "c")] 31 | | --- matches all the relevant values 32 | ... 33 | 22 | #[serde(rename = "c")] 34 | | ^^^ no value can reach this 35 | 36 | warning: unreachable pattern 37 | --> tests/ui/conflict/alias.rs:34:5 38 | | 39 | 29 | #[serde(alias = "B", alias = "c")] 40 | | --- matches all the relevant values 41 | ... 42 | 34 | b: (), 43 | | ^ no value can reach this 44 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/flatten-newtype-struct.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | use std::collections::HashMap; 3 | 4 | #[derive(Serialize)] 5 | struct Foo(#[serde(flatten)] HashMap); 6 | 7 | fn main() {} 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/flatten-newtype-struct.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(flatten)] cannot be used on newtype structs 2 | --> tests/ui/conflict/flatten-newtype-struct.rs:5:12 3 | | 4 | 5 | struct Foo(#[serde(flatten)] HashMap); 5 | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/flatten-tuple-struct.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | use std::collections::HashMap; 3 | 4 | #[derive(Serialize)] 5 | struct Foo(u32, #[serde(flatten)] HashMap); 6 | 7 | fn main() {} 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/flatten-tuple-struct.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(flatten)] cannot be used on tuple structs 2 | --> tests/ui/conflict/flatten-tuple-struct.rs:5:17 3 | | 4 | 5 | struct Foo(u32, #[serde(flatten)] HashMap); 5 | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/from-try-from.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(from = "u64", try_from = "u64")] 5 | struct S { 6 | a: u8, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/from-try-from.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(from = "...")] and #[serde(try_from = "...")] conflict with each other 2 | --> tests/ui/conflict/from-try-from.rs:4:1 3 | | 4 | 4 | / #[serde(from = "u64", try_from = "u64")] 5 | 5 | | struct S { 6 | 6 | | a: u8, 7 | 7 | | } 8 | | |_^ 9 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/internal-tag-alias.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(tag = "conflict")] 5 | enum E { 6 | A { 7 | #[serde(alias = "conflict")] 8 | x: (), 9 | }, 10 | } 11 | 12 | fn main() {} 13 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/internal-tag-alias.stderr: -------------------------------------------------------------------------------- 1 | error: variant field name `conflict` conflicts with internal tag 2 | --> tests/ui/conflict/internal-tag-alias.rs:4:1 3 | | 4 | 4 | / #[serde(tag = "conflict")] 5 | 5 | | enum E { 6 | 6 | | A { 7 | 7 | | #[serde(alias = "conflict")] 8 | 8 | | x: (), 9 | 9 | | }, 10 | 10 | | } 11 | | |_^ 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/internal-tag.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(tag = "conflict")] 5 | enum E { 6 | A { 7 | #[serde(rename = "conflict")] 8 | x: (), 9 | }, 10 | } 11 | 12 | fn main() {} 13 | -------------------------------------------------------------------------------- /test_suite/tests/ui/conflict/internal-tag.stderr: -------------------------------------------------------------------------------- 1 | error: variant field name `conflict` conflicts with internal tag 2 | --> tests/ui/conflict/internal-tag.rs:4:1 3 | | 4 | 4 | / #[serde(tag = "conflict")] 5 | 5 | | enum E { 6 | 6 | | A { 7 | 7 | | #[serde(rename = "conflict")] 8 | 8 | | x: (), 9 | 9 | | }, 10 | 10 | | } 11 | | |_^ 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/enum.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(default)] 5 | enum E { 6 | S { f: u8 }, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/enum.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(default)] can only be used on structs 2 | --> tests/ui/default-attribute/enum.rs:4:9 3 | | 4 | 4 | #[serde(default)] 5 | | ^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/enum_path.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(default = "default_e")] 5 | enum E { 6 | S { f: u8 }, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/enum_path.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(default = "...")] can only be used on structs 2 | --> tests/ui/default-attribute/enum_path.rs:4:9 3 | | 4 | 4 | #[serde(default = "default_e")] 5 | | ^^^^^^^^^^^^^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/incorrect_type_enum_adjacently_tagged.rs: -------------------------------------------------------------------------------- 1 | // Tests that type error points to the path in attribute 2 | 3 | use serde_derive::Deserialize; 4 | 5 | #[derive(Deserialize)] 6 | #[serde(tag = "tag", content = "content")] 7 | enum Enum { 8 | // Newtype variants do not use the provided path, so it is forbidden here 9 | // Newtype(#[serde(default = "main")] u8), 10 | Tuple(u8, #[serde(default = "main")] i8), 11 | Struct { 12 | #[serde(default = "main")] 13 | f1: u8, 14 | f2: u8, 15 | #[serde(default = "main")] 16 | f3: i8, 17 | }, 18 | } 19 | 20 | fn main() {} 21 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/incorrect_type_enum_adjacently_tagged.stderr: -------------------------------------------------------------------------------- 1 | error[E0308]: `match` arms have incompatible types 2 | --> tests/ui/default-attribute/incorrect_type_enum_adjacently_tagged.rs:10:33 3 | | 4 | 5 | #[derive(Deserialize)] 5 | | ----------- 6 | | | 7 | | this is found to be of type `i8` 8 | | `match` arms have incompatible types 9 | ... 10 | 10 | Tuple(u8, #[serde(default = "main")] i8), 11 | | ^^^^^^ expected `i8`, found `()` 12 | 13 | error[E0308]: `match` arms have incompatible types 14 | --> tests/ui/default-attribute/incorrect_type_enum_adjacently_tagged.rs:12:27 15 | | 16 | 5 | #[derive(Deserialize)] 17 | | ----------- 18 | | | 19 | | this is found to be of type `u8` 20 | | `match` arms have incompatible types 21 | ... 22 | 12 | #[serde(default = "main")] 23 | | ^^^^^^ expected `u8`, found `()` 24 | 25 | error[E0308]: `match` arms have incompatible types 26 | --> tests/ui/default-attribute/incorrect_type_enum_adjacently_tagged.rs:15:27 27 | | 28 | 5 | #[derive(Deserialize)] 29 | | ----------- 30 | | | 31 | | this is found to be of type `i8` 32 | | `match` arms have incompatible types 33 | ... 34 | 15 | #[serde(default = "main")] 35 | | ^^^^^^ expected `i8`, found `()` 36 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/incorrect_type_enum_externally_tagged.rs: -------------------------------------------------------------------------------- 1 | // Tests that type error points to the path in attribute 2 | 3 | use serde_derive::Deserialize; 4 | 5 | #[derive(Deserialize)] 6 | enum Enum { 7 | // Newtype variants do not use the provided path, so it is forbidden here 8 | // Newtype(#[serde(default = "main")] u8), 9 | Tuple(u8, #[serde(default = "main")] i8), 10 | Struct { 11 | #[serde(default = "main")] 12 | f1: u8, 13 | f2: u8, 14 | #[serde(default = "main")] 15 | f3: i8, 16 | }, 17 | } 18 | 19 | fn main() {} 20 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/incorrect_type_enum_externally_tagged.stderr: -------------------------------------------------------------------------------- 1 | error[E0308]: `match` arms have incompatible types 2 | --> tests/ui/default-attribute/incorrect_type_enum_externally_tagged.rs:9:33 3 | | 4 | 5 | #[derive(Deserialize)] 5 | | ----------- 6 | | | 7 | | this is found to be of type `i8` 8 | | `match` arms have incompatible types 9 | ... 10 | 9 | Tuple(u8, #[serde(default = "main")] i8), 11 | | ^^^^^^ expected `i8`, found `()` 12 | 13 | error[E0308]: `match` arms have incompatible types 14 | --> tests/ui/default-attribute/incorrect_type_enum_externally_tagged.rs:11:27 15 | | 16 | 5 | #[derive(Deserialize)] 17 | | ----------- 18 | | | 19 | | this is found to be of type `u8` 20 | | `match` arms have incompatible types 21 | ... 22 | 11 | #[serde(default = "main")] 23 | | ^^^^^^ expected `u8`, found `()` 24 | 25 | error[E0308]: `match` arms have incompatible types 26 | --> tests/ui/default-attribute/incorrect_type_enum_externally_tagged.rs:14:27 27 | | 28 | 5 | #[derive(Deserialize)] 29 | | ----------- 30 | | | 31 | | this is found to be of type `i8` 32 | | `match` arms have incompatible types 33 | ... 34 | 14 | #[serde(default = "main")] 35 | | ^^^^^^ expected `i8`, found `()` 36 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/incorrect_type_enum_internally_tagged.rs: -------------------------------------------------------------------------------- 1 | // Tests that type error points to the path in attribute 2 | 3 | use serde_derive::Deserialize; 4 | 5 | #[derive(Deserialize)] 6 | #[serde(tag = "tag")] 7 | enum Enum { 8 | // Newtype variants do not use the provided path, so it is forbidden here 9 | // Newtype(#[serde(default = "main")] u8), 10 | // Tuple variants are not supported in internally tagged enums 11 | Struct { 12 | #[serde(default = "main")] 13 | f1: u8, 14 | f2: u8, 15 | #[serde(default = "main")] 16 | f3: i8, 17 | }, 18 | } 19 | 20 | fn main() {} 21 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/incorrect_type_enum_internally_tagged.stderr: -------------------------------------------------------------------------------- 1 | error[E0308]: `match` arms have incompatible types 2 | --> tests/ui/default-attribute/incorrect_type_enum_internally_tagged.rs:12:27 3 | | 4 | 5 | #[derive(Deserialize)] 5 | | ----------- 6 | | | 7 | | this is found to be of type `u8` 8 | | `match` arms have incompatible types 9 | ... 10 | 12 | #[serde(default = "main")] 11 | | ^^^^^^ expected `u8`, found `()` 12 | 13 | error[E0308]: `match` arms have incompatible types 14 | --> tests/ui/default-attribute/incorrect_type_enum_internally_tagged.rs:15:27 15 | | 16 | 5 | #[derive(Deserialize)] 17 | | ----------- 18 | | | 19 | | this is found to be of type `i8` 20 | | `match` arms have incompatible types 21 | ... 22 | 15 | #[serde(default = "main")] 23 | | ^^^^^^ expected `i8`, found `()` 24 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/incorrect_type_enum_untagged.rs: -------------------------------------------------------------------------------- 1 | // Tests that type error points to the path in attribute 2 | 3 | use serde_derive::Deserialize; 4 | 5 | #[derive(Deserialize)] 6 | #[serde(untagged)] 7 | enum Enum { 8 | // Newtype variants do not use the provided path, so it is forbidden here 9 | // Newtype(#[serde(default = "main")] u8), 10 | Tuple(u8, #[serde(default = "main")] i8), 11 | Struct { 12 | #[serde(default = "main")] 13 | f1: u8, 14 | f2: u8, 15 | #[serde(default = "main")] 16 | f3: i8, 17 | }, 18 | } 19 | 20 | fn main() {} 21 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/incorrect_type_enum_untagged.stderr: -------------------------------------------------------------------------------- 1 | error[E0308]: `match` arms have incompatible types 2 | --> tests/ui/default-attribute/incorrect_type_enum_untagged.rs:10:33 3 | | 4 | 5 | #[derive(Deserialize)] 5 | | ----------- 6 | | | 7 | | this is found to be of type `i8` 8 | | `match` arms have incompatible types 9 | ... 10 | 10 | Tuple(u8, #[serde(default = "main")] i8), 11 | | ^^^^^^ expected `i8`, found `()` 12 | 13 | error[E0308]: `match` arms have incompatible types 14 | --> tests/ui/default-attribute/incorrect_type_enum_untagged.rs:12:27 15 | | 16 | 5 | #[derive(Deserialize)] 17 | | ----------- 18 | | | 19 | | this is found to be of type `u8` 20 | | `match` arms have incompatible types 21 | ... 22 | 12 | #[serde(default = "main")] 23 | | ^^^^^^ expected `u8`, found `()` 24 | 25 | error[E0308]: `match` arms have incompatible types 26 | --> tests/ui/default-attribute/incorrect_type_enum_untagged.rs:15:27 27 | | 28 | 5 | #[derive(Deserialize)] 29 | | ----------- 30 | | | 31 | | this is found to be of type `i8` 32 | | `match` arms have incompatible types 33 | ... 34 | 15 | #[serde(default = "main")] 35 | | ^^^^^^ expected `i8`, found `()` 36 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/incorrect_type_newtype.rs: -------------------------------------------------------------------------------- 1 | // Tests that type error points to the path in attribute 2 | 3 | use serde_derive::Deserialize; 4 | 5 | #[derive(Deserialize)] 6 | #[serde(default = "main")] 7 | struct Newtype(#[serde(default = "main")] u8); 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/incorrect_type_newtype.stderr: -------------------------------------------------------------------------------- 1 | error[E0308]: mismatched types 2 | --> tests/ui/default-attribute/incorrect_type_newtype.rs:6:19 3 | | 4 | 6 | #[serde(default = "main")] 5 | | ^^^^^^ 6 | | | 7 | | expected `Newtype`, found `()` 8 | | expected due to this 9 | 10 | error[E0308]: `match` arms have incompatible types 11 | --> tests/ui/default-attribute/incorrect_type_newtype.rs:7:34 12 | | 13 | 5 | #[derive(Deserialize)] 14 | | ----------- 15 | | | 16 | | this is found to be of type `u8` 17 | | `match` arms have incompatible types 18 | 6 | #[serde(default = "main")] 19 | 7 | struct Newtype(#[serde(default = "main")] u8); 20 | | ^^^^^^ expected `u8`, found `()` 21 | 22 | error[E0308]: mismatched types 23 | --> tests/ui/default-attribute/incorrect_type_newtype.rs:6:19 24 | | 25 | 6 | #[serde(default = "main")] 26 | | ^^^^^^ expected `Newtype`, found `()` 27 | 7 | struct Newtype(#[serde(default = "main")] u8); 28 | | ------- expected due to this 29 | 30 | error[E0308]: mismatched types 31 | --> tests/ui/default-attribute/incorrect_type_newtype.rs:7:34 32 | | 33 | 5 | #[derive(Deserialize)] 34 | | ----------- expected due to the type of this binding 35 | 6 | #[serde(default = "main")] 36 | 7 | struct Newtype(#[serde(default = "main")] u8); 37 | | ^^^^^^ expected `u8`, found `()` 38 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/incorrect_type_struct.rs: -------------------------------------------------------------------------------- 1 | // Tests that type error points to the path in attribute 2 | 3 | use serde_derive::Deserialize; 4 | 5 | #[derive(Deserialize)] 6 | #[serde(default = "main")] 7 | struct Struct { 8 | #[serde(default = "main")] 9 | f1: u8, 10 | f2: u8, 11 | #[serde(default = "main")] 12 | f3: i8, 13 | } 14 | 15 | fn main() {} 16 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/incorrect_type_struct.stderr: -------------------------------------------------------------------------------- 1 | error[E0308]: mismatched types 2 | --> tests/ui/default-attribute/incorrect_type_struct.rs:6:19 3 | | 4 | 6 | #[serde(default = "main")] 5 | | ^^^^^^ 6 | | | 7 | | expected `Struct`, found `()` 8 | | expected due to this 9 | 10 | error[E0308]: `match` arms have incompatible types 11 | --> tests/ui/default-attribute/incorrect_type_struct.rs:8:23 12 | | 13 | 5 | #[derive(Deserialize)] 14 | | ----------- 15 | | | 16 | | this is found to be of type `u8` 17 | | `match` arms have incompatible types 18 | ... 19 | 8 | #[serde(default = "main")] 20 | | ^^^^^^ expected `u8`, found `()` 21 | 22 | error[E0308]: `match` arms have incompatible types 23 | --> tests/ui/default-attribute/incorrect_type_struct.rs:11:23 24 | | 25 | 5 | #[derive(Deserialize)] 26 | | ----------- 27 | | | 28 | | this is found to be of type `i8` 29 | | `match` arms have incompatible types 30 | ... 31 | 11 | #[serde(default = "main")] 32 | | ^^^^^^ expected `i8`, found `()` 33 | 34 | error[E0308]: mismatched types 35 | --> tests/ui/default-attribute/incorrect_type_struct.rs:6:19 36 | | 37 | 6 | #[serde(default = "main")] 38 | | ^^^^^^ expected `Struct`, found `()` 39 | 7 | struct Struct { 40 | | ------ expected due to this 41 | 42 | error[E0308]: mismatched types 43 | --> tests/ui/default-attribute/incorrect_type_struct.rs:8:23 44 | | 45 | 5 | #[derive(Deserialize)] 46 | | ----------- expected due to the type of this binding 47 | ... 48 | 8 | #[serde(default = "main")] 49 | | ^^^^^^ expected `u8`, found `()` 50 | 51 | error[E0308]: mismatched types 52 | --> tests/ui/default-attribute/incorrect_type_struct.rs:11:23 53 | | 54 | 5 | #[derive(Deserialize)] 55 | | ----------- expected due to the type of this binding 56 | ... 57 | 11 | #[serde(default = "main")] 58 | | ^^^^^^ expected `i8`, found `()` 59 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/incorrect_type_tuple.rs: -------------------------------------------------------------------------------- 1 | // Tests that type error points to the path in attribute 2 | 3 | use serde_derive::Deserialize; 4 | 5 | #[derive(Deserialize)] 6 | #[serde(default = "main")] 7 | struct Tuple(u8, #[serde(default = "main")] i8); 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/incorrect_type_tuple.stderr: -------------------------------------------------------------------------------- 1 | error[E0308]: mismatched types 2 | --> tests/ui/default-attribute/incorrect_type_tuple.rs:6:19 3 | | 4 | 6 | #[serde(default = "main")] 5 | | ^^^^^^ 6 | | | 7 | | expected `Tuple`, found `()` 8 | | expected due to this 9 | 10 | error[E0308]: `match` arms have incompatible types 11 | --> tests/ui/default-attribute/incorrect_type_tuple.rs:7:36 12 | | 13 | 5 | #[derive(Deserialize)] 14 | | ----------- 15 | | | 16 | | this is found to be of type `i8` 17 | | `match` arms have incompatible types 18 | 6 | #[serde(default = "main")] 19 | 7 | struct Tuple(u8, #[serde(default = "main")] i8); 20 | | ^^^^^^ expected `i8`, found `()` 21 | 22 | error[E0308]: mismatched types 23 | --> tests/ui/default-attribute/incorrect_type_tuple.rs:6:19 24 | | 25 | 6 | #[serde(default = "main")] 26 | | ^^^^^^ expected `Tuple`, found `()` 27 | 7 | struct Tuple(u8, #[serde(default = "main")] i8); 28 | | ----- expected due to this 29 | 30 | error[E0308]: mismatched types 31 | --> tests/ui/default-attribute/incorrect_type_tuple.rs:7:36 32 | | 33 | 5 | #[derive(Deserialize)] 34 | | ----------- expected due to the type of this binding 35 | 6 | #[serde(default = "main")] 36 | 7 | struct Tuple(u8, #[serde(default = "main")] i8); 37 | | ^^^^^^ expected `i8`, found `()` 38 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/tuple_struct.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | // No errors expected. 4 | #[derive(Deserialize)] 5 | struct T0(u8, u8); 6 | 7 | // No errors expected: 8 | // - If both fields are provided, both get value from data. 9 | // - If only one field is provided, the second gets default value. 10 | #[derive(Deserialize)] 11 | struct T1(u8, #[serde(default)] u8); 12 | 13 | // ERROR: The first field can get default value only if sequence is empty, but 14 | // that mean that all other fields cannot be deserialized without errors. 15 | #[derive(Deserialize)] 16 | struct T2(#[serde(default)] u8, u8, u8); 17 | 18 | // No errors expected: 19 | // - If both fields are provided, both get value from data. 20 | // - If only one field is provided, the second gets default value. 21 | // - If no fields are provided, both get default value. 22 | #[derive(Deserialize)] 23 | struct T3(#[serde(default)] u8, #[serde(default)] u8); 24 | 25 | //////////////////////////////////////////////////////////////////////////////// 26 | 27 | // No errors expected -- missing fields get default values. 28 | #[derive(Deserialize, Default)] 29 | #[serde(default)] 30 | struct T4(u8, u8); 31 | 32 | // No errors expected -- missing fields get default values. 33 | #[derive(Deserialize, Default)] 34 | #[serde(default)] 35 | struct T5(#[serde(default)] u8, u8); 36 | 37 | // No errors expected -- missing fields get default values. 38 | #[derive(Deserialize, Default)] 39 | #[serde(default)] 40 | struct T6(u8, #[serde(default)] u8); 41 | 42 | // No errors expected -- missing fields get default values. 43 | #[derive(Deserialize, Default)] 44 | #[serde(default)] 45 | struct T7(#[serde(default)] u8, #[serde(default)] u8); 46 | 47 | fn main() {} 48 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/tuple_struct.stderr: -------------------------------------------------------------------------------- 1 | error: field must have #[serde(default)] because previous field 0 has #[serde(default)] 2 | --> tests/ui/default-attribute/tuple_struct.rs:16:33 3 | | 4 | 16 | struct T2(#[serde(default)] u8, u8, u8); 5 | | ^^ 6 | 7 | error: field must have #[serde(default)] because previous field 0 has #[serde(default)] 8 | --> tests/ui/default-attribute/tuple_struct.rs:16:37 9 | | 10 | 16 | struct T2(#[serde(default)] u8, u8, u8); 11 | | ^^ 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/tuple_struct_path.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | fn d() -> T { 4 | unimplemented!() 5 | } 6 | 7 | // No errors expected: 8 | // - If both fields are provided, both get value from data. 9 | // - If only one field is provided, the second gets default value. 10 | #[derive(Deserialize)] 11 | struct T1(u8, #[serde(default = "d")] u8); 12 | 13 | // ERROR: The first field can get default value only if sequence is empty, but 14 | // that mean that all other fields cannot be deserialized without errors. 15 | #[derive(Deserialize)] 16 | struct T2(#[serde(default = "d")] u8, u8, u8); 17 | 18 | // No errors expected: 19 | // - If both fields are provided, both get value from data. 20 | // - If only one field is provided, the second gets default value. 21 | // - If no fields are provided, both get default value. 22 | #[derive(Deserialize)] 23 | struct T3(#[serde(default = "d")] u8, #[serde(default = "d")] u8); 24 | 25 | //////////////////////////////////////////////////////////////////////////////// 26 | 27 | // No errors expected -- missing fields get default values. 28 | #[derive(Deserialize, Default)] 29 | #[serde(default)] 30 | struct T1D(#[serde(default = "d")] u8, u8); 31 | 32 | // No errors expected -- missing fields get default values. 33 | #[derive(Deserialize, Default)] 34 | #[serde(default)] 35 | struct T2D(u8, #[serde(default = "d")] u8); 36 | 37 | // No errors expected -- missing fields get default values. 38 | #[derive(Deserialize, Default)] 39 | #[serde(default)] 40 | struct T3D(#[serde(default = "d")] u8, #[serde(default = "d")] u8); 41 | 42 | //////////////////////////////////////////////////////////////////////////////// 43 | 44 | // No errors expected -- missing fields get default values. 45 | #[derive(Deserialize)] 46 | #[serde(default = "d")] 47 | struct T1Path(#[serde(default)] u8, u8); 48 | 49 | // No errors expected -- missing fields get default values. 50 | #[derive(Deserialize)] 51 | #[serde(default = "d")] 52 | struct T2Path(u8, #[serde(default)] u8); 53 | 54 | // No errors expected -- missing fields get default values. 55 | #[derive(Deserialize)] 56 | #[serde(default = "d")] 57 | struct T3Path(#[serde(default)] u8, #[serde(default)] u8); 58 | 59 | //////////////////////////////////////////////////////////////////////////////// 60 | 61 | // No errors expected -- missing fields get default values. 62 | #[derive(Deserialize)] 63 | #[serde(default = "d")] 64 | struct T1PathD(#[serde(default = "d")] u8, u8); 65 | 66 | // No errors expected -- missing fields get default values. 67 | #[derive(Deserialize)] 68 | #[serde(default = "d")] 69 | struct T2PathD(u8, #[serde(default = "d")] u8); 70 | 71 | // No errors expected -- missing fields get default values. 72 | #[derive(Deserialize)] 73 | #[serde(default = "d")] 74 | struct T3PathD(#[serde(default = "d")] u8, #[serde(default = "d")] u8); 75 | 76 | fn main() {} 77 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/tuple_struct_path.stderr: -------------------------------------------------------------------------------- 1 | error: field must have #[serde(default)] because previous field 0 has #[serde(default)] 2 | --> tests/ui/default-attribute/tuple_struct_path.rs:16:39 3 | | 4 | 16 | struct T2(#[serde(default = "d")] u8, u8, u8); 5 | | ^^ 6 | 7 | error: field must have #[serde(default)] because previous field 0 has #[serde(default)] 8 | --> tests/ui/default-attribute/tuple_struct_path.rs:16:43 9 | | 10 | 16 | struct T2(#[serde(default = "d")] u8, u8, u8); 11 | | ^^ 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/union.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(default)] 5 | union Union { 6 | f: u8, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/union.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(default)] can only be used on structs 2 | --> tests/ui/default-attribute/union.rs:4:9 3 | | 4 | 4 | #[serde(default)] 5 | | ^^^^^^^ 6 | 7 | error: Serde does not support derive for unions 8 | --> tests/ui/default-attribute/union.rs:4:1 9 | | 10 | 4 | / #[serde(default)] 11 | 5 | | union Union { 12 | 6 | | f: u8, 13 | 7 | | } 14 | | |_^ 15 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/union_path.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(default = "default_u")] 5 | union Union { 6 | f: u8, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/union_path.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(default = "...")] can only be used on structs 2 | --> tests/ui/default-attribute/union_path.rs:4:9 3 | | 4 | 4 | #[serde(default = "default_u")] 5 | | ^^^^^^^^^^^^^^^^^^^^^ 6 | 7 | error: Serde does not support derive for unions 8 | --> tests/ui/default-attribute/union_path.rs:4:1 9 | | 10 | 4 | / #[serde(default = "default_u")] 11 | 5 | | union Union { 12 | 6 | | f: u8, 13 | 7 | | } 14 | | |_^ 15 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/unit.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(default)] 5 | struct Unit; 6 | 7 | fn main() {} 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/unit.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(default)] can only be used on structs that have fields 2 | --> tests/ui/default-attribute/unit.rs:3:10 3 | | 4 | 3 | #[derive(Deserialize)] 5 | | ^^^^^^^^^^^ 6 | | 7 | = note: this error originates in the derive macro `Deserialize` (in Nightly builds, run with -Z macro-backtrace for more info) 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/unit_path.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(default = "default_u")] 5 | struct Unit; 6 | 7 | fn main() {} 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/default-attribute/unit_path.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(default = "...")] can only be used on structs that have fields 2 | --> tests/ui/default-attribute/unit_path.rs:4:9 3 | | 4 | 4 | #[serde(default = "default_u")] 5 | | ^^^^^^^^^^^^^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/duplicate-attribute/rename-and-ser.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(rename = "x", serialize = "y")] 6 | x: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/duplicate-attribute/rename-and-ser.stderr: -------------------------------------------------------------------------------- 1 | error: unknown serde field attribute `serialize` 2 | --> tests/ui/duplicate-attribute/rename-and-ser.rs:5:27 3 | | 4 | 5 | #[serde(rename = "x", serialize = "y")] 5 | | ^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/duplicate-attribute/rename-ser-rename-ser.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(rename(serialize = "x"), rename(serialize = "y"))] 6 | x: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/duplicate-attribute/rename-ser-rename-ser.stderr: -------------------------------------------------------------------------------- 1 | error: duplicate serde attribute `rename` 2 | --> tests/ui/duplicate-attribute/rename-ser-rename-ser.rs:5:38 3 | | 4 | 5 | #[serde(rename(serialize = "x"), rename(serialize = "y"))] 5 | | ^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/duplicate-attribute/rename-ser-rename.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(rename(serialize = "x"))] 6 | #[serde(rename = "y")] 7 | x: (), 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/duplicate-attribute/rename-ser-rename.stderr: -------------------------------------------------------------------------------- 1 | error: duplicate serde attribute `rename` 2 | --> tests/ui/duplicate-attribute/rename-ser-rename.rs:6:13 3 | | 4 | 6 | #[serde(rename = "y")] 5 | | ^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/duplicate-attribute/rename-ser-ser.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(rename(serialize = "x", serialize = "y"))] 6 | x: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/duplicate-attribute/rename-ser-ser.stderr: -------------------------------------------------------------------------------- 1 | error: duplicate serde attribute `rename` 2 | --> tests/ui/duplicate-attribute/rename-ser-ser.rs:5:37 3 | | 4 | 5 | #[serde(rename(serialize = "x", serialize = "y"))] 5 | | ^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/duplicate-attribute/two-rename-ser.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(rename(serialize = "x"))] 6 | #[serde(rename(serialize = "y"))] 7 | x: (), 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/duplicate-attribute/two-rename-ser.stderr: -------------------------------------------------------------------------------- 1 | error: duplicate serde attribute `rename` 2 | --> tests/ui/duplicate-attribute/two-rename-ser.rs:6:13 3 | | 4 | 6 | #[serde(rename(serialize = "y"))] 5 | | ^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/duplicate-attribute/with-and-serialize-with.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(with = "w", serialize_with = "s")] 6 | x: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/duplicate-attribute/with-and-serialize-with.stderr: -------------------------------------------------------------------------------- 1 | error: duplicate serde attribute `serialize_with` 2 | --> tests/ui/duplicate-attribute/with-and-serialize-with.rs:5:25 3 | | 4 | 5 | #[serde(with = "w", serialize_with = "s")] 5 | | ^^^^^^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/enum-representation/content-no-tag.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(content = "c")] 5 | enum E { 6 | A(u8), 7 | B(String), 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/enum-representation/content-no-tag.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(tag = "...", content = "...")] must be used together 2 | --> tests/ui/enum-representation/content-no-tag.rs:4:9 3 | | 4 | 4 | #[serde(content = "c")] 5 | | ^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/enum-representation/internal-tuple-variant.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(tag = "type")] 5 | enum E { 6 | Tuple(u8, u8), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/enum-representation/internal-tuple-variant.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(tag = "...")] cannot be used with tuple variants 2 | --> tests/ui/enum-representation/internal-tuple-variant.rs:6:5 3 | | 4 | 6 | Tuple(u8, u8), 5 | | ^^^^^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/enum-representation/partially_tagged_wrong_order.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | enum E { 5 | #[serde(untagged)] 6 | A(u8), 7 | B(String), 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/enum-representation/partially_tagged_wrong_order.stderr: -------------------------------------------------------------------------------- 1 | error: all variants with the #[serde(untagged)] attribute must be placed at the end of the enum 2 | --> tests/ui/enum-representation/partially_tagged_wrong_order.rs:6:5 3 | | 4 | 6 | A(u8), 5 | | ^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/enum-representation/untagged-and-adjacent.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(untagged)] 5 | #[serde(tag = "t", content = "c")] 6 | enum E { 7 | A(u8), 8 | B(String), 9 | } 10 | 11 | fn main() {} 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/enum-representation/untagged-and-adjacent.stderr: -------------------------------------------------------------------------------- 1 | error: untagged enum cannot have #[serde(tag = "...", content = "...")] 2 | --> tests/ui/enum-representation/untagged-and-adjacent.rs:4:9 3 | | 4 | 4 | #[serde(untagged)] 5 | | ^^^^^^^^ 6 | 7 | error: untagged enum cannot have #[serde(tag = "...", content = "...")] 8 | --> tests/ui/enum-representation/untagged-and-adjacent.rs:5:9 9 | | 10 | 5 | #[serde(tag = "t", content = "c")] 11 | | ^^^ 12 | 13 | error: untagged enum cannot have #[serde(tag = "...", content = "...")] 14 | --> tests/ui/enum-representation/untagged-and-adjacent.rs:5:20 15 | | 16 | 5 | #[serde(tag = "t", content = "c")] 17 | | ^^^^^^^ 18 | -------------------------------------------------------------------------------- /test_suite/tests/ui/enum-representation/untagged-and-content.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(untagged)] 5 | #[serde(content = "c")] 6 | enum E { 7 | A(u8), 8 | B(String), 9 | } 10 | 11 | fn main() {} 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/enum-representation/untagged-and-content.stderr: -------------------------------------------------------------------------------- 1 | error: untagged enum cannot have #[serde(content = "...")] 2 | --> tests/ui/enum-representation/untagged-and-content.rs:4:9 3 | | 4 | 4 | #[serde(untagged)] 5 | | ^^^^^^^^ 6 | 7 | error: untagged enum cannot have #[serde(content = "...")] 8 | --> tests/ui/enum-representation/untagged-and-content.rs:5:9 9 | | 10 | 5 | #[serde(content = "c")] 11 | | ^^^^^^^ 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/enum-representation/untagged-and-internal.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(untagged)] 5 | #[serde(tag = "type")] 6 | enum E { 7 | A(u8), 8 | B(String), 9 | } 10 | 11 | fn main() {} 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/enum-representation/untagged-and-internal.stderr: -------------------------------------------------------------------------------- 1 | error: enum cannot be both untagged and internally tagged 2 | --> tests/ui/enum-representation/untagged-and-internal.rs:4:9 3 | | 4 | 4 | #[serde(untagged)] 5 | | ^^^^^^^^ 6 | 7 | error: enum cannot be both untagged and internally tagged 8 | --> tests/ui/enum-representation/untagged-and-internal.rs:5:9 9 | | 10 | 5 | #[serde(tag = "type")] 11 | | ^^^ 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/enum-representation/untagged-struct.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(untagged)] 5 | struct S; 6 | 7 | fn main() {} 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/enum-representation/untagged-struct.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(untagged)] can only be used on enums 2 | --> tests/ui/enum-representation/untagged-struct.rs:4:9 3 | | 4 | 4 | #[serde(untagged)] 5 | | ^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/expected-string/boolean.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(rename = true)] 6 | boolean: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/expected-string/boolean.stderr: -------------------------------------------------------------------------------- 1 | error: expected serde rename attribute to be a string: `rename = "..."` 2 | --> tests/ui/expected-string/boolean.rs:5:22 3 | | 4 | 5 | #[serde(rename = true)] 5 | | ^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/expected-string/byte_character.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(rename = b'a')] 6 | byte_character: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/expected-string/byte_character.stderr: -------------------------------------------------------------------------------- 1 | error: expected serde rename attribute to be a string: `rename = "..."` 2 | --> tests/ui/expected-string/byte_character.rs:5:22 3 | | 4 | 5 | #[serde(rename = b'a')] 5 | | ^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/expected-string/byte_string.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(rename = b"byte string")] 6 | byte_string: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/expected-string/byte_string.stderr: -------------------------------------------------------------------------------- 1 | error: expected serde rename attribute to be a string: `rename = "..."` 2 | --> tests/ui/expected-string/byte_string.rs:5:22 3 | | 4 | 5 | #[serde(rename = b"byte string")] 5 | | ^^^^^^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/expected-string/character.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(rename = 'a')] 6 | character: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/expected-string/character.stderr: -------------------------------------------------------------------------------- 1 | error: expected serde rename attribute to be a string: `rename = "..."` 2 | --> tests/ui/expected-string/character.rs:5:22 3 | | 4 | 5 | #[serde(rename = 'a')] 5 | | ^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/expected-string/float.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(rename = 3.14)] 6 | float: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/expected-string/float.stderr: -------------------------------------------------------------------------------- 1 | error: expected serde rename attribute to be a string: `rename = "..."` 2 | --> tests/ui/expected-string/float.rs:5:22 3 | | 4 | 5 | #[serde(rename = 3.14)] 5 | | ^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/expected-string/integer.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(rename = 100)] 6 | integer: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/expected-string/integer.stderr: -------------------------------------------------------------------------------- 1 | error: expected serde rename attribute to be a string: `rename = "..."` 2 | --> tests/ui/expected-string/integer.rs:5:22 3 | | 4 | 5 | #[serde(rename = 100)] 5 | | ^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/both.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(field_identifier, variant_identifier)] 5 | enum F { 6 | A, 7 | B, 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/both.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(field_identifier)] and #[serde(variant_identifier)] cannot both be set 2 | --> tests/ui/identifier/both.rs:4:9 3 | | 4 | 4 | #[serde(field_identifier, variant_identifier)] 5 | | ^^^^^^^^^^^^^^^^ 6 | 7 | error: #[serde(field_identifier)] and #[serde(variant_identifier)] cannot both be set 8 | --> tests/ui/identifier/both.rs:4:27 9 | | 10 | 4 | #[serde(field_identifier, variant_identifier)] 11 | | ^^^^^^^^^^^^^^^^^^ 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/field_struct.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(field_identifier)] 5 | struct S; 6 | 7 | fn main() {} 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/field_struct.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(field_identifier)] can only be used on an enum 2 | --> tests/ui/identifier/field_struct.rs:5:1 3 | | 4 | 5 | struct S; 5 | | ^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/field_tuple.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(field_identifier)] 5 | enum F { 6 | A, 7 | B(u8, u8), 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/field_tuple.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(field_identifier)] may only contain unit variants 2 | --> tests/ui/identifier/field_tuple.rs:7:5 3 | | 4 | 7 | B(u8, u8), 5 | | ^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/newtype_not_last.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(field_identifier)] 5 | enum F { 6 | A, 7 | Other(String), 8 | B, 9 | } 10 | 11 | fn main() {} 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/newtype_not_last.stderr: -------------------------------------------------------------------------------- 1 | error: `Other` must be the last variant 2 | --> tests/ui/identifier/newtype_not_last.rs:7:5 3 | | 4 | 7 | Other(String), 5 | | ^^^^^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/not_unit.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(field_identifier)] 5 | enum F { 6 | A, 7 | #[serde(other)] 8 | Other(u8, u8), 9 | } 10 | 11 | fn main() {} 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/not_unit.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(other)] must be on a unit variant 2 | --> tests/ui/identifier/not_unit.rs:7:5 3 | | 4 | 7 | / #[serde(other)] 5 | 8 | | Other(u8, u8), 6 | | |_________________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/other_not_last.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(field_identifier)] 5 | enum F { 6 | A, 7 | #[serde(other)] 8 | Other, 9 | B, 10 | } 11 | 12 | fn main() {} 13 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/other_not_last.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(other)] must be on the last variant 2 | --> tests/ui/identifier/other_not_last.rs:7:5 3 | | 4 | 7 | / #[serde(other)] 5 | 8 | | Other, 6 | | |_________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/other_untagged.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(untagged)] 5 | enum F { 6 | #[serde(other)] 7 | Other, 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/other_untagged.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(other)] cannot appear on untagged enum 2 | --> tests/ui/identifier/other_untagged.rs:6:5 3 | | 4 | 6 | / #[serde(other)] 5 | 7 | | Other, 6 | | |_________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/other_variant.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(variant_identifier)] 5 | enum F { 6 | #[serde(other)] 7 | Other, 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/other_variant.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(other)] may not be used on a variant identifier 2 | --> tests/ui/identifier/other_variant.rs:6:5 3 | | 4 | 6 | / #[serde(other)] 5 | 7 | | Other, 6 | | |_________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/variant_struct.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(variant_identifier)] 5 | struct S; 6 | 7 | fn main() {} 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/variant_struct.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(variant_identifier)] can only be used on an enum 2 | --> tests/ui/identifier/variant_struct.rs:5:1 3 | | 4 | 5 | struct S; 5 | | ^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/variant_tuple.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(variant_identifier)] 5 | enum F { 6 | A, 7 | B(u8, u8), 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/identifier/variant_tuple.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(variant_identifier)] may only contain unit variants 2 | --> tests/ui/identifier/variant_tuple.rs:7:5 3 | | 4 | 7 | B(u8, u8), 5 | | ^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/malformed/bound.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(bound(unknown))] 6 | x: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/malformed/bound.stderr: -------------------------------------------------------------------------------- 1 | error: malformed bound attribute, expected `bound(serialize = ..., deserialize = ...)` 2 | --> tests/ui/malformed/bound.rs:5:19 3 | | 4 | 5 | #[serde(bound(unknown))] 5 | | ^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/malformed/cut_off.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(rename =)] 5 | struct S; 6 | 7 | fn main() {} 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/malformed/cut_off.stderr: -------------------------------------------------------------------------------- 1 | error: unexpected end of input, expected an expression 2 | --> tests/ui/malformed/cut_off.rs:4:17 3 | | 4 | 4 | #[serde(rename =)] 5 | | ^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/malformed/not_list.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde] 5 | #[serde = "?"] 6 | struct S; 7 | 8 | fn main() {} 9 | -------------------------------------------------------------------------------- /test_suite/tests/ui/malformed/not_list.stderr: -------------------------------------------------------------------------------- 1 | error: expected attribute arguments in parentheses: #[serde(...)] 2 | --> tests/ui/malformed/not_list.rs:4:3 3 | | 4 | 4 | #[serde] 5 | | ^^^^^ 6 | 7 | error: expected parentheses: #[serde(...)] 8 | --> tests/ui/malformed/not_list.rs:5:9 9 | | 10 | 5 | #[serde = "?"] 11 | | ^ 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/malformed/rename.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(rename(unknown))] 6 | x: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/malformed/rename.stderr: -------------------------------------------------------------------------------- 1 | error: malformed rename attribute, expected `rename(serialize = ..., deserialize = ...)` 2 | --> tests/ui/malformed/rename.rs:5:20 3 | | 4 | 5 | #[serde(rename(unknown))] 5 | | ^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/malformed/str_suffix.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(bound = ""huh)] 5 | pub struct Struct { 6 | #[serde(rename = ""what)] 7 | pub field: i32, 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/malformed/str_suffix.stderr: -------------------------------------------------------------------------------- 1 | error: unexpected suffix `huh` on string literal 2 | --> tests/ui/malformed/str_suffix.rs:4:17 3 | | 4 | 4 | #[serde(bound = ""huh)] 5 | | ^^^^^ 6 | 7 | error: unexpected suffix `what` on string literal 8 | --> tests/ui/malformed/str_suffix.rs:6:22 9 | | 10 | 6 | #[serde(rename = ""what)] 11 | | ^^^^^^ 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/malformed/trailing_expr.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(skip_serializing_if, x.is_empty())] 6 | x: Vec<()>, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/malformed/trailing_expr.stderr: -------------------------------------------------------------------------------- 1 | error: expected `=` 2 | --> tests/ui/malformed/trailing_expr.rs:5:32 3 | | 4 | 5 | #[serde(skip_serializing_if, x.is_empty())] 5 | | ^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/on_unimplemented.rs: -------------------------------------------------------------------------------- 1 | use serde::de::Deserialize; 2 | use serde::ser::Serialize; 3 | 4 | fn to_string(_: &T) -> String 5 | where 6 | T: Serialize, 7 | { 8 | unimplemented!() 9 | } 10 | 11 | fn from_str<'de, T>(_: &'de str) -> T 12 | where 13 | T: Deserialize<'de>, 14 | { 15 | unimplemented!() 16 | } 17 | 18 | struct MyStruct; 19 | 20 | fn main() { 21 | to_string(&MyStruct); 22 | let _: MyStruct = from_str(""); 23 | } 24 | -------------------------------------------------------------------------------- /test_suite/tests/ui/on_unimplemented.stderr: -------------------------------------------------------------------------------- 1 | error[E0277]: the trait bound `MyStruct: Serialize` is not satisfied 2 | --> tests/ui/on_unimplemented.rs:21:15 3 | | 4 | 21 | to_string(&MyStruct); 5 | | --------- ^^^^^^^^^ the trait `Serialize` is not implemented for `MyStruct` 6 | | | 7 | | required by a bound introduced by this call 8 | | 9 | = note: for local types consider adding `#[derive(serde::Serialize)]` to your `MyStruct` type 10 | = note: for types from other crates check whether the crate offers a `serde` feature flag 11 | = help: the following other types implement trait `Serialize`: 12 | &'a T 13 | &'a mut T 14 | () 15 | (T,) 16 | (T0, T1) 17 | (T0, T1, T2) 18 | (T0, T1, T2, T3) 19 | (T0, T1, T2, T3, T4) 20 | and $N others 21 | note: required by a bound in `to_string` 22 | --> tests/ui/on_unimplemented.rs:6:8 23 | | 24 | 4 | fn to_string(_: &T) -> String 25 | | --------- required by a bound in this function 26 | 5 | where 27 | 6 | T: Serialize, 28 | | ^^^^^^^^^ required by this bound in `to_string` 29 | 30 | error[E0277]: the trait bound `MyStruct: Deserialize<'_>` is not satisfied 31 | --> tests/ui/on_unimplemented.rs:22:23 32 | | 33 | 22 | let _: MyStruct = from_str(""); 34 | | ^^^^^^^^^^^^ the trait `Deserialize<'_>` is not implemented for `MyStruct` 35 | | 36 | = note: for local types consider adding `#[derive(serde::Deserialize)]` to your `MyStruct` type 37 | = note: for types from other crates check whether the crate offers a `serde` feature flag 38 | = help: the following other types implement trait `Deserialize<'de>`: 39 | &'a Path 40 | &'a [u8] 41 | &'a str 42 | () 43 | (T,) 44 | (T0, T1) 45 | (T0, T1, T2) 46 | (T0, T1, T2, T3) 47 | and $N others 48 | note: required by a bound in `from_str` 49 | --> tests/ui/on_unimplemented.rs:13:8 50 | | 51 | 11 | fn from_str<'de, T>(_: &'de str) -> T 52 | | -------- required by a bound in this function 53 | 12 | where 54 | 13 | T: Deserialize<'de>, 55 | | ^^^^^^^^^^^^^^^^ required by this bound in `from_str` 56 | -------------------------------------------------------------------------------- /test_suite/tests/ui/precondition/deserialize_de_lifetime.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | struct S<'de> { 5 | s: &'de str, 6 | } 7 | 8 | fn main() {} 9 | -------------------------------------------------------------------------------- /test_suite/tests/ui/precondition/deserialize_de_lifetime.stderr: -------------------------------------------------------------------------------- 1 | error: cannot deserialize when there is a lifetime parameter called 'de 2 | --> tests/ui/precondition/deserialize_de_lifetime.rs:4:10 3 | | 4 | 4 | struct S<'de> { 5 | | ^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/precondition/deserialize_dst.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | struct S { 5 | string: String, 6 | slice: [u8], 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/precondition/deserialize_dst.stderr: -------------------------------------------------------------------------------- 1 | error: cannot deserialize a dynamically sized struct 2 | --> tests/ui/precondition/deserialize_dst.rs:4:1 3 | | 4 | 4 | / struct S { 5 | 5 | | string: String, 6 | 6 | | slice: [u8], 7 | 7 | | } 8 | | |_^ 9 | -------------------------------------------------------------------------------- /test_suite/tests/ui/precondition/serialize_field_identifier.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(field_identifier)] 5 | enum F { 6 | A, 7 | B, 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/precondition/serialize_field_identifier.stderr: -------------------------------------------------------------------------------- 1 | error: field identifiers cannot be serialized 2 | --> tests/ui/precondition/serialize_field_identifier.rs:4:1 3 | | 4 | 4 | / #[serde(field_identifier)] 5 | 5 | | enum F { 6 | 6 | | A, 7 | 7 | | B, 8 | 8 | | } 9 | | |_^ 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/precondition/serialize_variant_identifier.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(variant_identifier)] 5 | enum F { 6 | A, 7 | B, 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/precondition/serialize_variant_identifier.stderr: -------------------------------------------------------------------------------- 1 | error: variant identifiers cannot be serialized 2 | --> tests/ui/precondition/serialize_variant_identifier.rs:4:1 3 | | 4 | 4 | / #[serde(variant_identifier)] 5 | 5 | | enum F { 6 | 6 | | A, 7 | 7 | | B, 8 | 8 | | } 9 | | |_^ 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/bad_getter.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | mod remote { 4 | pub struct S { 5 | a: u8, 6 | } 7 | } 8 | 9 | #[derive(Serialize)] 10 | #[serde(remote = "remote::S")] 11 | struct S { 12 | #[serde(getter = "~~~")] 13 | a: u8, 14 | } 15 | 16 | fn main() {} 17 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/bad_getter.stderr: -------------------------------------------------------------------------------- 1 | error: failed to parse path: "~~~" 2 | --> tests/ui/remote/bad_getter.rs:12:22 3 | | 4 | 12 | #[serde(getter = "~~~")] 5 | | ^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/bad_remote.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | mod remote { 4 | pub struct S { 5 | a: u8, 6 | } 7 | } 8 | 9 | #[derive(Serialize)] 10 | #[serde(remote = "~~~")] 11 | struct S { 12 | a: u8, 13 | } 14 | 15 | fn main() {} 16 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/bad_remote.stderr: -------------------------------------------------------------------------------- 1 | error: failed to parse path: "~~~" 2 | --> tests/ui/remote/bad_remote.rs:10:18 3 | | 4 | 10 | #[serde(remote = "~~~")] 5 | | ^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/double_generic.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::{Deserialize, Serialize}; 2 | 3 | mod remote { 4 | pub struct Struct { 5 | pub t: T, 6 | pub u: U, 7 | } 8 | } 9 | 10 | #[derive(Serialize, Deserialize)] 11 | #[serde(remote = "remote::StructGeneric")] 12 | struct StructDef { 13 | t: u8, 14 | u: U, 15 | } 16 | 17 | fn main() {} 18 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/double_generic.stderr: -------------------------------------------------------------------------------- 1 | error: remove generic parameters from this path 2 | --> tests/ui/remote/double_generic.rs:11:18 3 | | 4 | 11 | #[serde(remote = "remote::StructGeneric")] 5 | | ^^^^^^^^^^^^^^^^^^^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/enum_getter.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | mod remote { 4 | pub enum E { 5 | A { a: u8 }, 6 | } 7 | } 8 | 9 | #[derive(Serialize)] 10 | #[serde(remote = "remote::E")] 11 | pub enum E { 12 | A { 13 | #[serde(getter = "get_a")] 14 | a: u8, 15 | }, 16 | } 17 | 18 | fn main() {} 19 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/enum_getter.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(getter = "...")] is not allowed in an enum 2 | --> tests/ui/remote/enum_getter.rs:10:1 3 | | 4 | 10 | / #[serde(remote = "remote::E")] 5 | 11 | | pub enum E { 6 | 12 | | A { 7 | 13 | | #[serde(getter = "get_a")] 8 | 14 | | a: u8, 9 | 15 | | }, 10 | 16 | | } 11 | | |_^ 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/missing_field.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::{Deserialize, Serialize}; 2 | 3 | mod remote { 4 | pub struct S { 5 | pub a: u8, 6 | pub b: u8, 7 | } 8 | } 9 | 10 | #[derive(Serialize, Deserialize)] 11 | #[serde(remote = "remote::S")] 12 | struct S { 13 | a: u8, 14 | } 15 | 16 | fn main() {} 17 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/missing_field.stderr: -------------------------------------------------------------------------------- 1 | error[E0063]: missing field `b` in initializer of `remote::S` 2 | --> tests/ui/remote/missing_field.rs:11:18 3 | | 4 | 11 | #[serde(remote = "remote::S")] 5 | | ^^^^^^^^^^^ missing `b` 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/nonremote_getter.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde(getter = "S::get")] 6 | a: u8, 7 | } 8 | 9 | impl S { 10 | fn get(&self) -> u8 { 11 | self.a 12 | } 13 | } 14 | 15 | fn main() {} 16 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/nonremote_getter.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(getter = "...")] can only be used in structs that have #[serde(remote = "...")] 2 | --> tests/ui/remote/nonremote_getter.rs:4:1 3 | | 4 | 4 | / struct S { 5 | 5 | | #[serde(getter = "S::get")] 6 | 6 | | a: u8, 7 | 7 | | } 8 | | |_^ 9 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/unknown_field.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::{Deserialize, Serialize}; 2 | 3 | mod remote { 4 | pub struct S { 5 | pub a: u8, 6 | } 7 | } 8 | 9 | #[derive(Serialize, Deserialize)] 10 | #[serde(remote = "remote::S")] 11 | struct S { 12 | b: u8, 13 | } 14 | 15 | fn main() {} 16 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/unknown_field.stderr: -------------------------------------------------------------------------------- 1 | error[E0609]: no field `b` on type `&remote::S` 2 | --> tests/ui/remote/unknown_field.rs:12:5 3 | | 4 | 12 | b: u8, 5 | | ^ unknown field 6 | | 7 | help: a field with a similar name exists 8 | | 9 | 12 - b: u8, 10 | 12 + a: u8, 11 | | 12 | 13 | error[E0560]: struct `remote::S` has no field named `b` 14 | --> tests/ui/remote/unknown_field.rs:12:5 15 | | 16 | 12 | b: u8, 17 | | ^ `remote::S` does not have this field 18 | | 19 | = note: all struct fields are already assigned 20 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/wrong_de.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | mod remote { 4 | pub struct S(pub u16); 5 | } 6 | 7 | #[derive(Deserialize)] 8 | #[serde(remote = "remote::S")] 9 | struct S(u8); 10 | 11 | fn main() {} 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/wrong_de.stderr: -------------------------------------------------------------------------------- 1 | error[E0308]: mismatched types 2 | --> tests/ui/remote/wrong_de.rs:7:10 3 | | 4 | 7 | #[derive(Deserialize)] 5 | | ^^^^^^^^^^^ expected `u16`, found `u8` 6 | 8 | #[serde(remote = "remote::S")] 7 | | ----------- arguments to this struct are incorrect 8 | | 9 | note: tuple struct defined here 10 | --> tests/ui/remote/wrong_de.rs:4:16 11 | | 12 | 4 | pub struct S(pub u16); 13 | | ^ 14 | = note: this error originates in the derive macro `Deserialize` (in Nightly builds, run with -Z macro-backtrace for more info) 15 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/wrong_getter.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | mod remote { 4 | pub struct S { 5 | a: u8, 6 | } 7 | 8 | impl S { 9 | pub fn get(&self) -> u16 { 10 | self.a as u16 11 | } 12 | } 13 | } 14 | 15 | #[derive(Serialize)] 16 | #[serde(remote = "remote::S")] 17 | struct S { 18 | #[serde(getter = "remote::S::get")] 19 | a: u8, 20 | } 21 | 22 | fn main() {} 23 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/wrong_getter.stderr: -------------------------------------------------------------------------------- 1 | error[E0308]: mismatched types 2 | --> tests/ui/remote/wrong_getter.rs:15:10 3 | | 4 | 15 | #[derive(Serialize)] 5 | | ^^^^^^^^^ 6 | | | 7 | | expected `&u8`, found `&u16` 8 | | arguments to this function are incorrect 9 | | 10 | = note: expected reference `&u8` 11 | found reference `&u16` 12 | note: function defined here 13 | --> $WORKSPACE/serde/src/private/ser.rs 14 | | 15 | | pub fn constrain(t: &T) -> &T { 16 | | ^^^^^^^^^ 17 | = note: this error originates in the derive macro `Serialize` (in Nightly builds, run with -Z macro-backtrace for more info) 18 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/wrong_ser.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | mod remote { 4 | pub struct S { 5 | pub a: u16, 6 | } 7 | } 8 | 9 | #[derive(Serialize)] 10 | #[serde(remote = "remote::S")] 11 | struct S { 12 | a: u8, 13 | } 14 | 15 | fn main() {} 16 | -------------------------------------------------------------------------------- /test_suite/tests/ui/remote/wrong_ser.stderr: -------------------------------------------------------------------------------- 1 | error[E0308]: mismatched types 2 | --> tests/ui/remote/wrong_ser.rs:9:10 3 | | 4 | 9 | #[derive(Serialize)] 5 | | ^^^^^^^^^ 6 | | | 7 | | expected `&u8`, found `&u16` 8 | | arguments to this function are incorrect 9 | | 10 | = note: expected reference `&u8` 11 | found reference `&u16` 12 | note: function defined here 13 | --> $WORKSPACE/serde/src/private/ser.rs 14 | | 15 | | pub fn constrain(t: &T) -> &T { 16 | | ^^^^^^^^^ 17 | = note: this error originates in the derive macro `Serialize` (in Nightly builds, run with -Z macro-backtrace for more info) 18 | -------------------------------------------------------------------------------- /test_suite/tests/ui/rename/container_unknown_rename_rule.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(rename_all = "abc")] 5 | struct S { 6 | name: u8, 7 | long_name: u8, 8 | very_long_name: u8, 9 | } 10 | 11 | fn main() {} 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/rename/container_unknown_rename_rule.stderr: -------------------------------------------------------------------------------- 1 | error: unknown rename rule `rename_all = "abc"`, expected one of "lowercase", "UPPERCASE", "PascalCase", "camelCase", "snake_case", "SCREAMING_SNAKE_CASE", "kebab-case", "SCREAMING-KEBAB-CASE" 2 | --> tests/ui/rename/container_unknown_rename_rule.rs:4:22 3 | | 4 | 4 | #[serde(rename_all = "abc")] 5 | | ^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/rename/variant_unknown_rename_rule.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | enum S { 5 | #[serde(rename_all = "abc")] 6 | V { 7 | name: u8, 8 | long_name: u8, 9 | very_long_name: u8, 10 | }, 11 | } 12 | 13 | fn main() {} 14 | -------------------------------------------------------------------------------- /test_suite/tests/ui/rename/variant_unknown_rename_rule.stderr: -------------------------------------------------------------------------------- 1 | error: unknown rename rule `rename_all = "abc"`, expected one of "lowercase", "UPPERCASE", "PascalCase", "camelCase", "snake_case", "SCREAMING_SNAKE_CASE", "kebab-case", "SCREAMING-KEBAB-CASE" 2 | --> tests/ui/rename/variant_unknown_rename_rule.rs:5:26 3 | | 4 | 5 | #[serde(rename_all = "abc")] 5 | | ^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/struct-representation/internally-tagged-tuple.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(tag = "type")] 5 | struct S(u8, u8); 6 | 7 | fn main() {} 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/struct-representation/internally-tagged-tuple.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(tag = "...")] can only be used on enums and structs with named fields 2 | --> tests/ui/struct-representation/internally-tagged-tuple.rs:4:9 3 | | 4 | 4 | #[serde(tag = "type")] 5 | | ^^^^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/struct-representation/internally-tagged-unit.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(tag = "type")] 5 | struct U; 6 | 7 | fn main() {} 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/struct-representation/internally-tagged-unit.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(tag = "...")] can only be used on enums and structs with named fields 2 | --> tests/ui/struct-representation/internally-tagged-unit.rs:4:9 3 | | 4 | 4 | #[serde(tag = "type")] 5 | | ^^^^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/at_most_one.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(transparent)] 5 | struct S { 6 | a: u8, 7 | b: u8, 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/at_most_one.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(transparent)] requires struct to have at most one transparent field 2 | --> tests/ui/transparent/at_most_one.rs:4:1 3 | | 4 | 4 | / #[serde(transparent)] 5 | 5 | | struct S { 6 | 6 | | a: u8, 7 | 7 | | b: u8, 8 | 8 | | } 9 | | |_^ 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/de_at_least_one.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(transparent)] 5 | struct S { 6 | #[serde(skip)] 7 | a: u8, 8 | #[serde(default)] 9 | b: u8, 10 | } 11 | 12 | fn main() {} 13 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/de_at_least_one.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(transparent)] requires at least one field that is neither skipped nor has a default 2 | --> tests/ui/transparent/de_at_least_one.rs:4:1 3 | | 4 | 4 | / #[serde(transparent)] 5 | 5 | | struct S { 6 | 6 | | #[serde(skip)] 7 | 7 | | a: u8, 8 | 8 | | #[serde(default)] 9 | 9 | | b: u8, 10 | 10 | | } 11 | | |_^ 12 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/enum.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(transparent)] 5 | enum E {} 6 | 7 | fn main() {} 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/enum.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(transparent)] is not allowed on an enum 2 | --> tests/ui/transparent/enum.rs:4:1 3 | | 4 | 4 | / #[serde(transparent)] 5 | 5 | | enum E {} 6 | | |_________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/ser_at_least_one.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(transparent)] 5 | struct S { 6 | #[serde(skip)] 7 | a: u8, 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/ser_at_least_one.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(transparent)] requires at least one field that is not skipped 2 | --> tests/ui/transparent/ser_at_least_one.rs:4:1 3 | | 4 | 4 | / #[serde(transparent)] 5 | 5 | | struct S { 6 | 6 | | #[serde(skip)] 7 | 7 | | a: u8, 8 | 8 | | } 9 | | |_^ 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/unit_struct.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(transparent)] 5 | struct S; 6 | 7 | fn main() {} 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/unit_struct.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(transparent)] is not allowed on a unit struct 2 | --> tests/ui/transparent/unit_struct.rs:4:1 3 | | 4 | 4 | / #[serde(transparent)] 5 | 5 | | struct S; 6 | | |_________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/with_from.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(transparent, from = "u64")] 5 | struct S { 6 | a: u8, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/with_from.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(transparent)] is not allowed with #[serde(from = "...")] 2 | --> tests/ui/transparent/with_from.rs:4:1 3 | | 4 | 4 | / #[serde(transparent, from = "u64")] 5 | 5 | | struct S { 6 | 6 | | a: u8, 7 | 7 | | } 8 | | |_^ 9 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/with_into.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(transparent, into = "u64")] 5 | struct S { 6 | a: u8, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/with_into.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(transparent)] is not allowed with #[serde(into = "...")] 2 | --> tests/ui/transparent/with_into.rs:4:1 3 | | 4 | 4 | / #[serde(transparent, into = "u64")] 5 | 5 | | struct S { 6 | 6 | | a: u8, 7 | 7 | | } 8 | | |_^ 9 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/with_try_from.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(transparent, try_from = "u64")] 5 | struct S { 6 | a: u8, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/transparent/with_try_from.stderr: -------------------------------------------------------------------------------- 1 | error: #[serde(transparent)] is not allowed with #[serde(try_from = "...")] 2 | --> tests/ui/transparent/with_try_from.rs:4:1 3 | | 4 | 4 | / #[serde(transparent, try_from = "u64")] 5 | 5 | | struct S { 6 | 6 | | a: u8, 7 | 7 | | } 8 | | |_^ 9 | -------------------------------------------------------------------------------- /test_suite/tests/ui/type-attribute/from.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | #[serde(from = "Option tests/ui/type-attribute/from.rs:4:16 3 | | 4 | 4 | #[serde(from = "Option tests/ui/type-attribute/into.rs:4:16 3 | | 4 | 4 | #[serde(into = "Option tests/ui/type-attribute/try_from.rs:4:20 3 | | 4 | 4 | #[serde(try_from = "Option tests/ui/unexpected-literal/container.rs:4:9 3 | | 4 | 4 | #[serde("literal")] 5 | | ^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/unexpected-literal/field.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct S { 5 | #[serde("literal")] 6 | x: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/unexpected-literal/field.stderr: -------------------------------------------------------------------------------- 1 | error: unexpected literal in nested attribute, expected ident 2 | --> tests/ui/unexpected-literal/field.rs:5:13 3 | | 4 | 5 | #[serde("literal")] 5 | | ^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/unexpected-literal/variant.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | enum E { 5 | #[serde("literal")] 6 | V, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/unexpected-literal/variant.stderr: -------------------------------------------------------------------------------- 1 | error: unexpected literal in nested attribute, expected ident 2 | --> tests/ui/unexpected-literal/variant.rs:5:13 3 | | 4 | 5 | #[serde("literal")] 5 | | ^^^^^^^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/unknown-attribute/container.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | #[serde(abc = "xyz")] 5 | struct A { 6 | x: u32, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/unknown-attribute/container.stderr: -------------------------------------------------------------------------------- 1 | error: unknown serde container attribute `abc` 2 | --> tests/ui/unknown-attribute/container.rs:4:9 3 | | 4 | 4 | #[serde(abc = "xyz")] 5 | | ^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/unknown-attribute/field.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | struct C { 5 | #[serde(abc = "xyz")] 6 | x: u32, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/unknown-attribute/field.stderr: -------------------------------------------------------------------------------- 1 | error: unknown serde field attribute `abc` 2 | --> tests/ui/unknown-attribute/field.rs:5:13 3 | | 4 | 5 | #[serde(abc = "xyz")] 5 | | ^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/unknown-attribute/variant.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | enum E { 5 | #[serde(abc = "xyz")] 6 | V, 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/unknown-attribute/variant.stderr: -------------------------------------------------------------------------------- 1 | error: unknown serde variant attribute `abc` 2 | --> tests/ui/unknown-attribute/variant.rs:5:13 3 | | 4 | 5 | #[serde(abc = "xyz")] 5 | | ^^^ 6 | -------------------------------------------------------------------------------- /test_suite/tests/ui/unsupported/union_de.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | union Union { 5 | x: u8, 6 | y: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/unsupported/union_de.stderr: -------------------------------------------------------------------------------- 1 | error: Serde does not support derive for unions 2 | --> tests/ui/unsupported/union_de.rs:4:1 3 | | 4 | 4 | / union Union { 5 | 5 | | x: u8, 6 | 6 | | y: (), 7 | 7 | | } 8 | | |_^ 9 | -------------------------------------------------------------------------------- /test_suite/tests/ui/unsupported/union_ser.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | union Union { 5 | x: u8, 6 | y: (), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/unsupported/union_ser.stderr: -------------------------------------------------------------------------------- 1 | error: Serde does not support derive for unions 2 | --> tests/ui/unsupported/union_ser.rs:4:1 3 | | 4 | 4 | / union Union { 5 | 5 | | x: u8, 6 | 6 | | y: (), 7 | 7 | | } 8 | | |_^ 9 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_de_newtype_field.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | enum Enum { 5 | #[serde(deserialize_with = "deserialize_some_newtype_variant")] 6 | Newtype(#[serde(skip_deserializing)] String), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_de_newtype_field.stderr: -------------------------------------------------------------------------------- 1 | error: variant `Newtype` cannot have both #[serde(deserialize_with)] and a field #0 marked with #[serde(skip_deserializing)] 2 | --> tests/ui/with-variant/skip_de_newtype_field.rs:5:5 3 | | 4 | 5 | / #[serde(deserialize_with = "deserialize_some_newtype_variant")] 5 | 6 | | Newtype(#[serde(skip_deserializing)] String), 6 | | |________________________________________________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_de_struct_field.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | enum Enum { 5 | #[serde(deserialize_with = "deserialize_some_other_variant")] 6 | Struct { 7 | #[serde(skip_deserializing)] 8 | f1: String, 9 | f2: u8, 10 | }, 11 | } 12 | 13 | fn main() {} 14 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_de_struct_field.stderr: -------------------------------------------------------------------------------- 1 | error: variant `Struct` cannot have both #[serde(deserialize_with)] and a field `f1` marked with #[serde(skip_deserializing)] 2 | --> tests/ui/with-variant/skip_de_struct_field.rs:5:5 3 | | 4 | 5 | / #[serde(deserialize_with = "deserialize_some_other_variant")] 5 | 6 | | Struct { 6 | 7 | | #[serde(skip_deserializing)] 7 | 8 | | f1: String, 8 | 9 | | f2: u8, 9 | 10 | | }, 10 | | |_____^ 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_de_tuple_field.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | enum Enum { 5 | #[serde(deserialize_with = "deserialize_some_other_variant")] 6 | Tuple(#[serde(skip_deserializing)] String, u8), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_de_tuple_field.stderr: -------------------------------------------------------------------------------- 1 | error: variant `Tuple` cannot have both #[serde(deserialize_with)] and a field #0 marked with #[serde(skip_deserializing)] 2 | --> tests/ui/with-variant/skip_de_tuple_field.rs:5:5 3 | | 4 | 5 | / #[serde(deserialize_with = "deserialize_some_other_variant")] 5 | 6 | | Tuple(#[serde(skip_deserializing)] String, u8), 6 | | |__________________________________________________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_de_whole_variant.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Deserialize; 2 | 3 | #[derive(Deserialize)] 4 | enum Enum { 5 | #[serde(deserialize_with = "deserialize_some_unit_variant")] 6 | #[serde(skip_deserializing)] 7 | Unit, 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_de_whole_variant.stderr: -------------------------------------------------------------------------------- 1 | error: variant `Unit` cannot have both #[serde(deserialize_with)] and #[serde(skip_deserializing)] 2 | --> tests/ui/with-variant/skip_de_whole_variant.rs:5:5 3 | | 4 | 5 | / #[serde(deserialize_with = "deserialize_some_unit_variant")] 5 | 6 | | #[serde(skip_deserializing)] 6 | 7 | | Unit, 7 | | |________^ 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_ser_newtype_field.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | enum Enum { 5 | #[serde(serialize_with = "serialize_some_newtype_variant")] 6 | Newtype(#[serde(skip_serializing)] String), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_ser_newtype_field.stderr: -------------------------------------------------------------------------------- 1 | error: variant `Newtype` cannot have both #[serde(serialize_with)] and a field #0 marked with #[serde(skip_serializing)] 2 | --> tests/ui/with-variant/skip_ser_newtype_field.rs:5:5 3 | | 4 | 5 | / #[serde(serialize_with = "serialize_some_newtype_variant")] 5 | 6 | | Newtype(#[serde(skip_serializing)] String), 6 | | |______________________________________________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_ser_newtype_field_if.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | enum Enum { 5 | #[serde(serialize_with = "serialize_some_newtype_variant")] 6 | Newtype(#[serde(skip_serializing_if = "always")] String), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_ser_newtype_field_if.stderr: -------------------------------------------------------------------------------- 1 | error: variant `Newtype` cannot have both #[serde(serialize_with)] and a field #0 marked with #[serde(skip_serializing_if)] 2 | --> tests/ui/with-variant/skip_ser_newtype_field_if.rs:5:5 3 | | 4 | 5 | / #[serde(serialize_with = "serialize_some_newtype_variant")] 5 | 6 | | Newtype(#[serde(skip_serializing_if = "always")] String), 6 | | |____________________________________________________________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_ser_struct_field.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | enum Enum { 5 | #[serde(serialize_with = "serialize_some_other_variant")] 6 | Struct { 7 | #[serde(skip_serializing)] 8 | f1: String, 9 | f2: u8, 10 | }, 11 | } 12 | 13 | fn main() {} 14 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_ser_struct_field.stderr: -------------------------------------------------------------------------------- 1 | error: variant `Struct` cannot have both #[serde(serialize_with)] and a field `f1` marked with #[serde(skip_serializing)] 2 | --> tests/ui/with-variant/skip_ser_struct_field.rs:5:5 3 | | 4 | 5 | / #[serde(serialize_with = "serialize_some_other_variant")] 5 | 6 | | Struct { 6 | 7 | | #[serde(skip_serializing)] 7 | 8 | | f1: String, 8 | 9 | | f2: u8, 9 | 10 | | }, 10 | | |_____^ 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_ser_struct_field_if.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | enum Enum { 5 | #[serde(serialize_with = "serialize_some_newtype_variant")] 6 | Struct { 7 | #[serde(skip_serializing_if = "always")] 8 | f1: String, 9 | f2: u8, 10 | }, 11 | } 12 | 13 | fn main() {} 14 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_ser_struct_field_if.stderr: -------------------------------------------------------------------------------- 1 | error: variant `Struct` cannot have both #[serde(serialize_with)] and a field `f1` marked with #[serde(skip_serializing_if)] 2 | --> tests/ui/with-variant/skip_ser_struct_field_if.rs:5:5 3 | | 4 | 5 | / #[serde(serialize_with = "serialize_some_newtype_variant")] 5 | 6 | | Struct { 6 | 7 | | #[serde(skip_serializing_if = "always")] 7 | 8 | | f1: String, 8 | 9 | | f2: u8, 9 | 10 | | }, 10 | | |_____^ 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_ser_tuple_field.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | enum Enum { 5 | #[serde(serialize_with = "serialize_some_other_variant")] 6 | Tuple(#[serde(skip_serializing)] String, u8), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_ser_tuple_field.stderr: -------------------------------------------------------------------------------- 1 | error: variant `Tuple` cannot have both #[serde(serialize_with)] and a field #0 marked with #[serde(skip_serializing)] 2 | --> tests/ui/with-variant/skip_ser_tuple_field.rs:5:5 3 | | 4 | 5 | / #[serde(serialize_with = "serialize_some_other_variant")] 5 | 6 | | Tuple(#[serde(skip_serializing)] String, u8), 6 | | |________________________________________________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_ser_tuple_field_if.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | enum Enum { 5 | #[serde(serialize_with = "serialize_some_other_variant")] 6 | Tuple(#[serde(skip_serializing_if = "always")] String, u8), 7 | } 8 | 9 | fn main() {} 10 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_ser_tuple_field_if.stderr: -------------------------------------------------------------------------------- 1 | error: variant `Tuple` cannot have both #[serde(serialize_with)] and a field #0 marked with #[serde(skip_serializing_if)] 2 | --> tests/ui/with-variant/skip_ser_tuple_field_if.rs:5:5 3 | | 4 | 5 | / #[serde(serialize_with = "serialize_some_other_variant")] 5 | 6 | | Tuple(#[serde(skip_serializing_if = "always")] String, u8), 6 | | |______________________________________________________________^ 7 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_ser_whole_variant.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::Serialize; 2 | 3 | #[derive(Serialize)] 4 | enum Enum { 5 | #[serde(serialize_with = "serialize_some_unit_variant")] 6 | #[serde(skip_serializing)] 7 | Unit, 8 | } 9 | 10 | fn main() {} 11 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with-variant/skip_ser_whole_variant.stderr: -------------------------------------------------------------------------------- 1 | error: variant `Unit` cannot have both #[serde(serialize_with)] and #[serde(skip_serializing)] 2 | --> tests/ui/with-variant/skip_ser_whole_variant.rs:5:5 3 | | 4 | 5 | / #[serde(serialize_with = "serialize_some_unit_variant")] 5 | 6 | | #[serde(skip_serializing)] 6 | 7 | | Unit, 7 | | |________^ 8 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with/incorrect_type.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::{Deserialize, Serialize}; 2 | 3 | mod w { 4 | use serde::{Deserializer, Serializer}; 5 | 6 | pub fn deserialize<'de, D: Deserializer<'de>>(_: D) -> Result<(), D::Error> { 7 | unimplemented!() 8 | } 9 | pub fn serialize(_: S) -> Result { 10 | unimplemented!() 11 | } 12 | } 13 | 14 | #[derive(Serialize, Deserialize)] 15 | struct W(#[serde(with = "w")] u8, u8); 16 | 17 | #[derive(Serialize, Deserialize)] 18 | struct S(#[serde(serialize_with = "w::serialize")] u8, u8); 19 | 20 | #[derive(Serialize, Deserialize)] 21 | struct D(#[serde(deserialize_with = "w::deserialize")] u8, u8); 22 | 23 | fn main() {} 24 | -------------------------------------------------------------------------------- /test_suite/tests/ui/with/incorrect_type.stderr: -------------------------------------------------------------------------------- 1 | error[E0277]: the trait bound `&u8: Serializer` is not satisfied 2 | --> tests/ui/with/incorrect_type.rs:14:10 3 | | 4 | 14 | #[derive(Serialize, Deserialize)] 5 | | ^^^^^^^^^ the trait `Serializer` is not implemented for `&u8` 6 | 15 | struct W(#[serde(with = "w")] u8, u8); 7 | | --- required by a bound introduced by this call 8 | | 9 | = help: the following other types implement trait `Serializer`: 10 | &mut Formatter<'a> 11 | FlatMapSerializer<'a, M> 12 | _::_serde::__private::ser::content::ContentSerializer 13 | note: required by a bound in `w::serialize` 14 | --> tests/ui/with/incorrect_type.rs:9:28 15 | | 16 | 9 | pub fn serialize(_: S) -> Result { 17 | | ^^^^^^^^^^ required by this bound in `serialize` 18 | 19 | error[E0061]: this function takes 1 argument but 2 arguments were supplied 20 | --> tests/ui/with/incorrect_type.rs:15:25 21 | | 22 | 14 | #[derive(Serialize, Deserialize)] 23 | | --------- unexpected argument #2 of type `__S` 24 | 15 | struct W(#[serde(with = "w")] u8, u8); 25 | | ^^^ 26 | | 27 | note: function defined here 28 | --> tests/ui/with/incorrect_type.rs:9:12 29 | | 30 | 9 | pub fn serialize(_: S) -> Result { 31 | | ^^^^^^^^^ 32 | 33 | error[E0277]: the trait bound `&u8: Serializer` is not satisfied 34 | --> tests/ui/with/incorrect_type.rs:15:25 35 | | 36 | 15 | struct W(#[serde(with = "w")] u8, u8); 37 | | ^^^ the trait `Serializer` is not implemented for `&u8` 38 | | 39 | = help: the following other types implement trait `Serializer`: 40 | &mut Formatter<'a> 41 | FlatMapSerializer<'a, M> 42 | _::_serde::__private::ser::content::ContentSerializer 43 | 44 | error[E0308]: `?` operator has incompatible types 45 | --> tests/ui/with/incorrect_type.rs:15:25 46 | | 47 | 15 | struct W(#[serde(with = "w")] u8, u8); 48 | | ^^^ expected `u8`, found `()` 49 | | 50 | = note: `?` operator cannot convert from `()` to `u8` 51 | 52 | error[E0277]: the trait bound `&u8: Serializer` is not satisfied 53 | --> tests/ui/with/incorrect_type.rs:17:10 54 | | 55 | 17 | #[derive(Serialize, Deserialize)] 56 | | ^^^^^^^^^ the trait `Serializer` is not implemented for `&u8` 57 | 18 | struct S(#[serde(serialize_with = "w::serialize")] u8, u8); 58 | | -------------- required by a bound introduced by this call 59 | | 60 | = help: the following other types implement trait `Serializer`: 61 | &mut Formatter<'a> 62 | FlatMapSerializer<'a, M> 63 | _::_serde::__private::ser::content::ContentSerializer 64 | note: required by a bound in `w::serialize` 65 | --> tests/ui/with/incorrect_type.rs:9:28 66 | | 67 | 9 | pub fn serialize(_: S) -> Result { 68 | | ^^^^^^^^^^ required by this bound in `serialize` 69 | 70 | error[E0061]: this function takes 1 argument but 2 arguments were supplied 71 | --> tests/ui/with/incorrect_type.rs:18:35 72 | | 73 | 17 | #[derive(Serialize, Deserialize)] 74 | | --------- unexpected argument #2 of type `__S` 75 | 18 | struct S(#[serde(serialize_with = "w::serialize")] u8, u8); 76 | | ^^^^^^^^^^^^^^ 77 | | 78 | note: function defined here 79 | --> tests/ui/with/incorrect_type.rs:9:12 80 | | 81 | 9 | pub fn serialize(_: S) -> Result { 82 | | ^^^^^^^^^ 83 | 84 | error[E0277]: the trait bound `&u8: Serializer` is not satisfied 85 | --> tests/ui/with/incorrect_type.rs:18:35 86 | | 87 | 18 | struct S(#[serde(serialize_with = "w::serialize")] u8, u8); 88 | | ^^^^^^^^^^^^^^ the trait `Serializer` is not implemented for `&u8` 89 | | 90 | = help: the following other types implement trait `Serializer`: 91 | &mut Formatter<'a> 92 | FlatMapSerializer<'a, M> 93 | _::_serde::__private::ser::content::ContentSerializer 94 | 95 | error[E0308]: `?` operator has incompatible types 96 | --> tests/ui/with/incorrect_type.rs:21:37 97 | | 98 | 21 | struct D(#[serde(deserialize_with = "w::deserialize")] u8, u8); 99 | | ^^^^^^^^^^^^^^^^ expected `u8`, found `()` 100 | | 101 | = note: `?` operator cannot convert from `()` to `u8` 102 | -------------------------------------------------------------------------------- /test_suite/tests/unstable/mod.rs: -------------------------------------------------------------------------------- 1 | use serde_derive::{Deserialize, Serialize}; 2 | use serde_test::{assert_tokens, Token}; 3 | 4 | #[test] 5 | fn test_raw_identifiers() { 6 | #[derive(Debug, PartialEq, Serialize, Deserialize)] 7 | #[allow(non_camel_case_types)] 8 | enum r#type { 9 | r#type { r#type: () }, 10 | } 11 | 12 | assert_tokens( 13 | &r#type::r#type { r#type: () }, 14 | &[ 15 | Token::StructVariant { 16 | name: "type", 17 | variant: "type", 18 | len: 1, 19 | }, 20 | Token::Str("type"), 21 | Token::Unit, 22 | Token::StructVariantEnd, 23 | ], 24 | ); 25 | } 26 | --------------------------------------------------------------------------------