diff --git a/serde_codegen/src/de.rs b/serde_codegen/src/de.rs
index d60904b4..dd684945 100644
--- a/serde_codegen/src/de.rs
+++ b/serde_codegen/src/de.rs
@@ -518,24 +518,25 @@ fn deserialize_item_enum(
 
     let expecting = format!("enum {}", type_ident);
 
-    let variant_names_idents = variants.iter()
+    let variant_names_idents: Vec<_> = variants.iter()
         .enumerate()
         .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
         .map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)))
         .collect();
 
+    let variants_stmt = {
+        let variant_names = variant_names_idents.iter().map(|&(ref name, _)| name);
+        quote! {
+            const VARIANTS: &'static [&'static str] = &[ #(#variant_names),* ];
+        }
+    };
+
     let variant_visitor = deserialize_field_visitor(
         variant_names_idents,
         item_attrs,
         true,
     );
 
-    let variant_names = variants.iter().map(|variant| variant.attrs.name().deserialize_name());
-
-    let variants_stmt = quote! {
-        const VARIANTS: &'static [&'static str] = &[ #(#variant_names),* ];
-    };
-
     // Match arms to extract a variant from a string
     let variant_arms = variants.iter()
         .enumerate()
@@ -750,12 +751,19 @@ fn deserialize_struct_visitor(
     fields: &[Field],
     item_attrs: &attr::Item,
 ) -> (Tokens, Tokens, Tokens) {
-    let field_names_idents = fields.iter()
+    let field_names_idents: Vec<_> = fields.iter()
         .enumerate()
         .filter(|&(_, field)| !field.attrs.skip_deserializing())
         .map(|(i, field)| (field.attrs.name().deserialize_name(), field_i(i)))
         .collect();
 
+    let fields_stmt = {
+        let field_names = field_names_idents.iter().map(|&(ref name, _)| name);
+        quote! {
+            const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
+        }
+    };
+
     let field_visitor = deserialize_field_visitor(
         field_names_idents,
         item_attrs,
@@ -770,11 +778,6 @@ fn deserialize_struct_visitor(
         item_attrs,
     );
 
-    let field_names = fields.iter().map(|field| field.attrs.name().deserialize_name());
-    let fields_stmt = quote! {
-        const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
-    };
-
     (field_visitor, fields_stmt, visit_map)
 }
 
diff --git a/testing/tests/test_annotations.rs b/testing/tests/test_annotations.rs
index 5ca32651..7df8bb1c 100644
--- a/testing/tests/test_annotations.rs
+++ b/testing/tests/test_annotations.rs
@@ -145,7 +145,7 @@ fn test_default_enum() {
     assert_de_tokens(
         &DefaultEnum::Struct { a1: 1, a2: 2, a3: 3, a4: 0, a5: 123 },
         &[
-            Token::EnumMapStart("DefaultEnum", "Struct", 5),
+            Token::EnumMapStart("DefaultEnum", "Struct", 3),
 
             Token::EnumMapSep,
             Token::Str("a1"),
@@ -174,7 +174,7 @@ fn test_default_enum() {
     assert_de_tokens(
         &DefaultEnum::Struct { a1: 1, a2: 0, a3: 123, a4: 0, a5: 123 },
         &[
-            Token::EnumMapStart("DefaultEnum", "Struct", 5),
+            Token::EnumMapStart("DefaultEnum", "Struct", 3),
 
             Token::EnumMapSep,
             Token::Str("a1"),
diff --git a/testing/tests/test_de.rs b/testing/tests/test_de.rs
index 2e3ec01d..451d3d89 100644
--- a/testing/tests/test_de.rs
+++ b/testing/tests/test_de.rs
@@ -849,7 +849,7 @@ declare_error_tests! {
                 Token::StructSep,
                 Token::Str("d"),
         ],
-        Error::Message("unknown field `d`, expected `a` or `b`".to_owned()),
+        Error::Message("unknown field `d`, expected `a`".to_owned()),
     }
     test_skipped_field_is_unknown<StructDenyUnknown> {
         &[
@@ -857,7 +857,7 @@ declare_error_tests! {
                 Token::StructSep,
                 Token::Str("b"),
         ],
-        Error::Message("unknown field `b`, expected `a` or `b`".to_owned()),
+        Error::Message("unknown field `b`, expected `a`".to_owned()),
     }
     test_skip_all_deny_unknown<StructSkipAllDenyUnknown> {
         &[
@@ -865,25 +865,25 @@ declare_error_tests! {
                 Token::StructSep,
                 Token::Str("a"),
         ],
-        Error::Message("unknown field `a`, expected `a`".to_owned()),
+        Error::Message("unknown field `a`, there are no fields".to_owned()),
     }
     test_unknown_variant<Enum> {
         &[
             Token::EnumUnit("Enum", "Foo"),
         ],
-        Error::Message("unknown variant `Foo`, expected one of `Skipped`, `Unit`, `Simple`, `Seq`, `Map`".to_owned()),
+        Error::Message("unknown variant `Foo`, expected one of `Unit`, `Simple`, `Seq`, `Map`".to_owned()),
     }
     test_enum_skipped_variant<Enum> {
         &[
             Token::EnumUnit("Enum", "Skipped"),
         ],
-        Error::Message("unknown variant `Skipped`, expected one of `Skipped`, `Unit`, `Simple`, `Seq`, `Map`".to_owned()),
+        Error::Message("unknown variant `Skipped`, expected one of `Unit`, `Simple`, `Seq`, `Map`".to_owned()),
     }
     test_enum_skip_all<EnumSkipAll> {
         &[
             Token::EnumUnit("EnumSkipAll", "Skipped"),
         ],
-        Error::Message("unknown variant `Skipped`, expected `Skipped`".to_owned()),
+        Error::Message("unknown variant `Skipped`, there are no variants".to_owned()),
     }
     test_struct_seq_too_long<Struct> {
         &[