Skip unwanted text events in sequences

If sequence expected only tags, skip any texts (CDATA included)
If sequence expected any values, skip texts (CDATA included) if there is a dedicated "$text" field

Fixed:
  serde-de-seq:
    fixed_name::variable_size::text_and_value
    variable_name::variable_size::text_and_value
  serde-issues:
    issue868

Author: Mingun

Changelog.md

@@ -35,6 +35,7 @@ XML specification. See the updated `custom_entities` example!
 
 - [#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.
+- [#868]: Skip text events when deserialize a sequence of items overlapped with text (including CDATA).
 
 ### Misc Changes
 

src/de/map.rs

@@ -611,7 +611,7 @@ where
                 _ => unreachable!(),
             }
         } else {
-            TagFilter::Exclude(self.map.fields)
+            TagFilter::Exclude(self.map.fields, self.map.has_text_field)
         };
         visitor.visit_seq(MapValueSeqAccess {
             #[cfg(feature = "overlapped-lists")]
@@ -852,15 +852,27 @@ enum TagFilter<'de> {
     Include(BytesStart<'de>), //TODO: Need to store only name instead of a whole tag
     /// A `SeqAccess` interested in tags with any name, except explicitly listed.
     /// Excluded tags are used as struct field names and therefore should not
-    /// fall into a `$value` category
-    Exclude(&'static [&'static str]),
+    /// fall into a `$value` category.
+    ///
+    /// The `bool` represents the having of a `$text` special field in fields array.
+    /// It is used to exclude text events when `$text` fields is defined together with
+    /// `$value` fieldб and `$value` accepts sequence.
+    Exclude(&'static [&'static str], bool),
 }
 
 impl<'de> TagFilter<'de> {
     fn is_suitable(&self, start: &BytesStart) -> Result<bool, DeError> {
         match self {
             Self::Include(n) => Ok(n.name() == start.name()),
-            Self::Exclude(fields) => not_in(fields, start),
+            Self::Exclude(fields, _) => not_in(fields, start),
+        }
+    }
+    const fn need_skip_text(&self) -> bool {
+        match self {
+            // If we look only for tags, we should skip any $text keys
+            Self::Include(_) => true,
+            // If we look fo any data, we should exclude $text keys if it in the list
+            Self::Exclude(_, has_text_field) => *has_text_field,
         }
     }
 }
@@ -944,9 +956,17 @@ where
                     self.map.de.skip()?;
                     continue;
                 }
+                // Skip any text events if sequence expects only specific tag names
+                #[cfg(feature = "overlapped-lists")]
+                DeEvent::Text(_) if self.filter.need_skip_text() => {
+                    self.map.de.skip()?;
+                    continue;
+                }
                 // Stop iteration when list elements ends
                 #[cfg(not(feature = "overlapped-lists"))]
                 DeEvent::Start(e) if !self.filter.is_suitable(e)? => Ok(None),
+                #[cfg(not(feature = "overlapped-lists"))]
+                DeEvent::Text(_) if self.filter.need_skip_text() => Ok(None),
 
                 // Stop iteration after reaching a closing tag
                 // The matching tag name is guaranteed by the reader