pezkuwichain/serde
1
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-10-20 18:56:19 +00:00
Code Releases Activity
4,324 Commits 3 Branches 322 Tags
9f9a1ea35ee43b1a4d77171f50eaeaedd7583009
Commit Graph
100 Commits
This Branch
This Branch
All Branches
Author SHA1 Message Date
Mingun 9f9a1ea35e Do not use ? operator in the generated code where possible 
This may slightly improve compilation time and costs nothing
 2025-09-28 23:21:26 +05:00
Mingun 027112eccb Visibility fix for Rust 1.61 2025-09-21 20:58:53 +05:00
Mingun 8c3445efe4 Group some functions that used together 2025-09-21 20:40:22 +05:00
Mingun 88b6a9abf4 Rename functions and run cargo fmt 2025-09-21 20:40:21 +05:00
Mingun fa298c9df4 Move generator for identifiers to its own module 
Cut-paste
 2025-09-21 20:40:21 +05:00
Mingun c4a07ed4e8 Move body generator for unit structs to its own module 
Cut-paste
 2025-09-21 20:40:21 +05:00
Mingun c4986f10b9 Move body generator for tuple structs to its own module 
Cut-paste
 2025-09-21 20:40:21 +05:00
Mingun 2d607de146 Move body generator for structs to its own module 
Cut-paste
 2025-09-21 20:40:21 +05:00
Mingun 19956e6b8e Move body generator for enums to its own module 
Cut-paste
 2025-09-21 20:40:20 +05:00
Mingun ec13eb4ed6 Move body generator for untagged enums to its own module 
Cut-paste
 2025-09-21 20:40:20 +05:00
Mingun ae00c4acb7 Move body generator for internally tagged enums to its own module 
Cut-paste
 2025-09-21 20:40:20 +05:00
Mingun 85d0b9ccd8 Move body generator for externally tagged enums to its own module 
Cut-paste
 2025-09-21 20:40:20 +05:00
Mingun e60f62a289 Move body generator for adjacently tagged enums to its own module 
Cut-paste
 2025-09-21 20:40:20 +05:00
Mingun e04f0ba2de StructForm::InternallyTagged always instantiated with the same deserializer, so remove that parameter 2025-09-21 20:40:20 +05:00
Mingun c8184be238 StructForm::Untagged always instantiated with the same deserializer, so remove that parameter 2025-09-21 20:40:19 +05:00
Mingun 896d91f0bb TupleForm::Untagged always instantiated with the same deserializer, so remove that parameter 2025-09-21 20:40:19 +05:00
Mingun 915686d0ec deserialize_untagged_newtype_variant always called with the same deserializer, so remove that parameter 2025-09-21 20:40:19 +05:00
Mingun 3a682c951b deserialize_untagged_variant always called with the same deserializer, so remove that parameter 2025-09-21 20:40:19 +05:00
Mingun ca79f61d0f deserialize_internally_tagged_variant always called with the same deserializer, so remove that parameter 2025-09-21 20:40:19 +05:00
Mingun ddb7c4b30f Convert split_with_de_lifetime to method of Parameters 2025-09-21 15:39:11 +05:00
Mingun 4855fb467f Move code for injecting tagged variants to untagged generator to the place where the decision was made 2025-09-21 15:39:11 +05:00
Mingun 6dffc0b1c8 Remove one-line intermediate function 2025-09-21 15:39:11 +05:00
Mingun 15be2a600a Remove confusing call to deserialize_untagged_variant in deserialize_internally_tagged_variant 
deserialize_untagged_variant in that place is called when deserialzie_with attribute is set.
In that case it performs special actions that is better to use explicitly in deserialize_untagged_variant
for readability
 2025-09-21 15:39:11 +05:00
