From c91c33436d7aaef7472ebc18b734ddc9b5bd11fa Mon Sep 17 00:00:00 2001
From: Emil Bonne Kristiansen <emilbonnek@gmail.com>
Date: Tue, 21 Nov 2023 02:13:18 +0100
Subject: [PATCH] Fix Range{From,To} deserialize mixup

---
 serde/src/de/impls.rs | 72 +++++++++++++++++++++----------------------
 1 file changed, 36 insertions(+), 36 deletions(-)

diff --git a/serde/src/de/impls.rs b/serde/src/de/impls.rs
index 1f05c5333..6675f6206 100644
--- a/serde/src/de/impls.rs
+++ b/serde/src/de/impls.rs
@@ -2509,7 +2509,7 @@ where
     where
         D: Deserializer<'de>,
     {
-        let start = tri!(deserializer.deserialize_struct(
+        let end = tri!(deserializer.deserialize_struct(
             "RangeFrom",
             range_from::FIELDS,
             range_from::RangeFromVisitor {
@@ -2517,7 +2517,7 @@ where
                 phantom: PhantomData,
             },
         ));
-        Ok(start..)
+        Ok(end..)
     }
 }
 
@@ -2526,14 +2526,14 @@ mod range_from {
 
     use crate::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
 
-    pub const FIELDS: &[&str] = &["end"];
+    pub const FIELDS: &[&str] = &["start"];
 
     // If this were outside of the serde crate, it would just use:
     //
     //    #[derive(Deserialize)]
     //    #[serde(field_identifier, rename_all = "lowercase")]
     enum Field {
-        End,
+        Start,
     }
 
     impl<'de> Deserialize<'de> for Field {
@@ -2547,7 +2547,7 @@ mod range_from {
                 type Value = Field;
 
                 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("`end`")
+                    formatter.write_str("`start`")
                 }
 
                 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
@@ -2555,7 +2555,7 @@ mod range_from {
                     E: Error,
                 {
                     match value {
-                        "end" => Ok(Field::End),
+                        "start" => Ok(Field::Start),
                         _ => Err(Error::unknown_field(value, FIELDS)),
                     }
                 }
@@ -2565,7 +2565,7 @@ mod range_from {
                     E: Error,
                 {
                     match value {
-                        b"end" => Ok(Field::End),
+                        b"start" => Ok(Field::Start),
                         _ => {
                             let value = crate::__private::from_utf8_lossy(value);
                             Err(Error::unknown_field(&*value, FIELDS))
@@ -2597,35 +2597,35 @@ mod range_from {
         where
             A: SeqAccess<'de>,
         {
-            let end: Idx = match tri!(seq.next_element()) {
+            let start: Idx = match tri!(seq.next_element()) {
                 Some(value) => value,
                 None => {
                     return Err(Error::invalid_length(0, &self));
                 }
             };
-            Ok(end)
+            Ok(start)
         }
 
         fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
         where
             A: MapAccess<'de>,
         {
-            let mut end: Option<Idx> = None;
+            let mut start: Option<Idx> = None;
             while let Some(key) = tri!(map.next_key()) {
                 match key {
-                    Field::End => {
-                        if end.is_some() {
-                            return Err(<A::Error as Error>::duplicate_field("end"));
+                    Field::Start => {
+                        if start.is_some() {
+                            return Err(<A::Error as Error>::duplicate_field("start"));
                         }
-                        end = Some(tri!(map.next_value()));
+                        start = Some(tri!(map.next_value()));
                     }
                 }
             }
-            let end = match end {
-                Some(end) => end,
-                None => return Err(<A::Error as Error>::missing_field("end")),
+            let start = match start {
+                Some(start) => start,
+                None => return Err(<A::Error as Error>::missing_field("start")),
             };
-            Ok(end)
+            Ok(start)
         }
     }
 }
@@ -2647,7 +2647,7 @@ where
     where
         D: Deserializer<'de>,
     {
-        let end = tri!(deserializer.deserialize_struct(
+        let start = tri!(deserializer.deserialize_struct(
             "RangeTo",
             range_to::FIELDS,
             range_to::RangeToVisitor {
@@ -2655,7 +2655,7 @@ where
                 phantom: PhantomData,
             },
         ));
-        Ok(..end)
+        Ok(..start)
     }
 }
 
@@ -2664,14 +2664,14 @@ mod range_to {
 
     use crate::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
 
-    pub const FIELDS: &[&str] = &["start"];
+    pub const FIELDS: &[&str] = &["end"];
 
     // If this were outside of the serde crate, it would just use:
     //
     //    #[derive(Deserialize)]
     //    #[serde(field_identifier, rename_all = "lowercase")]
     enum Field {
-        Start,
+        End,
     }
 
     impl<'de> Deserialize<'de> for Field {
@@ -2685,7 +2685,7 @@ mod range_to {
                 type Value = Field;
 
                 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("`start`")
+                    formatter.write_str("`end`")
                 }
 
                 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
@@ -2693,7 +2693,7 @@ mod range_to {
                     E: Error,
                 {
                     match value {
-                        "start" => Ok(Field::Start),
+                        "end" => Ok(Field::End),
                         _ => Err(Error::unknown_field(value, FIELDS)),
                     }
                 }
@@ -2703,7 +2703,7 @@ mod range_to {
                     E: Error,
                 {
                     match value {
-                        b"start" => Ok(Field::Start),
+                        b"end" => Ok(Field::End),
                         _ => {
                             let value = crate::__private::from_utf8_lossy(value);
                             Err(Error::unknown_field(&*value, FIELDS))
@@ -2735,35 +2735,35 @@ mod range_to {
         where
             A: SeqAccess<'de>,
         {
-            let start: Idx = match tri!(seq.next_element()) {
+            let end: Idx = match tri!(seq.next_element()) {
                 Some(value) => value,
                 None => {
                     return Err(Error::invalid_length(0, &self));
                 }
             };
-            Ok(start)
+            Ok(end)
         }
 
         fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
         where
             A: MapAccess<'de>,
         {
-            let mut start: Option<Idx> = None;
+            let mut end: Option<Idx> = None;
             while let Some(key) = tri!(map.next_key()) {
                 match key {
-                    Field::Start => {
-                        if start.is_some() {
-                            return Err(<A::Error as Error>::duplicate_field("start"));
+                    Field::End => {
+                        if end.is_some() {
+                            return Err(<A::Error as Error>::duplicate_field("end"));
                         }
-                        start = Some(tri!(map.next_value()));
+                        end = Some(tri!(map.next_value()));
                     }
                 }
             }
-            let start = match start {
-                Some(start) => start,
-                None => return Err(<A::Error as Error>::missing_field("start")),
+            let end = match end {
+                Some(end) => end,
+                None => return Err(<A::Error as Error>::missing_field("end")),
             };
-            Ok(start)
+            Ok(end)
         }
     }
 }