Consume all sequence items in direct deserialization, matching deserialization from a Value

implementations/rust/src/de.rs

@@ -198,19 +198,28 @@ impl<'r, 'de, 'a, R: Reader<'de>> serde::de::Deserializer<'de> for &'a mut Deser
     fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value> where V: Visitor<'de>
     {
         let compound_body = self.read.open_simple_record("tuple", Some(len))?;
-        visitor.visit_seq(Seq::new(self, compound_body))
+        let mut seq = Seq::new(self, compound_body);
+        let result = visitor.visit_seq(&mut seq)?;
+        seq.skip_remainder()?;
+        Ok(result)
     }
 
     fn deserialize_tuple_struct<V>(self, name: &'static str, len: usize, visitor: V)
                                    -> Result<V::Value> where V: Visitor<'de>
     {
         let compound_body = self.read.open_simple_record(name, Some(len))?;
-        visitor.visit_seq(Seq::new(self, compound_body))
+        let mut seq = Seq::new(self, compound_body);
+        let result = visitor.visit_seq(&mut seq)?;
+        seq.skip_remainder()?;
+        Ok(result)
     }
 
     fn deserialize_map<V>(self, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
         let compound_body = self.read.open_dictionary()?;
-        visitor.visit_map(Seq::new(self, compound_body))
+        let mut seq = Seq::new(self, compound_body);
+        let result = visitor.visit_map(&mut seq)?;
+        seq.skip_remainder()?;
+        Ok(result)
     }
 
     fn deserialize_struct<V>(self,
@@ -220,7 +229,10 @@ impl<'r, 'de, 'a, R: Reader<'de>> serde::de::Deserializer<'de> for &'a mut Deser
                              -> Result<V::Value> where V: Visitor<'de>
     {
         let compound_body = self.read.open_simple_record(name, Some(fields.len()))?;
-        visitor.visit_seq(Seq::new(self, compound_body))
+        let mut seq = Seq::new(self, compound_body);
+        let result = visitor.visit_seq(&mut seq)?;
+        seq.skip_remainder()?;
+        Ok(result)
     }
 
     fn deserialize_enum<V>(self,
@@ -256,6 +268,10 @@ impl<'de, 'r, 'a, R: Reader<'de>> Seq<'de, 'r, 'a, R> {
         Seq { de, compound_body }
     }
 
+    fn skip_remainder(&mut self) -> Result<()> {
+        self.compound_body.skip_remainder(self.de.read)
+    }
+
     fn next_item<T>(&mut self, seed: T) ->
         Result<Option<T::Value>> where T: DeserializeSeed<'de>
     {
@@ -313,26 +329,36 @@ impl<'de, 'r, 'a, R: Reader<'de>> VariantAccess<'de> for Seq<'de, 'r, 'a, R> {
     type Error = Error;
 
     fn unit_variant(mut self) -> Result<()> {
-        self.compound_body.ensure_complete(self.de.read)
+        self.skip_remainder()
     }
 
     fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value> where T: DeserializeSeed<'de> {
         match self.next_item(seed)? {
             None => Err(Error::MissingItem),
             Some(v) => {
-                self.compound_body.ensure_complete(self.de.read)?;
+                self.skip_remainder()?;
                 Ok(v)
             }
         }
     }
 
-    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value> where V: Visitor<'de> {
-        visitor.visit_seq(self)
+    fn tuple_variant<V>(mut self, _len: usize, visitor: V) ->
+        Result<V::Value>
+    where
+        V: Visitor<'de>
+    {
+        let result = visitor.visit_seq(&mut self)?;
+        self.skip_remainder()?;
+        Ok(result)
     }
 
-    fn struct_variant<V>(self, _fields: &'static [&'static str], visitor: V)
-                         -> Result<V::Value> where V: Visitor<'de>
+    fn struct_variant<V>(mut self, _fields: &'static [&'static str], visitor: V) ->
+        Result<V::Value>
+    where
+        V: Visitor<'de>
     {
-        visitor.visit_seq(self)
+        let result = visitor.visit_seq(&mut self)?;
+        self.skip_remainder()?;
+        Ok(result)
     }
 }

implementations/rust/src/value/reader.rs

@@ -78,6 +78,15 @@ impl CompoundBody {
         Ok(result)
     }
 
+    pub fn skip_remainder<'de, R: Reader<'de>>(&mut self, read: &mut R) ->
+        ReaderResult<()>
+    {
+        while let true = self.more_expected(read)? {
+            read.skip_value()?;
+        }
+        Ok(())
+    }
+
     pub fn ensure_more_expected<'de, R: Reader<'de>>(&mut self, read: &mut R) -> ReaderResult<()> {
         if self.more_expected(read)? {
             Ok(())