Mingun c09e2bd690 Add tests for flatten unit variant in adjacently tagged (tag + content) enums 2025-09-17 23:53:07 +05:00
Mingun fe7dcc4cd8 Test all possible orders of map entries for enum-flatten-in-struct representations 2025-09-17 23:51:30 +05:00
Mingun a20e66e131 Check serialization in flatten::enum_::internally_tagged::unit_enum_with_unknown_fields 2025-09-17 23:50:00 +05:00
Mingun 1c1a5d95cd Reorder struct_ and newtype tests of adjacently_tagged enums to match order in Enum 2025-09-17 23:48:23 +05:00
Mingun bfb020d975 Use variant name for field instead of field 2025-09-17 00:09:51 +05:00
Mingun 6805bba308 Inline variables that used only once 2025-09-17 00:09:14 +05:00
Mingun 2659b94a62 Create deserializer only when needed 2025-09-17 00:08:07 +05:00
Mingun c451415d9f Do not duplicate variant deserialization code 2025-09-17 00:07:00 +05:00
Mingun 553a9ff15f Document functions that are entry points for generating bodies of different deserialization forms 2025-09-17 00:05:53 +05:00
Mingun 55615e8f8e Fix instructions for testing contributions 
Since separation of serde_core from serde, all doctests lives in serde_core project,
which also does not have the `derive` feature. Following the old instructions does not
run any tests.
 2025-09-16 21:15:49 +05:00
Mingun b47f4dfa96 Unify access to the serde namespace 
In other places `_serde` name is used to access the `serde` crate, so use it there
 2025-09-16 00:36:12 +05:00
Mingun ad6c548573 Use associated type in signature to not repeat concrete type 2025-06-06 10:39:51 +05:00
Mingun 80b2f5f9e1 Remove actually_private::T 
It just makes life harder in some cases without any benefits
 2025-06-06 10:39:51 +05:00
Mingun cb6eaea151 Fix roundtrip inconsistency: 
- deserialization of flatten unit variant is possible
- serialization of such variant gives Err("can only flatten structs and maps (got an enum)")
 2024-12-27 08:21:07 +00:00
Mingun 5f9fffa53e Add checks for conflicts for aliases 
- Check that alias is not the same as name of other field (it still can be the name of owning field/variant)
- Check that aliases are unique, i. e. two different fields does not use the same alias
 2024-10-25 19:18:31 +05:00
Mingun 9cda015733 Implement IntoDeserializer for all Deserializers in serde::de::value module 
Unfortunately, blanket implementation IntoDeserializer for Deserializer is impossible
right now because this would be a breaking change. External crates may have this
such implementation (and serde_json actually have it for Value)
 2024-10-25 19:17:50 +05:00
Mingun 7bde100237 Replace MapRefDeserializer with value::MapDeserializer 
Although they are slightly different, this difference is irrelevant:
- MapDeserializer has a specialization for deserialize_seq and deserialize_tuple, but
  only MapRefDeserializer::deserialize_any is used by the code which is almost the same
- MapDeserializer checks that map was consumed after visit_map, but MapRefDeserializer
  does not. Actually, each derived implementation consumes map and each manual implementation
  also should consume it

Also, MapDeserializer already used when value deserialized from ContentRefDeserializer
directly and MapRefDeserializer was only used to deserialize Struct variants of enums.
There are no reasons why the behavior should be different in those two cases
 2024-08-24 04:52:26 +05:00
Mingun da7fc795ee Fix deserialization of empty struct variant in untagged enums 
SeqRefDeserializer::deserialize_any has a special condition for empty sequence, which
emits visit_unit. That condition assumes that type would be able to deserialized from
unit, but:
1) struct variants was never able to deserialize from it (they expect only visit_map or visit_seq)
2) tuple variants even with zero fields expect visit_seq only. The suggestion to accept visit_unit
   instead was rejected in #2520

Fixes (2):
    newtype_enum::tuple0
    newtype_enum::empty_struct_from_seq
 2024-08-24 04:52:26 +05:00
Mingun 4c5fec1363 Test special cases that reaches SeqRefDeserializer::deserialize_any len==0 condition 
failures (2):
    newtype_enum::empty_struct_from_seq
    newtype_enum::tuple0
 2024-08-24 04:52:25 +05:00
Mingun 6588b0ad37 Cover Content::Seq case in VariantRefDeserializer::struct_variant 2024-08-24 04:52:25 +05:00
Mingun 0093f74cfe Split test newtype_enum into four tests for each variant 
(review this commit with "ignore whitespace changes" option on)
 2024-08-24 04:52:25 +05:00
