impl Serialize/Deserialize for RangeFull, RangeToInclusive

serde/src/de/impls.rs

@@ -2770,6 +2770,166 @@ mod range_to {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+impl<'de, Idx> Deserialize<'de> for RangeToInclusive<Idx>
+where
+    Idx: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let end = tri!(deserializer.deserialize_struct(
+            "RangeToInclusive",
+            range_to_inclusive::FIELDS,
+            range_to_inclusive::RangeToInclusiveVisitor {
+                expecting: "struct RangeToInclusive",
+                phantom: PhantomData,
+            },
+        ));
+        Ok(..=end)
+    }
+}
+
+mod range_to_inclusive {
+    use crate::lib::*;
+
+    use crate::de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
+
+    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 {
+        End,
+    }
+
+    impl<'de> Deserialize<'de> for Field {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            struct FieldVisitor;
+
+            impl<'de> Visitor<'de> for FieldVisitor {
+                type Value = Field;
+
+                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    formatter.write_str("`end`")
+                }
+
+                fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+                where
+                    E: Error,
+                {
+                    match value {
+                        "end" => Ok(Field::End),
+                        _ => Err(Error::unknown_field(value, FIELDS)),
+                    }
+                }
+
+                fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+                where
+                    E: Error,
+                {
+                    match value {
+                        b"end" => Ok(Field::End),
+                        _ => {
+                            let value = crate::__private::from_utf8_lossy(value);
+                            Err(Error::unknown_field(&*value, FIELDS))
+                        }
+                    }
+                }
+            }
+
+            deserializer.deserialize_identifier(FieldVisitor)
+        }
+    }
+
+    pub struct RangeToInclusiveVisitor<Idx> {
+        pub expecting: &'static str,
+        pub phantom: PhantomData<Idx>,
+    }
+
+    impl<'de, Idx> Visitor<'de> for RangeToInclusiveVisitor<Idx>
+    where
+        Idx: Deserialize<'de>,
+    {
+        type Value = Idx;
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str(self.expecting)
+        }
+
+        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+        where
+            A: SeqAccess<'de>,
+        {
+            let end: Idx = match tri!(seq.next_element()) {
+                Some(value) => value,
+                None => {
+                    return Err(Error::invalid_length(0, &self));
+                }
+            };
+            Ok(end)
+        }
+
+        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+        where
+            A: MapAccess<'de>,
+        {
+            let mut end: 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"));
+                        }
+                        end = Some(tri!(map.next_value()));
+                    }
+                }
+            }
+            let end = match end {
+                Some(end) => end,
+                None => return Err(<A::Error as Error>::missing_field("end")),
+            };
+            Ok(end)
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+impl<'de> Deserialize<'de> for RangeFull {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        deserializer.deserialize_unit_struct("RangeFull", RangeFullVisitor)
+    }
+}
+
+struct RangeFullVisitor;
+
+impl<'de> Visitor<'de> for RangeFullVisitor {
+    type Value = RangeFull;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("unit")
+    }
+
+    #[inline]
+    fn visit_unit<E>(self) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(..)
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 impl<'de, T> Deserialize<'de> for Bound<T>
 where
     T: Deserialize<'de>,

serde/src/lib.rs

@@ -185,7 +185,9 @@ mod lib {
     pub use self::core::fmt::{self, Debug, Display, Write as FmtWrite};
     pub use self::core::marker::{self, PhantomData};
     pub use self::core::num::Wrapping;
-    pub use self::core::ops::{Bound, Range, RangeFrom, RangeInclusive, RangeTo};
+    pub use self::core::ops::{
+        Bound, Range, RangeFrom, RangeFull, RangeInclusive, RangeTo, RangeToInclusive,
+    };
     pub use self::core::option::{self, Option};
     pub use self::core::result::{self, Result};
     pub use self::core::time::Duration;

serde/src/ser/impls.rs

@@ -335,6 +335,35 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
+impl<Idx> Serialize for RangeToInclusive<Idx>
+where
+    Idx: Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        use super::SerializeStruct;
+        let mut state = tri!(serializer.serialize_struct("RangeToInclusive", 1));
+        tri!(state.serialize_field("end", &self.end));
+        state.end()
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+impl Serialize for RangeFull {
+    #[inline]
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.serialize_unit_struct("RangeFull")
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 impl<T> Serialize for Bound<T>
 where
     T: Serialize,

test_suite/tests/test_de.rs

@@ -1938,6 +1938,32 @@ fn test_range_to() {
     );
 }
 
+#[test]
+fn test_range_to_inclusive() {
+    test(
+        ..=3u32,
+        &[
+            Token::Struct {
+                name: "RangeToInclusive",
+                len: 1,
+            },
+            Token::Str("end"),
+            Token::U32(3),
+            Token::StructEnd,
+        ],
+    );
+    test(
+        ..=3u32,
+        &[Token::Seq { len: Some(1) }, Token::U32(3), Token::SeqEnd],
+    );
+}
+
+#[test]
+fn test_range_full() {
+    test(.., &[Token::Unit]);
+    test(.., &[Token::UnitStruct { name: "RangeFull" }]);
+}
+
 #[test]
 fn test_bound() {
     test(

test_suite/tests/test_ser.rs

@@ -532,6 +532,27 @@ fn test_range_to() {
     );
 }
 
+#[test]
+fn test_range_to_inclusive() {
+    assert_ser_tokens(
+        &(..=3u32),
+        &[
+            Token::Struct {
+                name: "RangeToInclusive",
+                len: 1,
+            },
+            Token::Str("end"),
+            Token::U32(3),
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_range_full() {
+    assert_ser_tokens(&(..), &[Token::UnitStruct { name: "RangeFull" }]);
+}
+
 #[test]
 fn test_bound() {
     assert_ser_tokens(