Auto merge of #314 - dtolnay:revert, r=erickt

Revert "Enable use in no_std environments"

This commit failed to build even before it was merged. See #313.

.travis.yml

@@ -18,11 +18,6 @@ script:
 - (cd serde && travis-cargo build)
 - (cd serde && travis-cargo test)
 - (cd serde && travis-cargo --only nightly test -- --features nightly-testing)
-- (cd serde && travis-cargo --skip 1.5.0 build -- --no-default-features)
-- (cd serde && travis-cargo --only nightly build -- --no-default-features)
-- (cd serde && travis-cargo --only nightly build -- --no-default-features --features alloc)
-- (cd serde && travis-cargo --only nightly build -- --no-default-features --features collections)
-- (cd serde && travis-cargo --only nightly build -- --no-default-features --features rustc_unicode)
 - (cd serde_tests && travis-cargo test)
 - (cd serde_tests && travis-cargo --only nightly test -- --features nightly-testing)
 - (cd serde_macros && travis-cargo --only nightly test -- --features nightly-testing)

README.md

@@ -718,20 +718,6 @@ Field Annotations:
 | `#[serde(serialize_with="$path")]`      | Call a function `fn<S>(&T, &mut S) -> Result<(), S::Error> where S: Serializer` to serialize this value of type `T` |
 | `#[serde(deserialize_with="$path")]`    | Call a function `fn<D>(&mut D) -> Result<T, D::Error> where D: Deserializer` to deserialize this value of type `T`  |
 
-Using in `no_std` crates
-========================
-
-The core `serde` package defines a number of features to enable usage in a
-variety of freestanding environments. Enable any or none of the following
-features, and use `default-features = false` in your `Cargo.toml`:
-
-- `alloc` (implies `nightly`)
-- `collections` (implies `alloc` and `nightly`)
-- `std` (default)
-
-If you only use `default-features = false`, you will receive a stock `no_std`
-serde with no support for any of the collection types.
-
 Upgrading from Serde 0.6
 ========================
 

serde/Cargo.toml

@@ -10,13 +10,8 @@ readme = "../README.md"
 keywords = ["serde", "serialization"]
 
 [features]
-default = ["std"]
-
-std = []
 nightly = []
-alloc = ["nightly"]
+nightly-testing = ["clippy", "nightly"]
-collections = ["alloc"]
-nightly-testing = ["clippy", "nightly", "std"]
 
 [dependencies]
 clippy = { version = "^0.*", optional = true }

serde/src/bytes.rs

@@ -1,15 +1,11 @@
 //! Helper module to enable serializing bytes more efficiently
 
-use core::{ops, fmt, char, iter, slice};
+use std::ops;
-use core::fmt::Write;
+use std::fmt;
+use std::ascii;
 
 use ser;
-
+use de;
-#[cfg(any(feature = "std", feature = "collections"))]
-pub use self::bytebuf::{ByteBuf, ByteBufVisitor};
-
-#[cfg(feature = "collections")]
-use collections::Vec;
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -21,11 +17,7 @@ pub struct Bytes<'a> {
 
 impl<'a> fmt::Debug for Bytes<'a> {
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        try!(f.write_str("b\""));
+        write!(f, "b\"{}\"", escape_bytestring(self.bytes))
-        for c in escape_bytestring(self.bytes) {
-            try!(f.write_char(c));
-        }
-        f.write_char('"')
     }
 }
 
