mikros/serde
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Resolve multiple_bound_locations clippy lint

Browse Source 
warning: bound is defined in more than one place
      --> serde/src/ser/fmt.rs:77:33
       |
    77 |     fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> fmt::Result
       |                                 ^
    78 |     where
    79 |         T: Serialize,
       |         ^
       |
       = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations
       = note: `-W clippy::multiple-bound-locations` implied by `-W clippy::all`
       = help: to override `-W clippy::all` add `#[allow(clippy::multiple_bound_locations)]`

    warning: bound is defined in more than one place
      --> serde/src/ser/fmt.rs:92:23
       |
    92 |     fn serialize_some<T: ?Sized>(self, _value: &T) -> fmt::Result
       |                       ^
    93 |     where
    94 |         T: Serialize,
       |         ^
       |
       = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/ser/fmt.rs:103:34
        |
    103 |     fn serialize_newtype_variant<T: ?Sized>(
        |                                  ^
    ...
    111 |         T: Serialize,
        |         ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/ser/fmt.rs:164:20
        |
    164 |     fn collect_str<T: ?Sized>(self, value: &T) -> fmt::Result
        |                    ^
    165 |     where
    166 |         T: Display,
        |         ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
      --> serde/src/ser/impossible.rs:75:26
       |
    75 |     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
       |                          ^
    76 |     where
    77 |         T: Serialize,
       |         ^
       |
       = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
      --> serde/src/ser/impossible.rs:95:26
       |
    95 |     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
       |                          ^
    96 |     where
    97 |         T: Serialize,
       |         ^
       |
       = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/ser/impossible.rs:115:24
        |
    115 |     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
        |                        ^
    116 |     where
    117 |         T: Serialize,
        |         ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/ser/impossible.rs:135:24
        |
    135 |     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
        |                        ^
    136 |     where
    137 |         T: Serialize,
        |         ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/ser/impossible.rs:155:22
        |
    155 |     fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Error>
        |                      ^
    156 |     where
    157 |         T: Serialize,
        |         ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/ser/impossible.rs:163:24
        |
    163 |     fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
        |                        ^
    164 |     where
    165 |         T: Serialize,
        |         ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/ser/impossible.rs:183:24
        |
    183 |     fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
        |                        ^
    184 |     where
    185 |         T: Serialize,
        |         ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/ser/impossible.rs:204:24
        |
    204 |     fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
        |                        ^
    205 |     where
    206 |         T: Serialize,
        |         ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/ser/mod.rs:799:23
        |
    799 |     fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
        |                       ^
    800 |     where
    801 |         T: Serialize;
        |         ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/ser/mod.rs:894:33
        |
    894 |     fn serialize_newtype_struct<T: ?Sized>(
        |                                 ^
    ...
    900 |         T: Serialize;
        |         ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/ser/mod.rs:928:34
        |
    928 |     fn serialize_newtype_variant<T: ?Sized>(
        |                                  ^
    ...
    936 |         T: Serialize;
        |         ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/ser/mod.rs:1349:20
         |
    1349 |     fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
         |                    ^
    1350 |     where
    1351 |         T: Display,
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/ser/mod.rs:1496:26
         |
    1496 |     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
         |                          ^
    1497 |     where
    1498 |         T: Serialize;
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/ser/mod.rs:1596:26
         |
    1596 |     fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
         |                          ^
    1597 |     where
    1598 |         T: Serialize;
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/ser/mod.rs:1641:24
         |
    1641 |     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
         |                        ^
    1642 |     where
    1643 |         T: Serialize;
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/ser/mod.rs:1699:24
         |
    1699 |     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
         |                        ^
    1700 |     where
    1701 |         T: Serialize;
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/ser/mod.rs:1770:22
         |
    1770 |     fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
         |                      ^
    1771 |     where
    1772 |         T: Serialize;
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/ser/mod.rs:1780:24
         |
    1780 |     fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
         |                        ^
    1781 |     where
    1782 |         T: Serialize;
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/ser/mod.rs:1801:24
         |
    1801 |     fn serialize_entry<K: ?Sized, V: ?Sized>(
         |                        ^
    ...
    1807 |         K: Serialize,
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/ser/mod.rs:1801:35
         |
    1801 |     fn serialize_entry<K: ?Sized, V: ?Sized>(
         |                                   ^
    ...
    1808 |         V: Serialize,
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/ser/mod.rs:1859:24
         |
    1859 |     fn serialize_field<T: ?Sized>(
         |                        ^
    ...
    1865 |         T: Serialize;
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/ser/mod.rs:1925:24
         |
    1925 |     fn serialize_field<T: ?Sized>(
         |                        ^
    ...
    1931 |         T: Serialize;
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:177:23
        |
    177 |     fn serialize_some<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
        |                       ^
    178 |     where
    179 |         T: Serialize,
        |         ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:208:33
        |
    208 |     fn serialize_newtype_struct<T: ?Sized>(
        |                                 ^
    ...
    214 |         T: Serialize,
        |         ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:219:34
        |
    219 |     fn serialize_newtype_variant<T: ?Sized>(
        |                                  ^
    ...
    227 |         T: Serialize,
        |         ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:367:28
        |
    367 |         fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), M::Error>
        |                            ^
    368 |         where
    369 |             T: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:407:28
        |
    407 |         fn serialize_field<T: ?Sized>(
        |                            ^
    ...
    413 |             T: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:638:27
        |
    638 |         fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Content, E>
        |                           ^
    639 |         where
    640 |             T: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:662:37
        |
    662 |         fn serialize_newtype_struct<T: ?Sized>(
        |                                     ^
    ...
    668 |             T: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:676:38
        |
    676 |         fn serialize_newtype_variant<T: ?Sized>(
        |                                      ^
    ...
    684 |             T: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:785:30
        |
    785 |         fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
        |                              ^
    786 |         where
    787 |             T: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:811:30
        |
    811 |         fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
        |                              ^
    812 |         where
    813 |             T: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:838:28
        |
    838 |         fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
        |                            ^
    839 |         where
    840 |             T: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:867:28
        |
    867 |         fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
        |                            ^
    868 |         where
    869 |             T: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:899:26
        |
    899 |         fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), E>
        |                          ^
    900 |         where
    901 |             T: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:908:28
        |
    908 |         fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), E>
        |                            ^
    909 |         where
    910 |             T: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:925:28
        |
    925 |         fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<(), E>
        |                            ^
    926 |         where
    927 |             K: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:925:39
        |
    925 |         fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<(), E>
        |                                       ^
    ...
    928 |             V: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:950:28
        |
    950 |         fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E>
        |                            ^
    951 |         where
    952 |             T: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
       --> serde/src/private/ser.rs:979:28
        |
    979 |         fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E>
        |                            ^
    980 |         where
    981 |             T: Serialize,
        |             ^
        |
        = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/private/ser.rs:1091:23
         |
    1091 |     fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
         |                       ^
    1092 |     where
    1093 |         T: Serialize,
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/private/ser.rs:1115:33
         |
    1115 |     fn serialize_newtype_struct<T: ?Sized>(
         |                                 ^
    ...
    1121 |         T: Serialize,
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/private/ser.rs:1126:34
         |
    1126 |     fn serialize_newtype_variant<T: ?Sized>(
         |                                  ^
    ...
    1134 |         T: Serialize,
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/private/ser.rs:1205:22
         |
    1205 |     fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
         |                      ^
    1206 |     where
    1207 |         T: Serialize,
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/private/ser.rs:1212:24
         |
    1212 |     fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
         |                        ^
    1213 |     where
    1214 |         T: Serialize,
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/private/ser.rs:1219:24
         |
    1219 |     fn serialize_entry<K: ?Sized, V: ?Sized>(
         |                        ^
    ...
    1225 |         K: Serialize,
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/private/ser.rs:1219:35
         |
    1219 |     fn serialize_entry<K: ?Sized, V: ?Sized>(
         |                                   ^
    ...
    1226 |         V: Serialize,
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/private/ser.rs:1247:24
         |
    1247 |     fn serialize_field<T: ?Sized>(
         |                        ^
    ...
    1253 |         T: Serialize,
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/private/ser.rs:1292:24
         |
    1292 |     fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
         |                        ^
    1293 |     where
    1294 |         T: Serialize,
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations

    warning: bound is defined in more than one place
        --> serde/src/private/ser.rs:1338:24
         |
    1338 |     fn serialize_field<T: ?Sized>(
         |                        ^
    ...
    1344 |         T: Serialize,
         |         ^
         |
         = help: for further information visit https://rust-lang.github.io/rust-clippy/master/index.html#multiple_bound_locations
This commit is contained in:
David Tolnay 2024-02-27 22:37:04 -08:00
parent 5fa711d75d
commit c9cab490f7
No known key found for this signature in database
GPG Key ID: F9BA143B95FF6D82
8 changed files with 149 additions and 168 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

17
serde/src/de/impls.rs
View File

@ -852,7 +852,10 @@ struct PhantomDataVisitor<T: ?Sized> {
marker: PhantomData<T>, marker: PhantomData<T>,
} }
impl<'de, T: ?Sized> Visitor<'de> for PhantomDataVisitor<T> { impl<'de, T> Visitor<'de> for PhantomDataVisitor<T>
where
T: ?Sized,
{
type Value = PhantomData<T>; type Value = PhantomData<T>;
fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result { fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
@ -868,7 +871,10 @@ impl<'de, T: ?Sized> Visitor<'de> for PhantomDataVisitor<T> {
} }
} }
impl<'de, T: ?Sized> Deserialize<'de> for PhantomData<T> { impl<'de, T> Deserialize<'de> for PhantomData<T>
where
T: ?Sized,
{
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
where where
D: Deserializer<'de>, D: Deserializer<'de>,
@ -1877,9 +1883,9 @@ forwarded_impl! {
#[cfg(any(feature = "std", feature = "alloc"))] #[cfg(any(feature = "std", feature = "alloc"))]
#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T> impl<'de, 'a, T> Deserialize<'de> for Cow<'a, T>
where where
T: ToOwned, T: ?Sized + ToOwned,
T::Owned: Deserialize<'de>, T::Owned: Deserialize<'de>,
{ {
#[inline] #[inline]
@ -1945,8 +1951,9 @@ macro_rules! box_forwarded_impl {
$t:ident $t:ident
) => { ) => {
$(#[$attr])* $(#[$attr])*
impl<'de, T: ?Sized> Deserialize<'de> for $t<T> impl<'de, T> Deserialize<'de> for $t<T>
where where
T: ?Sized,
Box<T>: Deserialize<'de>, Box<T>: Deserialize<'de>,
{ {
fn deserialize<D>(deserializer: D) -> Result<Self, D::Error> fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

8
serde/src/de/mod.rs
View File

@ -1735,9 +1735,9 @@ pub trait SeqAccess<'de> {
} }
} }
impl<'de, 'a, A: ?Sized> SeqAccess<'de> for &'a mut A impl<'de, 'a, A> SeqAccess<'de> for &'a mut A
where where
A: SeqAccess<'de>, A: ?Sized + SeqAccess<'de>,
{ {
type Error = A::Error; type Error = A::Error;
@ -1888,9 +1888,9 @@ pub trait MapAccess<'de> {
} }
} }
impl<'de, 'a, A: ?Sized> MapAccess<'de> for &'a mut A impl<'de, 'a, A> MapAccess<'de> for &'a mut A
where where
A: MapAccess<'de>, A: ?Sized + MapAccess<'de>,
{ {
type Error = A::Error; type Error = A::Error;

5
serde/src/private/doc.rs
View File

@ -56,7 +56,10 @@ macro_rules! __serialize_unimplemented {
#[macro_export] #[macro_export]
macro_rules! __serialize_unimplemented_method { macro_rules! __serialize_unimplemented_method {
($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) => { ($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) => {
fn $func $(<$t: ?Sized + $crate::Serialize>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error> { fn $func $(<$t>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error>
where
$($t: ?Sized + $crate::Serialize,)*
{
unimplemented!() unimplemented!()
} }
}; };

132
serde/src/private/ser.rs
View File

@ -174,9 +174,9 @@ where
Err(self.bad_type(Unsupported::Optional)) Err(self.bad_type(Unsupported::Optional))
} }
fn serialize_some<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error> fn serialize_some<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
Err(self.bad_type(Unsupported::Optional)) Err(self.bad_type(Unsupported::Optional))
} }
@ -205,18 +205,18 @@ where
map.end() map.end()
} }
fn serialize_newtype_struct<T: ?Sized>( fn serialize_newtype_struct<T>(
self, self,
_: &'static str, _: &'static str,
value: &T, value: &T,
) -> Result<Self::Ok, Self::Error> ) -> Result<Self::Ok, Self::Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
fn serialize_newtype_variant<T: ?Sized>( fn serialize_newtype_variant<T>(
self, self,
_: &'static str, _: &'static str,
_: u32, _: u32,
@ -224,7 +224,7 @@ where
inner_value: &T, inner_value: &T,
) -> Result<Self::Ok, Self::Error> ) -> Result<Self::Ok, Self::Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let mut map = tri!(self.delegate.serialize_map(Some(2))); let mut map = tri!(self.delegate.serialize_map(Some(2)));
tri!(map.serialize_entry(self.tag, self.variant_name)); tri!(map.serialize_entry(self.tag, self.variant_name));
@ -327,9 +327,9 @@ where
} }
#[cfg(not(any(feature = "std", feature = "alloc")))] #[cfg(not(any(feature = "std", feature = "alloc")))]
fn collect_str<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error> fn collect_str<T>(self, _: &T) -> Result<Self::Ok, Self::Error>
where where
T: Display, T: ?Sized + Display,
{ {
Err(self.bad_type(Unsupported::String)) Err(self.bad_type(Unsupported::String))
} }
@ -364,9 +364,9 @@ mod content {
type Ok = M::Ok; type Ok = M::Ok;
type Error = M::Error; type Error = M::Error;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), M::Error> fn serialize_field<T>(&mut self, value: &T) -> Result<(), M::Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let value = tri!(value.serialize(ContentSerializer::<M::Error>::new())); let value = tri!(value.serialize(ContentSerializer::<M::Error>::new()));
self.fields.push(value); self.fields.push(value);
@ -404,13 +404,9 @@ mod content {
type Ok = M::Ok; type Ok = M::Ok;
type Error = M::Error; type Error = M::Error;
fn serialize_field<T: ?Sized>( fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), M::Error>
&mut self,
key: &'static str,
value: &T,
) -> Result<(), M::Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let value = tri!(value.serialize(ContentSerializer::<M::Error>::new())); let value = tri!(value.serialize(ContentSerializer::<M::Error>::new()));
self.fields.push((key, value)); self.fields.push((key, value));
@ -635,9 +631,9 @@ mod content {
Ok(Content::None) Ok(Content::None)
} }
fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Content, E> fn serialize_some<T>(self, value: &T) -> Result<Content, E>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
Ok(Content::Some(Box::new(tri!(value.serialize(self))))) Ok(Content::Some(Box::new(tri!(value.serialize(self)))))
} }
@ -659,13 +655,9 @@ mod content {
Ok(Content::UnitVariant(name, variant_index, variant)) Ok(Content::UnitVariant(name, variant_index, variant))
} }
fn serialize_newtype_struct<T: ?Sized>( fn serialize_newtype_struct<T>(self, name: &'static str, value: &T) -> Result<Content, E>
self,
name: &'static str,
value: &T,
) -> Result<Content, E>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
Ok(Content::NewtypeStruct( Ok(Content::NewtypeStruct(
name, name,
@ -673,7 +665,7 @@ mod content {
)) ))
} }
fn serialize_newtype_variant<T: ?Sized>( fn serialize_newtype_variant<T>(
self, self,
name: &'static str, name: &'static str,
variant_index: u32, variant_index: u32,
@ -681,7 +673,7 @@ mod content {
value: &T, value: &T,
) -> Result<Content, E> ) -> Result<Content, E>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
Ok(Content::NewtypeVariant( Ok(Content::NewtypeVariant(
name, name,
@ -782,9 +774,9 @@ mod content {
type Ok = Content; type Ok = Content;
type Error = E; type Error = E;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E> fn serialize_element<T>(&mut self, value: &T) -> Result<(), E>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let value = tri!(value.serialize(ContentSerializer::<E>::new())); let value = tri!(value.serialize(ContentSerializer::<E>::new()));
self.elements.push(value); self.elements.push(value);
@ -808,9 +800,9 @@ mod content {
type Ok = Content; type Ok = Content;
type Error = E; type Error = E;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), E> fn serialize_element<T>(&mut self, value: &T) -> Result<(), E>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let value = tri!(value.serialize(ContentSerializer::<E>::new())); let value = tri!(value.serialize(ContentSerializer::<E>::new()));
self.elements.push(value); self.elements.push(value);
@ -835,9 +827,9 @@ mod content {
type Ok = Content; type Ok = Content;
type Error = E; type Error = E;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E> fn serialize_field<T>(&mut self, value: &T) -> Result<(), E>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let value = tri!(value.serialize(ContentSerializer::<E>::new())); let value = tri!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push(value); self.fields.push(value);
@ -864,9 +856,9 @@ mod content {
type Ok = Content; type Ok = Content;
type Error = E; type Error = E;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), E> fn serialize_field<T>(&mut self, value: &T) -> Result<(), E>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let value = tri!(value.serialize(ContentSerializer::<E>::new())); let value = tri!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push(value); self.fields.push(value);
@ -896,18 +888,18 @@ mod content {
type Ok = Content; type Ok = Content;
type Error = E; type Error = E;
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), E> fn serialize_key<T>(&mut self, key: &T) -> Result<(), E>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let key = tri!(key.serialize(ContentSerializer::<E>::new())); let key = tri!(key.serialize(ContentSerializer::<E>::new()));
self.key = Some(key); self.key = Some(key);
Ok(()) Ok(())
} }
fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), E> fn serialize_value<T>(&mut self, value: &T) -> Result<(), E>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let key = self let key = self
.key .key
@ -922,10 +914,10 @@ mod content {
Ok(Content::Map(self.entries)) Ok(Content::Map(self.entries))
} }
fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<(), E> fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), E>
where where
K: Serialize, K: ?Sized + Serialize,
V: Serialize, V: ?Sized + Serialize,
{ {
let key = tri!(key.serialize(ContentSerializer::<E>::new())); let key = tri!(key.serialize(ContentSerializer::<E>::new()));
let value = tri!(value.serialize(ContentSerializer::<E>::new())); let value = tri!(value.serialize(ContentSerializer::<E>::new()));
@ -947,9 +939,9 @@ mod content {
type Ok = Content; type Ok = Content;
type Error = E; type Error = E;
fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E> fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), E>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let value = tri!(value.serialize(ContentSerializer::<E>::new())); let value = tri!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push((key, value)); self.fields.push((key, value));
@ -976,9 +968,9 @@ mod content {
type Ok = Content; type Ok = Content;
type Error = E; type Error = E;
fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), E> fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), E>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let value = tri!(value.serialize(ContentSerializer::<E>::new())); let value = tri!(value.serialize(ContentSerializer::<E>::new()));
self.fields.push((key, value)); self.fields.push((key, value));
@ -1088,9 +1080,9 @@ where
Ok(()) Ok(())
} }
fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
@ -1112,18 +1104,18 @@ where
Err(Self::bad_type(Unsupported::Enum)) Err(Self::bad_type(Unsupported::Enum))
} }
fn serialize_newtype_struct<T: ?Sized>( fn serialize_newtype_struct<T>(
self, self,
_: &'static str, _: &'static str,
value: &T, value: &T,
) -> Result<Self::Ok, Self::Error> ) -> Result<Self::Ok, Self::Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
value.serialize(self) value.serialize(self)
} }
fn serialize_newtype_variant<T: ?Sized>( fn serialize_newtype_variant<T>(
self, self,
_: &'static str, _: &'static str,
_: u32, _: u32,
@ -1131,7 +1123,7 @@ where
value: &T, value: &T,
) -> Result<Self::Ok, Self::Error> ) -> Result<Self::Ok, Self::Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
tri!(self.0.serialize_key(variant)); tri!(self.0.serialize_key(variant));
self.0.serialize_value(value) self.0.serialize_value(value)
@ -1202,28 +1194,24 @@ where
type Ok = (); type Ok = ();
type Error = M::Error; type Error = M::Error;
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error> fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
self.0.serialize_key(key) self.0.serialize_key(key)
} }
fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
self.0.serialize_value(value) self.0.serialize_value(value)
} }
fn serialize_entry<K: ?Sized, V: ?Sized>( fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
&mut self,
key: &K,
value: &V,
) -> Result<(), Self::Error>
where where
K: Serialize, K: ?Sized + Serialize,
V: Serialize, V: ?Sized + Serialize,
{ {
self.0.serialize_entry(key, value) self.0.serialize_entry(key, value)
} }
@ -1244,13 +1232,9 @@ where
type Ok = (); type Ok = ();
type Error = M::Error; type Error = M::Error;
fn serialize_field<T: ?Sized>( fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
&mut self,
key: &'static str,
value: &T,
) -> Result<(), Self::Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
self.0.serialize_entry(key, value) self.0.serialize_entry(key, value)
} }
@ -1289,9 +1273,9 @@ where
type Ok = (); type Ok = ();
type Error = M::Error; type Error = M::Error;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let value = tri!(value.serialize(ContentSerializer::<M::Error>::new())); let value = tri!(value.serialize(ContentSerializer::<M::Error>::new()));
self.fields.push(value); self.fields.push(value);
@ -1335,13 +1319,9 @@ where
type Ok = (); type Ok = ();
type Error = M::Error; type Error = M::Error;
fn serialize_field<T: ?Sized>( fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
&mut self,
key: &'static str,
value: &T,
) -> Result<(), Self::Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let value = tri!(value.serialize(ContentSerializer::<M::Error>::new())); let value = tri!(value.serialize(ContentSerializer::<M::Error>::new()));
self.fields.push((key, value)); self.fields.push((key, value));

16
serde/src/ser/fmt.rs
View File

@ -74,9 +74,9 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
Display::fmt(variant, self) Display::fmt(variant, self)
} }
fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> fmt::Result fn serialize_newtype_struct<T>(self, _name: &'static str, value: &T) -> fmt::Result
where where
T: Serialize, T: ?Sized + Serialize,
{ {
Serialize::serialize(value, self) Serialize::serialize(value, self)
} }
@ -89,9 +89,9 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
Err(fmt::Error) Err(fmt::Error)
} }
fn serialize_some<T: ?Sized>(self, _value: &T) -> fmt::Result fn serialize_some<T>(self, _value: &T) -> fmt::Result
where where
T: Serialize, T: ?Sized + Serialize,
{ {
Err(fmt::Error) Err(fmt::Error)
} }
@ -100,7 +100,7 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
Err(fmt::Error) Err(fmt::Error)
} }
fn serialize_newtype_variant<T: ?Sized>( fn serialize_newtype_variant<T>(
self, self,
_name: &'static str, _name: &'static str,
_variant_index: u32, _variant_index: u32,
@ -108,7 +108,7 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
_value: &T, _value: &T,
) -> fmt::Result ) -> fmt::Result
where where
T: Serialize, T: ?Sized + Serialize,
{ {
Err(fmt::Error) Err(fmt::Error)
} }
@ -161,9 +161,9 @@ impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
Err(fmt::Error) Err(fmt::Error)
} }
fn collect_str<T: ?Sized>(self, value: &T) -> fmt::Result fn collect_str<T>(self, value: &T) -> fmt::Result
where where
T: Display, T: ?Sized + Display,
{ {
Display::fmt(value, self) Display::fmt(value, self)
} }

