Auto merge of #68530 - estebank:abolish-ice, r=petrochenkov

[rust.git] / src / libserialize / serialize.rs

diff --git a/src/libserialize/serialize.rs b/src/libserialize/serialize.rs
index 2def2a455fb6448158a844a465d29e37fa900f07..19283ffc43864f29892b39298f7a6166432f792b 100644 (file)
--- a/src/libserialize/serialize.rs
+++ b/src/libserialize/serialize.rs
@@ -4,12 +4,12 @@
 Core encoding and decoding interfaces.
 */
 
+use std::any;
 use std::borrow::Cow;
-use std::intrinsics;
+use std::cell::{Cell, RefCell};
 use std::marker::PhantomData;
 use std::path;
 use std::rc::Rc;
-use std::cell::{Cell, RefCell};
 use std::sync::Arc;
 
 pub trait Encoder {
@@ -37,75 +37,109 @@ pub trait Encoder {
 
     // Compound types:
     fn emit_enum<F>(&mut self, _name: &str, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         f(self)
     }
 
-    fn emit_enum_variant<F>(&mut self, _v_name: &str, v_id: usize, _len: usize, f: F)
-        -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    fn emit_enum_variant<F>(
+        &mut self,
+        _v_name: &str,
+        v_id: usize,
+        _len: usize,
+        f: F,
+    ) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         self.emit_usize(v_id)?;
         f(self)
     }
 
     fn emit_enum_variant_arg<F>(&mut self, _a_idx: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         f(self)
     }
 
-    fn emit_enum_struct_variant<F>(&mut self, v_name: &str, v_id: usize, len: usize, f: F)
-        -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    fn emit_enum_struct_variant<F>(
+        &mut self,
+        v_name: &str,
+        v_id: usize,
+        len: usize,
+        f: F,
+    ) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         self.emit_enum_variant(v_name, v_id, len, f)
     }
 
-    fn emit_enum_struct_variant_field<F>(&mut self, _f_name: &str, f_idx: usize, f: F)
-        -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    fn emit_enum_struct_variant_field<F>(
+        &mut self,
+        _f_name: &str,
+        f_idx: usize,
+        f: F,
+    ) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         self.emit_enum_variant_arg(f_idx, f)
     }
 
     fn emit_struct<F>(&mut self, _name: &str, _len: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         f(self)
     }
 
-    fn emit_struct_field<F>(&mut self, _f_name: &str, _f_idx: usize, f: F)
-        -> Result<(), Self::Error> where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    fn emit_struct_field<F>(
+        &mut self,
+        _f_name: &str,
+        _f_idx: usize,
+        f: F,
+    ) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         f(self)
     }
 
     fn emit_tuple<F>(&mut self, _len: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         f(self)
     }
 
     fn emit_tuple_arg<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         f(self)
     }
 
     fn emit_tuple_struct<F>(&mut self, _name: &str, len: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         self.emit_tuple(len, f)
     }
 
     fn emit_tuple_struct_arg<F>(&mut self, f_idx: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         self.emit_tuple_arg(f_idx, f)
     }
 
     // Specialized types:
     fn emit_option<F>(&mut self, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         self.emit_enum("Option", f)
     }
@@ -116,39 +150,45 @@ fn emit_option_none(&mut self) -> Result<(), Self::Error> {
     }
 
     fn emit_option_some<F>(&mut self, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         self.emit_enum_variant("Some", 1, 1, f)
     }
 
     fn emit_seq<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         self.emit_usize(len)?;
         f(self)
     }
 
     fn emit_seq_elt<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         f(self)
     }
 
     fn emit_map<F>(&mut self, len: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         self.emit_usize(len)?;
         f(self)
     }
 
     fn emit_map_elt_key<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         f(self)
     }
 
     fn emit_map_elt_val<F>(&mut self, _idx: usize, f: F) -> Result<(), Self::Error>
-        where F: FnOnce(&mut Self) -> Result<(), Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<(), Self::Error>,
     {
         f(self)
     }