@@ -37,7 +29,6 @@ impl<'a> From<&'a [u8]> for Bytes<'a> {
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<'a> From<&'a Vec<u8>> for Bytes<'a> {
     fn from(bytes: &'a Vec<u8>) -> Self {
         Bytes {
@@ -69,172 +60,157 @@ impl<'a> ser::Serialize for Bytes<'a> {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(feature = "std", feature = "collections"))]
+/// `ByteBuf` wraps a `Vec<u8>` and serializes as a byte array.
-mod bytebuf {
+#[derive(Clone, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
-    use core::ops;
+pub struct ByteBuf {
-    use core::fmt;
+    bytes: Vec<u8>,
-    use core::fmt::Write;
+}
 
-    use ser;
+impl ByteBuf {
-    use de;
+    /// Construct a new, empty `ByteBuf`.
-
+    pub fn new() -> Self {
-    #[cfg(feature = "collections")]
+        ByteBuf {
-    use collections::Vec;
+            bytes: Vec::new(),
-
-    /// `ByteBuf` wraps a `Vec<u8>` and serializes as a byte array.
-    #[derive(Clone, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
-    pub struct ByteBuf {
-        bytes: Vec<u8>,
-    }
-
-    impl ByteBuf {
-        /// Construct a new, empty `ByteBuf`.
-        pub fn new() -> Self {
-            ByteBuf {
-                bytes: Vec::new(),
-            }
-        }
-
-        /// Construct a new, empty `ByteBuf` with the specified capacity.
-        pub fn with_capacity(cap: usize) -> Self {
-            ByteBuf {
-                bytes: Vec::with_capacity(cap)
-            }
         }
     }
 
-    impl fmt::Debug for ByteBuf {
+    /// Construct a new, empty `ByteBuf` with the specified capacity.
-        fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+    pub fn with_capacity(cap: usize) -> Self {
-            try!(f.write_str("b\""));
+        ByteBuf {
-            for c in super::escape_bytestring(self.bytes.as_ref()) {
+            bytes: Vec::with_capacity(cap)
-                try!(f.write_char(c));
-            }
-            f.write_char('"')
         }
     }
+}
 
-    impl Into<Vec<u8>> for ByteBuf {
+impl fmt::Debug for ByteBuf {
-        fn into(self) -> Vec<u8> {
+    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-            self.bytes
+        write!(f, "b\"{}\"", escape_bytestring(self.bytes.as_ref()))
+    }
+}
+
+impl Into<Vec<u8>> for ByteBuf {
+    fn into(self) -> Vec<u8> {
+        self.bytes
+    }
+}
+
+impl From<Vec<u8>> for ByteBuf {
+    fn from(bytes: Vec<u8>) -> Self {
+        ByteBuf {
+            bytes: bytes,
         }
     }
+}
 
-    impl From<Vec<u8>> for ByteBuf {
+impl AsRef<Vec<u8>> for ByteBuf {
-        fn from(bytes: Vec<u8>) -> Self {
+    fn as_ref(&self) -> &Vec<u8> {
-            ByteBuf {
+        &self.bytes
-                bytes: bytes,
+    }
-            }
+}
-        }
+
+impl AsRef<[u8]> for ByteBuf {
+    fn as_ref(&self) -> &[u8] {
+        &self.bytes
+    }
+}
+
+impl AsMut<Vec<u8>> for ByteBuf {
+    fn as_mut(&mut self) -> &mut Vec<u8> {
+        &mut self.bytes
+    }
+}
+
+impl AsMut<[u8]> for ByteBuf {
+    fn as_mut(&mut self) -> &mut [u8] {
+        &mut self.bytes
+    }
+}
+
+impl ops::Deref for ByteBuf {
+    type Target = [u8];
+
+    fn deref(&self) -> &[u8] { &self.bytes[..] }
+}
+
+impl ops::DerefMut for ByteBuf {
+    fn deref_mut(&mut self) -> &mut [u8] { &mut self.bytes[..] }
+}
+
+impl ser::Serialize for ByteBuf {
+    fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+        where S: ser::Serializer
+    {
+        serializer.serialize_bytes(&self)
+    }
+}
+
+/// This type implements the `serde::de::Visitor` trait for a `ByteBuf`.
+pub struct ByteBufVisitor;
+
+impl de::Visitor for ByteBufVisitor {
+    type Value = ByteBuf;
+
+    #[inline]
+    fn visit_unit<E>(&mut self) -> Result<ByteBuf, E>
+        where E: de::Error,
+    {
+        Ok(ByteBuf {
+            bytes: Vec::new(),
+        })
     }
 
-    impl AsRef<Vec<u8>> for ByteBuf {
+    #[inline]
-        fn as_ref(&self) -> &Vec<u8> {
+    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<ByteBuf, V::Error>
-            &self.bytes
+        where V: de::SeqVisitor,
+    {
+        let (len, _) = visitor.size_hint();
+        let mut values = Vec::with_capacity(len);
+
+        while let Some(value) = try!(visitor.visit()) {
+            values.push(value);
         }
+
+        try!(visitor.end());
+
+        Ok(ByteBuf {
+            bytes: values,
+        })
     }
 
-    impl AsRef<[u8]> for ByteBuf {
+    #[inline]
-        fn as_ref(&self) -> &[u8] {
+    fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<ByteBuf, E>
-            &self.bytes
+        where E: de::Error,
-        }
+    {
+        self.visit_byte_buf(v.to_vec())
     }
 
-    impl AsMut<Vec<u8>> for ByteBuf {
+    #[inline]
-        fn as_mut(&mut self) -> &mut Vec<u8> {
+    fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<ByteBuf, E>
-            &mut self.bytes
+        where E: de::Error,
-        }
+    {
+        Ok(ByteBuf {
+            bytes: v,
+        })
     }
+}
 
-    impl AsMut<[u8]> for ByteBuf {
+impl de::Deserialize for ByteBuf {
-        fn as_mut(&mut self) -> &mut [u8] {
+    #[inline]
-            &mut self.bytes
+    fn deserialize<D>(deserializer: &mut D) -> Result<ByteBuf, D::Error>
-        }
+        where D: de::Deserializer
-    }
+    {
-
+        deserializer.deserialize_bytes(ByteBufVisitor)
-    impl ops::Deref for ByteBuf {
-        type Target = [u8];
-
-        fn deref(&self) -> &[u8] { &self.bytes[..] }
-    }
-
-    impl ops::DerefMut for ByteBuf {
-        fn deref_mut(&mut self) -> &mut [u8] { &mut self.bytes[..] }
-    }
-
-    impl ser::Serialize for ByteBuf {
-        fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
-            where S: ser::Serializer
-        {
-            serializer.serialize_bytes(&self)
-        }
-    }
-
-    /// This type implements the `serde::de::Visitor` trait for a `ByteBuf`.
-    pub struct ByteBufVisitor;
-
-    impl de::Visitor for ByteBufVisitor {
-        type Value = ByteBuf;
-
-        #[inline]
-        fn visit_unit<E>(&mut self) -> Result<ByteBuf, E>
-            where E: de::Error,
-        {
-            Ok(ByteBuf {
-                bytes: Vec::new(),
-            })
-        }
-
-        #[inline]
-        fn visit_seq<V>(&mut self, mut visitor: V) -> Result<ByteBuf, V::Error>
-            where V: de::SeqVisitor,
-        {
-            let (len, _) = visitor.size_hint();
-            let mut values = Vec::with_capacity(len);
-
-            while let Some(value) = try!(visitor.visit()) {
-                values.push(value);
-            }
-
-            try!(visitor.end());
-
-            Ok(ByteBuf {
-                bytes: values,
-            })
-        }
-
-        #[inline]
-        fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<ByteBuf, E>
-            where E: de::Error,
-        {
-            self.visit_byte_buf(v.to_vec())
-        }
-
-        #[inline]
-        fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<ByteBuf, E>
-            where E: de::Error,
-        {
-            Ok(ByteBuf {
-                bytes: v,
-            })
-        }
-    }
-
-    impl de::Deserialize for ByteBuf {
-        #[inline]
-        fn deserialize<D>(deserializer: &mut D) -> Result<ByteBuf, D::Error>
-            where D: de::Deserializer
-        {
-            deserializer.deserialize_bytes(ByteBufVisitor)
-        }
     }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[inline]
+fn escape_bytestring(bytes: &[u8]) -> String {
-fn escape_bytestring<'a>(bytes: &'a [u8]) -> iter::FlatMap<slice::Iter<'a, u8>, char::EscapeDefault, fn(&u8) -> char::EscapeDefault> {
+    let mut result = String::new();
-    fn f(b: &u8) -> char::EscapeDefault {
+    for &b in bytes {
-        char::from_u32(*b as u32).unwrap().escape_default()
+        for esc in ascii::escape_default(b) {
+            result.push(esc as char);
+        }
     }
-    bytes.iter().flat_map(f as fn(&u8) -> char::EscapeDefault)
+    result
 }

serde/src/de/from_primitive.rs

@@ -13,10 +13,10 @@
 // Rust 1.5 is unhappy that this private module is undocumented.
 #![allow(missing_docs)]
 
-use core::{usize, u8, u16, u32, u64};
+use std::{usize, u8, u16, u32, u64};
-use core::{isize, i8, i16, i32, i64};
+use std::{isize, i8, i16, i32, i64};
-use core::{f32, f64};
+use std::{f32, f64};
-use core::mem::size_of;
+use std::mem::size_of;
 
 /// Numbers which have upper and lower bounds
 pub trait Bounded {
@@ -274,7 +274,7 @@ macro_rules! impl_to_primitive_float_to_float {
             Some($slf as $DstT)
         } else {
             let n = $slf as f64;
-            let max_value: $SrcT = ::core::$SrcT::MAX;
+            let max_value: $SrcT = ::std::$SrcT::MAX;
             if -max_value as f64 <= n && n <= max_value as f64 {
                 Some($slf as $DstT)
             } else {

serde/src/de/impls.rs

@@ -1,63 +1,30 @@
 //! This module contains `Deserialize` and `Visitor` implementations.
 
-#[cfg(feature = "std")]
 use std::borrow::Cow;
-#[cfg(all(feature = "nightly", feature = "collections", not(feature = "std")))]
+use std::collections::{
-use collections::borrow::Cow;
-
-#[cfg(all(feature = "collections", not(feature = "std")))]
-use collections::{
     BinaryHeap,
     BTreeMap,
     BTreeSet,
     LinkedList,
-    VecDeque,
-    Vec,
-    String,
-};
-
-#[cfg(feature = "std")]
-use std::collections::{
     HashMap,
     HashSet,
-    BinaryHeap,
-    BTreeMap,
-    BTreeSet,
-    LinkedList,
     VecDeque,
 };
-
+#[cfg(feature = "nightly")]
-#[cfg(all(feature = "nightly", feature = "collections"))]
 use collections::enum_set::{CLike, EnumSet};
-#[cfg(all(feature = "nightly", feature = "collections"))]
+use std::hash::Hash;
-use collections::borrow::ToOwned;
+use std::marker::PhantomData;
-
-use core::hash::Hash;
-use core::marker::PhantomData;
-#[cfg(feature = "std")]
 use std::net;
-#[cfg(feature = "std")]
 use std::path;
-use core::str;
-
-#[cfg(feature = "std")]
 use std::rc::Rc;
-#[cfg(all(feature = "nightly", feature = "alloc", not(feature = "std")))]
+use std::str;
-use alloc::rc::Rc;
-
-#[cfg(feature = "std")]
 use std::sync::Arc;
-#[cfg(all(feature = "nightly", feature = "alloc", not(feature = "std")))]
-use alloc::arc::Arc;
-
-#[cfg(all(feature = "nightly", feature = "alloc", not(feature = "std")))]
-use alloc::boxed::Box;
 
 #[cfg(feature = "nightly")]
 use core::nonzero::{NonZero, Zeroable};
 
 #[cfg(feature = "nightly")]
-use core::num::Zero;
+use std::num::Zero;
 
 use de::{
     Deserialize,
@@ -118,7 +85,7 @@ impl Visitor for BoolVisitor {
     fn visit_str<E>(&mut self, s: &str) -> Result<bool, E>
         where E: Error,
     {
-        match s.trim_matches(|c| ::utils::Pattern_White_Space(c)) {
+        match s.trim() {
             "true" => Ok(true),
             "false" => Ok(false),
             _ => Err(Error::invalid_type(Type::Bool)),
@@ -184,10 +151,10 @@ impl<T> Visitor for PrimitiveVisitor<T>
     impl_deserialize_num_method!(f64, visit_f64, from_f64, Type::F64);
 
     #[inline]
-    fn visit_str<E>(&mut self, s: &str) -> Result<T, E>
+    fn visit_str<E>(&mut self, v: &str) -> Result<T, E>
         where E: Error,
     {
-        str::FromStr::from_str(s.trim_matches(::utils::Pattern_White_Space)).or_else(|_| {
+        str::FromStr::from_str(v.trim()).or_else(|_| {
             Err(Error::invalid_type(Type::Str))
         })
     }
@@ -261,10 +228,8 @@ impl Deserialize for char {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(feature = "std", feature = "collections"))]
 struct StringVisitor;
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl Visitor for StringVisitor {
     type Value = String;
 
@@ -299,7 +264,6 @@ impl Visitor for StringVisitor {
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl Deserialize for String {
     fn deserialize<D>(deserializer: &mut D) -> Result<String, D::Error>
         where D: Deserializer,
@@ -442,7 +406,6 @@ macro_rules! seq_impl {
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 seq_impl!(
     BinaryHeap<T>,
     <Deserialize, Ord>,
@@ -452,7 +415,6 @@ seq_impl!(
     BinaryHeap::with_capacity(visitor.size_hint().0),
     BinaryHeap::push);
 
-#[cfg(any(feature = "std", feature = "collections"))]
 seq_impl!(
     BTreeSet<T>,
     <Deserialize, Eq, Ord>,
@@ -462,7 +424,7 @@ seq_impl!(
     BTreeSet::new(),
     BTreeSet::insert);
 
-#[cfg(all(feature = "nightly", feature = "collections"))]
+#[cfg(feature = "nightly")]
 seq_impl!(
     EnumSet<T>,
     <Deserialize, CLike>,
@@ -472,7 +434,6 @@ seq_impl!(
     EnumSet::new(),
     EnumSet::insert);
 
-#[cfg(any(feature = "std", feature = "collections"))]
 seq_impl!(
     LinkedList<T>,
     <Deserialize>,
@@ -482,7 +443,6 @@ seq_impl!(
     LinkedList::new(),
     LinkedList::push_back);
 
-#[cfg(feature = "std")]
 seq_impl!(
     HashSet<T>,
     <Deserialize, Eq, Hash>,
@@ -492,7 +452,6 @@ seq_impl!(
     HashSet::with_capacity(visitor.size_hint().0),
     HashSet::insert);
 
-#[cfg(any(feature = "std", feature = "collections"))]
 seq_impl!(
     Vec<T>,
     <Deserialize>,
@@ -502,7 +461,6 @@ seq_impl!(
     Vec::with_capacity(visitor.size_hint().0),
     Vec::push);
 
-#[cfg(any(feature = "std", feature = "collections"))]
 seq_impl!(
     VecDeque<T>,
     <Deserialize>,
@@ -789,7 +747,6 @@ macro_rules! map_impl {
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 map_impl!(
     BTreeMap<K, V>,
     <Deserialize, Eq, Ord>,
@@ -799,7 +756,6 @@ map_impl!(
     BTreeMap::new(),
     BTreeMap::insert);
 
-#[cfg(feature = "std")]
 map_impl!(
     HashMap<K, V>,
     <Deserialize, Eq, Hash>,
@@ -811,7 +767,7 @@ map_impl!(
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[cfg(all(feature = "nightly", feature = "std"))]
+#[cfg(feature = "nightly")]
 impl Deserialize for net::IpAddr {
     fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
         where D: Deserializer,
@@ -824,7 +780,6 @@ impl Deserialize for net::IpAddr {
     }
 }
 
-#[cfg(feature = "std")]
 impl Deserialize for net::Ipv4Addr {
     fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
         where D: Deserializer,
@@ -837,7 +792,6 @@ impl Deserialize for net::Ipv4Addr {
     }
 }
 
-#[cfg(feature = "std")]
 impl Deserialize for net::Ipv6Addr {
     fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
         where D: Deserializer,
@@ -852,7 +806,6 @@ impl Deserialize for net::Ipv6Addr {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "std")]
 impl Deserialize for net::SocketAddr {
     fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
         where D: Deserializer,
@@ -865,7 +818,6 @@ impl Deserialize for net::SocketAddr {
     }
 }
 
-#[cfg(feature = "std")]
 impl Deserialize for net::SocketAddrV4 {
     fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
         where D: Deserializer,
@@ -878,7 +830,6 @@ impl Deserialize for net::SocketAddrV4 {
     }
 }
 
-#[cfg(feature = "std")]
 impl Deserialize for net::SocketAddrV6 {
     fn deserialize<D>(deserializer: &mut D) -> Result<Self, D::Error>
         where D: Deserializer,
@@ -893,10 +844,8 @@ impl Deserialize for net::SocketAddrV6 {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "std")]
 struct PathBufVisitor;
 
-#[cfg(feature = "std")]
 impl Visitor for PathBufVisitor {
     type Value = path::PathBuf;
 
@@ -913,7 +862,6 @@ impl Visitor for PathBufVisitor {
     }
 }
 
-#[cfg(feature = "std")]
 impl Deserialize for path::PathBuf {
     fn deserialize<D>(deserializer: &mut D) -> Result<path::PathBuf, D::Error>
         where D: Deserializer,
@@ -924,7 +872,6 @@ impl Deserialize for path::PathBuf {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(feature = "std", feature = "alloc"))]
 impl<T: Deserialize> Deserialize for Box<T> {
     fn deserialize<D>(deserializer: &mut D) -> Result<Box<T>, D::Error>
         where D: Deserializer,
@@ -934,7 +881,6 @@ impl<T: Deserialize> Deserialize for Box<T> {
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<T: Deserialize> Deserialize for Box<[T]> {
     fn deserialize<D>(deserializer: &mut D) -> Result<Box<[T]>, D::Error>
         where D: Deserializer,
@@ -944,7 +890,6 @@ impl<T: Deserialize> Deserialize for Box<[T]> {
     }
 }
 
-#[cfg(any(feature = "std", feature = "alloc"))]
 impl<T: Deserialize> Deserialize for Arc<T> {
     fn deserialize<D>(deserializer: &mut D) -> Result<Arc<T>, D::Error>
         where D: Deserializer,
@@ -954,7 +899,6 @@ impl<T: Deserialize> Deserialize for Arc<T> {
     }
 }
 
-#[cfg(any(feature = "std", feature = "alloc"))]
 impl<T: Deserialize> Deserialize for Rc<T> {
     fn deserialize<D>(deserializer: &mut D) -> Result<Rc<T>, D::Error>
         where D: Deserializer,
@@ -964,7 +908,6 @@ impl<T: Deserialize> Deserialize for Rc<T> {
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<'a, T: ?Sized> Deserialize for Cow<'a, T> where T: ToOwned, T::Owned: Deserialize, {
     #[inline]
     fn deserialize<D>(deserializer: &mut D) -> Result<Cow<'a, T>, D::Error>
@@ -1011,10 +954,7 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
                 impl ::de::Visitor for FieldVisitor {
                     type Value = Field;
 
-                    #[cfg(any(feature = "std", feature = "collections"))]
                     fn visit_usize<E>(&mut self, value: usize) -> Result<Field, E> where E: Error {
-                        #[cfg(feature = "collections")]
-                        use collections::string::ToString;
                         match value {
                             0 => Ok(Field::Ok),
                             1 => Ok(Field::Err),
@@ -1022,17 +962,6 @@ impl<T, E> Deserialize for Result<T, E> where T: Deserialize, E: Deserialize {
                         }
                     }
 
-                    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
-                    fn visit_usize<E>(&mut self, value: usize) -> Result<Field, E> where E: Error {
-                        #[cfg(feature = "collections")]
-                        use collections::string::ToString;
-                        match value {
-                            0 => Ok(Field::Ok),
-                            1 => Ok(Field::Err),
-                            _ => Err(Error::unknown_field("some number")),
-                        }
-                    }
-
                     fn visit_str<E>(&mut self, value: &str) -> Result<Field, E> where E: Error {
                         match value {
                             "Ok" => Ok(Field::Ok),

serde/src/de/mod.rs

@@ -1,12 +1,6 @@
 //! Generic deserialization framework.
 
-#[cfg(feature = "std")]
 use std::error;
-#[cfg(not(feature = "std"))]
-use error;
-
-#[cfg(all(not(feature = "std"), feature = "collections"))]
-use collections::{String, Vec};
 
 pub mod impls;
 pub mod value;
@@ -18,13 +12,8 @@ mod from_primitive;
 /// `Deserializer` error.
 pub trait Error: Sized + error::Error {
     /// Raised when there is general error when deserializing a type.
-    #[cfg(any(feature = "std", feature = "collections"))]
     fn custom<T: Into<String>>(msg: T) -> Self;
 
-    /// Raised when there is general error when deserializing a type.
-    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
-    fn custom<T: Into<&'static str>>(msg: T) -> Self;
-
     /// Raised when a `Deserialize` type unexpectedly hit the end of the stream.
     fn end_of_stream() -> Self;
 
@@ -569,7 +558,9 @@ pub trait Visitor {
     fn visit_char<E>(&mut self, v: char) -> Result<Self::Value, E>
         where E: Error,
     {
-        self.visit_str(::core::str::from_utf8(::utils::encode_utf8(v).as_slice()).unwrap())
+        // FIXME: this allocation is required in order to be compatible with stable rust, which
+        // doesn't support encoding a `char` into a stack buffer.
+        self.visit_string(v.to_string())
     }
 
     /// `visit_str` deserializes a `&str` into a `Value`.
@@ -583,7 +574,6 @@ pub trait Visitor {
     /// a copy if it is deserializing a string from a `String` type.  By default it passes a `&str`
     /// to the `visit_str` method.
     #[inline]
-    #[cfg(any(feature = "std", feature = "collections"))]
     fn visit_string<E>(&mut self, v: String) -> Result<Self::Value, E>
         where E: Error,
     {
@@ -648,7 +638,6 @@ pub trait Visitor {
     }
 
     /// `visit_byte_buf` deserializes a `Vec<u8>` into a `Value`.
-    #[cfg(any(feature = "std", feature = "collections"))]
     fn visit_byte_buf<E>(&mut self, v: Vec<u8>) -> Result<Self::Value, E>
         where E: Error,
     {

serde/src/de/value.rs

@@ -1,6 +1,5 @@
 //! This module supports deserializing from primitives with the `ValueDeserializer` trait.
 
-#[cfg(feature = "std")]
 use std::collections::{
     BTreeMap,
     BTreeSet,
@@ -11,31 +10,11 @@ use std::collections::{
     hash_map,
     hash_set,
 };
-#[cfg(feature = "std")]
+use std::hash::Hash;
-use std::vec;
-
-#[cfg(all(feature = "collections", not(feature = "std")))]
-use collections::{
-    BTreeMap,
-    BTreeSet,
-    Vec,
-    String,
-    btree_map,
-    btree_set,
-    vec,
-};
-
-#[cfg(all(feature = "nightly", feature = "collections"))]
-use collections::borrow::ToOwned;
-
-use core::hash::Hash;
-#[cfg(feature = "std")]
 use std::error;
-#[cfg(not(feature = "std"))]
+use std::fmt;
-use error;
+use std::vec;
-
+use std::marker::PhantomData;
-use core::fmt;
-use core::marker::PhantomData;
 
 use de;
 use bytes;
@@ -46,11 +25,7 @@ use bytes;
 #[derive(Clone, Debug, PartialEq)]
 pub enum Error {
     /// The value had some custom error.
-    #[cfg(any(feature = "std", feature = "collections"))]
     Custom(String),
-    /// The value had some custom error.
-    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
-    Custom(&'static str),
 
     /// The value had an incorrect type.
     InvalidType(de::Type),
@@ -59,60 +34,29 @@ pub enum Error {
     InvalidLength(usize),
 
     /// The value is invalid and cannot be deserialized.
-    #[cfg(any(feature = "std", feature = "collections"))]
     InvalidValue(String),
-    /// The value is invalid and cannot be deserialized.
-    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
-    InvalidValue(&'static str),
 
     /// EOF while deserializing a value.
     EndOfStream,
 
     /// Unknown variant in enum.
-    #[cfg(any(feature = "std", feature = "collections"))]
     UnknownVariant(String),
-    /// Unknown variant in enum.
-    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
-    UnknownVariant(&'static str),
 
     /// Unknown field in struct.
-    #[cfg(any(feature = "std", feature = "collections"))]
     UnknownField(String),
-    /// Unknown field in struct.
-    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
-    UnknownField(&'static str),
 
     /// Struct is missing a field.
     MissingField(&'static str),
 }
 
 impl de::Error for Error {
-    #[cfg(any(feature = "std", feature = "collections"))]
     fn custom<T: Into<String>>(msg: T) -> Self { Error::Custom(msg.into()) }
-
-    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
-    fn custom<T: Into<&'static str>>(msg: T) -> Self { Error::Custom(msg.into()) }
-
     fn end_of_stream() -> Self { Error::EndOfStream }
     fn invalid_type(ty: de::Type) -> Self { Error::InvalidType(ty) }
-
-    #[cfg(any(feature = "std", feature = "collections"))]
     fn invalid_value(msg: &str) -> Self { Error::InvalidValue(msg.to_owned()) }
-
-    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
-    fn invalid_value(msg: &str) -> Self { Error::InvalidValue("invalid value") }
-
     fn invalid_length(len: usize) -> Self { Error::InvalidLength(len) }
-
-    #[cfg(any(feature = "std", feature = "collections"))]
     fn unknown_variant(variant: &str) -> Self { Error::UnknownVariant(String::from(variant)) }
-    #[cfg(any(feature = "std", feature = "collections"))]
     fn unknown_field(field: &str) -> Self { Error::UnknownField(String::from(field)) }
-
-    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
-    fn unknown_variant(variant: &str) -> Self { Error::UnknownVariant("unknown variant") }
-    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
-    fn unknown_field(field: &str) -> Self { Error::UnknownField("unknown field") }
     fn missing_field(field: &'static str) -> Self { Error::MissingField(field) }
 }
 
@@ -294,10 +238,8 @@ impl<'a, E> de::VariantVisitor for StrDeserializer<'a, E>
 ///////////////////////////////////////////////////////////////////////////////
 
 /// A helper deserializer that deserializes a `String`.
-#[cfg(any(feature = "std", feature = "collections"))]
 pub struct StringDeserializer<E>(Option<String>, PhantomData<E>);
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<E> ValueDeserializer<E> for String
     where E: de::Error,
 {
@@ -308,7 +250,6 @@ impl<E> ValueDeserializer<E> for String
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<E> de::Deserializer for StringDeserializer<E>
     where E: de::Error,
 {
@@ -333,7 +274,6 @@ impl<E> de::Deserializer for StringDeserializer<E>
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<'a, E> de::VariantVisitor for StringDeserializer<E>
     where E: de::Error,
 {
@@ -421,7 +361,6 @@ impl<I, T, E> de::SeqVisitor for SeqDeserializer<I, E>
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<T, E> ValueDeserializer<E> for Vec<T>
     where T: ValueDeserializer<E>,
           E: de::Error,
@@ -434,7 +373,6 @@ impl<T, E> ValueDeserializer<E> for Vec<T>
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<T, E> ValueDeserializer<E> for BTreeSet<T>
     where T: ValueDeserializer<E> + Eq + Ord,
           E: de::Error,
@@ -447,7 +385,6 @@ impl<T, E> ValueDeserializer<E> for BTreeSet<T>
     }
 }
 
-#[cfg(feature = "std")]
 impl<T, E> ValueDeserializer<E> for HashSet<T>
     where T: ValueDeserializer<E> + Eq + Hash,
           E: de::Error,
@@ -590,7 +527,6 @@ impl<I, K, V, E> de::MapVisitor for MapDeserializer<I, K, V, E>
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<K, V, E> ValueDeserializer<E> for BTreeMap<K, V>
     where K: ValueDeserializer<E> + Eq + Ord,
           V: ValueDeserializer<E>,
@@ -604,7 +540,6 @@ impl<K, V, E> ValueDeserializer<E> for BTreeMap<K, V>
     }
 }
 
-#[cfg(feature = "std")]
 impl<K, V, E> ValueDeserializer<E> for HashMap<K, V>
     where K: ValueDeserializer<E> + Eq + Hash,
           V: ValueDeserializer<E>,
@@ -683,7 +618,6 @@ impl<'a, E> de::Deserializer for BytesDeserializer<'a, E>
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<E> ValueDeserializer<E> for bytes::ByteBuf
     where E: de::Error,
 {
@@ -695,10 +629,8 @@ impl<E> ValueDeserializer<E> for bytes::ByteBuf
 }
 
 /// A helper deserializer that deserializes a `Vec<u8>`.
-#[cfg(any(feature = "std", feature = "collections"))]
 pub struct ByteBufDeserializer<E>(Option<Vec<u8>>, PhantomData<E>);
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<E> de::Deserializer for ByteBufDeserializer<E>
     where E: de::Error,
 {

serde/src/error.rs

@@ -1,44 +0,0 @@
-//! A stand-in for `std::error`
-use core::any::TypeId;
-use core::fmt::{Debug, Display};
-
-
-/// A stand-in for `std::error::Error`, which requires no allocation.
-#[cfg(feature = "nightly")]
-pub trait Error: Debug + Display + ::core::marker::Reflect {
-    /// A short description of the error.
-    ///
-    /// The description should not contain newlines or sentence-ending
-    /// punctuation, to facilitate embedding in larger user-facing
-    /// strings.
-    fn description(&self) -> &str;
-
-    /// The lower-level cause of this error, if any.
-    fn cause(&self) -> Option<&Error> { None }
-
-    /// Get the `TypeId` of `self`
-    #[doc(hidden)]
-    fn type_id(&self) -> TypeId where Self: 'static {
-        TypeId::of::<Self>()
-    }
-}
-
-/// A stand-in for `std::error::Error`, which requires no allocation.
-#[cfg(not(feature = "nightly"))]
-pub trait Error: Debug + Display {
-    /// A short description of the error.
-    ///
-    /// The description should not contain newlines or sentence-ending
-    /// punctuation, to facilitate embedding in larger user-facing
-    /// strings.
-    fn description(&self) -> &str;
-
-    /// The lower-level cause of this error, if any.
-    fn cause(&self) -> Option<&Error> { None }
-
-    /// Stubbed! Returns type_id of `()`
-    #[doc(hidden)]
-    fn type_id(&self) -> TypeId where Self: 'static {
-        TypeId::of::<()>()
-    }
-}

serde/src/lib.rs

@@ -10,42 +10,23 @@
 //! [github repository](https://github.com/serde-rs/serde)
 
 #![doc(html_root_url="https://serde-rs.github.io/serde/serde")]
-#![cfg_attr(not(feature = "std"), no_std)]
+#![cfg_attr(feature = "nightly", feature(collections, enumset, nonzero, plugin, step_trait,
-#![cfg_attr(feature = "nightly", feature(reflect_marker, unicode, nonzero, plugin, step_trait, zero_one))]
+                                         zero_one))]
-#![cfg_attr(feature = "alloc", feature(alloc))]
-#![cfg_attr(feature = "collections", feature(collections, enumset))]
 #![cfg_attr(feature = "nightly-testing", plugin(clippy))]
 #![cfg_attr(feature = "nightly-testing", allow(linkedlist))]
 
-#![cfg_attr(any(not(feature = "std"), feature = "nightly"), allow(unused_variables, unused_imports, unused_features, dead_code))]
-
 #![deny(missing_docs)]
 
-#[cfg(all(feature = "nightly", feature = "collections"))]
+#[cfg(feature = "nightly")]
 extern crate collections;
 
-#[cfg(all(feature = "nightly", feature = "alloc"))]
+#[cfg(feature = "nightly")]
-extern crate alloc;
+extern crate core;
-
-#[cfg(feature = "std")]
-mod core {
-    pub use std::{ops, hash, fmt, cmp, marker, mem, i8, i16, i32, i64, u8, u16, u32, u64, isize,
-            usize, f32, f64, char, str, slice, iter};
-}
 
 pub use ser::{Serialize, Serializer};
 pub use de::{Deserialize, Deserializer, Error};
 
-#[cfg(not(feature = "std"))]
-macro_rules! format {
-    ($s:expr, $($rest:tt)*) => ($s)
-}
-
 pub mod bytes;
 pub mod de;
-#[cfg(feature = "std")]
 pub mod iter;
 pub mod ser;
-#[cfg(not(feature = "std"))]
-pub mod error;
-mod utils;

serde/src/ser/impls.rs

@@ -1,11 +1,6 @@
 //! Implementations for all of Rust's builtin types.
 
-#[cfg(feature = "std")]
 use std::borrow::Cow;
-#[cfg(all(feature = "collections", not(feature = "std")))]
-use collections::borrow::Cow;
-
-#[cfg(feature = "std")]
 use std::collections::{
     BinaryHeap,
     BTreeMap,
@@ -15,47 +10,20 @@ use std::collections::{
     HashSet,
     VecDeque,
 };
-#[cfg(all(feature = "collections", not(feature = "std")))]
-use collections::{
-    BinaryHeap,
-    BTreeMap,
-    BTreeSet,
-    LinkedList,
-    VecDeque,
-    String,
-    Vec,
-};
-
-#[cfg(all(feature = "nightly", feature = "collections"))]
-use collections::enum_set::{CLike, EnumSet};
-#[cfg(all(feature = "nightly", feature = "collections"))]
-use collections::borrow::ToOwned;
-
-use core::hash::Hash;
 #[cfg(feature = "nightly")]
-use core::iter;
+use collections::enum_set::{CLike, EnumSet};
-#[cfg(feature = "std")]
+use std::hash::Hash;
+#[cfg(feature = "nightly")]
+use std::iter;
 use std::net;
 #[cfg(feature = "nightly")]
-use core::num;
+use std::num;
 #[cfg(feature = "nightly")]
-use core::ops;
+use std::ops;
-#[cfg(feature = "std")]
 use std::path;
-#[cfg(feature = "std")]
 use std::rc::Rc;
-#[cfg(all(feature = "alloc", not(feature = "std")))]
-use alloc::rc::Rc;
-
-#[cfg(feature = "std")]
 use std::sync::Arc;
-#[cfg(all(feature = "alloc", not(feature = "std")))]
+use std::marker::PhantomData;
-use alloc::arc::Arc;
-
-#[cfg(all(feature = "alloc", not(feature = "std")))]
-use alloc::boxed::Box;
-
-use core::marker::PhantomData;
 
 #[cfg(feature = "nightly")]
 use core::nonzero::{NonZero, Zeroable};
@@ -109,7 +77,6 @@ impl Serialize for str {
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl Serialize for String {
     #[inline]
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -293,7 +260,6 @@ array_impls!(32);
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<T> Serialize for BinaryHeap<T>
     where T: Serialize + Ord
 {
@@ -305,7 +271,6 @@ impl<T> Serialize for BinaryHeap<T>
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<T> Serialize for BTreeSet<T>
     where T: Serialize + Ord,
 {
@@ -317,7 +282,7 @@ impl<T> Serialize for BTreeSet<T>
     }
 }
 
-#[cfg(all(feature = "nightly", feature = "collections"))]
+#[cfg(feature = "nightly")]
 impl<T> Serialize for EnumSet<T>
     where T: Serialize + CLike
 {
@@ -329,7 +294,6 @@ impl<T> Serialize for EnumSet<T>
     }
 }
 
-#[cfg(feature = "std")]
 impl<T> Serialize for HashSet<T>
     where T: Serialize + Eq + Hash,
 {
@@ -341,7 +305,6 @@ impl<T> Serialize for HashSet<T>
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<T> Serialize for LinkedList<T>
     where T: Serialize,
 {
@@ -367,7 +330,6 @@ impl<A> Serialize for ops::Range<A>
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<T> Serialize for Vec<T> where T: Serialize {
     #[inline]
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -377,7 +339,6 @@ impl<T> Serialize for Vec<T> where T: Serialize {
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<T> Serialize for VecDeque<T> where T: Serialize {
     #[inline]
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -637,7 +598,6 @@ impl<K, V, I> MapVisitor for MapIteratorVisitor<I>
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<K, V> Serialize for BTreeMap<K, V>
     where K: Serialize + Ord,
           V: Serialize,
@@ -650,7 +610,6 @@ impl<K, V> Serialize for BTreeMap<K, V>
     }
 }
 
-#[cfg(feature = "std")]
 impl<K, V> Serialize for HashMap<K, V>
     where K: Serialize + Eq + Hash,
           V: Serialize,
@@ -683,7 +642,6 @@ impl<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize {
     }
 }
 
-#[cfg(any(feature = "std", feature = "alloc"))]
 impl<T: ?Sized> Serialize for Box<T> where T: Serialize {
     #[inline]
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -693,7 +651,6 @@ impl<T: ?Sized> Serialize for Box<T> where T: Serialize {
     }
 }
 
-#[cfg(any(feature = "std", feature = "alloc"))]
 impl<T> Serialize for Rc<T> where T: Serialize, {
     #[inline]
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -703,7 +660,6 @@ impl<T> Serialize for Rc<T> where T: Serialize, {
     }
 }
 
-#[cfg(any(feature = "std", feature = "alloc"))]
 impl<T> Serialize for Arc<T> where T: Serialize, {
     #[inline]
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -713,7 +669,6 @@ impl<T> Serialize for Arc<T> where T: Serialize, {
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
 impl<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned, {
     #[inline]
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
@@ -740,7 +695,7 @@ impl<T, E> Serialize for Result<T, E> where T: Serialize, E: Serialize {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[cfg(all(feature = "std", feature = "nightly"))]
+#[cfg(feature = "nightly")]
 impl Serialize for net::IpAddr {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
@@ -752,7 +707,6 @@ impl Serialize for net::IpAddr {
     }
 }
 
-#[cfg(feature = "std")]
 impl Serialize for net::Ipv4Addr {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
@@ -761,7 +715,6 @@ impl Serialize for net::Ipv4Addr {
     }
 }
 
-#[cfg(feature = "std")]
 impl Serialize for net::Ipv6Addr {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
@@ -772,7 +725,6 @@ impl Serialize for net::Ipv6Addr {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "std")]
 impl Serialize for net::SocketAddr {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
@@ -784,7 +736,6 @@ impl Serialize for net::SocketAddr {
     }
 }
 
-#[cfg(feature = "std")]
 impl Serialize for net::SocketAddrV4 {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
@@ -793,7 +744,6 @@ impl Serialize for net::SocketAddrV4 {
     }
 }
 
-#[cfg(feature = "std")]
 impl Serialize for net::SocketAddrV6 {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
@@ -804,7 +754,6 @@ impl Serialize for net::SocketAddrV6 {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "std")]
 impl Serialize for path::Path {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
@@ -816,7 +765,6 @@ impl Serialize for path::Path {
     }
 }
 
-#[cfg(feature = "std")]
 impl Serialize for path::PathBuf {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,

serde/src/ser/mod.rs

@@ -1,12 +1,6 @@
 //! Generic serialization framework.
 
-#[cfg(feature = "std")]
 use std::error;
-#[cfg(not(feature = "std"))]
-use error;
-
-#[cfg(all(feature = "collections", not(feature = "std")))]
-use collections::String;
 
 pub mod impls;
 
@@ -16,13 +10,8 @@ pub mod impls;
 /// `Serializer` error.
 pub trait Error: Sized + error::Error {
     /// Raised when there is general error when deserializing a type.
-    #[cfg(any(feature = "std", feature = "collections"))]
     fn custom<T: Into<String>>(msg: T) -> Self;
 
-    /// Raised when there is general error when deserializing a type.
-    #[cfg(all(not(feature = "std"), not(feature = "collections")))]
-    fn custom<T: Into<&'static str>>(msg: T) -> Self;
-
     /// Raised when a `Serialize` was passed an incorrect value.
     fn invalid_value(msg: &str) -> Self {
         Error::custom(format!("invalid value: {}", msg))
@@ -122,10 +111,13 @@ pub trait Serializer {
     /// Serializes a `f64` value.
     fn serialize_f64(&mut self, v: f64) -> Result<(), Self::Error>;
 
-    /// Serializes a character. By default it serializes as bytes containing the UTF-8 encoding
+    /// Serializes a character. By default it serializes it as a `&str` containing a
-    /// of the character.
+    /// single character.
+    #[inline]
     fn serialize_char(&mut self, v: char) -> Result<(), Self::Error> {
-        self.serialize_bytes(::utils::encode_utf8(v).as_slice())
+        // FIXME: this allocation is required in order to be compatible with stable rust, which
+        // doesn't support encoding a `char` into a stack buffer.
+        self.serialize_str(&v.to_string())
     }
 
     /// Serializes a `&str`.

serde/src/utils.rs

@@ -1,72 +0,0 @@
-//! Private utility functions
-
-const TAG_CONT: u8    = 0b1000_0000;
-const TAG_TWO_B: u8   = 0b1100_0000;
-const TAG_THREE_B: u8 = 0b1110_0000;
-const TAG_FOUR_B: u8  = 0b1111_0000;
-const MAX_ONE_B: u32   =     0x80;
-const MAX_TWO_B: u32   =    0x800;
-const MAX_THREE_B: u32 =  0x10000;
-
-#[inline]
-pub fn encode_utf8(c: char) -> EncodeUtf8 {
-    let code = c as u32;
-    let mut buf = [0; 4];
-    let pos = if code < MAX_ONE_B {
-        buf[3] = code as u8;
-        3
-    } else if code < MAX_TWO_B {
-        buf[2] = (code >> 6 & 0x1F) as u8 | TAG_TWO_B;
-        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
-        2
-    } else if code < MAX_THREE_B {
-        buf[1] = (code >> 12 & 0x0F) as u8 | TAG_THREE_B;
-        buf[2] = (code >>  6 & 0x3F) as u8 | TAG_CONT;
-        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
-        1
-    } else {
-        buf[0] = (code >> 18 & 0x07) as u8 | TAG_FOUR_B;
-        buf[1] = (code >> 12 & 0x3F) as u8 | TAG_CONT;
-        buf[2] = (code >>  6 & 0x3F) as u8 | TAG_CONT;
-        buf[3] = (code & 0x3F) as u8 | TAG_CONT;
-        0
-    };
-    EncodeUtf8 { buf: buf, pos: pos }
-}
-
-pub struct EncodeUtf8 {
-    buf: [u8; 4],
-    pos: usize,
-}
-
-impl EncodeUtf8 {
-    /// Returns the remaining bytes of this iterator as a slice.
-    pub fn as_slice(&self) -> &[u8] {
-        &self.buf[self.pos..]
-    }
-}
-
-#[allow(non_upper_case_globals)]
-const Pattern_White_Space_table: &'static [(char, char)] = &[
-    ('\u{9}', '\u{d}'), ('\u{20}', '\u{20}'), ('\u{85}', '\u{85}'), ('\u{200e}', '\u{200f}'),
-    ('\u{2028}', '\u{2029}')
-];
-
-fn bsearch_range_table(c: char, r: &'static [(char, char)]) -> bool {
-    use core::cmp::Ordering::{Equal, Less, Greater};
-    r.binary_search_by(|&(lo, hi)| {
-        if c < lo {
-            Greater
-        } else if hi < c {
-            Less
-        } else {
-            Equal
-        }
-    })
-    .is_ok()
-}
-
-#[allow(non_snake_case)]
-pub fn Pattern_White_Space(c: char) -> bool {
-    bsearch_range_table(c, Pattern_White_Space_table)
-}