37
serde/src/ser/impls.rs
View File

@ -114,7 +114,10 @@ where
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
impl<T: ?Sized> Serialize for PhantomData<T> { impl<T> Serialize for PhantomData<T>
where
T: ?Sized,
{
#[inline] #[inline]
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
@ -504,17 +507,17 @@ macro_rules! deref_impl {
} }
deref_impl! { deref_impl! {
<'a, T: ?Sized> Serialize for &'a T where T: Serialize <'a, T> Serialize for &'a T where T: ?Sized + Serialize
} }
deref_impl! { deref_impl! {
<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize <'a, T> Serialize for &'a mut T where T: ?Sized + Serialize
} }
deref_impl! { deref_impl! {
#[cfg(any(feature = "std", feature = "alloc"))] #[cfg(any(feature = "std", feature = "alloc"))]
#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
<T: ?Sized> Serialize for Box<T> where T: Serialize <T> Serialize for Box<T> where T: ?Sized + Serialize
} }
deref_impl! { deref_impl! {
@ -528,7 +531,7 @@ deref_impl! {
/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
#[cfg_attr(doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))] #[cfg_attr(doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))]
<T: ?Sized> Serialize for Rc<T> where T: Serialize <T> Serialize for Rc<T> where T: ?Sized + Serialize
} }
deref_impl! { deref_impl! {
@ -542,13 +545,13 @@ deref_impl! {
/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))] #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
#[cfg_attr(doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))] #[cfg_attr(doc_cfg, doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))))]
<T: ?Sized> Serialize for Arc<T> where T: Serialize <T> Serialize for Arc<T> where T: ?Sized + Serialize
} }
deref_impl! { deref_impl! {
#[cfg(any(feature = "std", feature = "alloc"))] #[cfg(any(feature = "std", feature = "alloc"))]
#[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))] #[cfg_attr(doc_cfg, doc(cfg(any(feature = "std", feature = "alloc"))))]
<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned <'a, T> Serialize for Cow<'a, T> where T: ?Sized + Serialize + ToOwned
} }
//////////////////////////////////////////////////////////////////////////////// ////////////////////////////////////////////////////////////////////////////////
@ -561,9 +564,9 @@ deref_impl! {
doc_cfg, doc_cfg,
doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))) doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc"))))
)] )]
impl<T: ?Sized> Serialize for RcWeak<T> impl<T> Serialize for RcWeak<T>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
@ -581,9 +584,9 @@ where
doc_cfg, doc_cfg,
doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))) doc(cfg(all(feature = "rc", any(feature = "std", feature = "alloc"))))
)] )]
impl<T: ?Sized> Serialize for ArcWeak<T> impl<T> Serialize for ArcWeak<T>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
@ -641,9 +644,9 @@ where
} }
} }
impl<T: ?Sized> Serialize for RefCell<T> impl<T> Serialize for RefCell<T>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
@ -658,9 +661,9 @@ where
#[cfg(feature = "std")] #[cfg(feature = "std")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
impl<T: ?Sized> Serialize for Mutex<T> impl<T> Serialize for Mutex<T>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where
@ -675,9 +678,9 @@ where
#[cfg(feature = "std")] #[cfg(feature = "std")]
#[cfg_attr(doc_cfg, doc(cfg(feature = "std")))] #[cfg_attr(doc_cfg, doc(cfg(feature = "std")))]
impl<T: ?Sized> Serialize for RwLock<T> impl<T> Serialize for RwLock<T>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error> fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
where where

