From 12207ed2a3dff29e695222a27ebb22767c6c44e1 Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Sat, 28 Aug 2021 11:21:40 -0700
Subject: [PATCH 1/2] Add regression test for issue 795

---
 tests/regression/issue795.rs | 57 ++++++++++++++++++++++++++++++++++++
 1 file changed, 57 insertions(+)
 create mode 100644 tests/regression/issue795.rs

diff --git a/tests/regression/issue795.rs b/tests/regression/issue795.rs
new file mode 100644
index 000000000..43198a33d
--- /dev/null
+++ b/tests/regression/issue795.rs
@@ -0,0 +1,57 @@
+use serde::de::{
+    Deserialize, Deserializer, EnumAccess, IgnoredAny, MapAccess, VariantAccess, Visitor,
+};
+use serde_json::json;
+use std::fmt;
+
+#[derive(Debug)]
+enum Enum {
+    Variant { x: u8 },
+}
+
+impl<'de> Deserialize<'de> for Enum {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct EnumVisitor;
+
+        impl<'de> Visitor<'de> for EnumVisitor {
+            type Value = Enum;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("enum Enum")
+            }
+
+            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
+            where
+                A: EnumAccess<'de>,
+            {
+                let (IgnoredAny, variant) = data.variant()?;
+                variant.struct_variant(&["x"], self)
+            }
+
+            fn visit_map<A>(self, mut data: A) -> Result<Self::Value, A::Error>
+            where
+                A: MapAccess<'de>,
+            {
+                let mut x = 0;
+                if let Some((IgnoredAny, value)) = data.next_entry()? {
+                    x = value;
+                }
+                Ok(Enum::Variant { x })
+            }
+        }
+
+        deserializer.deserialize_enum("Enum", &["Variant"], EnumVisitor)
+    }
+}
+
+#[test]
+fn test() {
+    let s = r#" {"Variant":{"x":0,"y":0}} "#;
+    assert!(serde_json::from_str::<Enum>(s).is_err());
+
+    let j = json!({"Variant":{"x":0,"y":0}});
+    assert!(serde_json::from_value::<Enum>(j).is_err());
+}

From c7b71869571ad1825a5983df84d05760769ec71f Mon Sep 17 00:00:00 2001
From: David Tolnay <dtolnay@gmail.com>
Date: Sat, 28 Aug 2021 11:21:54 -0700
Subject: [PATCH 2/2] Detect unknown struct variant fields deserializing from
 Value

---
 src/value/de.rs | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/value/de.rs b/src/value/de.rs
index 5ff011961..24ca82696 100644
--- a/src/value/de.rs
+++ b/src/value/de.rs
@@ -538,7 +538,7 @@ impl<'de> VariantAccess<'de> for VariantDeserializer {
         V: Visitor<'de>,
     {
         match self.value {
-            Some(Value::Object(v)) => visitor.visit_map(MapDeserializer::new(v)),
+            Some(Value::Object(v)) => visit_object(v, visitor),
             Some(other) => Err(serde::de::Error::invalid_type(
                 other.unexpected(),
                 &"struct variant",
@@ -1021,7 +1021,7 @@ impl<'de> VariantAccess<'de> for VariantRefDeserializer<'de> {
         V: Visitor<'de>,
     {
         match self.value {
-            Some(&Value::Object(ref v)) => visitor.visit_map(MapRefDeserializer::new(v)),
+            Some(&Value::Object(ref v)) => visit_object_ref(v, visitor),
             Some(other) => Err(serde::de::Error::invalid_type(
                 other.unexpected(),
                 &"struct variant",