@@ -179,115 +219,140 @@ pub trait Decoder {
 
     // Compound types:
     fn read_enum<T, F>(&mut self, _name: &str, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<T, Self::Error>,
     {
         f(self)
     }
 
     fn read_enum_variant<T, F>(&mut self, _names: &[&str], mut f: F) -> Result<T, Self::Error>
-        where F: FnMut(&mut Self, usize) -> Result<T, Self::Error>
+    where
+        F: FnMut(&mut Self, usize) -> Result<T, Self::Error>,
     {
         let disr = self.read_usize()?;
         f(self, disr)
     }
 
     fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<T, Self::Error>,
     {
         f(self)
     }
 
     fn read_enum_struct_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, Self::Error>
-        where F: FnMut(&mut Self, usize) -> Result<T, Self::Error>
+    where
+        F: FnMut(&mut Self, usize) -> Result<T, Self::Error>,
     {
         self.read_enum_variant(names, f)
     }
 
-    fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, f_idx: usize, f: F)
-        -> Result<T, Self::Error> where F: FnOnce(&mut Self) -> Result<T, Self::Error>
+    fn read_enum_struct_variant_field<T, F>(
+        &mut self,
+        _f_name: &str,
+        f_idx: usize,
+        f: F,
+    ) -> Result<T, Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<T, Self::Error>,
     {
         self.read_enum_variant_arg(f_idx, f)
     }
 
     fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<T, Self::Error>,
     {
         f(self)
     }
 
-    fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, f: F)
-        -> Result<T, Self::Error> where F: FnOnce(&mut Self) -> Result<T, Self::Error>
+    fn read_struct_field<T, F>(
+        &mut self,
+        _f_name: &str,
+        _f_idx: usize,
+        f: F,
+    ) -> Result<T, Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<T, Self::Error>,
     {
         f(self)
     }
 
     fn read_tuple<T, F>(&mut self, _len: usize, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<T, Self::Error>,
     {
         f(self)
     }
 
     fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<T, Self::Error>,
     {
         f(self)
     }
 
     fn read_tuple_struct<T, F>(&mut self, _s_name: &str, len: usize, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<T, Self::Error>,
     {
         self.read_tuple(len, f)
     }
 
     fn read_tuple_struct_arg<T, F>(&mut self, a_idx: usize, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<T, Self::Error>,
     {
         self.read_tuple_arg(a_idx, f)
     }
 
     // Specialized types:
     fn read_option<T, F>(&mut self, mut f: F) -> Result<T, Self::Error>
-        where F: FnMut(&mut Self, bool) -> Result<T, Self::Error>
+    where
+        F: FnMut(&mut Self, bool) -> Result<T, Self::Error>,
     {
         self.read_enum("Option", move |this| {
-            this.read_enum_variant(&["None", "Some"], move |this, idx| {
-                match idx {
-                    0 => f(this, false),
-                    1 => f(this, true),
-                    _ => Err(this.error("read_option: expected 0 for None or 1 for Some")),
-                }
+            this.read_enum_variant(&["None", "Some"], move |this, idx| match idx {
+                0 => f(this, false),
+                1 => f(this, true),
+                _ => Err(this.error("read_option: expected 0 for None or 1 for Some")),
             })
         })
     }
 
     fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>
+    where
+        F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>,
     {
         let len = self.read_usize()?;
         f(self, len)
     }
 
     fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<T, Self::Error>,
     {
         f(self)
     }
 
     fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>
+    where
+        F: FnOnce(&mut Self, usize) -> Result<T, Self::Error>,
     {
         let len = self.read_usize()?;
         f(self, len)
     }
 
     fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<T, Self::Error>,
     {
         f(self)
     }
 
     fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Self::Error>
-        where F: FnOnce(&mut Self) -> Result<T, Self::Error>
+    where
+        F: FnOnce(&mut Self) -> Result<T, Self::Error>,
     {
         f(self)
     }
@@ -563,32 +628,32 @@ fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
     }
 }
 
-impl< T: Decodable> Decodable for Box<T> {
+impl<T: Decodable> Decodable for Box<T> {
     fn decode<D: Decoder>(d: &mut D) -> Result<Box<T>, D::Error> {
         Ok(box Decodable::decode(d)?)
     }
 }
 
-impl< T: Decodable> Decodable for Box<[T]> {
+impl<T: Decodable> Decodable for Box<[T]> {
     fn decode<D: Decoder>(d: &mut D) -> Result<Box<[T]>, D::Error> {
         let v: Vec<T> = Decodable::decode(d)?;
         Ok(v.into_boxed_slice())
     }
 }
 
-impl<T:Encodable> Encodable for Rc<T> {
+impl<T: Encodable> Encodable for Rc<T> {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         (**self).encode(s)
     }
 }
 
-impl<T:Decodable> Decodable for Rc<T> {
+impl<T: Decodable> Decodable for Rc<T> {
     fn decode<D: Decoder>(d: &mut D) -> Result<Rc<T>, D::Error> {
         Ok(Rc::new(Decodable::decode(d)?))
     }
 }
 
-impl<T:Encodable> Encodable for [T] {
+impl<T: Encodable> Encodable for [T] {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         s.emit_seq(self.len(), |s| {
             for (i, e) in self.iter().enumerate() {
@@ -599,7 +664,7 @@ fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
     }
 }
 
-impl<T:Encodable> Encodable for Vec<T> {
+impl<T: Encodable> Encodable for Vec<T> {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         s.emit_seq(self.len(), |s| {
             for (i, e) in self.iter().enumerate() {
@@ -610,7 +675,7 @@ fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
     }
 }
 
-impl<T:Decodable> Decodable for Vec<T> {
+impl<T: Decodable> Decodable for Vec<T> {
     fn decode<D: Decoder>(d: &mut D) -> Result<Vec<T>, D::Error> {
         d.read_seq(|d, len| {
             let mut v = Vec::with_capacity(len);
@@ -622,7 +687,10 @@ fn decode<D: Decoder>(d: &mut D) -> Result<Vec<T>, D::Error> {
     }
 }
 
-impl<'a, T:Encodable> Encodable for Cow<'a, [T]> where [T]: ToOwned<Owned = Vec<T>> {
+impl<'a, T: Encodable> Encodable for Cow<'a, [T]>
+where
+    [T]: ToOwned<Owned = Vec<T>>,
+{
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         s.emit_seq(self.len(), |s| {
             for (i, e) in self.iter().enumerate() {
@@ -633,8 +701,9 @@ fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
     }
 }
 
-impl<T:Decodable+ToOwned> Decodable for Cow<'static, [T]>
-    where [T]: ToOwned<Owned = Vec<T>>
+impl<T: Decodable + ToOwned> Decodable for Cow<'static, [T]>
+where
+    [T]: ToOwned<Owned = Vec<T>>,
 {
     fn decode<D: Decoder>(d: &mut D) -> Result<Cow<'static, [T]>, D::Error> {
         d.read_seq(|d, len| {
@@ -647,72 +716,45 @@ fn decode<D: Decoder>(d: &mut D) -> Result<Cow<'static, [T]>, D::Error> {
     }
 }
 
-
-impl<T:Encodable> Encodable for Option<T> {
+impl<T: Encodable> Encodable for Option<T> {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_option(|s| {
-            match *self {
-                None => s.emit_option_none(),
-                Some(ref v) => s.emit_option_some(|s| v.encode(s)),
-            }
+        s.emit_option(|s| match *self {
+            None => s.emit_option_none(),
+            Some(ref v) => s.emit_option_some(|s| v.encode(s)),
         })
     }
 }
 
-impl<T:Decodable> Decodable for Option<T> {
+impl<T: Decodable> Decodable for Option<T> {
     fn decode<D: Decoder>(d: &mut D) -> Result<Option<T>, D::Error> {
-        d.read_option(|d, b| {
-            if b {
-                Ok(Some(Decodable::decode(d)?))
-            } else {
-                Ok(None)
-            }
-        })
+        d.read_option(|d, b| if b { Ok(Some(Decodable::decode(d)?)) } else { Ok(None) })
     }
 }
 
 impl<T1: Encodable, T2: Encodable> Encodable for Result<T1, T2> {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_enum("Result", |s| {
-            match *self {
-                Ok(ref v) => {
-                    s.emit_enum_variant("Ok", 0, 1, |s| {
-                        s.emit_enum_variant_arg(0, |s| {
-                            v.encode(s)
-                        })
-                    })
-                }
-                Err(ref v) => {
-                    s.emit_enum_variant("Err", 1, 1, |s| {
-                        s.emit_enum_variant_arg(0, |s| {
-                            v.encode(s)
-                        })
-                    })
-                }
+        s.emit_enum("Result", |s| match *self {
+            Ok(ref v) => {
+                s.emit_enum_variant("Ok", 0, 1, |s| s.emit_enum_variant_arg(0, |s| v.encode(s)))
+            }
+            Err(ref v) => {
+                s.emit_enum_variant("Err", 1, 1, |s| s.emit_enum_variant_arg(0, |s| v.encode(s)))
             }
         })
     }
 }
 
-impl<T1:Decodable, T2:Decodable> Decodable for Result<T1, T2> {
+impl<T1: Decodable, T2: Decodable> Decodable for Result<T1, T2> {
     fn decode<D: Decoder>(d: &mut D) -> Result<Result<T1, T2>, D::Error> {
         d.read_enum("Result", |d| {
-            d.read_enum_variant(&["Ok", "Err"], |d, disr| {
-                match disr {
-                    0 => {
-                        Ok(Ok(d.read_enum_variant_arg(0, |d| {
-                            T1::decode(d)
-                        })?))
-                    }
-                    1 => {
-                        Ok(Err(d.read_enum_variant_arg(0, |d| {
-                            T2::decode(d)
-                        })?))
-                    }
-                    _ => {
-                        panic!("Encountered invalid discriminant while \
-                                decoding `Result`.");
-                    }
+            d.read_enum_variant(&["Ok", "Err"], |d, disr| match disr {
+                0 => Ok(Ok(d.read_enum_variant_arg(0, |d| T1::decode(d))?)),
+                1 => Ok(Err(d.read_enum_variant_arg(0, |d| T2::decode(d))?)),
+                _ => {
+                    panic!(
+                        "Encountered invalid discriminant while \
+                                decoding `Result`."
+                    );
                 }
             })
         })
@@ -819,13 +861,13 @@ fn decode<D: Decoder>(d: &mut D) -> Result<RefCell<T>, D::Error> {
     }
 }
 
-impl<T:Encodable> Encodable for Arc<T> {
+impl<T: Encodable> Encodable for Arc<T> {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
         (**self).encode(s)
     }
 }
 
-impl<T:Decodable> Decodable for Arc<T> {
+impl<T: Decodable> Decodable for Arc<T> {
     fn decode<D: Decoder>(d: &mut D) -> Result<Arc<T>, D::Error> {
         Ok(Arc::new(Decodable::decode(d)?))
     }
@@ -848,11 +890,13 @@ pub trait SpecializationError {
 
 impl<E> SpecializationError for E {
     default fn not_found<S, T: ?Sized>(trait_name: &'static str, method_name: &'static str) -> E {
-        panic!("missing specialization: `<{} as {}<{}>>::{}` not overridden",
-               unsafe { intrinsics::type_name::<S>() },
-               trait_name,
-               unsafe { intrinsics::type_name::<T>() },
-               method_name);
+        panic!(
+            "missing specialization: `<{} as {}<{}>>::{}` not overridden",
+            any::type_name::<S>(),
+            trait_name,
+            any::type_name::<T>(),
+            method_name
+        );
     }
 }