Mingun 171c6da57a Complete coverage of ContentRefDeserializer::deserialize_newtype_struct 2024-08-24 04:52:25 +05:00
Mingun 2dddc7796d Cover ContentRefDeserializer::deserialize_option 2024-08-24 04:52:25 +05:00
Mingun 8514f4119a Remove unnecessary generics 2024-08-24 04:52:24 +05:00
Mingun 98fb7d94aa Move all untagged enum tests (except flatten) into a dedicated module 
Moved and renamed:
From test_annotations
- test_expecting_message_untagged_tagged_enum                  => expecting_message
- flatten::enum_::untagged::straitforward                      => contains_flatten

From test_macros
- test_untagged_newtype_struct                                 => newtype_struct
- test_untagged_enum                                           => complex
- test_untagged_enum_with_flattened_integer_key                => contains_flatten_with_integer_key
- test_enum_in_untagged_enum                                   => newtype_enum
- test_untagged_bytes                                          => string_and_bytes
- test_untagged_newtype_variant_containing_unit_struct_not_map => newtype_unit_and_empty_map
 2024-08-24 04:52:22 +05:00
Mingun 9f72ce695e Struct: add tests for deserialization from sequence 
(review this commit with "ignore whitespace changes" option on)
 2024-08-16 22:51:42 +05:00
Mingun c383e4f953 Tuple: add tests for deserialization from sequence 
(review this commit with "ignore whitespace changes" option on)
 2024-08-16 22:51:16 +05:00
Mingun a94d8750fb Newtype: move up the test with tag only 2024-08-16 22:51:13 +05:00
Mingun b0d651be40 Newtype: add tests for deserialization from sequence 
(review this commit with "ignore whitespace changes" option on)
 2024-08-16 22:51:13 +05:00
Mingun d5a9c11b5c No need to test integer and byte array field names, they already tested for Unit case 
There is no difference what variant is deserialized so we can test only one kind of variant
 2024-08-16 22:51:10 +05:00
Mingun 6bfe1c435a Unit: add tests for deserialization from bytes tag and content fields 2024-08-16 22:43:15 +05:00
Mingun a02da49b87 Unit: add tests for deserialization from integer tag and content fields 2024-08-16 22:43:15 +05:00
Mingun 29dc6c3367 Unit: add tests for deserialization from sequence 
(review this commit with "ignore whitespace changes" option on)
 2024-08-16 22:38:02 +05:00
Mingun a7f0bab078 Document fields in internal structs used to deserialize adjacently tagged enums 2024-08-16 21:39:55 +05:00
Mingun 3dc6829303 Integrate bytes test into struct_ test 
`newtype` test also integrates test with `Bytes` tag, so be like

Removed the first assert_tokens because it is the same as the first assert in the merged method
 2024-08-16 21:39:53 +05:00
Mingun 42e63ff942 Reuse AdjacentlyTagged enum in bytes test 
Change 0i32 to 1u8 so the test can be merged with the previous in the next commit
 2024-08-16 21:38:23 +05:00
Mingun df07751e6f Group newtype and newtype_with_newtype tests 2024-08-16 21:36:56 +05:00
Mingun 5445f1741b Reuse AdjacentlyTagged enum in newtype_with_newtype test 2024-08-16 21:36:56 +05:00
Mingun 9d0f811221 Remove unnecessary generic 2024-08-16 21:36:56 +05:00
Mingun 36b9a859c4 Test deserialization of the serialized unit format for adjacently tagged enum 2024-08-16 21:36:55 +05:00
Mingun 59628d1712 Create only one value for all checks 2024-08-16 21:36:55 +05:00
Mingun bee7470715 Split test test_adjacently_tagged_enum into four tests for each variant 
(review this commit with "ignore whitespace changes" option on)
 2024-08-16 21:36:55 +05:00
Mingun 5a359e10f4 Group Newtype variant checks in test_adjacently_tagged_enum together 2024-08-16 21:36:55 +05:00
Mingun 5e37ade519 Move all adjacently tagged enum tests (except flatten) into a dedicated module 
Moved and renamed:
From test_annotatons
- test_adjacently_tagged_enum_bytes               => bytes
- flatten::enum_::adjacently_tagged::straitforward=> struct_with_flatten
- test_expecting_message_adjacently_tagged_enum   => expecting_message
- test_partially_untagged_adjacently_tagged_enum  => partially_untagged

From test_macros
- test_adjacently_tagged_newtype_struct           => newtype_with_newtype
- test_adjacently_tagged_enum
- test_adjacently_tagged_enum_deny_unknown_fields => deny_unknown_fields
 2024-08-16 21:36:52 +05:00
