Allow both &text and $value fields in the same struct

failures:
    fixed_name::variable_size::text_and_value
    variable_name::variable_size::text_and_value

Author: Mingun

Changelog.md

@@ -33,6 +33,9 @@ XML specification. See the updated `custom_entities` example!
 
 ### Bug Fixes
 
+- [#868]: Allow to have both `$text` and `$value` special fields in one struct. Previously
+  any text will be recognized as `$value` field even when `$text` field is also presented.
+
 ### Misc Changes
 
 - [#863]: Remove `From<QName<'a>> for BytesStart<'a>` because now `BytesStart` stores the
@@ -42,6 +45,7 @@ XML specification. See the updated `custom_entities` example!
 
 [#766]: https://github.com/tafia/quick-xml/pull/766
 [#863]: https://github.com/tafia/quick-xml/pull/863
+[#868]: https://github.com/tafia/quick-xml/pull/868
 [general entity]: https://www.w3.org/TR/xml11/#gen-entity
 
 

src/de/map.rs

@@ -192,6 +192,8 @@ where
     /// <tag>value for VALUE_KEY field<tag>
     /// ```
     has_value_field: bool,
+    /// Determines if struct have [`VALUE_KEY`], but not [`TEXT_KEY`] special fields.
+    text_as_value: bool,
 }
 
 impl<'de, 'd, R, E> ElementMapAccess<'de, 'd, R, E>
@@ -205,13 +207,16 @@ where
         start: BytesStart<'de>,
         fields: &'static [&'static str],
     ) -> Result<Self, DeError> {
+        let has_value_field = fields.contains(&VALUE_KEY);
         Ok(Self {
             de,
             iter: IterState::new(start.name().as_ref().len(), false),
             start,
             source: ValueSource::Unknown,
             fields,
-            has_value_field: fields.contains(&VALUE_KEY),
+            has_value_field,
+            // If we have dedicated "$text" field, it will not be passed to "$value" field
+            text_as_value: has_value_field && !fields.contains(&TEXT_KEY),
         })
     }
 
@@ -264,10 +269,7 @@ where
         } else {
             // try getting from events (<key>value</key>)
             match self.de.peek()? {
-                // We shouldn't have both `$value` and `$text` fields in the same
-                // struct, so if we have `$value` field, the we should deserialize
-                // text content to `$value`
-                DeEvent::Text(_) if self.has_value_field => {
+                DeEvent::Text(_) if self.text_as_value => {
                     self.source = ValueSource::Content;
                     // Deserialize `key` from special attribute name which means
                     // that value should be taken from the text content of the

tests/serde-de-seq.rs

@@ -821,6 +821,28 @@ mod fixed_name {
             );
         }
 
+        #[test]
+        fn text_and_value() {
+            #[derive(Debug, PartialEq, Deserialize)]
+            struct List {
+                #[serde(rename = "$text")]
+                text: (),
+                item: [(); 2],
+            }
+
+            from_str::<List>(
+                r#"
+                <root>
+                    <item/>
+                    <item/>
+                    text
+                    <![CDATA[cdata]]>
+                </root>
+                "#,
+            )
+            .unwrap();
+        }
+
         /// Checks that sequences represented by elements can contain sequences,
         /// represented by [`xs:list`s](https://www.w3schools.com/xml/el_list.asp)
         mod xs_list {
@@ -1656,6 +1678,33 @@ mod fixed_name {
             );
         }
 
+        #[test]
+        fn text_and_value() {
+            #[derive(Debug, PartialEq, Deserialize)]
+            struct List {
+                #[serde(rename = "$text")]
+                text: (),
+                item: Vec<()>,
+            }
+
+            let data: List = from_str(
+                r#"
+                <root>
+                    <item/>
+                    <item/>
+                    text
+                    <![CDATA[cdata]]>
+                </root>
+                "#,
+            )
+            .unwrap();
+
+            assert_eq!(data, List {
+                text: (),
+                item: vec![(); 2],
+            });
+        }
+
         /// Checks that sequences represented by elements can contain sequences,
         /// represented by `xs:list`s
         mod xs_list {
@@ -2883,6 +2932,29 @@ mod variable_name {
             );
         }
 
+        #[test]
+        fn text_and_value() {
+            #[derive(Debug, PartialEq, Deserialize)]
+            struct List {
+                #[serde(rename = "$text")]
+                text: (),
+                #[serde(rename = "$value")]
+                value: [(); 2],
+            }
+
+            from_str::<List>(
+                r#"
+                <root>
+                    <item/>
+                    <item/>
+                    text
+                    <![CDATA[cdata]]>
+                </root>
+                "#,
+            )
+            .unwrap();
+        }
+
         /// Checks that sequences represented by elements can contain sequences,
         /// represented by `xs:list`s
         mod xs_list {
@@ -3929,6 +4001,34 @@ mod variable_name {
             .unwrap_err();
         }
 
+        #[test]
+        fn text_and_value() {
+            #[derive(Debug, PartialEq, Deserialize)]
+            struct List {
+                #[serde(rename = "$text")]
+                text: (),
+                #[serde(rename = "$value")]
+                value: Vec<()>,
+            }
+
+            let data: List = from_str(
+                r#"
+                <root>
+                    <item/>
+                    <item/>
+                    text
+                    <![CDATA[cdata]]>
+                </root>
+                "#,
+            )
+            .unwrap();
+
+            assert_eq!(data, List {
+                text: (),
+                value: vec![(); 2],
+            });
+        }
+
         /// Checks that sequences represented by elements can contain sequences,
         /// represented by `xs:list`s
         mod xs_list {