Optimize internally tagged enums -- do not use internal buffer if tag is the first field

serde/src/de/mod.rs

@@ -1739,6 +1739,17 @@ pub trait SeqAccess<'de> {
     fn size_hint(&self) -> Option<usize> {
         None
     }
+
+    /// Checks if this sequence is empty. If that is unknown, implementation can
+    /// return `false`, but deserialization of internally tagged enums would
+    /// work incorrectly in that case.
+    #[inline]
+    fn is_empty(&mut self) -> bool {
+        match self.size_hint() {
+            Some(0) => true,
+            _ => false,
+        }
+    }
 }
 
 impl<'de, A> SeqAccess<'de> for &mut A
@@ -1767,6 +1778,11 @@ where
     fn size_hint(&self) -> Option<usize> {
         (**self).size_hint()
     }
+
+    #[inline]
+    fn is_empty(&mut self) -> bool {
+        (**self).is_empty()
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1892,6 +1908,17 @@ pub trait MapAccess<'de> {
     fn size_hint(&self) -> Option<usize> {
         None
     }
+
+    /// Checks if this map is empty. If that is unknown, implementation can
+    /// return `false`, but deserialization of internally tagged enums would
+    /// work incorrectly in that case.
+    #[inline]
+    fn is_empty(&mut self) -> bool {
+        match self.size_hint() {
+            Some(0) => true,
+            _ => false,
+        }
+    }
 }
 
 impl<'de, A> MapAccess<'de> for &mut A
@@ -1958,6 +1985,11 @@ where
     fn size_hint(&self) -> Option<usize> {
         (**self).size_hint()
     }
+
+    #[inline]
+    fn is_empty(&mut self) -> bool {
+        (**self).is_empty()
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////

serde/src/de/size_hint.rs

@@ -7,6 +7,16 @@ where
     helper(iter.size_hint())
 }
 
+pub fn is_empty<I>(iter: &I) -> bool
+where
+    I: Iterator,
+{
+    match iter.size_hint() {
+        (0, _) => true,
+        _ => false,
+    }
+}
+
 #[cfg(any(feature = "std", feature = "alloc"))]
 pub fn cautious<Element>(hint: Option<usize>) -> usize {
     const MAX_PREALLOC_BYTES: usize = 1024 * 1024;

serde/src/de/value.rs

@@ -1076,9 +1076,40 @@ where
         visitor.visit_seq(self.seq)
     }
 
+    fn deserialize_unit<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        // Covered by tests/test_enum_internally_tagged.rs/newtype_unit
+        if self.seq.is_empty() {
+            visitor.visit_unit()
+        } else {
+            visitor.visit_seq(self.seq)
+        }
+    }
+
+    fn deserialize_unit_struct<V>(
+        self,
+        _name: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        // Covered by tests/test_enum_internally_tagged.rs/newtype_unit_struct
+        self.deserialize_unit(visitor)
+    }
+
+    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
     forward_to_deserialize_any! {
         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
+        bytes byte_buf option seq tuple
         tuple_struct map struct enum identifier ignored_any
     }
 }
@@ -1253,6 +1284,10 @@ where
     fn size_hint(&self) -> Option<usize> {
         size_hint::from_bounds(&self.iter)
     }
+
+    fn is_empty(&mut self) -> bool {
+        size_hint::is_empty(&self.iter)
+    }
 }
 
 impl<'de, I, E> de::SeqAccess<'de> for MapDeserializer<'de, I, E>
@@ -1281,6 +1316,10 @@ where
     fn size_hint(&self) -> Option<usize> {
         size_hint::from_bounds(&self.iter)
     }
+
+    fn is_empty(&mut self) -> bool {
+        size_hint::is_empty(&self.iter)
+    }
 }
 
 // Cannot #[derive(Clone)] because of the bound `Second<I::Item>: Clone`.
@@ -1479,6 +1518,30 @@ where
         visitor.visit_map(self.map)
     }
 
+    fn deserialize_unit<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        // For newtype_variant_containing_unit
+        if self.map.is_empty() {
+            visitor.visit_unit()
+        } else {
+            visitor.visit_map(self.map)
+        }
+    }
+
+    fn deserialize_unit_struct<V>(
+        self,
+        _name: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        // For newtype_variant_containing_unit_struct
+        self.deserialize_unit(visitor)
+    }
+
     fn deserialize_enum<V>(
         self,
         _name: &str,
@@ -1491,9 +1554,21 @@ where
         visitor.visit_enum(self)
     }
 
+    fn deserialize_newtype_struct<V>(
+        self,
+        _name: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        // For test_internally_tagged_enum
+        visitor.visit_newtype_struct(self)
+    }
+
     forward_to_deserialize_any! {
         bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
-        bytes byte_buf option unit unit_struct newtype_struct seq tuple
+        bytes byte_buf option seq tuple
         tuple_struct map struct identifier ignored_any
     }
 }