Mingun 2adb0e99b0 Add additional checks for unit and newtype_unit tests 
- check that unit variant can be deserialized from a map
- check that newtype variant with unit can be deserialized from a struct
 2024-08-15 23:39:14 +05:00
Mingun 71ed1f2f12 Add tests for special and general cases for internally tagged enums 
Special case is the tag field first (so the enum variant are known after reading the first entry from map).
General case is the tag field not the first (so we need to buffer entries until we found an entry with tag)
 2024-08-15 23:39:13 +05:00
Mingun 47954502af Add tests with borrowed strings for the tag field name and tag value 2024-08-15 23:39:13 +05:00
Mingun 4987fd15f7 Convert newtype_enum and struct_enum tests into modules 
Separate testing each variant kind of enum (unit, newtype, tuple, struct) results
in more specific information if that checks fail

(review this commit with "ignore whitespace changes" option on)
 2024-08-15 23:39:12 +05:00
Mingun 8bfe0d0ac0 Move and rename tests: 
- newtype_variant_containing_unit                   -> newtype_unit
- newtype_variant_containing_unit_struct            -> newtype_unit_struct
- newtype_variant_containing_externally_tagged_enum -> newtype_enum
- struct_variant_containing_unit_variant            -> struct_enum
 2024-08-15 23:39:12 +05:00
Mingun 7c0e6bd18f Reuse type in struct_variant_containing_unit_variant 2024-08-15 23:39:11 +05:00
Mingun 41b9c33c2b Reuse type in newtype_variant_containing_externally_tagged_enum 2024-08-15 23:39:11 +05:00
Mingun 28a775db22 Share externally tagged enum Enum between all tests and reuse in struct_variant_containing_unit_variant 2024-08-15 23:39:10 +05:00
Mingun e999600f8f Rename externally tagged enum Inner to Enum 2024-08-15 23:39:10 +05:00
Mingun d3492d8d36 Reuse type in newtype_variant_containing_unit_struct 2024-08-15 23:39:09 +05:00
Mingun 48de0c51b0 Share unit struct Unit between all tests 2024-08-15 23:39:09 +05:00
Mingun 93bda5f1dc Rename unit struct to a generic name: Info->Unit 2024-08-15 23:39:09 +05:00
Mingun 2d75ef6b30 Reuse type in newtype_variant_containing_unit 2024-08-15 23:39:07 +05:00
Mingun f97160f715 Reuse type in unit_variant_with_unknown_fields and add test for sequence 2024-08-15 23:39:06 +05:00
Mingun eb59c776ca Use name "tag" to refer to tag field 2024-08-15 23:39:06 +05:00
Mingun 9128201c78 Use the same order of derives 2024-08-15 23:39:05 +05:00
Mingun 2cbfd37072 Move all other internally tagged enum tests into a dedicated file 
Moved all except flattened tests:
- test_internally_tagged_enum_with_skipped_conflict    => with_skipped_conflict
- test_internally_tagged_enum_new_type_with_unit       => newtype_variant_containing_unit
- test_internally_tagged_unit_enum_with_unknown_fields => unit_variant_with_unknown_fields
- test_expecting_message_internally_tagged_enum        => expecting_message
- flatten::enum_::internally_tagged::straightforward   => containing_flatten
 2024-08-15 23:39:05 +05:00
Mingun 0939214c51 Move internally tagged enum tests into a dedicated file 
Ctrl+X, Ctrl+V
 2024-08-15 23:34:01 +05:00
Mingun 8c60f5aea7 Reorder enum variants and tests to canonical order (Unit, Newtype, Tuple, Struct) 2024-08-15 23:34:00 +05:00
Mingun da0ed4021d Give meaningful names to enum variants 2024-08-15 23:34:00 +05:00
Mingun 99f905403b Move all internally tagged enum tests of test_macros into a dedicated module 
Moved:
- test_internally_tagged_enum_with_untagged_variant             => untagged_variant
- test_internally_tagged_bytes                                  => string_and_bytes mod
- test_internally_tagged_struct_variant_containing_unit_variant => struct_variant_containing_unit_variant
- test_internally_tagged_borrow                                 => borrow
- test_enum_in_internally_tagged_enum                           => newtype_variant_containing_externally_tagged_enum
- test_internally_tagged_newtype_variant_containing_unit_struct => newtype_variant_containing_unit_struct