32
serde/src/ser/impossible.rs
View File

@ -72,9 +72,9 @@ where
type Ok = Ok; type Ok = Ok;
type Error = Error; type Error = Error;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let _ = value; let _ = value;
match self.void {} match self.void {}
@ -92,9 +92,9 @@ where
type Ok = Ok; type Ok = Ok;
type Error = Error; type Error = Error;
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let _ = value; let _ = value;
match self.void {} match self.void {}
@ -112,9 +112,9 @@ where
type Ok = Ok; type Ok = Ok;
type Error = Error; type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let _ = value; let _ = value;
match self.void {} match self.void {}
@ -132,9 +132,9 @@ where
type Ok = Ok; type Ok = Ok;
type Error = Error; type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let _ = value; let _ = value;
match self.void {} match self.void {}
@ -152,17 +152,17 @@ where
type Ok = Ok; type Ok = Ok;
type Error = Error; type Error = Error;
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Error> fn serialize_key<T>(&mut self, key: &T) -> Result<(), Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let _ = key; let _ = key;
match self.void {} match self.void {}
} }
fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Error> fn serialize_value<T>(&mut self, value: &T) -> Result<(), Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let _ = value; let _ = value;
match self.void {} match self.void {}
@ -180,9 +180,9 @@ where
type Ok = Ok; type Ok = Ok;
type Error = Error; type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error> fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let _ = key; let _ = key;
let _ = value; let _ = value;
@ -201,9 +201,9 @@ where
type Ok = Ok; type Ok = Ok;
type Error = Error; type Error = Error;
fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Error> fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Error>
where where
T: Serialize, T: ?Sized + Serialize,
{ {
let _ = key; let _ = key;
let _ = value; let _ = value;

70
serde/src/ser/mod.rs
View File

@ -796,9 +796,9 @@ pub trait Serializer: Sized {
/// ``` /// ```
/// ///
/// [`Some(T)`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some /// [`Some(T)`]: https://doc.rust-lang.org/std/option/enum.Option.html#variant.Some
fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
where where
T: Serialize; T: ?Sized + Serialize;
/// Serialize a `()` value. /// Serialize a `()` value.
/// ///
@ -891,13 +891,13 @@ pub trait Serializer: Sized {
/// } /// }
/// } /// }
/// ``` /// ```
fn serialize_newtype_struct<T: ?Sized>( fn serialize_newtype_struct<T>(
self, self,
name: &'static str, name: &'static str,
value: &T, value: &T,
) -> Result<Self::Ok, Self::Error> ) -> Result<Self::Ok, Self::Error>
where where
T: Serialize; T: ?Sized + Serialize;
/// Serialize a newtype variant like `E::N` in `enum E { N(u8) }`. /// Serialize a newtype variant like `E::N` in `enum E { N(u8) }`.
/// ///
@ -925,7 +925,7 @@ pub trait Serializer: Sized {
/// } /// }
/// } /// }
/// ``` /// ```
fn serialize_newtype_variant<T: ?Sized>( fn serialize_newtype_variant<T>(
self, self,
name: &'static str, name: &'static str,
variant_index: u32, variant_index: u32,
@ -933,7 +933,7 @@ pub trait Serializer: Sized {
value: &T, value: &T,
) -> Result<Self::Ok, Self::Error> ) -> Result<Self::Ok, Self::Error>
where where
T: Serialize; T: ?Sized + Serialize;
/// Begin to serialize a variably sized sequence. This call must be /// Begin to serialize a variably sized sequence. This call must be
/// followed by zero or more calls to `serialize_element`, then a call to /// followed by zero or more calls to `serialize_element`, then a call to
@ -1346,9 +1346,9 @@ pub trait Serializer: Sized {
/// [`String`]: https://doc.rust-lang.org/std/string/struct.String.html /// [`String`]: https://doc.rust-lang.org/std/string/struct.String.html
/// [`serialize_str`]: #tymethod.serialize_str /// [`serialize_str`]: #tymethod.serialize_str
#[cfg(any(feature = "std", feature = "alloc"))] #[cfg(any(feature = "std", feature = "alloc"))]
fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
where where
T: Display, T: ?Sized + Display,
{ {
self.serialize_str(&value.to_string()) self.serialize_str(&value.to_string())
} }
@ -1379,9 +1379,9 @@ pub trait Serializer: Sized {
/// } /// }
/// ``` /// ```
#[cfg(not(any(feature = "std", feature = "alloc")))] #[cfg(not(any(feature = "std", feature = "alloc")))]
fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error> fn collect_str<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
where where
T: Display; T: ?Sized + Display;
/// Determine whether `Serialize` implementations should serialize in /// Determine whether `Serialize` implementations should serialize in
/// human-readable form. /// human-readable form.
@ -1493,9 +1493,9 @@ pub trait SerializeSeq {
type Error: Error; type Error: Error;
/// Serialize a sequence element. /// Serialize a sequence element.
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
where where
T: Serialize; T: ?Sized + Serialize;
/// Finish serializing a sequence. /// Finish serializing a sequence.
fn end(self) -> Result<Self::Ok, Self::Error>; fn end(self) -> Result<Self::Ok, Self::Error>;
@ -1593,9 +1593,9 @@ pub trait SerializeTuple {
type Error: Error; type Error: Error;
/// Serialize a tuple element. /// Serialize a tuple element.
fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
where where
T: Serialize; T: ?Sized + Serialize;
/// Finish serializing a tuple. /// Finish serializing a tuple.
fn end(self) -> Result<Self::Ok, Self::Error>; fn end(self) -> Result<Self::Ok, Self::Error>;
@ -1638,9 +1638,9 @@ pub trait SerializeTupleStruct {
type Error: Error; type Error: Error;
/// Serialize a tuple struct field. /// Serialize a tuple struct field.
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
where where
T: Serialize; T: ?Sized + Serialize;
/// Finish serializing a tuple struct. /// Finish serializing a tuple struct.
fn end(self) -> Result<Self::Ok, Self::Error>; fn end(self) -> Result<Self::Ok, Self::Error>;
@ -1696,9 +1696,9 @@ pub trait SerializeTupleVariant {
type Error: Error; type Error: Error;
/// Serialize a tuple variant field. /// Serialize a tuple variant field.
fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
where where
T: Serialize; T: ?Sized + Serialize;
/// Finish serializing a tuple variant. /// Finish serializing a tuple variant.
fn end(self) -> Result<Self::Ok, Self::Error>; fn end(self) -> Result<Self::Ok, Self::Error>;
@ -1767,9 +1767,9 @@ pub trait SerializeMap {
/// `serialize_entry` instead as it may be implemented more efficiently in /// `serialize_entry` instead as it may be implemented more efficiently in
/// some formats compared to a pair of calls to `serialize_key` and /// some formats compared to a pair of calls to `serialize_key` and
/// `serialize_value`. /// `serialize_value`.
fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error> fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
where where
T: Serialize; T: ?Sized + Serialize;
/// Serialize a map value. /// Serialize a map value.
/// ///
@ -1777,9 +1777,9 @@ pub trait SerializeMap {
/// ///
/// Calling `serialize_value` before `serialize_key` is incorrect and is /// Calling `serialize_value` before `serialize_key` is incorrect and is
/// allowed to panic or produce bogus results. /// allowed to panic or produce bogus results.
fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error> fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
where where
T: Serialize; T: ?Sized + Serialize;
/// Serialize a map entry consisting of a key and a value. /// Serialize a map entry consisting of a key and a value.
/// ///
@ -1798,14 +1798,10 @@ pub trait SerializeMap {
/// [`Serialize`]: ../trait.Serialize.html /// [`Serialize`]: ../trait.Serialize.html
/// [`serialize_key`]: #tymethod.serialize_key /// [`serialize_key`]: #tymethod.serialize_key
/// [`serialize_value`]: #tymethod.serialize_value /// [`serialize_value`]: #tymethod.serialize_value
fn serialize_entry<K: ?Sized, V: ?Sized>( fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<(), Self::Error>
&mut self,
key: &K,
value: &V,
) -> Result<(), Self::Error>
where where
K: Serialize, K: ?Sized + Serialize,
V: Serialize, V: ?Sized + Serialize,
{ {
tri!(self.serialize_key(key)); tri!(self.serialize_key(key));
self.serialize_value(value) self.serialize_value(value)
@ -1856,13 +1852,9 @@ pub trait SerializeStruct {
type Error: Error; type Error: Error;
/// Serialize a struct field. /// Serialize a struct field.
fn serialize_field<T: ?Sized>( fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
&mut self,
key: &'static str,
value: &T,
) -> Result<(), Self::Error>
where where
T: Serialize; T: ?Sized + Serialize;
/// Indicate that a struct field has been skipped. /// Indicate that a struct field has been skipped.
#[inline] #[inline]
@ -1922,13 +1914,9 @@ pub trait SerializeStructVariant {
type Error: Error; type Error: Error;
/// Serialize a struct variant field. /// Serialize a struct variant field.
fn serialize_field<T: ?Sized>( fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
&mut self,
key: &'static str,
value: &T,
) -> Result<(), Self::Error>
where where
T: Serialize; T: ?Sized + Serialize;
/// Indicate that a struct variant field has been skipped. /// Indicate that a struct variant field has been skipped.
#[inline] #[inline]