Naming, compile-time flag check

* `seq` to `seq_form` rename
* now flag is only evaluated at the compile time.

Author: Dzordzu

serde/src/private/de.rs

@@ -12,8 +12,9 @@ use crate::de::{MapAccess, Unexpected};
 #[cfg(any(feature = "std", feature = "alloc"))]
 pub use self::content::{
     Content, ContentDeserializer, ContentRefDeserializer, EnumDeserializer,
-    InternallyTaggedUnitVisitor, TagContentOtherField, TagContentOtherFieldVisitor,
-    TagOrContentField, TagOrContentFieldVisitor, TaggedContentVisitor, UntaggedUnitVisitor,
+    InternallyTaggedUnitVisitor, NoSeqTaggedContentVisitor, TagContentOtherField,
+    TagContentOtherFieldVisitor, TagOrContentField, TagOrContentFieldVisitor, TaggedContentVisitor,
+    UntaggedUnitVisitor,
 };
 
 pub use crate::seed::InPlaceSeed;
@@ -206,7 +207,6 @@ mod content {
     // This issue is tracking making some of this stuff public:
     // https://github.com/serde-rs/serde/issues/741
 
-    use crate::de::Error;
     use crate::lib::*;
 
     use crate::actually_private;
@@ -830,6 +830,40 @@ mod content {
         }
     }
 
+    /// Used by generated code to deserialize an internally tagged enum without sequence format.
+    ///
+    /// Captures map from the original deserializer and searches
+    /// a tag in it.
+    ///
+    /// Not public API.
+    pub struct NoSeqTaggedContentVisitor<T>(TaggedContentVisitor<T>);
+
+    impl<T> NoSeqTaggedContentVisitor<T> {
+        /// Visitor for the content of an internally tagged enum with the given
+        /// tag name.
+        pub fn new(name: &'static str, expecting: &'static str) -> Self {
+            Self(TaggedContentVisitor::new(name, expecting))
+        }
+    }
+
+    impl<'de, T> Visitor<'de> for NoSeqTaggedContentVisitor<T>
+    where
+        T: Deserialize<'de>,
+    {
+        type Value = (T, Content<'de>);
+
+        fn expecting(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
+            self.0.expecting(fmt)
+        }
+
+        fn visit_map<M>(self, map: M) -> Result<Self::Value, M::Error>
+        where
+            M: MapAccess<'de>,
+        {
+            self.0.visit_map(map)
+        }
+    }
+
     /// Used by generated code to deserialize an internally tagged enum.
     ///
     /// Captures map or sequence from the original deserializer and searches
@@ -840,18 +874,16 @@ mod content {
         tag_name: &'static str,
         expecting: &'static str,
         value: PhantomData<T>,
-        use_seq: bool,
     }
 
     impl<T> TaggedContentVisitor<T> {
         /// Visitor for the content of an internally tagged enum with the given
         /// tag name.
-        pub fn new(name: &'static str, expecting: &'static str, use_seq: bool) -> Self {
+        pub fn new(name: &'static str, expecting: &'static str) -> Self {
             TaggedContentVisitor {
                 tag_name: name,
                 expecting,
                 value: PhantomData,
-                use_seq,
             }
         }
     }
@@ -870,18 +902,14 @@ mod content {
         where
             S: SeqAccess<'de>,
         {
-            if self.use_seq {
-                let tag = match tri!(seq.next_element()) {
-                    Some(tag) => tag,
-                    None => {
-                        return Err(de::Error::missing_field(self.tag_name));
-                    }
-                };
-                let rest = de::value::SeqAccessDeserializer::new(seq);
-                Ok((tag, tri!(Content::deserialize(rest))))
-            } else {
-                Err(Error::invalid_type(Unexpected::Seq, &self))
-            }
+            let tag = match tri!(seq.next_element()) {
+                Some(tag) => tag,
+                None => {
+                    return Err(de::Error::missing_field(self.tag_name));
+                }
+            };
+            let rest = de::value::SeqAccessDeserializer::new(seq);
+            Ok((tag, tri!(Content::deserialize(rest))))
         }
 
         fn visit_map<M>(self, mut map: M) -> Result<Self::Value, M::Error>

serde_derive/src/de.rs

@@ -1409,14 +1409,20 @@ fn deserialize_internally_tagged_enum(
     let expecting = format!("internally tagged enum {}", params.type_name());
     let expecting = cattrs.expecting().unwrap_or(&expecting);
 
+    let tagged_content_visitor = if use_seq {
+        quote!(_serde::__private::de::TaggedContentVisitor)
+    } else {
+        quote!(_serde::__private::de::NoSeqTaggedContentVisitor)
+    };
+
     quote_block! {
         #variant_visitor
 
         #variants_stmt
 
         let (__tag, __content) = _serde::Deserializer::deserialize_any(
             __deserializer,
-            _serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting, #use_seq))?;
+            #tagged_content_visitor::<__Field>::new(#tag, #expecting))?;
         let __deserializer = _serde::__private::de::ContentDeserializer::<__D::Error>::new(__content);
 
         match __tag {

serde_derive/src/internals/symbol.rs

@@ -37,7 +37,7 @@ pub const TAG: Symbol = Symbol("tag");
 pub const TRANSPARENT: Symbol = Symbol("transparent");
 pub const TRY_FROM: Symbol = Symbol("try_from");
 pub const UNTAGGED: Symbol = Symbol("untagged");
-pub const USE_SEQ: Symbol = Symbol("seq");
+pub const USE_SEQ: Symbol = Symbol("seq_form");
 pub const VARIANT_IDENTIFIER: Symbol = Symbol("variant_identifier");
 pub const WITH: Symbol = Symbol("with");