src/librustc_serialize/serialize.rs

   1 //! Support code for encoding and decoding types.
   2
   3 /*
   4 Core encoding and decoding interfaces.
   5 */
   6
   7 use std::borrow::Cow;
   8 use std::cell::{Cell, RefCell};
   9 use std::marker::PhantomData;
  10 use std::path;
  11 use std::rc::Rc;
  12 use std::sync::Arc;
  13
  14 pub trait Encoder {
  15     type Error;
  16
  17     // Primitive types:
  18     fn emit_unit(&mut self) -> Result<(), Self::Error>;
  19     fn emit_usize(&mut self, v: usize) -> Result<(), Self::Error>;
  20     fn emit_u128(&mut self, v: u128) -> Result<(), Self::Error>;
  21     fn emit_u64(&mut self, v: u64) -> Result<(), Self::Error>;
  22     fn emit_u32(&mut self, v: u32) -> Result<(), Self::Error>;
  23     fn emit_u16(&mut self, v: u16) -> Result<(), Self::Error>;
  24     fn emit_u8(&mut self, v: u8) -> Result<(), Self::Error>;
  25     fn emit_isize(&mut self, v: isize) -> Result<(), Self::Error>;
  26     fn emit_i128(&mut self, v: i128) -> Result<(), Self::Error>;
  27     fn emit_i64(&mut self, v: i64) -> Result<(), Self::Error>;
  28     fn emit_i32(&mut self, v: i32) -> Result<(), Self::Error>;
  29     fn emit_i16(&mut self, v: i16) -> Result<(), Self::Error>;
  30     fn emit_i8(&mut self, v: i8) -> Result<(), Self::Error>;
  31     fn emit_bool(&mut self, v: bool) -> Result<(), Self::Error>;
  32     fn emit_f64(&mut self, v: f64) -> Result<(), Self::Error>;
  33     fn emit_f32(&mut self, v: f32) -> Result<(), Self::Error>;
  34     fn emit_char(&mut self, v: char) -> Result<(), Self::Error>;
  35     fn emit_str(&mut self, v: &str) -> Result<(), Self::Error>;
  36
  37     // Compound types:
  38     #[inline]
  39     fn emit_enum<F>(&mut self, _name: &str, f: F) -> Result<(), Self::Error>
  40     where
  41         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
  42     {
  43         f(self)
  44     }
  45
  46     fn emit_enum_variant<F>(
  47         &mut self,
  48         _v_name: &str,
  49         v_id: usize,
  50         _len: usize,
  51         f: F,
  52     ) -> Result<(), Self::Error>
  53     where
  54         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
  55     {
  56         self.emit_usize(v_id)?;
  57         f(self)
  58     }
  59
  60     #[inline]
  61     fn emit_enum_variant_arg<F>(&mut self, _a_idx: usize, f: F) -> Result<(), Self::Error>
  62     where
  63         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
  64     {
  65         f(self)
  66     }
  67
  68     fn emit_enum_struct_variant<F>(
  69         &mut self,
  70         v_name: &str,
  71         v_id: usize,
  72         len: usize,
  73         f: F,
  74     ) -> Result<(), Self::Error>
  75     where
  76         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
  77     {
  78         self.emit_enum_variant(v_name, v_id, len, f)
  79     }
  80
  81     fn emit_enum_struct_variant_field<F>(
  82         &mut self,
  83         _f_name: &str,
  84         f_idx: usize,
  85         f: F,
  86     ) -> Result<(), Self::Error>
  87     where
  88         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
  89     {
  90         self.emit_enum_variant_arg(f_idx, f)
  91     }
  92
  93     #[inline]
  94     fn emit_struct<F>(&mut self, _name: &str, _len: usize, f: F) -> Result<(), Self::Error>
  95     where
  96         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
  97     {
  98         f(self)
  99     }
 100
 101     #[inline]
 102     fn emit_struct_field<F>(
 103         &mut self,
 104         _f_name: &str,
 105         _f_idx: usize,
 106         f: F,
 107     ) -> Result<(), Self::Error>
 108     where
 109         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 110     {
 111         f(self)
 112     }
 113
 114     #[inline]
 115     fn emit_tuple<F>(&mut self, _len: usize, f: F) -> Result<(), Self::Error>
 116     where
 117         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 118     {
 119         f(self)
 120     }
 121
 122     #[inline]
 123     fn emit_tuple_arg<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error>
 124     where
 125         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 126     {
 127         f(self)
 128     }
 129
 130     fn emit_tuple_struct<F>(&mut self, _name: &str, len: usize, f: F) -> Result<(), Self::Error>
 131     where
 132         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 133     {
 134         self.emit_tuple(len, f)
 135     }
 136
 137     fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F) -> Result<(), Self::Error>
 138     where
 139         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 140     {
 141         self.emit_tuple_arg(f_idx, f)
 142     }
 143
 144     // Specialized types:
 145     fn emit_option<F>(&mut self, f: F) -> Result<(), Self::Error>
 146     where
 147         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 148     {
 149         self.emit_enum("Option", f)
 150     }
 151
 152     #[inline]
 153     fn emit_option_none(&mut self) -> Result<(), Self::Error> {
 154         self.emit_enum_variant("None", 0, 0, |_| Ok(()))
 155     }
 156
 157     fn emit_option_some<F>(&mut self, f: F) -> Result<(), Self::Error>
 158     where
 159         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 160     {
 161         self.emit_enum_variant("Some", 1, 1, f)
 162     }
 163
 164     fn emit_seq<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
 165     where
 166         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 167     {
 168         self.emit_usize(len)?;
 169         f(self)
 170     }
 171
 172     #[inline]
 173     fn emit_seq_elt<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error>
 174     where
 175         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 176     {
 177         f(self)
 178     }
 179
 180     fn emit_map<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
 181     where
 182         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 183     {
 184         self.emit_usize(len)?;
 185         f(self)
 186     }
 187
 188     #[inline]
 189     fn emit_map_elt_key<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error>
 190     where
 191         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 192     {
 193         f(self)
 194     }
 195
 196     #[inline]
 197     fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error>
 198     where
 199         F: FnOnce(&mut Self) -> Result<(), Self::Error>,
 200     {
 201         f(self)
 202     }
 203 }
 204
 205 pub trait Decoder {
 206     type Error;
 207
 208     // Primitive types:
 209     fn read_nil(&mut self) -> Result<(), Self::Error>;
 210     fn read_usize(&mut self) -> Result<usize, Self::Error>;
 211     fn read_u128(&mut self) -> Result<u128, Self::Error>;
 212     fn read_u64(&mut self) -> Result<u64, Self::Error>;
 213     fn read_u32(&mut self) -> Result<u32, Self::Error>;
 214     fn read_u16(&mut self) -> Result<u16, Self::Error>;
 215     fn read_u8(&mut self) -> Result<u8, Self::Error>;
 216     fn read_isize(&mut self) -> Result<isize, Self::Error>;
 217     fn read_i128(&mut self) -> Result<i128, Self::Error>;
 218     fn read_i64(&mut self) -> Result<i64, Self::Error>;
 219     fn read_i32(&mut self) -> Result<i32, Self::Error>;
 220     fn read_i16(&mut self) -> Result<i16, Self::Error>;
 221     fn read_i8(&mut self) -> Result<i8, Self::Error>;
 222     fn read_bool(&mut self) -> Result<bool, Self::Error>;
 223     fn read_f64(&mut self) -> Result<f64, Self::Error>;
 224     fn read_f32(&mut self) -> Result<f32, Self::Error>;
 225     fn read_char(&mut self) -> Result<char, Self::Error>;
 226     fn read_str(&mut self) -> Result<Cow<'_, str>, Self::Error>;
 227
 228     // Compound types:
 229     #[inline]
 230     fn read_enum<T, F>(&mut self, _name: &str, f: F) -> Result<T, Self::Error>
 231     where
 232         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 233     {
 234         f(self)
 235     }
 236
 237     #[inline]
 238     fn read_enum_variant<T, F>(&mut self, _names: &[&str], mut f: F) -> Result<T, Self::Error>
 239     where
 240         F: FnMut(&mut Self, usize) -> Result<T, Self::Error>,
 241     {
 242         let disr = self.read_usize()?;
 243         f(self, disr)
 244     }
 245
 246     #[inline]
 247     fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, f: F) -> Result<T, Self::Error>
 248     where
 249         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 250     {
 251         f(self)
 252     }
 253
 254     fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, Self::Error>
 255     where
 256         F: FnMut(&mut Self, usize) -> Result<T, Self::Error>,
 257     {
 258         self.read_enum_variant(names, f)
 259     }
 260
 261     fn read_enum_struct_variant_field<T, F>(
 262         &mut self,
 263         _f_name: &str,
 264         f_idx: usize,
 265         f: F,
 266     ) -> Result<T, Self::Error>
 267     where
 268         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 269     {
 270         self.read_enum_variant_arg(f_idx, f)
 271     }
 272
 273     #[inline]
 274     fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, f: F) -> Result<T, Self::Error>
 275     where
 276         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 277     {
 278         f(self)
 279     }
 280
 281     #[inline]
 282     fn read_struct_field<T, F>(
 283         &mut self,
 284         _f_name: &str,
 285         _f_idx: usize,
 286         f: F,
 287     ) -> Result<T, Self::Error>
 288     where
 289         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 290     {
 291         f(self)
 292     }
 293
 294     #[inline]
 295     fn read_tuple<T, F>(&mut self, _len: usize, f: F) -> Result<T, Self::Error>
 296     where
 297         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 298     {
 299         f(self)
 300     }
 301
 302     #[inline]
 303     fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, f: F) -> Result<T, Self::Error>
 304     where
 305         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 306     {
 307         f(self)
 308     }
 309
 310     fn read_tuple_struct<T, F>(&mut self, _s_name: &str, len: usize, f: F) -> Result<T, Self::Error>
 311     where
 312         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 313     {
 314         self.read_tuple(len, f)
 315     }
 316
 317     fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F) -> Result<T, Self::Error>
 318     where
 319         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 320     {
 321         self.read_tuple_arg(a_idx, f)
 322     }
 323
 324     // Specialized types:
 325     fn read_option<T, F>(&mut self, mut f: F) -> Result<T, Self::Error>
 326     where
 327         F: FnMut(&mut Self, bool) -> Result<T, Self::Error>,
 328     {
 329         self.read_enum("Option", move |this| {
 330             this.read_enum_variant(&["None", "Some"], move |this, idx| match idx {
 331                 0 => f(this, false),
 332                 1 => f(this, true),
 333                 _ => Err(this.error("read_option: expected 0 for None or 1 for Some")),
 334             })
 335         })
 336     }
 337
 338     fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error>
 339     where
 340         F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>,
 341     {
 342         let len = self.read_usize()?;
 343         f(self, len)
 344     }
 345
 346     #[inline]
 347     fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Self::Error>
 348     where
 349         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 350     {
 351         f(self)
 352     }
 353
 354     fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error>
 355     where
 356         F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>,
 357     {
 358         let len = self.read_usize()?;
 359         f(self, len)
 360     }
 361
 362     #[inline]
 363     fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Self::Error>
 364     where
 365         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 366     {
 367         f(self)
 368     }
 369
 370     #[inline]
 371     fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Self::Error>
 372     where
 373         F: FnOnce(&mut Self) -> Result<T, Self::Error>,
 374     {
 375         f(self)
 376     }
 377
 378     // Failure
 379     fn error(&mut self, err: &str) -> Self::Error;
 380 }
 381
 382 /// Trait for types that can be serialized
 383 ///
 384 /// This can be implemented using the `Encodable`, `TyEncodable` and
 385 /// `MetadataEncodable` macros.
 386 ///
 387 /// * `Encodable` should be used in crates that don't depend on
 388 ///   `librustc_middle`.
 389 /// * `TyEncodable` should be used for types that are only serialized in crate
 390 ///   metadata or the incremental cache, except for simple enums.where
 391 /// * `MetadataEncodable` is used in `rustc_metadata` for types that are only
 392 ///   serialized in crate metadata.
 393 pub trait Encodable<S: Encoder> {
 394     fn encode(&self, s: &mut S) -> Result<(), S::Error>;
 395 }
 396
 397 /// Trait for types that can be deserialized
 398 ///
 399 /// This can be implemented using the `Decodable`, `TyDecodable` and
 400 /// `MetadataDecodable` macros.
 401 ///
 402 /// * `Decodable` should be used in crates that don't depend on
 403 ///   `librustc_middle`.
 404 /// * `TyDecodable` should be used for types that are only serialized in crate
 405 ///   metadata or the incremental cache, except for simple enums.where
 406 /// * `MetadataDecodable` is used in `rustc_metadata` for types that are only
 407 ///   serialized in crate metadata.
 408 pub trait Decodable<D: Decoder>: Sized {
 409     fn decode(d: &mut D) -> Result<Self, D::Error>;
 410 }
 411
 412 impl<S: Encoder> Encodable<S> for usize {
 413     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 414         s.emit_usize(*self)
 415     }
 416 }
 417
 418 impl<D: Decoder> Decodable<D> for usize {
 419     fn decode(d: &mut D) -> Result<usize, D::Error> {
 420         d.read_usize()
 421     }
 422 }
 423
 424 impl<S: Encoder> Encodable<S> for u8 {
 425     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 426         s.emit_u8(*self)
 427     }
 428 }
 429
 430 impl<D: Decoder> Decodable<D> for u8 {
 431     fn decode(d: &mut D) -> Result<u8, D::Error> {
 432         d.read_u8()
 433     }
 434 }
 435
 436 impl<S: Encoder> Encodable<S> for u16 {
 437     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 438         s.emit_u16(*self)
 439     }
 440 }
 441
 442 impl<D: Decoder> Decodable<D> for u16 {
 443     fn decode(d: &mut D) -> Result<u16, D::Error> {
 444         d.read_u16()
 445     }
 446 }
 447
 448 impl<S: Encoder> Encodable<S> for u32 {
 449     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 450         s.emit_u32(*self)
 451     }
 452 }
 453
 454 impl<D: Decoder> Decodable<D> for u32 {
 455     fn decode(d: &mut D) -> Result<u32, D::Error> {
 456         d.read_u32()
 457     }
 458 }
 459
 460 impl<S: Encoder> Encodable<S> for ::std::num::NonZeroU32 {
 461     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 462         s.emit_u32(self.get())
 463     }
 464 }
 465
 466 impl<D: Decoder> Decodable<D> for ::std::num::NonZeroU32 {
 467     fn decode(d: &mut D) -> Result<Self, D::Error> {
 468         d.read_u32().map(|d| ::std::num::NonZeroU32::new(d).unwrap())
 469     }
 470 }
 471
 472 impl<S: Encoder> Encodable<S> for u64 {
 473     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 474         s.emit_u64(*self)
 475     }
 476 }
 477
 478 impl<D: Decoder> Decodable<D> for u64 {
 479     fn decode(d: &mut D) -> Result<u64, D::Error> {
 480         d.read_u64()
 481     }
 482 }
 483
 484 impl<S: Encoder> Encodable<S> for u128 {
 485     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 486         s.emit_u128(*self)
 487     }
 488 }
 489
 490 impl<D: Decoder> Decodable<D> for u128 {
 491     fn decode(d: &mut D) -> Result<u128, D::Error> {
 492         d.read_u128()
 493     }
 494 }
 495
 496 impl<S: Encoder> Encodable<S> for isize {
 497     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 498         s.emit_isize(*self)
 499     }
 500 }
 501
 502 impl<D: Decoder> Decodable<D> for isize {
 503     fn decode(d: &mut D) -> Result<isize, D::Error> {
 504         d.read_isize()
 505     }
 506 }
 507
 508 impl<S: Encoder> Encodable<S> for i8 {
 509     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 510         s.emit_i8(*self)
 511     }
 512 }
 513
 514 impl<D: Decoder> Decodable<D> for i8 {
 515     fn decode(d: &mut D) -> Result<i8, D::Error> {
 516         d.read_i8()
 517     }
 518 }
 519
 520 impl<S: Encoder> Encodable<S> for i16 {
 521     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 522         s.emit_i16(*self)
 523     }
 524 }
 525
 526 impl<D: Decoder> Decodable<D> for i16 {
 527     fn decode(d: &mut D) -> Result<i16, D::Error> {
 528         d.read_i16()
 529     }
 530 }
 531
 532 impl<S: Encoder> Encodable<S> for i32 {
 533     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 534         s.emit_i32(*self)
 535     }
 536 }
 537
 538 impl<D: Decoder> Decodable<D> for i32 {
 539     fn decode(d: &mut D) -> Result<i32, D::Error> {
 540         d.read_i32()
 541     }
 542 }
 543
 544 impl<S: Encoder> Encodable<S> for i64 {
 545     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 546         s.emit_i64(*self)
 547     }
 548 }
 549
 550 impl<D: Decoder> Decodable<D> for i64 {
 551     fn decode(d: &mut D) -> Result<i64, D::Error> {
 552         d.read_i64()
 553     }
 554 }
 555
 556 impl<S: Encoder> Encodable<S> for i128 {
 557     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 558         s.emit_i128(*self)
 559     }
 560 }
 561
 562 impl<D: Decoder> Decodable<D> for i128 {
 563     fn decode(d: &mut D) -> Result<i128, D::Error> {
 564         d.read_i128()
 565     }
 566 }
 567
 568 impl<S: Encoder> Encodable<S> for str {
 569     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 570         s.emit_str(self)
 571     }
 572 }
 573
 574 impl<S: Encoder> Encodable<S> for &str {
 575     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 576         s.emit_str(self)
 577     }
 578 }
 579
 580 impl<S: Encoder> Encodable<S> for String {
 581     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 582         s.emit_str(&self[..])
 583     }
 584 }
 585
 586 impl<D: Decoder> Decodable<D> for String {
 587     fn decode(d: &mut D) -> Result<String, D::Error> {
 588         Ok(d.read_str()?.into_owned())
 589     }
 590 }
 591
 592 impl<S: Encoder> Encodable<S> for f32 {
 593     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 594         s.emit_f32(*self)
 595     }
 596 }
 597
 598 impl<D: Decoder> Decodable<D> for f32 {
 599     fn decode(d: &mut D) -> Result<f32, D::Error> {
 600         d.read_f32()
 601     }
 602 }
 603
 604 impl<S: Encoder> Encodable<S> for f64 {
 605     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 606         s.emit_f64(*self)
 607     }
 608 }
 609
 610 impl<D: Decoder> Decodable<D> for f64 {
 611     fn decode(d: &mut D) -> Result<f64, D::Error> {
 612         d.read_f64()
 613     }
 614 }
 615
 616 impl<S: Encoder> Encodable<S> for bool {
 617     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 618         s.emit_bool(*self)
 619     }
 620 }
 621
 622 impl<D: Decoder> Decodable<D> for bool {
 623     fn decode(d: &mut D) -> Result<bool, D::Error> {
 624         d.read_bool()
 625     }
 626 }
 627
 628 impl<S: Encoder> Encodable<S> for char {
 629     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 630         s.emit_char(*self)
 631     }
 632 }
 633
 634 impl<D: Decoder> Decodable<D> for char {
 635     fn decode(d: &mut D) -> Result<char, D::Error> {
 636         d.read_char()
 637     }
 638 }
 639
 640 impl<S: Encoder> Encodable<S> for () {
 641     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 642         s.emit_unit()
 643     }
 644 }
 645
 646 impl<D: Decoder> Decodable<D> for () {
 647     fn decode(d: &mut D) -> Result<(), D::Error> {
 648         d.read_nil()
 649     }
 650 }
 651
 652 impl<S: Encoder, T> Encodable<S> for PhantomData<T> {
 653     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 654         s.emit_unit()
 655     }
 656 }
 657
 658 impl<D: Decoder, T> Decodable<D> for PhantomData<T> {
 659     fn decode(d: &mut D) -> Result<PhantomData<T>, D::Error> {
 660         d.read_nil()?;
 661         Ok(PhantomData)
 662     }
 663 }
 664
 665 impl<D: Decoder, T: Decodable<D>> Decodable<D> for Box<[T]> {
 666     fn decode(d: &mut D) -> Result<Box<[T]>, D::Error> {
 667         let v: Vec<T> = Decodable::decode(d)?;
 668         Ok(v.into_boxed_slice())
 669     }
 670 }
 671
 672 impl<S: Encoder, T: Encodable<S>> Encodable<S> for Rc<T> {
 673     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 674         (**self).encode(s)
 675     }
 676 }
 677
 678 impl<D: Decoder, T: Decodable<D>> Decodable<D> for Rc<T> {
 679     fn decode(d: &mut D) -> Result<Rc<T>, D::Error> {
 680         Ok(Rc::new(Decodable::decode(d)?))
 681     }
 682 }
 683
 684 impl<S: Encoder, T: Encodable<S>> Encodable<S> for [T] {
 685     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 686         s.emit_seq(self.len(), |s| {
 687             for (i, e) in self.iter().enumerate() {
 688                 s.emit_seq_elt(i, |s| e.encode(s))?
 689             }
 690             Ok(())
 691         })
 692     }
 693 }
 694
 695 impl<S: Encoder, T: Encodable<S>> Encodable<S> for Vec<T> {
 696     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 697         s.emit_seq(self.len(), |s| {
 698             for (i, e) in self.iter().enumerate() {
 699                 s.emit_seq_elt(i, |s| e.encode(s))?
 700             }
 701             Ok(())
 702         })
 703     }
 704 }
 705
 706 impl<D: Decoder, T: Decodable<D>> Decodable<D> for Vec<T> {
 707     fn decode(d: &mut D) -> Result<Vec<T>, D::Error> {
 708         d.read_seq(|d, len| {
 709             let mut v = Vec::with_capacity(len);
 710             for i in 0..len {
 711                 v.push(d.read_seq_elt(i, |d| Decodable::decode(d))?);
 712             }
 713             Ok(v)
 714         })
 715     }
 716 }
 717
 718 impl<S: Encoder> Encodable<S> for [u8; 20] {
 719     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 720         s.emit_seq(self.len(), |s| {
 721             for (i, e) in self.iter().enumerate() {
 722                 s.emit_seq_elt(i, |s| e.encode(s))?
 723             }
 724             Ok(())
 725         })
 726     }
 727 }
 728
 729 impl<D: Decoder> Decodable<D> for [u8; 20] {
 730     fn decode(d: &mut D) -> Result<[u8; 20], D::Error> {
 731         d.read_seq(|d, len| {
 732             assert!(len == 20);
 733             let mut v = [0u8; 20];
 734             for i in 0..len {
 735                 v[i] = d.read_seq_elt(i, |d| Decodable::decode(d))?;
 736             }
 737             Ok(v)
 738         })
 739     }
 740 }
 741
 742 impl<'a, S: Encoder, T: Encodable<S>> Encodable<S> for Cow<'a, [T]>
 743 where
 744     [T]: ToOwned<Owned = Vec<T>>,
 745 {
 746     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 747         s.emit_seq(self.len(), |s| {
 748             for (i, e) in self.iter().enumerate() {
 749                 s.emit_seq_elt(i, |s| e.encode(s))?
 750             }
 751             Ok(())
 752         })
 753     }
 754 }
 755
 756 impl<D: Decoder, T: Decodable<D> + ToOwned> Decodable<D> for Cow<'static, [T]>
 757 where
 758     [T]: ToOwned<Owned = Vec<T>>,
 759 {
 760     fn decode(d: &mut D) -> Result<Cow<'static, [T]>, D::Error> {
 761         d.read_seq(|d, len| {
 762             let mut v = Vec::with_capacity(len);
 763             for i in 0..len {
 764                 v.push(d.read_seq_elt(i, |d| Decodable::decode(d))?);
 765             }
 766             Ok(Cow::Owned(v))
 767         })
 768     }
 769 }
 770
 771 impl<S: Encoder, T: Encodable<S>> Encodable<S> for Option<T> {
 772     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 773         s.emit_option(|s| match *self {
 774             None => s.emit_option_none(),
 775             Some(ref v) => s.emit_option_some(|s| v.encode(s)),
 776         })
 777     }
 778 }
 779
 780 impl<D: Decoder, T: Decodable<D>> Decodable<D> for Option<T> {
 781     fn decode(d: &mut D) -> Result<Option<T>, D::Error> {
 782         d.read_option(|d, b| if b { Ok(Some(Decodable::decode(d)?)) } else { Ok(None) })
 783     }
 784 }
 785
 786 impl<S: Encoder, T1: Encodable<S>, T2: Encodable<S>> Encodable<S> for Result<T1, T2> {
 787     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 788         s.emit_enum("Result", |s| match *self {
 789             Ok(ref v) => {
 790                 s.emit_enum_variant("Ok", 0, 1, |s| s.emit_enum_variant_arg(0, |s| v.encode(s)))
 791             }
 792             Err(ref v) => {
 793                 s.emit_enum_variant("Err", 1, 1, |s| s.emit_enum_variant_arg(0, |s| v.encode(s)))
 794             }
 795         })
 796     }
 797 }
 798
 799 impl<D: Decoder, T1: Decodable<D>, T2: Decodable<D>> Decodable<D> for Result<T1, T2> {
 800     fn decode(d: &mut D) -> Result<Result<T1, T2>, D::Error> {
 801         d.read_enum("Result", |d| {
 802             d.read_enum_variant(&["Ok", "Err"], |d, disr| match disr {
 803                 0 => Ok(Ok(d.read_enum_variant_arg(0, |d| T1::decode(d))?)),
 804                 1 => Ok(Err(d.read_enum_variant_arg(0, |d| T2::decode(d))?)),
 805                 _ => {
 806                     panic!(
 807                         "Encountered invalid discriminant while \
 808                                 decoding `Result`."
 809                     );
 810                 }
 811             })
 812         })
 813     }
 814 }
 815
 816 macro_rules! peel {
 817     ($name:ident, $($other:ident,)*) => (tuple! { $($other,)* })
 818 }
 819
 820 /// Evaluates to the number of tokens passed to it.
 821 ///
 822 /// Logarithmic counting: every one or two recursive expansions, the number of
 823 /// tokens to count is divided by two, instead of being reduced by one.
 824 /// Therefore, the recursion depth is the binary logarithm of the number of
 825 /// tokens to count, and the expanded tree is likewise very small.
 826 macro_rules! count {
 827     ()                     => (0usize);
 828     ($one:tt)              => (1usize);
 829     ($($pairs:tt $_p:tt)*) => (count!($($pairs)*) << 1usize);
 830     ($odd:tt $($rest:tt)*) => (count!($($rest)*) | 1usize);
 831 }
 832
 833 macro_rules! tuple {
 834     () => ();
 835     ( $($name:ident,)+ ) => (
 836         impl<D: Decoder, $($name: Decodable<D>),+> Decodable<D> for ($($name,)+) {
 837             #[allow(non_snake_case)]
 838             fn decode(d: &mut D) -> Result<($($name,)+), D::Error> {
 839                 let len: usize = count!($($name)+);
 840                 d.read_tuple(len, |d| {
 841                     let mut i = 0;
 842                     let ret = ($(d.read_tuple_arg({ i+=1; i-1 }, |d| -> Result<$name, D::Error> {
 843                         Decodable::decode(d)
 844                     })?,)+);
 845                     Ok(ret)
 846                 })
 847             }
 848         }
 849         impl<S: Encoder, $($name: Encodable<S>),+> Encodable<S> for ($($name,)+) {
 850             #[allow(non_snake_case)]
 851             fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 852                 let ($(ref $name,)+) = *self;
 853                 let mut n = 0;
 854                 $(let $name = $name; n += 1;)+
 855                 s.emit_tuple(n, |s| {
 856                     let mut i = 0;
 857                     $(s.emit_tuple_arg({ i+=1; i-1 }, |s| $name.encode(s))?;)+
 858                     Ok(())
 859                 })
 860             }
 861         }
 862         peel! { $($name,)+ }
 863     )
 864 }
 865
 866 tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
 867
 868 impl<S: Encoder> Encodable<S> for path::Path {
 869     fn encode(&self, e: &mut S) -> Result<(), S::Error> {
 870         self.to_str().unwrap().encode(e)
 871     }
 872 }
 873
 874 impl<S: Encoder> Encodable<S> for path::PathBuf {
 875     fn encode(&self, e: &mut S) -> Result<(), S::Error> {
 876         path::Path::encode(self, e)
 877     }
 878 }
 879
 880 impl<D: Decoder> Decodable<D> for path::PathBuf {
 881     fn decode(d: &mut D) -> Result<path::PathBuf, D::Error> {
 882         let bytes: String = Decodable::decode(d)?;
 883         Ok(path::PathBuf::from(bytes))
 884     }
 885 }
 886
 887 impl<S: Encoder, T: Encodable<S> + Copy> Encodable<S> for Cell<T> {
 888     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 889         self.get().encode(s)
 890     }
 891 }
 892
 893 impl<D: Decoder, T: Decodable<D> + Copy> Decodable<D> for Cell<T> {
 894     fn decode(d: &mut D) -> Result<Cell<T>, D::Error> {
 895         Ok(Cell::new(Decodable::decode(d)?))
 896     }
 897 }
 898
 899 // FIXME: #15036
 900 // Should use `try_borrow`, returning a
 901 // `encoder.error("attempting to Encode borrowed RefCell")`
 902 // from `encode` when `try_borrow` returns `None`.
 903
 904 impl<S: Encoder, T: Encodable<S>> Encodable<S> for RefCell<T> {
 905     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 906         self.borrow().encode(s)
 907     }
 908 }
 909
 910 impl<D: Decoder, T: Decodable<D>> Decodable<D> for RefCell<T> {
 911     fn decode(d: &mut D) -> Result<RefCell<T>, D::Error> {
 912         Ok(RefCell::new(Decodable::decode(d)?))
 913     }
 914 }
 915
 916 impl<S: Encoder, T: Encodable<S>> Encodable<S> for Arc<T> {
 917     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 918         (**self).encode(s)
 919     }
 920 }
 921
 922 impl<D: Decoder, T: Decodable<D>> Decodable<D> for Arc<T> {
 923     fn decode(d: &mut D) -> Result<Arc<T>, D::Error> {
 924         Ok(Arc::new(Decodable::decode(d)?))
 925     }
 926 }
 927
 928 impl<S: Encoder, T: ?Sized + Encodable<S>> Encodable<S> for Box<T> {
 929     fn encode(&self, s: &mut S) -> Result<(), S::Error> {
 930         (**self).encode(s)
 931     }
 932 }
 933 impl<D: Decoder, T: Decodable<D>> Decodable<D> for Box<T> {
 934     fn decode(d: &mut D) -> Result<Box<T>, D::Error> {
 935         Ok(box Decodable::decode(d)?)
 936     }
 937 }