Fix Range{From,To} deserialize mixup

emilbonnek · web-flow · commit c91c33436d7a · 2023-11-21T02:13:18.000+01:00
diff --git a/serde/src/de/impls.rs b/serde/src/de/impls.rs
@@ -2509,15 +2509,15 @@ where
     where
         D: Deserializer<'de>,
     {
-        let start = tri!(deserializer.deserialize_struct(
+        let end = tri!(deserializer.deserialize_struct(
             "RangeFrom",
             range_from::FIELDS,
             range_from::RangeFromVisitor {
                 expecting: "struct RangeFrom",
                 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,15 +2547,15 @@ 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>
                 where
                     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,15 +2647,15 @@ where
     where
         D: Deserializer<'de>,
     {
-        let end = tri!(deserializer.deserialize_struct(
+        let start = tri!(deserializer.deserialize_struct(
             "RangeTo",
             range_to::FIELDS,
             range_to::RangeToVisitor {
                 expecting: "struct RangeTo",
                 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,15 +2685,15 @@ 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>
                 where
                     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)
         }
     }
 }

Original file line number	Diff line number	Diff line change
`@@ -2509,15 +2509,15 @@ where`
`2509`	`2509`	`where`
`2510`	`2510`	`D: Deserializer<'de>,`
`2511`	`2511`	`{`
`2512`		`- let start = tri!(deserializer.deserialize_struct(`
	`2512`	`+ let end = tri!(deserializer.deserialize_struct(`
`2513`	`2513`	`"RangeFrom",`
`2514`	`2514`	`range_from::FIELDS,`
`2515`	`2515`	`range_from::RangeFromVisitor {`
`2516`	`2516`	`expecting: "struct RangeFrom",`
`2517`	`2517`	`phantom: PhantomData,`
`2518`	`2518`	`},`
`2519`	`2519`	`));`
`2520`		`- Ok(start..)`
	`2520`	`+ Ok(end..)`
`2521`	`2521`	`}`
`2522`	`2522`	`}`
`2523`	`2523`
`@@ -2526,14 +2526,14 @@ mod range_from {`
`2526`	`2526`
`2527`	`2527`	`use crate::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};`
`2528`	`2528`
`2529`		`- pub const FIELDS: &[&str] = &["end"];`
	`2529`	`+ pub const FIELDS: &[&str] = &["start"];`
`2530`	`2530`
`2531`	`2531`	`// If this were outside of the serde crate, it would just use:`
`2532`	`2532`	`//`
`2533`	`2533`	`// #[derive(Deserialize)]`
`2534`	`2534`	`// #[serde(field_identifier, rename_all = "lowercase")]`
`2535`	`2535`	`enum Field {`
`2536`		`- End,`
	`2536`	`+ Start,`
`2537`	`2537`	`}`
`2538`	`2538`
`2539`	`2539`	`impl<'de> Deserialize<'de> for Field {`
`@@ -2547,15 +2547,15 @@ mod range_from {`
`2547`	`2547`	`type Value = Field;`
`2548`	`2548`
`2549`	`2549`	`fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {`
`2550`		- formatter.write_str("`end`")
	`2550`	+ formatter.write_str("`start`")
`2551`	`2551`	`}`
`2552`	`2552`
`2553`	`2553`	`fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>`
`2554`	`2554`	`where`
`2555`	`2555`	`E: Error,`
`2556`	`2556`	`{`
`2557`	`2557`	`match value {`
`2558`		`- "end" => Ok(Field::End),`
	`2558`	`+ "start" => Ok(Field::Start),`
`2559`	`2559`	`_ => Err(Error::unknown_field(value, FIELDS)),`
`2560`	`2560`	`}`
`2561`	`2561`	`}`
`@@ -2565,7 +2565,7 @@ mod range_from {`
`2565`	`2565`	`E: Error,`
`2566`	`2566`	`{`
`2567`	`2567`	`match value {`
`2568`		`- b"end" => Ok(Field::End),`
	`2568`	`+ b"start" => Ok(Field::Start),`
`2569`	`2569`	`_ => {`
`2570`	`2570`	`let value = crate::__private::from_utf8_lossy(value);`
`2571`	`2571`	`Err(Error::unknown_field(&*value, FIELDS))`
`@@ -2597,35 +2597,35 @@ mod range_from {`
`2597`	`2597`	`where`
`2598`	`2598`	`A: SeqAccess<'de>,`
`2599`	`2599`	`{`
`2600`		`- let end: Idx = match tri!(seq.next_element()) {`
	`2600`	`+ let start: Idx = match tri!(seq.next_element()) {`
`2601`	`2601`	`Some(value) => value,`
`2602`	`2602`	`None => {`
`2603`	`2603`	`return Err(Error::invalid_length(0, &self));`
`2604`	`2604`	`}`
`2605`	`2605`	`};`
`2606`		`- Ok(end)`
	`2606`	`+ Ok(start)`
`2607`	`2607`	`}`
`2608`	`2608`
`2609`	`2609`	`fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>`
`2610`	`2610`	`where`
`2611`	`2611`	`A: MapAccess<'de>,`
`2612`	`2612`	`{`
`2613`		`- let mut end: Option<Idx> = None;`
	`2613`	`+ let mut start: Option<Idx> = None;`
`2614`	`2614`	`while let Some(key) = tri!(map.next_key()) {`
`2615`	`2615`	`match key {`
`2616`		`- Field::End => {`
`2617`		`- if end.is_some() {`
`2618`		`- return Err(<A::Error as Error>::duplicate_field("end"));`
	`2616`	`+ Field::Start => {`
	`2617`	`+ if start.is_some() {`
	`2618`	`+ return Err(<A::Error as Error>::duplicate_field("start"));`
`2619`	`2619`	`}`
`2620`		`- end = Some(tri!(map.next_value()));`
	`2620`	`+ start = Some(tri!(map.next_value()));`
`2621`	`2621`	`}`
`2622`	`2622`	`}`
`2623`	`2623`	`}`
`2624`		`- let end = match end {`
`2625`		`- Some(end) => end,`
`2626`		`- None => return Err(<A::Error as Error>::missing_field("end")),`
	`2624`	`+ let start = match start {`
	`2625`	`+ Some(start) => start,`
	`2626`	`+ None => return Err(<A::Error as Error>::missing_field("start")),`
`2627`	`2627`	`};`
`2628`		`- Ok(end)`
	`2628`	`+ Ok(start)`
`2629`	`2629`	`}`
`2630`	`2630`	`}`
`2631`	`2631`	`}`
`@@ -2647,15 +2647,15 @@ where`
`2647`	`2647`	`where`
`2648`	`2648`	`D: Deserializer<'de>,`
`2649`	`2649`	`{`
`2650`		`- let end = tri!(deserializer.deserialize_struct(`
	`2650`	`+ let start = tri!(deserializer.deserialize_struct(`
`2651`	`2651`	`"RangeTo",`
`2652`	`2652`	`range_to::FIELDS,`
`2653`	`2653`	`range_to::RangeToVisitor {`
`2654`	`2654`	`expecting: "struct RangeTo",`
`2655`	`2655`	`phantom: PhantomData,`
`2656`	`2656`	`},`
`2657`	`2657`	`));`
`2658`		`- Ok(..end)`
	`2658`	`+ Ok(..start)`
`2659`	`2659`	`}`
`2660`	`2660`	`}`
`2661`	`2661`
`@@ -2664,14 +2664,14 @@ mod range_to {`
`2664`	`2664`
`2665`	`2665`	`use crate::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};`
`2666`	`2666`
`2667`		`- pub const FIELDS: &[&str] = &["start"];`
	`2667`	`+ pub const FIELDS: &[&str] = &["end"];`
`2668`	`2668`
`2669`	`2669`	`// If this were outside of the serde crate, it would just use:`
`2670`	`2670`	`//`
`2671`	`2671`	`// #[derive(Deserialize)]`
`2672`	`2672`	`// #[serde(field_identifier, rename_all = "lowercase")]`
`2673`	`2673`	`enum Field {`
`2674`		`- Start,`
	`2674`	`+ End,`
`2675`	`2675`	`}`
`2676`	`2676`
`2677`	`2677`	`impl<'de> Deserialize<'de> for Field {`
`@@ -2685,15 +2685,15 @@ mod range_to {`
`2685`	`2685`	`type Value = Field;`
`2686`	`2686`
`2687`	`2687`	`fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {`
`2688`		- formatter.write_str("`start`")
	`2688`	+ formatter.write_str("`end`")
`2689`	`2689`	`}`
`2690`	`2690`
`2691`	`2691`	`fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>`
`2692`	`2692`	`where`
`2693`	`2693`	`E: Error,`
`2694`	`2694`	`{`
`2695`	`2695`	`match value {`
`2696`		`- "start" => Ok(Field::Start),`
	`2696`	`+ "end" => Ok(Field::End),`
`2697`	`2697`	`_ => Err(Error::unknown_field(value, FIELDS)),`
`2698`	`2698`	`}`
`2699`	`2699`	`}`
`@@ -2703,7 +2703,7 @@ mod range_to {`
`2703`	`2703`	`E: Error,`
`2704`	`2704`	`{`
`2705`	`2705`	`match value {`
`2706`		`- b"start" => Ok(Field::Start),`
	`2706`	`+ b"end" => Ok(Field::End),`
`2707`	`2707`	`_ => {`
`2708`	`2708`	`let value = crate::__private::from_utf8_lossy(value);`
`2709`	`2709`	`Err(Error::unknown_field(&*value, FIELDS))`
`@@ -2735,35 +2735,35 @@ mod range_to {`
`2735`	`2735`	`where`
`2736`	`2736`	`A: SeqAccess<'de>,`
`2737`	`2737`	`{`
`2738`		`- let start: Idx = match tri!(seq.next_element()) {`
	`2738`	`+ let end: Idx = match tri!(seq.next_element()) {`
`2739`	`2739`	`Some(value) => value,`
`2740`	`2740`	`None => {`
`2741`	`2741`	`return Err(Error::invalid_length(0, &self));`
`2742`	`2742`	`}`
`2743`	`2743`	`};`
`2744`		`- Ok(start)`
	`2744`	`+ Ok(end)`
`2745`	`2745`	`}`
`2746`	`2746`
`2747`	`2747`	`fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>`
`2748`	`2748`	`where`
`2749`	`2749`	`A: MapAccess<'de>,`
`2750`	`2750`	`{`
`2751`		`- let mut start: Option<Idx> = None;`
	`2751`	`+ let mut end: Option<Idx> = None;`
`2752`	`2752`	`while let Some(key) = tri!(map.next_key()) {`
`2753`	`2753`	`match key {`
`2754`		`- Field::Start => {`
`2755`		`- if start.is_some() {`
`2756`		`- return Err(<A::Error as Error>::duplicate_field("start"));`
	`2754`	`+ Field::End => {`
	`2755`	`+ if end.is_some() {`
	`2756`	`+ return Err(<A::Error as Error>::duplicate_field("end"));`
`2757`	`2757`	`}`
`2758`		`- start = Some(tri!(map.next_value()));`
	`2758`	`+ end = Some(tri!(map.next_value()));`
`2759`	`2759`	`}`
`2760`	`2760`	`}`
`2761`	`2761`	`}`
`2762`		`- let start = match start {`
`2763`		`- Some(start) => start,`
`2764`		`- None => return Err(<A::Error as Error>::missing_field("start")),`
	`2762`	`+ let end = match end {`
	`2763`	`+ Some(end) => end,`
	`2764`	`+ None => return Err(<A::Error as Error>::missing_field("end")),`
`2765`	`2765`	`};`
`2766`		`- Ok(start)`
	`2766`	`+ Ok(end)`
`2767`	`2767`	`}`
`2768`	`2768`	`}`
`2769`	`2769`	`}`