(review this commit with "ignore whitespace changes" option on)
 2024-08-15 23:34:00 +05:00
Mingun aa0654332d Convert test_internally_tagged_enum into module 
(review this commit with "ignore whitespace changes" option on)
 2024-08-15 23:33:59 +05:00
Mingun 8b769fcc20 Remove unused component from tuple 2024-08-12 19:05:57 +05:00
Mingun 9c954264f4 Include variant aliases in error messages 2024-08-12 19:05:04 +05:00
Mingun 77a6a9d4e1 Take into account only not skipped flatten fields when choose serialization form 
Consequence: `FlattenSkipSerializing`
- uses `serialize_struct` instead of `serialize_map`
 2024-08-11 20:12:09 +05:00
Mingun 547d843cca Remove dead code - serialize_struct_as_map always called when cattrs.has_flatten()==true 2024-08-11 20:12:08 +05:00
Mingun 005cb84593 Fail with an understandable message is number of fields for serialization is too many 2024-08-11 20:12:07 +05:00
Mingun fd5b5e9aa5 Correctly calculate has_flatten attribute in all cases for deserialization 
Consequence: `FlattenSkipDeserializing[DenyUnknown]`
- does not collect data in Field, because do not read them anyway
- gets `deserialize_in_place` method
- gets ability to deserialize from sequence (visit_seq method)
- uses `deserialize_struct` instead of `deserialize_map`
 2024-08-11 20:01:33 +05:00
Mingun 0647a7c1fe Fix creating and filling a collections that was not read 2024-08-11 20:01:00 +05:00
Mingun 2afe5b4ef9 Add regression test for issue #2792 2024-08-10 21:29:39 +05:00
Mingun b4ec2595c9 Correctly process flatten fields in enum variants 
- Fix incorrect deserialization of variants that doesn't contain flatten field when other contains
- Fix a panic when deriving `Deserialize` for an enum with tuple and struct with flatten field

Fixes (2):
    regression::issue2565::simple_variant
    regression::issue1904 (compilation)
 2024-08-09 19:59:23 +05:00
Mingun c3ac7b675a Add regression test for issue #1904 
Currently panics in derive:

error: proc-macro derive panicked
    --> test_suite\tests\test_annotations.rs:2386:25
     |
2386 |     #[derive(Serialize, Deserialize, PartialEq, Debug)]
     |                         ^^^^^^^^^^^
     |
     = help: message: assertion failed: !cattrs.has_flatten()

error: proc-macro derive panicked
  --> test_suite\tests\regression\issue1904.rs:57:10
   |
57 | #[derive(Deserialize)]
   |          ^^^^^^^^^^^
   |
   = help: message: assertion failed: !cattrs.has_flatten()

error: proc-macro derive panicked
  --> test_suite\tests\regression\issue1904.rs:47:10
   |
47 | #[derive(Deserialize)]
   |          ^^^^^^^^^^^
   |
   = help: message: assertion failed: !cattrs.has_flatten()

error: proc-macro derive panicked
  --> test_suite\tests\regression\issue1904.rs:37:10
   |
37 | #[derive(Deserialize)]
   |          ^^^^^^^^^^^
   |
   = help: message: assertion failed: !cattrs.has_flatten()

error: proc-macro derive panicked
  --> test_suite\tests\regression\issue1904.rs:27:10
   |
27 | #[derive(Deserialize)]
   |          ^^^^^^^^^^^
   |
   = help: message: assertion failed: !cattrs.has_flatten()

error: proc-macro derive panicked
  --> test_suite\tests\regression\issue1904.rs:16:10
   |
16 | #[derive(Deserialize)]
   |          ^^^^^^^^^^^
   |
   = help: message: assertion failed: !cattrs.has_flatten()

error: proc-macro derive panicked
 --> test_suite\tests\regression\issue1904.rs:7:10
  |
7 | #[derive(Deserialize)]
  |          ^^^^^^^^^^^
  |
  = help: message: assertion failed: !cattrs.has_flatten()
 2024-08-09 19:55:56 +05:00
Mingun 24614e44bf Add regression test for issue #2565 
failures (1):
    regression::issue2565::simple_variant
 2024-08-09 19:53:14 +05:00