vendor/serde/src/de/impls.rs

   1 use lib::*;
   2
   3 use de::{
   4     Deserialize, Deserializer, EnumAccess, Error, SeqAccess, Unexpected, VariantAccess, Visitor,
   5 };
   6
   7 #[cfg(any(core_duration, feature = "std", feature = "alloc"))]
   8 use de::MapAccess;
   9
  10 use de::from_primitive::FromPrimitive;
  11 use private::de::InPlaceSeed;
  12
  13 #[cfg(any(feature = "std", feature = "alloc"))]
  14 use private::de::size_hint;
  15
  16 ////////////////////////////////////////////////////////////////////////////////
  17
  18 struct UnitVisitor;
  19
  20 impl<'de> Visitor<'de> for UnitVisitor {
  21     type Value = ();
  22
  23     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  24         formatter.write_str("unit")
  25     }
  26
  27     fn visit_unit<E>(self) -> Result<Self::Value, E>
  28     where
  29         E: Error,
  30     {
  31         Ok(())
  32     }
  33 }
  34
  35 impl<'de> Deserialize<'de> for () {
  36     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  37     where
  38         D: Deserializer<'de>,
  39     {
  40         deserializer.deserialize_unit(UnitVisitor)
  41     }
  42 }
  43
  44 #[cfg(feature = "unstable")]
  45 impl<'de> Deserialize<'de> for ! {
  46     fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
  47     where
  48         D: Deserializer<'de>,
  49     {
  50         Err(Error::custom("cannot deserialize `!`"))
  51     }
  52 }
  53
  54 ////////////////////////////////////////////////////////////////////////////////
  55
  56 struct BoolVisitor;
  57
  58 impl<'de> Visitor<'de> for BoolVisitor {
  59     type Value = bool;
  60
  61     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
  62         formatter.write_str("a boolean")
  63     }
  64
  65     fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
  66     where
  67         E: Error,
  68     {
  69         Ok(v)
  70     }
  71 }
  72
  73 impl<'de> Deserialize<'de> for bool {
  74     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
  75     where
  76         D: Deserializer<'de>,
  77     {
  78         deserializer.deserialize_bool(BoolVisitor)
  79     }
  80 }
  81
  82 ////////////////////////////////////////////////////////////////////////////////
  83
  84 macro_rules! visit_integer_method {
  85     ($src_ty:ident, $method:ident, $from_method:ident, $group:ident, $group_ty:ident) => {
  86         #[inline]
  87         fn $method<E>(self, v: $src_ty) -> Result<Self::Value, E>
  88         where
  89             E: Error,
  90         {
  91             match FromPrimitive::$from_method(v) {
  92                 Some(v) => Ok(v),
  93                 None => Err(Error::invalid_value(
  94                     Unexpected::$group(v as $group_ty),
  95                     &self,
  96                 )),
  97             }
  98         }
  99     };
 100 }
 101
 102 macro_rules! visit_float_method {
 103     ($src_ty:ident, $method:ident) => {
 104         #[inline]
 105         fn $method<E>(self, v: $src_ty) -> Result<Self::Value, E>
 106         where
 107             E: Error,
 108         {
 109             Ok(v as Self::Value)
 110         }
 111     };
 112 }
 113
 114 macro_rules! impl_deserialize_num {
 115     ($ty:ident, $method:ident, $($visit:ident),*) => {
 116         impl<'de> Deserialize<'de> for $ty {
 117             #[inline]
 118             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 119             where
 120                 D: Deserializer<'de>,
 121             {
 122                 struct PrimitiveVisitor;
 123
 124                 impl<'de> Visitor<'de> for PrimitiveVisitor {
 125                     type Value = $ty;
 126
 127                     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 128                         formatter.write_str(stringify!($ty))
 129                     }
 130
 131                     $(
 132                         impl_deserialize_num!($visit $ty);
 133                     )*
 134                 }
 135
 136                 deserializer.$method(PrimitiveVisitor)
 137             }
 138         }
 139     };
 140
 141     (integer $ty:ident) => {
 142         visit_integer_method!(i8, visit_i8, from_i8, Signed, i64);
 143         visit_integer_method!(i16, visit_i16, from_i16, Signed, i64);
 144         visit_integer_method!(i32, visit_i32, from_i32, Signed, i64);
 145         visit_integer_method!(i64, visit_i64, from_i64, Signed, i64);
 146
 147         visit_integer_method!(u8, visit_u8, from_u8, Unsigned, u64);
 148         visit_integer_method!(u16, visit_u16, from_u16, Unsigned, u64);
 149         visit_integer_method!(u32, visit_u32, from_u32, Unsigned, u64);
 150         visit_integer_method!(u64, visit_u64, from_u64, Unsigned, u64);
 151     };
 152
 153     (float $ty:ident) => {
 154         visit_float_method!(f32, visit_f32);
 155         visit_float_method!(f64, visit_f64);
 156     };
 157 }
 158
 159 impl_deserialize_num!(i8, deserialize_i8, integer);
 160 impl_deserialize_num!(i16, deserialize_i16, integer);
 161 impl_deserialize_num!(i32, deserialize_i32, integer);
 162 impl_deserialize_num!(i64, deserialize_i64, integer);
 163 impl_deserialize_num!(isize, deserialize_i64, integer);
 164
 165 impl_deserialize_num!(u8, deserialize_u8, integer);
 166 impl_deserialize_num!(u16, deserialize_u16, integer);
 167 impl_deserialize_num!(u32, deserialize_u32, integer);
 168 impl_deserialize_num!(u64, deserialize_u64, integer);
 169 impl_deserialize_num!(usize, deserialize_u64, integer);
 170
 171 impl_deserialize_num!(f32, deserialize_f32, integer, float);
 172 impl_deserialize_num!(f64, deserialize_f64, integer, float);
 173
 174 serde_if_integer128! {
 175     impl<'de> Deserialize<'de> for i128 {
 176         #[inline]
 177         fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 178         where
 179             D: Deserializer<'de>,
 180         {
 181             struct PrimitiveVisitor;
 182
 183             impl<'de> Visitor<'de> for PrimitiveVisitor {
 184                 type Value = i128;
 185
 186                 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 187                     formatter.write_str("i128")
 188                 }
 189
 190                 impl_deserialize_num!(integer i128);
 191
 192                 #[inline]
 193                 fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
 194                 where
 195                     E: Error,
 196                 {
 197                     Ok(v)
 198                 }
 199
 200                 #[inline]
 201                 fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
 202                 where
 203                     E: Error,
 204                 {
 205                     if v <= i128::max_value() as u128 {
 206                         Ok(v as i128)
 207                     } else {
 208                         Err(Error::invalid_value(Unexpected::Other("u128"), &self))
 209                     }
 210                 }
 211             }
 212
 213             deserializer.deserialize_i128(PrimitiveVisitor)
 214         }
 215     }
 216
 217     impl<'de> Deserialize<'de> for u128 {
 218         #[inline]
 219         fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 220         where
 221             D: Deserializer<'de>,
 222         {
 223             struct PrimitiveVisitor;
 224
 225             impl<'de> Visitor<'de> for PrimitiveVisitor {
 226                 type Value = u128;
 227
 228                 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 229                     formatter.write_str("u128")
 230                 }
 231
 232                 impl_deserialize_num!(integer u128);
 233
 234                 #[inline]
 235                 fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
 236                 where
 237                     E: Error,
 238                 {
 239                     if v >= 0 {
 240                         Ok(v as u128)
 241                     } else {
 242                         Err(Error::invalid_value(Unexpected::Other("i128"), &self))
 243                     }
 244                 }
 245
 246                 #[inline]
 247                 fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
 248                 where
 249                     E: Error,
 250                 {
 251                     Ok(v)
 252                 }
 253             }
 254
 255             deserializer.deserialize_u128(PrimitiveVisitor)
 256         }
 257     }
 258 }
 259
 260 ////////////////////////////////////////////////////////////////////////////////
 261
 262 struct CharVisitor;
 263
 264 impl<'de> Visitor<'de> for CharVisitor {
 265     type Value = char;
 266
 267     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 268         formatter.write_str("a character")
 269     }
 270
 271     #[inline]
 272     fn visit_char<E>(self, v: char) -> Result<Self::Value, E>
 273     where
 274         E: Error,
 275     {
 276         Ok(v)
 277     }
 278
 279     #[inline]
 280     fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
 281     where
 282         E: Error,
 283     {
 284         let mut iter = v.chars();
 285         match (iter.next(), iter.next()) {
 286             (Some(c), None) => Ok(c),
 287             _ => Err(Error::invalid_value(Unexpected::Str(v), &self)),
 288         }
 289     }
 290 }
 291
 292 impl<'de> Deserialize<'de> for char {
 293     #[inline]
 294     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 295     where
 296         D: Deserializer<'de>,
 297     {
 298         deserializer.deserialize_char(CharVisitor)
 299     }
 300 }
 301
 302 ////////////////////////////////////////////////////////////////////////////////
 303
 304 #[cfg(any(feature = "std", feature = "alloc"))]
 305 struct StringVisitor;
 306 #[cfg(any(feature = "std", feature = "alloc"))]
 307 struct StringInPlaceVisitor<'a>(&'a mut String);
 308
 309 #[cfg(any(feature = "std", feature = "alloc"))]
 310 impl<'de> Visitor<'de> for StringVisitor {
 311     type Value = String;
 312
 313     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 314         formatter.write_str("a string")
 315     }
 316
 317     fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
 318     where
 319         E: Error,
 320     {
 321         Ok(v.to_owned())
 322     }
 323
 324     fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
 325     where
 326         E: Error,
 327     {
 328         Ok(v)
 329     }
 330
 331     fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
 332     where
 333         E: Error,
 334     {
 335         match str::from_utf8(v) {
 336             Ok(s) => Ok(s.to_owned()),
 337             Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
 338         }
 339     }
 340
 341     fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
 342     where
 343         E: Error,
 344     {
 345         match String::from_utf8(v) {
 346             Ok(s) => Ok(s),
 347             Err(e) => Err(Error::invalid_value(
 348                 Unexpected::Bytes(&e.into_bytes()),
 349                 &self,
 350             )),
 351         }
 352     }
 353 }
 354
 355 #[cfg(any(feature = "std", feature = "alloc"))]
 356 impl<'a, 'de> Visitor<'de> for StringInPlaceVisitor<'a> {
 357     type Value = ();
 358
 359     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 360         formatter.write_str("a string")
 361     }
 362
 363     fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
 364     where
 365         E: Error,
 366     {
 367         self.0.clear();
 368         self.0.push_str(v);
 369         Ok(())
 370     }
 371
 372     fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
 373     where
 374         E: Error,
 375     {
 376         *self.0 = v;
 377         Ok(())
 378     }
 379
 380     fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
 381     where
 382         E: Error,
 383     {
 384         match str::from_utf8(v) {
 385             Ok(s) => {
 386                 self.0.clear();
 387                 self.0.push_str(s);
 388                 Ok(())
 389             }
 390             Err(_) => Err(Error::invalid_value(Unexpected::Bytes(v), &self)),
 391         }
 392     }
 393
 394     fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
 395     where
 396         E: Error,
 397     {
 398         match String::from_utf8(v) {
 399             Ok(s) => {
 400                 *self.0 = s;
 401                 Ok(())
 402             }
 403             Err(e) => Err(Error::invalid_value(
 404                 Unexpected::Bytes(&e.into_bytes()),
 405                 &self,
 406             )),
 407         }
 408     }
 409 }
 410
 411 #[cfg(any(feature = "std", feature = "alloc"))]
 412 impl<'de> Deserialize<'de> for String {
 413     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 414     where
 415         D: Deserializer<'de>,
 416     {
 417         deserializer.deserialize_string(StringVisitor)
 418     }
 419
 420     fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
 421     where
 422         D: Deserializer<'de>,
 423     {
 424         deserializer.deserialize_string(StringInPlaceVisitor(place))
 425     }
 426 }
 427
 428 ////////////////////////////////////////////////////////////////////////////////
 429
 430 struct StrVisitor;
 431
 432 impl<'a> Visitor<'a> for StrVisitor {
 433     type Value = &'a str;
 434
 435     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 436         formatter.write_str("a borrowed string")
 437     }
 438
 439     fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
 440     where
 441         E: Error,
 442     {
 443         Ok(v) // so easy
 444     }
 445
 446     fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
 447     where
 448         E: Error,
 449     {
 450         str::from_utf8(v).map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
 451     }
 452 }
 453
 454 impl<'de: 'a, 'a> Deserialize<'de> for &'a str {
 455     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 456     where
 457         D: Deserializer<'de>,
 458     {
 459         deserializer.deserialize_str(StrVisitor)
 460     }
 461 }
 462
 463 ////////////////////////////////////////////////////////////////////////////////
 464
 465 struct BytesVisitor;
 466
 467 impl<'a> Visitor<'a> for BytesVisitor {
 468     type Value = &'a [u8];
 469
 470     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 471         formatter.write_str("a borrowed byte array")
 472     }
 473
 474     fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
 475     where
 476         E: Error,
 477     {
 478         Ok(v)
 479     }
 480
 481     fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
 482     where
 483         E: Error,
 484     {
 485         Ok(v.as_bytes())
 486     }
 487 }
 488
 489 impl<'de: 'a, 'a> Deserialize<'de> for &'a [u8] {
 490     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 491     where
 492         D: Deserializer<'de>,
 493     {
 494         deserializer.deserialize_bytes(BytesVisitor)
 495     }
 496 }
 497
 498 ////////////////////////////////////////////////////////////////////////////////
 499
 500 #[cfg(feature = "std")]
 501 struct CStringVisitor;
 502
 503 #[cfg(feature = "std")]
 504 impl<'de> Visitor<'de> for CStringVisitor {
 505     type Value = CString;
 506
 507     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 508         formatter.write_str("byte array")
 509     }
 510
 511     fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
 512     where
 513         A: SeqAccess<'de>,
 514     {
 515         let len = size_hint::cautious(seq.size_hint());
 516         let mut values = Vec::with_capacity(len);
 517
 518         while let Some(value) = try!(seq.next_element()) {
 519             values.push(value);
 520         }
 521
 522         CString::new(values).map_err(Error::custom)
 523     }
 524
 525     fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
 526     where
 527         E: Error,
 528     {
 529         CString::new(v).map_err(Error::custom)
 530     }
 531
 532     fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
 533     where
 534         E: Error,
 535     {
 536         CString::new(v).map_err(Error::custom)
 537     }
 538
 539     fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
 540     where
 541         E: Error,
 542     {
 543         CString::new(v).map_err(Error::custom)
 544     }
 545
 546     fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
 547     where
 548         E: Error,
 549     {
 550         CString::new(v).map_err(Error::custom)
 551     }
 552 }
 553
 554 #[cfg(feature = "std")]
 555 impl<'de> Deserialize<'de> for CString {
 556     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 557     where
 558         D: Deserializer<'de>,
 559     {
 560         deserializer.deserialize_byte_buf(CStringVisitor)
 561     }
 562 }
 563
 564 macro_rules! forwarded_impl {
 565     (
 566         $(#[doc = $doc:tt])*
 567         ( $($id: ident),* ), $ty: ty, $func: expr
 568     ) => {
 569         $(#[doc = $doc])*
 570         impl<'de $(, $id : Deserialize<'de>,)*> Deserialize<'de> for $ty {
 571             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 572             where
 573                 D: Deserializer<'de>,
 574             {
 575                 Deserialize::deserialize(deserializer).map($func)
 576             }
 577         }
 578     }
 579 }
 580
 581 #[cfg(all(feature = "std", de_boxed_c_str))]
 582 forwarded_impl!((), Box<CStr>, CString::into_boxed_c_str);
 583
 584 #[cfg(core_reverse)]
 585 forwarded_impl!((T), Reverse<T>, Reverse);
 586
 587 ////////////////////////////////////////////////////////////////////////////////
 588
 589 struct OptionVisitor<T> {
 590     marker: PhantomData<T>,
 591 }
 592
 593 impl<'de, T> Visitor<'de> for OptionVisitor<T>
 594 where
 595     T: Deserialize<'de>,
 596 {
 597     type Value = Option<T>;
 598
 599     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 600         formatter.write_str("option")
 601     }
 602
 603     #[inline]
 604     fn visit_unit<E>(self) -> Result<Self::Value, E>
 605     where
 606         E: Error,
 607     {
 608         Ok(None)
 609     }
 610
 611     #[inline]
 612     fn visit_none<E>(self) -> Result<Self::Value, E>
 613     where
 614         E: Error,
 615     {
 616         Ok(None)
 617     }
 618
 619     #[inline]
 620     fn visit_some<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
 621     where
 622         D: Deserializer<'de>,
 623     {
 624         T::deserialize(deserializer).map(Some)
 625     }
 626
 627     #[doc(hidden)]
 628     fn __private_visit_untagged_option<D>(self, deserializer: D) -> Result<Self::Value, ()>
 629     where
 630         D: Deserializer<'de>,
 631     {
 632         Ok(T::deserialize(deserializer).ok())
 633     }
 634 }
 635
 636 impl<'de, T> Deserialize<'de> for Option<T>
 637 where
 638     T: Deserialize<'de>,
 639 {
 640     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 641     where
 642         D: Deserializer<'de>,
 643     {
 644         deserializer.deserialize_option(OptionVisitor {
 645             marker: PhantomData,
 646         })
 647     }
 648
 649     // The Some variant's repr is opaque, so we can't play cute tricks with its
 650     // tag to have deserialize_in_place build the content in place unconditionally.
 651     //
 652     // FIXME: investigate whether branching on the old value being Some to
 653     // deserialize_in_place the value is profitable (probably data-dependent?)
 654 }
 655
 656 ////////////////////////////////////////////////////////////////////////////////
 657
 658 struct PhantomDataVisitor<T: ?Sized> {
 659     marker: PhantomData<T>,
 660 }
 661
 662 impl<'de, T: ?Sized> Visitor<'de> for PhantomDataVisitor<T> {
 663     type Value = PhantomData<T>;
 664
 665     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 666         formatter.write_str("unit")
 667     }
 668
 669     #[inline]
 670     fn visit_unit<E>(self) -> Result<Self::Value, E>
 671     where
 672         E: Error,
 673     {
 674         Ok(PhantomData)
 675     }
 676 }
 677
 678 impl<'de, T: ?Sized> Deserialize<'de> for PhantomData<T> {
 679     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 680     where
 681         D: Deserializer<'de>,
 682     {
 683         let visitor = PhantomDataVisitor {
 684             marker: PhantomData,
 685         };
 686         deserializer.deserialize_unit_struct("PhantomData", visitor)
 687     }
 688 }
 689
 690 ////////////////////////////////////////////////////////////////////////////////
 691
 692 #[cfg(any(feature = "std", feature = "alloc"))]
 693 macro_rules! seq_impl {
 694     (
 695         $ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >,
 696         $access:ident,
 697         $clear:expr,
 698         $with_capacity:expr,
 699         $reserve:expr,
 700         $insert:expr
 701     ) => {
 702         impl<'de, T $(, $typaram)*> Deserialize<'de> for $ty<T $(, $typaram)*>
 703         where
 704             T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*,
 705             $($typaram: $bound1 $(+ $bound2)*,)*
 706         {
 707             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 708             where
 709                 D: Deserializer<'de>,
 710             {
 711                 struct SeqVisitor<T $(, $typaram)*> {
 712                     marker: PhantomData<$ty<T $(, $typaram)*>>,
 713                 }
 714
 715                 impl<'de, T $(, $typaram)*> Visitor<'de> for SeqVisitor<T $(, $typaram)*>
 716                 where
 717                     T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*,
 718                     $($typaram: $bound1 $(+ $bound2)*,)*
 719                 {
 720                     type Value = $ty<T $(, $typaram)*>;
 721
 722                     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 723                         formatter.write_str("a sequence")
 724                     }
 725
 726                     #[inline]
 727                     fn visit_seq<A>(self, mut $access: A) -> Result<Self::Value, A::Error>
 728                     where
 729                         A: SeqAccess<'de>,
 730                     {
 731                         let mut values = $with_capacity;
 732
 733                         while let Some(value) = try!($access.next_element()) {
 734                             $insert(&mut values, value);
 735                         }
 736
 737                         Ok(values)
 738                     }
 739                 }
 740
 741                 let visitor = SeqVisitor { marker: PhantomData };
 742                 deserializer.deserialize_seq(visitor)
 743             }
 744
 745             fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
 746             where
 747                 D: Deserializer<'de>,
 748             {
 749                 struct SeqInPlaceVisitor<'a, T: 'a $(, $typaram: 'a)*>(&'a mut $ty<T $(, $typaram)*>);
 750
 751                 impl<'a, 'de, T $(, $typaram)*> Visitor<'de> for SeqInPlaceVisitor<'a, T $(, $typaram)*>
 752                 where
 753                     T: Deserialize<'de> $(+ $tbound1 $(+ $tbound2)*)*,
 754                     $($typaram: $bound1 $(+ $bound2)*,)*
 755                 {
 756                     type Value = ();
 757
 758                     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 759                         formatter.write_str("a sequence")
 760                     }
 761
 762                     #[inline]
 763                     fn visit_seq<A>(mut self, mut $access: A) -> Result<Self::Value, A::Error>
 764                     where
 765                         A: SeqAccess<'de>,
 766                     {
 767                         $clear(&mut self.0);
 768                         $reserve(&mut self.0, size_hint::cautious($access.size_hint()));
 769
 770                         // FIXME: try to overwrite old values here? (Vec, VecDeque, LinkedList)
 771                         while let Some(value) = try!($access.next_element()) {
 772                             $insert(&mut self.0, value);
 773                         }
 774
 775                         Ok(())
 776                     }
 777                 }
 778
 779                 deserializer.deserialize_seq(SeqInPlaceVisitor(place))
 780             }
 781         }
 782     }
 783 }
 784
 785 // Dummy impl of reserve
 786 #[cfg(any(feature = "std", feature = "alloc"))]
 787 fn nop_reserve<T>(_seq: T, _n: usize) {}
 788
 789 #[cfg(any(feature = "std", feature = "alloc"))]
 790 seq_impl!(
 791     BinaryHeap<T: Ord>,
 792     seq,
 793     BinaryHeap::clear,
 794     BinaryHeap::with_capacity(size_hint::cautious(seq.size_hint())),
 795     BinaryHeap::reserve,
 796     BinaryHeap::push
 797 );
 798
 799 #[cfg(any(feature = "std", feature = "alloc"))]
 800 seq_impl!(
 801     BTreeSet<T: Eq + Ord>,
 802     seq,
 803     BTreeSet::clear,
 804     BTreeSet::new(),
 805     nop_reserve,
 806     BTreeSet::insert
 807 );
 808
 809 #[cfg(any(feature = "std", feature = "alloc"))]
 810 seq_impl!(
 811     LinkedList<T>,
 812     seq,
 813     LinkedList::clear,
 814     LinkedList::new(),
 815     nop_reserve,
 816     LinkedList::push_back
 817 );
 818
 819 #[cfg(feature = "std")]
 820 seq_impl!(
 821     HashSet<T: Eq + Hash, S: BuildHasher + Default>,
 822     seq,
 823     HashSet::clear,
 824     HashSet::with_capacity_and_hasher(size_hint::cautious(seq.size_hint()), S::default()),
 825     HashSet::reserve,
 826     HashSet::insert);
 827
 828 #[cfg(any(feature = "std", feature = "alloc"))]
 829 seq_impl!(
 830     VecDeque<T>,
 831     seq,
 832     VecDeque::clear,
 833     VecDeque::with_capacity(size_hint::cautious(seq.size_hint())),
 834     VecDeque::reserve,
 835     VecDeque::push_back
 836 );
 837
 838 ////////////////////////////////////////////////////////////////////////////////
 839
 840 #[cfg(any(feature = "std", feature = "alloc"))]
 841 impl<'de, T> Deserialize<'de> for Vec<T>
 842 where
 843     T: Deserialize<'de>,
 844 {
 845     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 846     where
 847         D: Deserializer<'de>,
 848     {
 849         struct VecVisitor<T> {
 850             marker: PhantomData<T>,
 851         }
 852
 853         impl<'de, T> Visitor<'de> for VecVisitor<T>
 854         where
 855             T: Deserialize<'de>,
 856         {
 857             type Value = Vec<T>;
 858
 859             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 860                 formatter.write_str("a sequence")
 861             }
 862
 863             fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
 864             where
 865                 A: SeqAccess<'de>,
 866             {
 867                 let mut values = Vec::with_capacity(size_hint::cautious(seq.size_hint()));
 868
 869                 while let Some(value) = try!(seq.next_element()) {
 870                     values.push(value);
 871                 }
 872
 873                 Ok(values)
 874             }
 875         }
 876
 877         let visitor = VecVisitor {
 878             marker: PhantomData,
 879         };
 880         deserializer.deserialize_seq(visitor)
 881     }
 882
 883     fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
 884     where
 885         D: Deserializer<'de>,
 886     {
 887         struct VecInPlaceVisitor<'a, T: 'a>(&'a mut Vec<T>);
 888
 889         impl<'a, 'de, T> Visitor<'de> for VecInPlaceVisitor<'a, T>
 890         where
 891             T: Deserialize<'de>,
 892         {
 893             type Value = ();
 894
 895             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 896                 formatter.write_str("a sequence")
 897             }
 898
 899             fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
 900             where
 901                 A: SeqAccess<'de>,
 902             {
 903                 let hint = size_hint::cautious(seq.size_hint());
 904                 if let Some(additional) = hint.checked_sub(self.0.len()) {
 905                     self.0.reserve(additional);
 906                 }
 907
 908                 for i in 0..self.0.len() {
 909                     let next = {
 910                         let next_place = InPlaceSeed(&mut self.0[i]);
 911                         try!(seq.next_element_seed(next_place))
 912                     };
 913                     if next.is_none() {
 914                         self.0.truncate(i);
 915                         return Ok(());
 916                     }
 917                 }
 918
 919                 while let Some(value) = try!(seq.next_element()) {
 920                     self.0.push(value);
 921                 }
 922
 923                 Ok(())
 924             }
 925         }
 926
 927         deserializer.deserialize_seq(VecInPlaceVisitor(place))
 928     }
 929 }
 930
 931 ////////////////////////////////////////////////////////////////////////////////
 932
 933 struct ArrayVisitor<A> {
 934     marker: PhantomData<A>,
 935 }
 936 struct ArrayInPlaceVisitor<'a, A: 'a>(&'a mut A);
 937
 938 impl<A> ArrayVisitor<A> {
 939     fn new() -> Self {
 940         ArrayVisitor {
 941             marker: PhantomData,
 942         }
 943     }
 944 }
 945
 946 impl<'de, T> Visitor<'de> for ArrayVisitor<[T; 0]> {
 947     type Value = [T; 0];
 948
 949     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 950         formatter.write_str("an empty array")
 951     }
 952
 953     #[inline]
 954     fn visit_seq<A>(self, _: A) -> Result<Self::Value, A::Error>
 955     where
 956         A: SeqAccess<'de>,
 957     {
 958         Ok([])
 959     }
 960 }
 961
 962 // Does not require T: Deserialize<'de>.
 963 impl<'de, T> Deserialize<'de> for [T; 0] {
 964     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
 965     where
 966         D: Deserializer<'de>,
 967     {
 968         deserializer.deserialize_tuple(0, ArrayVisitor::<[T; 0]>::new())
 969     }
 970 }
 971
 972 macro_rules! array_impls {
 973     ($($len:expr => ($($n:tt)+))+) => {
 974         $(
 975             impl<'de, T> Visitor<'de> for ArrayVisitor<[T; $len]>
 976             where
 977                 T: Deserialize<'de>,
 978             {
 979                 type Value = [T; $len];
 980
 981                 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
 982                     formatter.write_str(concat!("an array of length ", $len))
 983                 }
 984
 985                 #[inline]
 986                 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
 987                 where
 988                     A: SeqAccess<'de>,
 989                 {
 990                     Ok([$(
 991                         match try!(seq.next_element()) {
 992                             Some(val) => val,
 993                             None => return Err(Error::invalid_length($n, &self)),
 994                         }
 995                     ),+])
 996                 }
 997             }
 998
 999             impl<'a, 'de, T> Visitor<'de> for ArrayInPlaceVisitor<'a, [T; $len]>
1000             where
1001                 T: Deserialize<'de>,
1002             {
1003                 type Value = ();
1004
1005                 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1006                     formatter.write_str(concat!("an array of length ", $len))
1007                 }
1008
1009                 #[inline]
1010                 fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
1011                 where
1012                     A: SeqAccess<'de>,
1013                 {
1014                     let mut fail_idx = None;
1015                     for (idx, dest) in self.0[..].iter_mut().enumerate() {
1016                         if try!(seq.next_element_seed(InPlaceSeed(dest))).is_none() {
1017                             fail_idx = Some(idx);
1018                             break;
1019                         }
1020                     }
1021                     if let Some(idx) = fail_idx {
1022                         return Err(Error::invalid_length(idx, &self));
1023                     }
1024                     Ok(())
1025                 }
1026             }
1027
1028             impl<'de, T> Deserialize<'de> for [T; $len]
1029             where
1030                 T: Deserialize<'de>,
1031             {
1032                 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1033                 where
1034                     D: Deserializer<'de>,
1035                 {
1036                     deserializer.deserialize_tuple($len, ArrayVisitor::<[T; $len]>::new())
1037                 }
1038
1039                 fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
1040                 where
1041                     D: Deserializer<'de>,
1042                 {
1043                     deserializer.deserialize_tuple($len, ArrayInPlaceVisitor(place))
1044                 }
1045             }
1046         )+
1047     }
1048 }
1049
1050 array_impls! {
1051     1 => (0)
1052     2 => (0 1)
1053     3 => (0 1 2)
1054     4 => (0 1 2 3)
1055     5 => (0 1 2 3 4)
1056     6 => (0 1 2 3 4 5)
1057     7 => (0 1 2 3 4 5 6)
1058     8 => (0 1 2 3 4 5 6 7)
1059     9 => (0 1 2 3 4 5 6 7 8)
1060     10 => (0 1 2 3 4 5 6 7 8 9)
1061     11 => (0 1 2 3 4 5 6 7 8 9 10)
1062     12 => (0 1 2 3 4 5 6 7 8 9 10 11)
1063     13 => (0 1 2 3 4 5 6 7 8 9 10 11 12)
1064     14 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13)
1065     15 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14)
1066     16 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
1067     17 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
1068     18 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17)
1069     19 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18)
1070     20 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19)
1071     21 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20)
1072     22 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21)
1073     23 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22)
1074     24 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23)
1075     25 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24)
1076     26 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25)
1077     27 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26)
1078     28 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27)
1079     29 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28)
1080     30 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29)
1081     31 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
1082     32 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
1083 }
1084
1085 ////////////////////////////////////////////////////////////////////////////////
1086
1087 macro_rules! tuple_impls {
1088     ($($len:tt => ($($n:tt $name:ident)+))+) => {
1089         $(
1090             impl<'de, $($name: Deserialize<'de>),+> Deserialize<'de> for ($($name,)+) {
1091                 #[inline]
1092                 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1093                 where
1094                     D: Deserializer<'de>,
1095                 {
1096                     struct TupleVisitor<$($name,)+> {
1097                         marker: PhantomData<($($name,)+)>,
1098                     }
1099
1100                     impl<'de, $($name: Deserialize<'de>),+> Visitor<'de> for TupleVisitor<$($name,)+> {
1101                         type Value = ($($name,)+);
1102
1103                         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1104                             formatter.write_str(concat!("a tuple of size ", $len))
1105                         }
1106
1107                         #[inline]
1108                         #[allow(non_snake_case)]
1109                         fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
1110                         where
1111                             A: SeqAccess<'de>,
1112                         {
1113                             $(
1114                                 let $name = match try!(seq.next_element()) {
1115                                     Some(value) => value,
1116                                     None => return Err(Error::invalid_length($n, &self)),
1117                                 };
1118                             )+
1119
1120                             Ok(($($name,)+))
1121                         }
1122                     }
1123
1124                     deserializer.deserialize_tuple($len, TupleVisitor { marker: PhantomData })
1125                 }
1126
1127                 #[inline]
1128                 fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
1129                 where
1130                     D: Deserializer<'de>,
1131                 {
1132                     struct TupleInPlaceVisitor<'a, $($name: 'a,)+>(&'a mut ($($name,)+));
1133
1134                     impl<'a, 'de, $($name: Deserialize<'de>),+> Visitor<'de> for TupleInPlaceVisitor<'a, $($name,)+> {
1135                         type Value = ();
1136
1137                         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1138                             formatter.write_str(concat!("a tuple of size ", $len))
1139                         }
1140
1141                         #[inline]
1142                         #[allow(non_snake_case)]
1143                         fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
1144                         where
1145                             A: SeqAccess<'de>,
1146                         {
1147                             $(
1148                                 if try!(seq.next_element_seed(InPlaceSeed(&mut (self.0).$n))).is_none() {
1149                                     return Err(Error::invalid_length($n, &self));
1150                                 }
1151                             )+
1152
1153                             Ok(())
1154                         }
1155                     }
1156
1157                     deserializer.deserialize_tuple($len, TupleInPlaceVisitor(place))
1158                 }
1159             }
1160         )+
1161     }
1162 }
1163
1164 tuple_impls! {
1165     1  => (0 T0)
1166     2  => (0 T0 1 T1)
1167     3  => (0 T0 1 T1 2 T2)
1168     4  => (0 T0 1 T1 2 T2 3 T3)
1169     5  => (0 T0 1 T1 2 T2 3 T3 4 T4)
1170     6  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5)
1171     7  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6)
1172     8  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7)
1173     9  => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8)
1174     10 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9)
1175     11 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10)
1176     12 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11)
1177     13 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12)
1178     14 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13)
1179     15 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14)
1180     16 => (0 T0 1 T1 2 T2 3 T3 4 T4 5 T5 6 T6 7 T7 8 T8 9 T9 10 T10 11 T11 12 T12 13 T13 14 T14 15 T15)
1181 }
1182
1183 ////////////////////////////////////////////////////////////////////////////////
1184
1185 #[cfg(any(feature = "std", feature = "alloc"))]
1186 macro_rules! map_impl {
1187     (
1188         $ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >,
1189         $access:ident,
1190         $with_capacity:expr
1191     ) => {
1192         impl<'de, K, V $(, $typaram)*> Deserialize<'de> for $ty<K, V $(, $typaram)*>
1193         where
1194             K: Deserialize<'de> $(+ $kbound1 $(+ $kbound2)*)*,
1195             V: Deserialize<'de>,
1196             $($typaram: $bound1 $(+ $bound2)*),*
1197         {
1198             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1199             where
1200                 D: Deserializer<'de>,
1201             {
1202                 struct MapVisitor<K, V $(, $typaram)*> {
1203                     marker: PhantomData<$ty<K, V $(, $typaram)*>>,
1204                 }
1205
1206                 impl<'de, K, V $(, $typaram)*> Visitor<'de> for MapVisitor<K, V $(, $typaram)*>
1207                 where
1208                     K: Deserialize<'de> $(+ $kbound1 $(+ $kbound2)*)*,
1209                     V: Deserialize<'de>,
1210                     $($typaram: $bound1 $(+ $bound2)*),*
1211                 {
1212                     type Value = $ty<K, V $(, $typaram)*>;
1213
1214                     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1215                         formatter.write_str("a map")
1216                     }
1217
1218                     #[inline]
1219                     fn visit_map<A>(self, mut $access: A) -> Result<Self::Value, A::Error>
1220                     where
1221                         A: MapAccess<'de>,
1222                     {
1223                         let mut values = $with_capacity;
1224
1225                         while let Some((key, value)) = try!($access.next_entry()) {
1226                             values.insert(key, value);
1227                         }
1228
1229                         Ok(values)
1230                     }
1231                 }
1232
1233                 let visitor = MapVisitor { marker: PhantomData };
1234                 deserializer.deserialize_map(visitor)
1235             }
1236         }
1237     }
1238 }
1239
1240 #[cfg(any(feature = "std", feature = "alloc"))]
1241 map_impl!(
1242     BTreeMap<K: Ord, V>,
1243     map,
1244     BTreeMap::new());
1245
1246 #[cfg(feature = "std")]
1247 map_impl!(
1248     HashMap<K: Eq + Hash, V, S: BuildHasher + Default>,
1249     map,
1250     HashMap::with_capacity_and_hasher(size_hint::cautious(map.size_hint()), S::default()));
1251
1252 ////////////////////////////////////////////////////////////////////////////////
1253
1254 #[cfg(feature = "std")]
1255 macro_rules! parse_ip_impl {
1256     ($expecting:tt $ty:ty; $size:tt) => {
1257         impl<'de> Deserialize<'de> for $ty {
1258             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1259             where
1260                 D: Deserializer<'de>,
1261             {
1262                 if deserializer.is_human_readable() {
1263                     struct IpAddrVisitor;
1264
1265                     impl<'de> Visitor<'de> for IpAddrVisitor {
1266                         type Value = $ty;
1267
1268                         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1269                             formatter.write_str($expecting)
1270                         }
1271
1272                         fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1273                         where
1274                             E: Error,
1275                         {
1276                             s.parse().map_err(Error::custom)
1277                         }
1278                     }
1279
1280                     deserializer.deserialize_str(IpAddrVisitor)
1281                 } else {
1282                     <[u8; $size]>::deserialize(deserializer).map(<$ty>::from)
1283                 }
1284             }
1285         }
1286     };
1287 }
1288
1289 #[cfg(feature = "std")]
1290 macro_rules! variant_identifier {
1291     (
1292         $name_kind: ident ( $($variant: ident; $bytes: expr; $index: expr),* )
1293         $expecting_message: expr,
1294         $variants_name: ident
1295     ) => {
1296         enum $name_kind {
1297             $( $variant ),*
1298         }
1299
1300         static $variants_name: &'static [&'static str] = &[ $( stringify!($variant) ),*];
1301
1302         impl<'de> Deserialize<'de> for $name_kind {
1303             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1304             where
1305                 D: Deserializer<'de>,
1306             {
1307                 struct KindVisitor;
1308
1309                 impl<'de> Visitor<'de> for KindVisitor {
1310                     type Value = $name_kind;
1311
1312                     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1313                         formatter.write_str($expecting_message)
1314                     }
1315
1316                     fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
1317                     where
1318                         E: Error,
1319                     {
1320                         match value {
1321                             $(
1322                                 $index => Ok($name_kind :: $variant),
1323                             )*
1324                             _ => Err(Error::invalid_value(Unexpected::Unsigned(value as u64), &self),),
1325                         }
1326                     }
1327
1328                     fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1329                     where
1330                         E: Error,
1331                     {
1332                         match value {
1333                             $(
1334                                 stringify!($variant) => Ok($name_kind :: $variant),
1335                             )*
1336                             _ => Err(Error::unknown_variant(value, $variants_name)),
1337                         }
1338                     }
1339
1340                     fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
1341                     where
1342                         E: Error,
1343                     {
1344                         match value {
1345                             $(
1346                                 $bytes => Ok($name_kind :: $variant),
1347                             )*
1348                             _ => {
1349                                 match str::from_utf8(value) {
1350                                     Ok(value) => Err(Error::unknown_variant(value, $variants_name)),
1351                                     Err(_) => Err(Error::invalid_value(Unexpected::Bytes(value), &self)),
1352                                 }
1353                             }
1354                         }
1355                     }
1356                 }
1357
1358                 deserializer.deserialize_identifier(KindVisitor)
1359             }
1360         }
1361     }
1362 }
1363
1364 #[cfg(feature = "std")]
1365 macro_rules! deserialize_enum {
1366     (
1367         $name: ident $name_kind: ident ( $($variant: ident; $bytes: expr; $index: expr),* )
1368         $expecting_message: expr,
1369         $deserializer: expr
1370     ) => {
1371         variant_identifier!{
1372             $name_kind ( $($variant; $bytes; $index),* )
1373             $expecting_message,
1374             VARIANTS
1375         }
1376
1377         struct EnumVisitor;
1378         impl<'de> Visitor<'de> for EnumVisitor {
1379             type Value = $name;
1380
1381             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1382                 formatter.write_str(concat!("a ", stringify!($name)))
1383             }
1384
1385
1386             fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1387             where
1388                 A: EnumAccess<'de>,
1389             {
1390                 match try!(data.variant()) {
1391                     $(
1392                         ($name_kind :: $variant, v) => v.newtype_variant().map($name :: $variant),
1393                     )*
1394                 }
1395             }
1396         }
1397         $deserializer.deserialize_enum(stringify!($name), VARIANTS, EnumVisitor)
1398     }
1399 }
1400
1401 #[cfg(feature = "std")]
1402 impl<'de> Deserialize<'de> for net::IpAddr {
1403     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1404     where
1405         D: Deserializer<'de>,
1406     {
1407         if deserializer.is_human_readable() {
1408             struct IpAddrVisitor;
1409
1410             impl<'de> Visitor<'de> for IpAddrVisitor {
1411                 type Value = net::IpAddr;
1412
1413                 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1414                     formatter.write_str("IP address")
1415                 }
1416
1417                 fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1418                 where
1419                     E: Error,
1420                 {
1421                     s.parse().map_err(Error::custom)
1422                 }
1423             }
1424
1425             deserializer.deserialize_str(IpAddrVisitor)
1426         } else {
1427             use lib::net::IpAddr;
1428             deserialize_enum! {
1429                 IpAddr IpAddrKind (V4; b"V4"; 0, V6; b"V6"; 1)
1430                 "`V4` or `V6`",
1431                 deserializer
1432             }
1433         }
1434     }
1435 }
1436
1437 #[cfg(feature = "std")]
1438 parse_ip_impl!("IPv4 address" net::Ipv4Addr; 4);
1439
1440 #[cfg(feature = "std")]
1441 parse_ip_impl!("IPv6 address" net::Ipv6Addr; 16);
1442
1443 #[cfg(feature = "std")]
1444 macro_rules! parse_socket_impl {
1445     ($expecting:tt $ty:ty, $new:expr) => {
1446         impl<'de> Deserialize<'de> for $ty {
1447             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1448             where
1449                 D: Deserializer<'de>,
1450             {
1451                 if deserializer.is_human_readable() {
1452                     struct SocketAddrVisitor;
1453
1454                     impl<'de> Visitor<'de> for SocketAddrVisitor {
1455                         type Value = $ty;
1456
1457                         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1458                             formatter.write_str($expecting)
1459                         }
1460
1461                         fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1462                         where
1463                             E: Error,
1464                         {
1465                             s.parse().map_err(Error::custom)
1466                         }
1467                     }
1468
1469                     deserializer.deserialize_str(SocketAddrVisitor)
1470                 } else {
1471                     <(_, u16)>::deserialize(deserializer).map(|(ip, port)| $new(ip, port))
1472                 }
1473             }
1474         }
1475     };
1476 }
1477
1478 #[cfg(feature = "std")]
1479 impl<'de> Deserialize<'de> for net::SocketAddr {
1480     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1481     where
1482         D: Deserializer<'de>,
1483     {
1484         if deserializer.is_human_readable() {
1485             struct SocketAddrVisitor;
1486
1487             impl<'de> Visitor<'de> for SocketAddrVisitor {
1488                 type Value = net::SocketAddr;
1489
1490                 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1491                     formatter.write_str("socket address")
1492                 }
1493
1494                 fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
1495                 where
1496                     E: Error,
1497                 {
1498                     s.parse().map_err(Error::custom)
1499                 }
1500             }
1501
1502             deserializer.deserialize_str(SocketAddrVisitor)
1503         } else {
1504             use lib::net::SocketAddr;
1505             deserialize_enum! {
1506                 SocketAddr SocketAddrKind (V4; b"V4"; 0, V6; b"V6"; 1)
1507                 "`V4` or `V6`",
1508                 deserializer
1509             }
1510         }
1511     }
1512 }
1513
1514 #[cfg(feature = "std")]
1515 parse_socket_impl!("IPv4 socket address" net::SocketAddrV4, net::SocketAddrV4::new);
1516
1517 #[cfg(feature = "std")]
1518 parse_socket_impl!("IPv6 socket address" net::SocketAddrV6, |ip, port| net::SocketAddrV6::new(
1519     ip, port, 0, 0
1520 ));
1521
1522 ////////////////////////////////////////////////////////////////////////////////
1523
1524 #[cfg(feature = "std")]
1525 struct PathVisitor;
1526
1527 #[cfg(feature = "std")]
1528 impl<'a> Visitor<'a> for PathVisitor {
1529     type Value = &'a Path;
1530
1531     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1532         formatter.write_str("a borrowed path")
1533     }
1534
1535     fn visit_borrowed_str<E>(self, v: &'a str) -> Result<Self::Value, E>
1536     where
1537         E: Error,
1538     {
1539         Ok(v.as_ref())
1540     }
1541
1542     fn visit_borrowed_bytes<E>(self, v: &'a [u8]) -> Result<Self::Value, E>
1543     where
1544         E: Error,
1545     {
1546         str::from_utf8(v)
1547             .map(AsRef::as_ref)
1548             .map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
1549     }
1550 }
1551
1552 #[cfg(feature = "std")]
1553 impl<'de: 'a, 'a> Deserialize<'de> for &'a Path {
1554     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1555     where
1556         D: Deserializer<'de>,
1557     {
1558         deserializer.deserialize_str(PathVisitor)
1559     }
1560 }
1561
1562 #[cfg(feature = "std")]
1563 struct PathBufVisitor;
1564
1565 #[cfg(feature = "std")]
1566 impl<'de> Visitor<'de> for PathBufVisitor {
1567     type Value = PathBuf;
1568
1569     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1570         formatter.write_str("path string")
1571     }
1572
1573     fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
1574     where
1575         E: Error,
1576     {
1577         Ok(From::from(v))
1578     }
1579
1580     fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
1581     where
1582         E: Error,
1583     {
1584         Ok(From::from(v))
1585     }
1586
1587     fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
1588     where
1589         E: Error,
1590     {
1591         str::from_utf8(v)
1592             .map(From::from)
1593             .map_err(|_| Error::invalid_value(Unexpected::Bytes(v), &self))
1594     }
1595
1596     fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
1597     where
1598         E: Error,
1599     {
1600         String::from_utf8(v)
1601             .map(From::from)
1602             .map_err(|e| Error::invalid_value(Unexpected::Bytes(&e.into_bytes()), &self))
1603     }
1604 }
1605
1606 #[cfg(feature = "std")]
1607 impl<'de> Deserialize<'de> for PathBuf {
1608     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1609     where
1610         D: Deserializer<'de>,
1611     {
1612         deserializer.deserialize_string(PathBufVisitor)
1613     }
1614 }
1615
1616 #[cfg(all(feature = "std", de_boxed_path))]
1617 forwarded_impl!((), Box<Path>, PathBuf::into_boxed_path);
1618
1619 ////////////////////////////////////////////////////////////////////////////////
1620
1621 // If this were outside of the serde crate, it would just use:
1622 //
1623 //    #[derive(Deserialize)]
1624 //    #[serde(variant_identifier)]
1625 #[cfg(all(feature = "std", any(unix, windows)))]
1626 variant_identifier! {
1627     OsStringKind (Unix; b"Unix"; 0, Windows; b"Windows"; 1)
1628     "`Unix` or `Windows`",
1629     OSSTR_VARIANTS
1630 }
1631
1632 #[cfg(all(feature = "std", any(unix, windows)))]
1633 struct OsStringVisitor;
1634
1635 #[cfg(all(feature = "std", any(unix, windows)))]
1636 impl<'de> Visitor<'de> for OsStringVisitor {
1637     type Value = OsString;
1638
1639     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1640         formatter.write_str("os string")
1641     }
1642
1643     #[cfg(unix)]
1644     fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1645     where
1646         A: EnumAccess<'de>,
1647     {
1648         use std::os::unix::ffi::OsStringExt;
1649
1650         match try!(data.variant()) {
1651             (OsStringKind::Unix, v) => v.newtype_variant().map(OsString::from_vec),
1652             (OsStringKind::Windows, _) => Err(Error::custom(
1653                 "cannot deserialize Windows OS string on Unix",
1654             )),
1655         }
1656     }
1657
1658     #[cfg(windows)]
1659     fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
1660     where
1661         A: EnumAccess<'de>,
1662     {
1663         use std::os::windows::ffi::OsStringExt;
1664
1665         match try!(data.variant()) {
1666             (OsStringKind::Windows, v) => v
1667                 .newtype_variant::<Vec<u16>>()
1668                 .map(|vec| OsString::from_wide(&vec)),
1669             (OsStringKind::Unix, _) => Err(Error::custom(
1670                 "cannot deserialize Unix OS string on Windows",
1671             )),
1672         }
1673     }
1674 }
1675
1676 #[cfg(all(feature = "std", any(unix, windows)))]
1677 impl<'de> Deserialize<'de> for OsString {
1678     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1679     where
1680         D: Deserializer<'de>,
1681     {
1682         deserializer.deserialize_enum("OsString", OSSTR_VARIANTS, OsStringVisitor)
1683     }
1684 }
1685
1686 ////////////////////////////////////////////////////////////////////////////////
1687
1688 #[cfg(any(feature = "std", feature = "alloc"))]
1689 forwarded_impl!((T), Box<T>, Box::new);
1690
1691 #[cfg(any(feature = "std", feature = "alloc"))]
1692 forwarded_impl!((T), Box<[T]>, Vec::into_boxed_slice);
1693
1694 #[cfg(any(feature = "std", feature = "alloc"))]
1695 forwarded_impl!((), Box<str>, String::into_boxed_str);
1696
1697 #[cfg(all(
1698     not(de_rc_dst),
1699     feature = "rc",
1700     any(feature = "std", feature = "alloc")
1701 ))]
1702 forwarded_impl! {
1703     /// This impl requires the [`"rc"`] Cargo feature of Serde.
1704     ///
1705     /// Deserializing a data structure containing `Arc` will not attempt to
1706     /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
1707     /// will end up with a strong count of 1.
1708     ///
1709     /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1710     (T), Arc<T>, Arc::new
1711 }
1712
1713 #[cfg(all(
1714     not(de_rc_dst),
1715     feature = "rc",
1716     any(feature = "std", feature = "alloc")
1717 ))]
1718 forwarded_impl! {
1719     /// This impl requires the [`"rc"`] Cargo feature of Serde.
1720     ///
1721     /// Deserializing a data structure containing `Rc` will not attempt to
1722     /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
1723     /// will end up with a strong count of 1.
1724     ///
1725     /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1726     (T), Rc<T>, Rc::new
1727 }
1728
1729 #[cfg(any(feature = "std", feature = "alloc"))]
1730 impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T>
1731 where
1732     T: ToOwned,
1733     T::Owned: Deserialize<'de>,
1734 {
1735     #[inline]
1736     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1737     where
1738         D: Deserializer<'de>,
1739     {
1740         T::Owned::deserialize(deserializer).map(Cow::Owned)
1741     }
1742 }
1743
1744 ////////////////////////////////////////////////////////////////////////////////
1745
1746 /// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
1747 /// `Weak<T>` has a reference count of 0 and cannot be upgraded.
1748 ///
1749 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1750 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
1751 impl<'de, T: ?Sized> Deserialize<'de> for RcWeak<T>
1752 where
1753     T: Deserialize<'de>,
1754 {
1755     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1756     where
1757         D: Deserializer<'de>,
1758     {
1759         try!(Option::<T>::deserialize(deserializer));
1760         Ok(RcWeak::new())
1761     }
1762 }
1763
1764 /// This impl requires the [`"rc"`] Cargo feature of Serde. The resulting
1765 /// `Weak<T>` has a reference count of 0 and cannot be upgraded.
1766 ///
1767 /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1768 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
1769 impl<'de, T: ?Sized> Deserialize<'de> for ArcWeak<T>
1770 where
1771     T: Deserialize<'de>,
1772 {
1773     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1774     where
1775         D: Deserializer<'de>,
1776     {
1777         try!(Option::<T>::deserialize(deserializer));
1778         Ok(ArcWeak::new())
1779     }
1780 }
1781
1782 ////////////////////////////////////////////////////////////////////////////////
1783
1784 #[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
1785 macro_rules! box_forwarded_impl {
1786     (
1787         $(#[doc = $doc:tt])*
1788         $t:ident
1789     ) => {
1790         $(#[doc = $doc])*
1791         impl<'de, T: ?Sized> Deserialize<'de> for $t<T>
1792         where
1793             Box<T>: Deserialize<'de>,
1794         {
1795             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1796             where
1797                 D: Deserializer<'de>,
1798             {
1799                 Box::deserialize(deserializer).map(Into::into)
1800             }
1801         }
1802     };
1803 }
1804
1805 #[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
1806 box_forwarded_impl! {
1807     /// This impl requires the [`"rc"`] Cargo feature of Serde.
1808     ///
1809     /// Deserializing a data structure containing `Rc` will not attempt to
1810     /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
1811     /// will end up with a strong count of 1.
1812     ///
1813     /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1814     Rc
1815 }
1816
1817 #[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
1818 box_forwarded_impl! {
1819     /// This impl requires the [`"rc"`] Cargo feature of Serde.
1820     ///
1821     /// Deserializing a data structure containing `Arc` will not attempt to
1822     /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
1823     /// will end up with a strong count of 1.
1824     ///
1825     /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
1826     Arc
1827 }
1828
1829 ////////////////////////////////////////////////////////////////////////////////
1830
1831 impl<'de, T> Deserialize<'de> for Cell<T>
1832 where
1833     T: Deserialize<'de> + Copy,
1834 {
1835     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1836     where
1837         D: Deserializer<'de>,
1838     {
1839         T::deserialize(deserializer).map(Cell::new)
1840     }
1841 }
1842
1843 forwarded_impl!((T), RefCell<T>, RefCell::new);
1844
1845 #[cfg(feature = "std")]
1846 forwarded_impl!((T), Mutex<T>, Mutex::new);
1847
1848 #[cfg(feature = "std")]
1849 forwarded_impl!((T), RwLock<T>, RwLock::new);
1850
1851 ////////////////////////////////////////////////////////////////////////////////
1852
1853 // This is a cleaned-up version of the impl generated by:
1854 //
1855 //     #[derive(Deserialize)]
1856 //     #[serde(deny_unknown_fields)]
1857 //     struct Duration {
1858 //         secs: u64,
1859 //         nanos: u32,
1860 //     }
1861 #[cfg(any(core_duration, feature = "std"))]
1862 impl<'de> Deserialize<'de> for Duration {
1863     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1864     where
1865         D: Deserializer<'de>,
1866     {
1867         // If this were outside of the serde crate, it would just use:
1868         //
1869         //    #[derive(Deserialize)]
1870         //    #[serde(field_identifier, rename_all = "lowercase")]
1871         enum Field {
1872             Secs,
1873             Nanos,
1874         };
1875
1876         impl<'de> Deserialize<'de> for Field {
1877             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1878             where
1879                 D: Deserializer<'de>,
1880             {
1881                 struct FieldVisitor;
1882
1883                 impl<'de> Visitor<'de> for FieldVisitor {
1884                     type Value = Field;
1885
1886                     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1887                         formatter.write_str("`secs` or `nanos`")
1888                     }
1889
1890                     fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
1891                     where
1892                         E: Error,
1893                     {
1894                         match value {
1895                             "secs" => Ok(Field::Secs),
1896                             "nanos" => Ok(Field::Nanos),
1897                             _ => Err(Error::unknown_field(value, FIELDS)),
1898                         }
1899                     }
1900
1901                     fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
1902                     where
1903                         E: Error,
1904                     {
1905                         match value {
1906                             b"secs" => Ok(Field::Secs),
1907                             b"nanos" => Ok(Field::Nanos),
1908                             _ => {
1909                                 let value = ::export::from_utf8_lossy(value);
1910                                 Err(Error::unknown_field(&value, FIELDS))
1911                             }
1912                         }
1913                     }
1914                 }
1915
1916                 deserializer.deserialize_identifier(FieldVisitor)
1917             }
1918         }
1919
1920         struct DurationVisitor;
1921
1922         impl<'de> Visitor<'de> for DurationVisitor {
1923             type Value = Duration;
1924
1925             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
1926                 formatter.write_str("struct Duration")
1927             }
1928
1929             fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
1930             where
1931                 A: SeqAccess<'de>,
1932             {
1933                 let secs: u64 = match try!(seq.next_element()) {
1934                     Some(value) => value,
1935                     None => {
1936                         return Err(Error::invalid_length(0, &self));
1937                     }
1938                 };
1939                 let nanos: u32 = match try!(seq.next_element()) {
1940                     Some(value) => value,
1941                     None => {
1942                         return Err(Error::invalid_length(1, &self));
1943                     }
1944                 };
1945                 Ok(Duration::new(secs, nanos))
1946             }
1947
1948             fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
1949             where
1950                 A: MapAccess<'de>,
1951             {
1952                 let mut secs: Option<u64> = None;
1953                 let mut nanos: Option<u32> = None;
1954                 while let Some(key) = try!(map.next_key()) {
1955                     match key {
1956                         Field::Secs => {
1957                             if secs.is_some() {
1958                                 return Err(<A::Error as Error>::duplicate_field("secs"));
1959                             }
1960                             secs = Some(try!(map.next_value()));
1961                         }
1962                         Field::Nanos => {
1963                             if nanos.is_some() {
1964                                 return Err(<A::Error as Error>::duplicate_field("nanos"));
1965                             }
1966                             nanos = Some(try!(map.next_value()));
1967                         }
1968                     }
1969                 }
1970                 let secs = match secs {
1971                     Some(secs) => secs,
1972                     None => return Err(<A::Error as Error>::missing_field("secs")),
1973                 };
1974                 let nanos = match nanos {
1975                     Some(nanos) => nanos,
1976                     None => return Err(<A::Error as Error>::missing_field("nanos")),
1977                 };
1978                 Ok(Duration::new(secs, nanos))
1979             }
1980         }
1981
1982         const FIELDS: &'static [&'static str] = &["secs", "nanos"];
1983         deserializer.deserialize_struct("Duration", FIELDS, DurationVisitor)
1984     }
1985 }
1986
1987 ////////////////////////////////////////////////////////////////////////////////
1988
1989 #[cfg(feature = "std")]
1990 impl<'de> Deserialize<'de> for SystemTime {
1991     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
1992     where
1993         D: Deserializer<'de>,
1994     {
1995         // Reuse duration
1996         enum Field {
1997             Secs,
1998             Nanos,
1999         };
2000
2001         impl<'de> Deserialize<'de> for Field {
2002             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2003             where
2004                 D: Deserializer<'de>,
2005             {
2006                 struct FieldVisitor;
2007
2008                 impl<'de> Visitor<'de> for FieldVisitor {
2009                     type Value = Field;
2010
2011                     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2012                         formatter.write_str("`secs_since_epoch` or `nanos_since_epoch`")
2013                     }
2014
2015                     fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2016                     where
2017                         E: Error,
2018                     {
2019                         match value {
2020                             "secs_since_epoch" => Ok(Field::Secs),
2021                             "nanos_since_epoch" => Ok(Field::Nanos),
2022                             _ => Err(Error::unknown_field(value, FIELDS)),
2023                         }
2024                     }
2025
2026                     fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2027                     where
2028                         E: Error,
2029                     {
2030                         match value {
2031                             b"secs_since_epoch" => Ok(Field::Secs),
2032                             b"nanos_since_epoch" => Ok(Field::Nanos),
2033                             _ => {
2034                                 let value = String::from_utf8_lossy(value);
2035                                 Err(Error::unknown_field(&value, FIELDS))
2036                             }
2037                         }
2038                     }
2039                 }
2040
2041                 deserializer.deserialize_identifier(FieldVisitor)
2042             }
2043         }
2044
2045         struct DurationVisitor;
2046
2047         impl<'de> Visitor<'de> for DurationVisitor {
2048             type Value = Duration;
2049
2050             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2051                 formatter.write_str("struct SystemTime")
2052             }
2053
2054             fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
2055             where
2056                 A: SeqAccess<'de>,
2057             {
2058                 let secs: u64 = match try!(seq.next_element()) {
2059                     Some(value) => value,
2060                     None => {
2061                         return Err(Error::invalid_length(0, &self));
2062                     }
2063                 };
2064                 let nanos: u32 = match try!(seq.next_element()) {
2065                     Some(value) => value,
2066                     None => {
2067                         return Err(Error::invalid_length(1, &self));
2068                     }
2069                 };
2070                 Ok(Duration::new(secs, nanos))
2071             }
2072
2073             fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
2074             where
2075                 A: MapAccess<'de>,
2076             {
2077                 let mut secs: Option<u64> = None;
2078                 let mut nanos: Option<u32> = None;
2079                 while let Some(key) = try!(map.next_key()) {
2080                     match key {
2081                         Field::Secs => {
2082                             if secs.is_some() {
2083                                 return Err(<A::Error as Error>::duplicate_field(
2084                                     "secs_since_epoch",
2085                                 ));
2086                             }
2087                             secs = Some(try!(map.next_value()));
2088                         }
2089                         Field::Nanos => {
2090                             if nanos.is_some() {
2091                                 return Err(<A::Error as Error>::duplicate_field(
2092                                     "nanos_since_epoch",
2093                                 ));
2094                             }
2095                             nanos = Some(try!(map.next_value()));
2096                         }
2097                     }
2098                 }
2099                 let secs = match secs {
2100                     Some(secs) => secs,
2101                     None => return Err(<A::Error as Error>::missing_field("secs_since_epoch")),
2102                 };
2103                 let nanos = match nanos {
2104                     Some(nanos) => nanos,
2105                     None => return Err(<A::Error as Error>::missing_field("nanos_since_epoch")),
2106                 };
2107                 Ok(Duration::new(secs, nanos))
2108             }
2109         }
2110
2111         const FIELDS: &'static [&'static str] = &["secs_since_epoch", "nanos_since_epoch"];
2112         let duration = try!(deserializer.deserialize_struct("SystemTime", FIELDS, DurationVisitor));
2113         Ok(UNIX_EPOCH + duration)
2114     }
2115 }
2116
2117 ////////////////////////////////////////////////////////////////////////////////
2118
2119 // Similar to:
2120 //
2121 //     #[derive(Deserialize)]
2122 //     #[serde(deny_unknown_fields)]
2123 //     struct Range {
2124 //         start: u64,
2125 //         end: u32,
2126 //     }
2127 impl<'de, Idx> Deserialize<'de> for Range<Idx>
2128 where
2129     Idx: Deserialize<'de>,
2130 {
2131     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2132     where
2133         D: Deserializer<'de>,
2134     {
2135         let (start, end) = deserializer.deserialize_struct(
2136             "Range",
2137             range::FIELDS,
2138             range::RangeVisitor {
2139                 expecting: "struct Range",
2140                 phantom: PhantomData,
2141             },
2142         )?;
2143         Ok(start..end)
2144     }
2145 }
2146
2147 #[cfg(range_inclusive)]
2148 impl<'de, Idx> Deserialize<'de> for RangeInclusive<Idx>
2149 where
2150     Idx: Deserialize<'de>,
2151 {
2152     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2153     where
2154         D: Deserializer<'de>,
2155     {
2156         let (start, end) = deserializer.deserialize_struct(
2157             "RangeInclusive",
2158             range::FIELDS,
2159             range::RangeVisitor {
2160                 expecting: "struct RangeInclusive",
2161                 phantom: PhantomData,
2162             },
2163         )?;
2164         Ok(RangeInclusive::new(start, end))
2165     }
2166 }
2167
2168 mod range {
2169     use lib::*;
2170
2171     use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
2172
2173     pub const FIELDS: &'static [&'static str] = &["start", "end"];
2174
2175     // If this were outside of the serde crate, it would just use:
2176     //
2177     //    #[derive(Deserialize)]
2178     //    #[serde(field_identifier, rename_all = "lowercase")]
2179     enum Field {
2180         Start,
2181         End,
2182     }
2183
2184     impl<'de> Deserialize<'de> for Field {
2185         fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2186         where
2187             D: Deserializer<'de>,
2188         {
2189             struct FieldVisitor;
2190
2191             impl<'de> Visitor<'de> for FieldVisitor {
2192                 type Value = Field;
2193
2194                 fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2195                     formatter.write_str("`start` or `end`")
2196                 }
2197
2198                 fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2199                 where
2200                     E: Error,
2201                 {
2202                     match value {
2203                         "start" => Ok(Field::Start),
2204                         "end" => Ok(Field::End),
2205                         _ => Err(Error::unknown_field(value, FIELDS)),
2206                     }
2207                 }
2208
2209                 fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2210                 where
2211                     E: Error,
2212                 {
2213                     match value {
2214                         b"start" => Ok(Field::Start),
2215                         b"end" => Ok(Field::End),
2216                         _ => {
2217                             let value = ::export::from_utf8_lossy(value);
2218                             Err(Error::unknown_field(&value, FIELDS))
2219                         }
2220                     }
2221                 }
2222             }
2223
2224             deserializer.deserialize_identifier(FieldVisitor)
2225         }
2226     }
2227
2228     pub struct RangeVisitor<Idx> {
2229         pub expecting: &'static str,
2230         pub phantom: PhantomData<Idx>,
2231     }
2232
2233     impl<'de, Idx> Visitor<'de> for RangeVisitor<Idx>
2234     where
2235         Idx: Deserialize<'de>,
2236     {
2237         type Value = (Idx, Idx);
2238
2239         fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2240             formatter.write_str(self.expecting)
2241         }
2242
2243         fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
2244         where
2245             A: SeqAccess<'de>,
2246         {
2247             let start: Idx = match try!(seq.next_element()) {
2248                 Some(value) => value,
2249                 None => {
2250                     return Err(Error::invalid_length(0, &self));
2251                 }
2252             };
2253             let end: Idx = match try!(seq.next_element()) {
2254                 Some(value) => value,
2255                 None => {
2256                     return Err(Error::invalid_length(1, &self));
2257                 }
2258             };
2259             Ok((start, end))
2260         }
2261
2262         fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
2263         where
2264             A: MapAccess<'de>,
2265         {
2266             let mut start: Option<Idx> = None;
2267             let mut end: Option<Idx> = None;
2268             while let Some(key) = try!(map.next_key()) {
2269                 match key {
2270                     Field::Start => {
2271                         if start.is_some() {
2272                             return Err(<A::Error as Error>::duplicate_field("start"));
2273                         }
2274                         start = Some(try!(map.next_value()));
2275                     }
2276                     Field::End => {
2277                         if end.is_some() {
2278                             return Err(<A::Error as Error>::duplicate_field("end"));
2279                         }
2280                         end = Some(try!(map.next_value()));
2281                     }
2282                 }
2283             }
2284             let start = match start {
2285                 Some(start) => start,
2286                 None => return Err(<A::Error as Error>::missing_field("start")),
2287             };
2288             let end = match end {
2289                 Some(end) => end,
2290                 None => return Err(<A::Error as Error>::missing_field("end")),
2291             };
2292             Ok((start, end))
2293         }
2294     }
2295 }
2296
2297 ////////////////////////////////////////////////////////////////////////////////
2298
2299 #[cfg(any(ops_bound, collections_bound))]
2300 impl<'de, T> Deserialize<'de> for Bound<T>
2301 where
2302     T: Deserialize<'de>,
2303 {
2304     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2305     where
2306         D: Deserializer<'de>,
2307     {
2308         enum Field {
2309             Unbounded,
2310             Included,
2311             Excluded,
2312         }
2313
2314         impl<'de> Deserialize<'de> for Field {
2315             #[inline]
2316             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2317             where
2318                 D: Deserializer<'de>,
2319             {
2320                 struct FieldVisitor;
2321
2322                 impl<'de> Visitor<'de> for FieldVisitor {
2323                     type Value = Field;
2324
2325                     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2326                         formatter.write_str("`Unbounded`, `Included` or `Excluded`")
2327                     }
2328
2329                     fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
2330                     where
2331                         E: Error,
2332                     {
2333                         match value {
2334                             0 => Ok(Field::Unbounded),
2335                             1 => Ok(Field::Included),
2336                             2 => Ok(Field::Excluded),
2337                             _ => Err(Error::invalid_value(
2338                                 Unexpected::Unsigned(value as u64),
2339                                 &self,
2340                             )),
2341                         }
2342                     }
2343
2344                     fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2345                     where
2346                         E: Error,
2347                     {
2348                         match value {
2349                             "Unbounded" => Ok(Field::Unbounded),
2350                             "Included" => Ok(Field::Included),
2351                             "Excluded" => Ok(Field::Excluded),
2352                             _ => Err(Error::unknown_variant(value, VARIANTS)),
2353                         }
2354                     }
2355
2356                     fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2357                     where
2358                         E: Error,
2359                     {
2360                         match value {
2361                             b"Unbounded" => Ok(Field::Unbounded),
2362                             b"Included" => Ok(Field::Included),
2363                             b"Excluded" => Ok(Field::Excluded),
2364                             _ => match str::from_utf8(value) {
2365                                 Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
2366                                 Err(_) => {
2367                                     Err(Error::invalid_value(Unexpected::Bytes(value), &self))
2368                                 }
2369                             },
2370                         }
2371                     }
2372                 }
2373
2374                 deserializer.deserialize_identifier(FieldVisitor)
2375             }
2376         }
2377
2378         struct BoundVisitor<T>(PhantomData<Bound<T>>);
2379
2380         impl<'de, T> Visitor<'de> for BoundVisitor<T>
2381         where
2382             T: Deserialize<'de>,
2383         {
2384             type Value = Bound<T>;
2385
2386             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2387                 formatter.write_str("enum Bound")
2388             }
2389
2390             fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
2391             where
2392                 A: EnumAccess<'de>,
2393             {
2394                 match try!(data.variant()) {
2395                     (Field::Unbounded, v) => v.unit_variant().map(|()| Bound::Unbounded),
2396                     (Field::Included, v) => v.newtype_variant().map(Bound::Included),
2397                     (Field::Excluded, v) => v.newtype_variant().map(Bound::Excluded),
2398                 }
2399             }
2400         }
2401
2402         const VARIANTS: &'static [&'static str] = &["Unbounded", "Included", "Excluded"];
2403
2404         deserializer.deserialize_enum("Bound", VARIANTS, BoundVisitor(PhantomData))
2405     }
2406 }
2407
2408 ////////////////////////////////////////////////////////////////////////////////
2409
2410 macro_rules! nonzero_integers {
2411     ( $( $T: ident, )+ ) => {
2412         $(
2413             #[cfg(num_nonzero)]
2414             impl<'de> Deserialize<'de> for num::$T {
2415                 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2416                 where
2417                     D: Deserializer<'de>,
2418                 {
2419                     let value = try!(Deserialize::deserialize(deserializer));
2420                     match <num::$T>::new(value) {
2421                         Some(nonzero) => Ok(nonzero),
2422                         None => Err(Error::custom("expected a non-zero value")),
2423                     }
2424                 }
2425             }
2426         )+
2427     };
2428 }
2429
2430 nonzero_integers! {
2431     NonZeroU8,
2432     NonZeroU16,
2433     NonZeroU32,
2434     NonZeroU64,
2435     NonZeroUsize,
2436 }
2437
2438 #[cfg(num_nonzero_signed)]
2439 nonzero_integers! {
2440     NonZeroI8,
2441     NonZeroI16,
2442     NonZeroI32,
2443     NonZeroI64,
2444     NonZeroIsize,
2445 }
2446
2447 // Currently 128-bit integers do not work on Emscripten targets so we need an
2448 // additional `#[cfg]`
2449 serde_if_integer128! {
2450     nonzero_integers! {
2451         NonZeroU128,
2452     }
2453
2454     #[cfg(num_nonzero_signed)]
2455     nonzero_integers! {
2456         NonZeroI128,
2457     }
2458 }
2459
2460 ////////////////////////////////////////////////////////////////////////////////
2461
2462 impl<'de, T, E> Deserialize<'de> for Result<T, E>
2463 where
2464     T: Deserialize<'de>,
2465     E: Deserialize<'de>,
2466 {
2467     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2468     where
2469         D: Deserializer<'de>,
2470     {
2471         // If this were outside of the serde crate, it would just use:
2472         //
2473         //    #[derive(Deserialize)]
2474         //    #[serde(variant_identifier)]
2475         enum Field {
2476             Ok,
2477             Err,
2478         }
2479
2480         impl<'de> Deserialize<'de> for Field {
2481             #[inline]
2482             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2483             where
2484                 D: Deserializer<'de>,
2485             {
2486                 struct FieldVisitor;
2487
2488                 impl<'de> Visitor<'de> for FieldVisitor {
2489                     type Value = Field;
2490
2491                     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2492                         formatter.write_str("`Ok` or `Err`")
2493                     }
2494
2495                     fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
2496                     where
2497                         E: Error,
2498                     {
2499                         match value {
2500                             0 => Ok(Field::Ok),
2501                             1 => Ok(Field::Err),
2502                             _ => Err(Error::invalid_value(
2503                                 Unexpected::Unsigned(value as u64),
2504                                 &self,
2505                             )),
2506                         }
2507                     }
2508
2509                     fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
2510                     where
2511                         E: Error,
2512                     {
2513                         match value {
2514                             "Ok" => Ok(Field::Ok),
2515                             "Err" => Ok(Field::Err),
2516                             _ => Err(Error::unknown_variant(value, VARIANTS)),
2517                         }
2518                     }
2519
2520                     fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
2521                     where
2522                         E: Error,
2523                     {
2524                         match value {
2525                             b"Ok" => Ok(Field::Ok),
2526                             b"Err" => Ok(Field::Err),
2527                             _ => match str::from_utf8(value) {
2528                                 Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
2529                                 Err(_) => {
2530                                     Err(Error::invalid_value(Unexpected::Bytes(value), &self))
2531                                 }
2532                             },
2533                         }
2534                     }
2535                 }
2536
2537                 deserializer.deserialize_identifier(FieldVisitor)
2538             }
2539         }
2540
2541         struct ResultVisitor<T, E>(PhantomData<Result<T, E>>);
2542
2543         impl<'de, T, E> Visitor<'de> for ResultVisitor<T, E>
2544         where
2545             T: Deserialize<'de>,
2546             E: Deserialize<'de>,
2547         {
2548             type Value = Result<T, E>;
2549
2550             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
2551                 formatter.write_str("enum Result")
2552             }
2553
2554             fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
2555             where
2556                 A: EnumAccess<'de>,
2557             {
2558                 match try!(data.variant()) {
2559                     (Field::Ok, v) => v.newtype_variant().map(Ok),
2560                     (Field::Err, v) => v.newtype_variant().map(Err),
2561                 }
2562             }
2563         }
2564
2565         const VARIANTS: &'static [&'static str] = &["Ok", "Err"];
2566
2567         deserializer.deserialize_enum("Result", VARIANTS, ResultVisitor(PhantomData))
2568     }
2569 }
2570
2571 ////////////////////////////////////////////////////////////////////////////////
2572
2573 #[cfg(feature = "std")]
2574 impl<'de, T> Deserialize<'de> for Wrapping<T>
2575 where
2576     T: Deserialize<'de>,
2577 {
2578     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2579     where
2580         D: Deserializer<'de>,
2581     {
2582         Deserialize::deserialize(deserializer).map(Wrapping)
2583     }
2584 }
2585
2586 #[cfg(all(feature = "std", std_atomic))]
2587 macro_rules! atomic_impl {
2588     ($($ty:ident)*) => {
2589         $(
2590             impl<'de> Deserialize<'de> for $ty {
2591                 fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
2592                 where
2593                     D: Deserializer<'de>,
2594                 {
2595                     Deserialize::deserialize(deserializer).map(Self::new)
2596                 }
2597             }
2598         )*
2599     };
2600 }
2601
2602 #[cfg(all(feature = "std", std_atomic))]
2603 atomic_impl! {
2604     AtomicBool
2605     AtomicI8 AtomicI16 AtomicI32 AtomicIsize
2606     AtomicU8 AtomicU16 AtomicU32 AtomicUsize
2607 }
2608
2609 #[cfg(all(feature = "std", std_atomic64))]
2610 atomic_impl! {
2611     AtomicI64 AtomicU64
2612 }