From bfd1fb0ee932312b819d1737520f45b091761d0b Mon Sep 17 00:00:00 2001
From: kvark <kvark@seemeroll.in>
Date: Mon, 29 Sep 2014 21:50:24 -0400
Subject: [PATCH 1/4] Fixed String and Option conflicts for the latest Rust

---
 serde_macros/src/lib.rs | 17 ++++++-------
 src/de.rs               | 30 +++++++++++-----------
 src/json/builder.rs     |  4 +--
 src/json/mod.rs         | 56 ++++++++++++++++++++---------------------
 4 files changed, 54 insertions(+), 53 deletions(-)

diff --git a/serde_macros/src/lib.rs b/serde_macros/src/lib.rs
index 66685a2a..20e2247e 100644
--- a/serde_macros/src/lib.rs
+++ b/serde_macros/src/lib.rs
@@ -17,7 +17,6 @@ use syntax::ast::{
     ItemStruct,
     Expr,
     MutMutable,
-    LitNil,
     LitStr,
     StructField,
     Variant,
@@ -25,7 +24,7 @@ use syntax::ast::{
 use syntax::ast;
 use syntax::attr;
 use syntax::codemap::Span;
-use syntax::ext::base::{ExtCtxt, ItemDecorator};
+use syntax::ext::base::{ExtCtxt, Decorator};
 use syntax::ext::build::AstBuilder;
 use syntax::ext::deriving::generic::{
     EnumMatching,
@@ -61,11 +60,11 @@ use rustc::plugin::Registry;
 pub fn plugin_registrar(reg: &mut Registry) {
     reg.register_syntax_extension(
         token::intern("deriving_serializable"),
-        ItemDecorator(box expand_deriving_serializable));
+        Decorator(box expand_deriving_serializable));
 
     reg.register_syntax_extension(
         token::intern("deriving_deserializable"),
-        ItemDecorator(box expand_deriving_deserializable));
+        Decorator(box expand_deriving_deserializable));
 }
 
 fn expand_deriving_serializable(cx: &mut ExtCtxt,
@@ -137,7 +136,7 @@ fn serializable_substructure(cx: &ExtCtxt,
                 );
                 let len = fields.len();
 
-                let mut stmts: Vec<P<ast::Stmt>> = definition.fields.iter()
+                let stmts: Vec<P<ast::Stmt>> = definition.fields.iter()
                     .zip(fields.iter())
                     .enumerate()
                     .map(|(i, (def, &FieldInfo { name, ref self_, span, .. }))| {
@@ -178,7 +177,7 @@ fn serializable_substructure(cx: &ExtCtxt,
 
             let stmts: Vec<P<ast::Stmt>> = definition.variants.iter()
                 .zip(fields.iter())
-                .map(|(def, &FieldInfo { ref self_, span, .. })| {
+                .map(|(def, &FieldInfo { ref self_, .. })| {
                     let _serial_name = find_serial_name(def.node.attrs.iter());
                     quote_stmt!(
                         cx,
@@ -336,7 +335,7 @@ fn deserialize_struct_from_struct(
     fields: &StaticFields,
     deserializer: P<ast::Expr>
 ) -> P<ast::Expr> {
-    let expect_struct_field = cx.ident_of("expect_struct_field");
+    //let expect_struct_field = cx.ident_of("expect_struct_field");
 
     let call = deserializable_static_fields(
         cx,
@@ -375,7 +374,7 @@ fn deserialize_struct_from_map(
 
     // Declare each field.
     let let_fields: Vec<P<ast::Stmt>> = fields.iter()
-        .map(|&(name, span)| {
+        .map(|&(name, _)| {
             quote_stmt!(cx, let mut $name = None)
         })
         .collect();
@@ -494,7 +493,7 @@ fn deserialize_enum(
                 name,
                 serial_names.as_slice(),
                 parts,
-                |cx, span, _| {
+                |cx, _, _| {
                     quote_expr!(cx, try!($deserializer.expect_enum_elt()))
                 }
             );
diff --git a/src/de.rs b/src/de.rs
index 618b9f49..340348dc 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -13,6 +13,8 @@ use std::gc::{GC, Gc};
 use std::hash::Hash;
 use std::num;
 use std::rc::Rc;
+use std::option;
+use std::string;
 use std::sync::Arc;
 
 #[deriving(Clone, PartialEq, Show)]
@@ -33,7 +35,7 @@ pub enum Token {
     F64(f64),
     Char(char),
     Str(&'static str),
-    String(String),
+    String(string::String),
     Option(bool),
 
     TupleStart(uint),
@@ -293,7 +295,7 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
     }
 
     #[inline]
-    fn expect_string(&mut self, token: Token) -> Result<String, E> {
+    fn expect_string(&mut self, token: Token) -> Result<string::String, E> {
         match token {
             Char(value) => Ok(value.to_string()),
             Str(value) => Ok(value.to_string()),
@@ -305,7 +307,7 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
     #[inline]
     fn expect_option<
         T: Deserializable<Self, E>
-    >(&mut self, token: Token) -> Result<Option<T>, E> {
+    >(&mut self, token: Token) -> Result<option::Option<T>, E> {
         match token {
             Option(false) => Ok(None),
             Option(true) => {
@@ -429,7 +431,7 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
     #[inline]
     fn expect_seq_elt_or_end<
         T: Deserializable<Self, E>
-    >(&mut self) -> Result<Option<T>, E> {
+    >(&mut self) -> Result<option::Option<T>, E> {
         match try!(self.expect_token()) {
             End => Ok(None),
             token => {
@@ -473,7 +475,7 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
     fn expect_map_elt_or_end<
         K: Deserializable<Self, E>,
         V: Deserializable<Self, E>
-    >(&mut self) -> Result<Option<(K, V)>, E> {
+    >(&mut self) -> Result<option::Option<(K, V)>, E> {
         match try!(self.expect_token()) {
             End => Ok(None),
             token => {
@@ -513,7 +515,7 @@ pub trait Deserializer<E>: Iterator<Result<Token, E>> {
 struct SeqDeserializer<'a, D: 'a, E> {
     d: &'a mut D,
     len: uint,
-    err: Option<E>,
+    err: option::Option<E>,
 }
 
 impl<
@@ -523,7 +525,7 @@ impl<
     T: Deserializable<D, E>
 > Iterator<T> for SeqDeserializer<'a, D, E> {
     #[inline]
-    fn next(&mut self) -> Option<T> {
+    fn next(&mut self) -> option::Option<T> {
         match self.d.expect_seq_elt_or_end() {
             Ok(next) => next,
             Err(err) => {
@@ -534,7 +536,7 @@ impl<
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (uint, option::Option<uint>) {
         (self.len, Some(self.len))
     }
 }
@@ -544,7 +546,7 @@ impl<
 struct MapDeserializer<'a, D:'a, E> {
     d: &'a mut D,
     len: uint,
-    err: Option<E>,
+    err: option::Option<E>,
 }
 
 impl<
@@ -555,7 +557,7 @@ impl<
     V: Deserializable<D, E>
 > Iterator<(K, V)> for MapDeserializer<'a, D, E> {
     #[inline]
-    fn next(&mut self) -> Option<(K, V)> {
+    fn next(&mut self) -> option::Option<(K, V)> {
         match self.d.expect_map_elt_or_end() {
             Ok(next) => next,
             Err(err) => {
@@ -566,7 +568,7 @@ impl<
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (uint, option::Option<uint>) {
         (self.len, Some(self.len))
     }
 }
@@ -611,7 +613,7 @@ impl_deserializable!(f32, expect_num)
 impl_deserializable!(f64, expect_num)
 impl_deserializable!(char, expect_char)
 impl_deserializable!(&'static str, expect_str)
-impl_deserializable!(String, expect_string)
+impl_deserializable!(string::String, expect_string)
 
 //////////////////////////////////////////////////////////////////////////////
 
@@ -665,9 +667,9 @@ impl<
     D: Deserializer<E>,
     E,
     T: Deserializable<D ,E>
-> Deserializable<D, E> for Option<T> {
+> Deserializable<D, E> for option::Option<T> {
     #[inline]
-    fn deserialize_token(d: &mut D, token: Token) -> Result<Option<T>, E> {
+    fn deserialize_token(d: &mut D, token: Token) -> Result<option::Option<T>, E> {
         d.expect_option(token)
     }
 }
diff --git a/src/json/builder.rs b/src/json/builder.rs
index 16fc1e47..d2af7b1c 100644
--- a/src/json/builder.rs
+++ b/src/json/builder.rs
@@ -11,7 +11,7 @@
 use std::collections::TreeMap;
 use std::str::StrAllocating;
 
-use super::{Json, List, Object, ToJson};
+use super::{Json, JsonObject, List, Object, ToJson};
 
 pub struct ListBuilder {
     list: Vec<Json>,
@@ -44,7 +44,7 @@ impl ListBuilder {
 }
 
 pub struct ObjectBuilder {
-    object: Object,
+    object: JsonObject,
 }
 
 impl ObjectBuilder {
diff --git a/src/json/mod.rs b/src/json/mod.rs
index ba709910..7f96064b 100644
--- a/src/json/mod.rs
+++ b/src/json/mod.rs
@@ -274,7 +274,7 @@ use std::num::{FPNaN, FPInfinite};
 use std::num;
 use std::str::ScalarValue;
 use std::str;
-use std::string::String;
+use std::string;
 use std::vec::Vec;
 use std::vec;
 
@@ -291,13 +291,13 @@ pub enum Json {
     Boolean(bool),
     Integer(i64),
     Floating(f64),
-    String(String),
-    List(List),
-    Object(Object),
+    String(string::String),
+    List(JsonList),
+    Object(JsonObject),
 }
 
-pub type List = Vec<Json>;
-pub type Object = TreeMap<String, Json>;
+pub type JsonList = Vec<Json>;
+pub type JsonObject = TreeMap<string::String, Json>;
 
 impl Json {
     /// Serializes a json value into an io::writer.  Uses a single line.
@@ -314,7 +314,7 @@ impl Json {
     }
 
     /// Serializes a json value into a string
-    pub fn to_pretty_string(&self) -> String {
+    pub fn to_pretty_string(&self) -> string::String {
         let mut wr = MemWriter::new();
         self.to_pretty_writer(wr.by_ref()).unwrap();
         str::from_utf8(wr.unwrap().as_slice()).unwrap().to_string()
@@ -322,7 +322,7 @@ impl Json {
 
      /// If the Json value is an Object, returns the value associated with the provided key.
     /// Otherwise, returns None.
-    pub fn find<'a>(&'a self, key: &String) -> Option<&'a Json>{
+    pub fn find<'a>(&'a self, key: &string::String) -> Option<&'a Json>{
         match self {
             &Object(ref map) => map.find(key),
             _ => None
@@ -332,7 +332,7 @@ impl Json {
     /// Attempts to get a nested Json Object for each key in `keys`.
     /// If any key is found not to exist, find_path will return None.
     /// Otherwise, it will return the Json value associated with the final key.
-    pub fn find_path<'a>(&'a self, keys: &[&String]) -> Option<&'a Json>{
+    pub fn find_path<'a>(&'a self, keys: &[&string::String]) -> Option<&'a Json>{
         let mut target = self;
         for key in keys.iter() {
             match target.find(*key) {
@@ -346,7 +346,7 @@ impl Json {
     /// If the Json value is an Object, performs a depth-first search until
     /// a value associated with the provided key is found. If no value is found
     /// or the Json value is not an Object, returns None.
-    pub fn search<'a>(&'a self, key: &String) -> Option<&'a Json> {
+    pub fn search<'a>(&'a self, key: &string::String) -> Option<&'a Json> {
         match self {
             &Object(ref map) => {
                 match map.find(key) {
@@ -374,7 +374,7 @@ impl Json {
 
     /// If the Json value is an Object, returns the associated TreeMap.
     /// Returns None otherwise.
-    pub fn as_object<'a>(&'a self) -> Option<&'a Object> {
+    pub fn as_object<'a>(&'a self) -> Option<&'a JsonObject> {
         match *self {
             Object(ref map) => Some(map),
             _ => None
@@ -388,7 +388,7 @@ impl Json {
 
     /// If the Json value is a List, returns the associated vector.
     /// Returns None otherwise.
-    pub fn as_list<'a>(&'a self) -> Option<&'a List> {
+    pub fn as_list<'a>(&'a self) -> Option<&'a JsonList> {
         match *self {
             List(ref list) => Some(list),
             _ => None
@@ -564,7 +564,7 @@ impl<D: de::Deserializer<E>, E> de::Deserializable<D, E> for Json {
 enum JsonDeserializerState {
     JsonDeserializerValueState(Json),
     JsonDeserializerListState(vec::MoveItems<Json>),
-    JsonDeserializerObjectState(treemap::MoveEntries<String, Json>),
+    JsonDeserializerObjectState(treemap::MoveEntries<string::String, Json>),
     JsonDeserializerEndState,
 }
 
@@ -595,12 +595,12 @@ impl Iterator<Result<de::Token, ParserError>> for JsonDeserializer {
                         String(x) => de::String(x),
                         List(x) => {
                             let len = x.len();
-                            self.stack.push(JsonDeserializerListState(x.move_iter()));
+                            self.stack.push(JsonDeserializerListState(x.into_iter()));
                             de::SeqStart(len)
                         }
                         Object(x) => {
                             let len = x.len();
-                            self.stack.push(JsonDeserializerObjectState(x.move_iter()));
+                            self.stack.push(JsonDeserializerObjectState(x.into_iter()));
                             de::MapStart(len)
                         }
                     };
@@ -716,7 +716,7 @@ impl de::Deserializer<ParserError> for JsonDeserializer {
 
                 self.stack.push(JsonDeserializerEndState);
 
-                for field in fields.move_iter().rev() {
+                for field in fields.into_iter().rev() {
                     self.stack.push(JsonDeserializerValueState(field));
                 }
 
@@ -786,9 +786,9 @@ pub enum ParserError {
     /// msg, line, col
     SyntaxError(ErrorCode, uint, uint),
     IoError(io::IoErrorKind, &'static str),
-    ExpectedError(String, String),
-    MissingFieldError(String),
-    UnknownVariantError(String),
+    ExpectedError(string::String, string::String),
+    MissingFieldError(string::String),
+    UnknownVariantError(string::String),
 }
 
 // Builder and Parser have the same errors.
@@ -1422,9 +1422,9 @@ pub fn to_vec<
 #[inline]
 pub fn to_string<
     T: ser::Serializable<Serializer<MemWriter>, io::IoError>
->(value: &T) -> Result<String, Vec<u8>> {
+>(value: &T) -> Result<string::String, Vec<u8>> {
     let buf = to_vec(value);
-    String::from_utf8(buf)
+    string::String::from_utf8(buf)
 }
 
 /// Encode the specified struct into a json `[u8]` buffer.
@@ -1440,9 +1440,9 @@ pub fn to_pretty_vec<
 /// Encode the specified struct into a json `String` buffer.
 pub fn to_pretty_string<
     T: ser::Serializable<PrettySerializer<MemWriter>, io::IoError>
->(value: &T) -> Result<String, Vec<u8>> {
+>(value: &T) -> Result<string::String, Vec<u8>> {
     let buf = to_pretty_vec(value);
-    String::from_utf8(buf)
+    string::String::from_utf8(buf)
 }
 
 /*
@@ -1862,9 +1862,9 @@ impl<Iter: Iterator<char>> Parser<Iter> {
         Ok(n)
     }
 
-    fn parse_string(&mut self) -> Result<String, ParserError> {
+    fn parse_string(&mut self) -> Result<string::String, ParserError> {
         let mut escape = false;
-        let mut res = String::new();
+        let mut res = string::String::new();
 
         loop {
             self.bump();
@@ -2260,7 +2260,7 @@ impl<'a> ToJson for &'a str {
     fn to_json(&self) -> Json { String(self.to_string()) }
 }
 
-impl ToJson for String {
+impl ToJson for string::String {
     fn to_json(&self) -> Json { String((*self).clone()) }
 }
 
@@ -2306,7 +2306,7 @@ impl<A:ToJson> ToJson for Vec<A> {
     fn to_json(&self) -> Json { List(self.iter().map(|elt| elt.to_json()).collect()) }
 }
 
-impl<A:ToJson> ToJson for TreeMap<String, A> {
+impl<A:ToJson> ToJson for TreeMap<string::String, A> {
     fn to_json(&self) -> Json {
         let mut d = TreeMap::new();
         for (key, value) in self.iter() {
@@ -2316,7 +2316,7 @@ impl<A:ToJson> ToJson for TreeMap<String, A> {
     }
 }
 
-impl<A:ToJson> ToJson for HashMap<String, A> {
+impl<A:ToJson> ToJson for HashMap<string::String, A> {
     fn to_json(&self) -> Json {
         let mut d = TreeMap::new();
         for (key, value) in self.iter() {

From 997d3901c13498335af85eb3384d45a4104071a7 Mon Sep 17 00:00:00 2001
From: kvark <kvark@seemeroll.in>
Date: Mon, 29 Sep 2014 21:58:22 -0400
Subject: [PATCH 2/4] Fixed all the tests

---
 benches/bench_map.rs    |  4 ++--
 benches/bench_struct.rs |  8 ++++----
 benches/bench_vec.rs    |  8 ++++----
 src/de.rs               | 20 +++++++++++---------
 src/json/mod.rs         | 18 ++++++++++--------
 src/ser.rs              | 36 +++++++++++++++++++-----------------
 6 files changed, 50 insertions(+), 44 deletions(-)

diff --git a/benches/bench_map.rs b/benches/bench_map.rs
index 89d82437..17c69b61 100644
--- a/benches/bench_map.rs
+++ b/benches/bench_map.rs
@@ -49,7 +49,7 @@ mod decoder {
         pub fn new(values: HashMap<String, int>) -> IntDecoder {
             IntDecoder {
                 len: values.len(),
-                iter: values.move_iter(),
+                iter: values.into_iter(),
                 stack: vec!(),
             }
         }
@@ -195,7 +195,7 @@ mod deserializer {
             IntDeserializer {
                 stack: vec!(StartState),
                 len: values.len(),
-                iter: values.move_iter(),
+                iter: values.into_iter(),
             }
         }
     }
diff --git a/benches/bench_struct.rs b/benches/bench_struct.rs
index cc1c177b..f266bb77 100644
--- a/benches/bench_struct.rs
+++ b/benches/bench_struct.rs
@@ -214,7 +214,7 @@ mod decoder {
             match self.stack.pop() {
                 Some(VecState(value)) => {
                     let len = value.len();
-                    for inner in value.move_iter().rev() {
+                    for inner in value.into_iter().rev() {
                         self.stack.push(InnerState(inner));
                     }
                     f(self, len)
@@ -232,7 +232,7 @@ mod decoder {
             match self.stack.pop() {
                 Some(MapState(map)) => {
                     let len = map.len();
-                    for (key, value) in map.move_iter() {
+                    for (key, value) in map.into_iter() {
                         match value {
                             Some(c) => {
                                 self.stack.push(CharState(c));
@@ -322,7 +322,7 @@ mod deserializer {
                 Some(VecState(value)) => {
                     self.stack.push(EndState);
                     let len = value.len();
-                    for inner in value.move_iter().rev() {
+                    for inner in value.into_iter().rev() {
                         self.stack.push(InnerState(inner));
                     }
                     Some(Ok(de::SeqStart(len)))
@@ -330,7 +330,7 @@ mod deserializer {
                 Some(MapState(value)) => {
                     self.stack.push(EndState);
                     let len = value.len();
-                    for (key, value) in value.move_iter() {
+                    for (key, value) in value.into_iter() {
                         match value {
                             Some(c) => {
                                 self.stack.push(CharState(c));
diff --git a/benches/bench_vec.rs b/benches/bench_vec.rs
index 10554831..46e57bc0 100644
--- a/benches/bench_vec.rs
+++ b/benches/bench_vec.rs
@@ -41,7 +41,7 @@ mod decoder {
         pub fn new(values: Vec<int>) -> IntDecoder {
             IntDecoder {
                 len: values.len(),
-                iter: values.move_iter(),
+                iter: values.into_iter(),
             }
         }
     }
@@ -146,7 +146,7 @@ mod decoder {
         pub fn new(values: Vec<u8>) -> U8Decoder {
             U8Decoder {
                 len: values.len(),
-                iter: values.move_iter(),
+                iter: values.into_iter(),
             }
         }
     }
@@ -271,7 +271,7 @@ mod deserializer {
             IntDeserializer {
                 state: StartState,
                 len: values.len(),
-                iter: values.move_iter(),
+                iter: values.into_iter(),
             }
         }
     }
@@ -343,7 +343,7 @@ mod deserializer {
             U8Deserializer {
                 state: StartState,
                 len: values.len(),
-                iter: values.move_iter(),
+                iter: values.into_iter(),
             }
         }
     }
diff --git a/src/de.rs b/src/de.rs
index 340348dc..49cd4769 100644
--- a/src/de.rs
+++ b/src/de.rs
@@ -991,6 +991,7 @@ impl<D: Deserializer<E>, E> Deserializable<D, E> for GatherTokens {
 #[cfg(test)]
 mod tests {
     use std::collections::TreeMap;
+    use std::{option, string};
     use serialize::Decoder;
 
     use super::{Deserializer, Deserializable, Token, TokenKind};
@@ -1035,7 +1036,7 @@ mod tests {
     struct Inner {
         a: (),
         b: uint,
-        c: TreeMap<String, Option<char>>,
+        c: TreeMap<string::String, option::Option<char>>,
     }
 
     impl<
@@ -1075,7 +1076,7 @@ mod tests {
     #[deriving(Clone, PartialEq, Show, Decodable)]
     enum Animal {
         Dog,
-        Frog(String, int)
+        Frog(string::String, int)
     }
 
     impl<D: Deserializer<E>, E> Deserializable<D, E> for Animal {
@@ -1126,7 +1127,7 @@ mod tests {
 
     impl<Iter: Iterator<Token>> Iterator<Result<Token, Error>> for TokenDeserializer<Iter> {
         #[inline]
-        fn next(&mut self) -> Option<Result<Token, Error>> {
+        fn next(&mut self) -> option::Option<Result<Token, Error>> {
             match self.tokens.next() {
                 None => None,
                 Some(token) => Some(Ok(token)),
@@ -1166,7 +1167,7 @@ mod tests {
             #[test]
             fn $name() {
                 $(
-                    let mut deserializer = TokenDeserializer::new($tokens.move_iter());
+                    let mut deserializer = TokenDeserializer::new($tokens.into_iter());
                     let value: $ty = Deserializable::deserialize(&mut deserializer).unwrap();
 
                     assert_eq!(value, $value);
@@ -1193,7 +1194,7 @@ mod tests {
         vec!(F64(5.0)) => 5.0: f64,
         vec!(Char('c')) => 'c': char,
         vec!(Str("abc")) => "abc": &str,
-        vec!(String("abc".to_string())) => "abc".to_string(): String
+        vec!(String("abc".to_string())) => "abc".to_string(): string::String
     ])
 
     test_value!(test_tuples, [
@@ -1227,12 +1228,12 @@ mod tests {
     ])
 
     test_value!(test_options, [
-        vec!(Option(false)) => None: Option<int>,
+        vec!(Option(false)) => None: option::Option<int>,
 
         vec!(
             Option(true),
             Int(5),
-        ) => Some(5): Option<int>
+        ) => Some(5): option::Option<int>
     ])
 
     test_value!(test_structs, [
@@ -1334,7 +1335,7 @@ mod tests {
         vec!(
             MapStart(0),
             End,
-        ) => treemap!(): TreeMap<int, String>,
+        ) => treemap!(): TreeMap<int, string::String>,
 
         vec!(
             MapStart(2),
@@ -1344,6 +1345,7 @@ mod tests {
                 Int(6),
                 String("b".to_string()),
             End,
-        ) => treemap!(5i => "a".to_string(), 6i => "b".to_string()): TreeMap<int, String>
+        ) => treemap!(5i => "a".to_string(), 6i => "b".to_string()): TreeMap<int, string::
+        String>
     ])
 }
diff --git a/src/json/mod.rs b/src/json/mod.rs
index 7f96064b..16bcb08c 100644
--- a/src/json/mod.rs
+++ b/src/json/mod.rs
@@ -2340,6 +2340,7 @@ mod tests {
     use std::fmt::Show;
     use std::io;
     use std::str;
+    use std::string;
     use std::collections::TreeMap;
 
     use super::{Json, Null, Boolean, Floating, String, List, Object};
@@ -2378,7 +2379,7 @@ mod tests {
     #[deriving_deserializable]
     enum Animal {
         Dog,
-        Frog(String, Vec<int>)
+        Frog(string::String, Vec<int>)
     }
 
     impl ToJson for Animal {
@@ -2408,7 +2409,7 @@ mod tests {
     struct Inner {
         a: (),
         b: uint,
-        c: Vec<String>,
+        c: Vec<string::String>,
     }
 
     impl ToJson for Inner {
@@ -2922,7 +2923,7 @@ mod tests {
 
     #[test]
     fn test_parse_string() {
-        test_parse_err::<String>([
+        test_parse_err::<string::String>([
             ("\"", SyntaxError(EOFWhileParsingString, 1, 2)),
             ("\"lol", SyntaxError(EOFWhileParsingString, 1, 5)),
             ("\"lol\"a", SyntaxError(TrailingCharacters, 1, 6)),
@@ -3018,7 +3019,7 @@ mod tests {
 
     #[test]
     fn test_parse_object() {
-        test_parse_err::<TreeMap<String, int>>([
+        test_parse_err::<TreeMap<string::String, int>>([
             ("{", SyntaxError(EOFWhileParsingString, 1, 2)),
             ("{ ", SyntaxError(EOFWhileParsingString, 1, 3)),
             ("{1", SyntaxError(KeyMustBeAString, 1, 2)),
@@ -3187,7 +3188,7 @@ mod tests {
 
     #[test]
     fn test_multiline_errors() {
-        test_parse_err::<TreeMap<String, String>>([
+        test_parse_err::<TreeMap<string::String, string::String>>([
             ("{\n  \"foo\":\n \"bar\"", SyntaxError(EOFWhileParsingObject, 3u, 8u)),
         ]);
     }
@@ -3283,7 +3284,7 @@ mod tests {
     fn test_as_object() {
         let json_value: Json = from_str("{}").unwrap();
         let json_object = json_value.as_object();
-        let map = TreeMap::<String, Json>::new();
+        let map = TreeMap::<string::String, Json>::new();
         assert_eq!(json_object, Some(&map));
     }
 
@@ -3717,6 +3718,7 @@ mod tests {
 #[cfg(test)]
 mod bench {
     use std::collections::TreeMap;
+    use std::string;
     use serialize;
     use test::Bencher;
 
@@ -3732,7 +3734,7 @@ mod bench {
         })
     }
 
-    fn json_str(count: uint) -> String {
+    fn json_str(count: uint) -> string::String {
         let mut src = "[".to_string();
         for _ in range(0, count) {
             src.push_str(r#"{"a":true,"b":null,"c":3.1415,"d":"Hello world","e":[1,2,3]},"#);
@@ -3741,7 +3743,7 @@ mod bench {
         src
     }
 
-    fn pretty_json_str(count: uint) -> String {
+    fn pretty_json_str(count: uint) -> string::String {
         let mut src = "[\n".to_string();
         for _ in range(0, count) {
             src.push_str(
diff --git a/src/ser.rs b/src/ser.rs
index b33b32da..314de15f 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -321,6 +321,8 @@ impl_serialize_tuple! { T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, }
 mod tests {
     use std::collections::{HashMap, TreeMap};
 
+    use std::{option, string};
+
     use serialize::Decoder;
 
     use super::{Serializer, Serializable};
@@ -332,7 +334,7 @@ mod tests {
     struct Inner {
         a: (),
         b: uint,
-        c: HashMap<String, Option<char>>,
+        c: HashMap<string::String, option::Option<char>>,
     }
 
     //////////////////////////////////////////////////////////////////////////////
@@ -535,7 +537,7 @@ mod tests {
 
         fn serialize_option<
             T: Serializable<AssertSerializer<Iter>, Error>
-        >(&mut self, v: &Option<T>) -> Result<(), Error> {
+        >(&mut self, v: &option::Option<T>) -> Result<(), Error> {
             match *v {
                 Some(ref v) => {
                     try!(self.serialize(Option(true)));
@@ -581,7 +583,7 @@ mod tests {
         let tokens = vec!(
             Int(5)
         );
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
         5i.serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
@@ -592,7 +594,7 @@ mod tests {
             Str("a"),
         );
 
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
         "a".serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
@@ -603,7 +605,7 @@ mod tests {
             Null,
         );
 
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
         ().serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
@@ -614,7 +616,7 @@ mod tests {
             Option(false),
         );
 
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
         None::<int>.serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
@@ -626,7 +628,7 @@ mod tests {
             Int(5),
         );
 
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
         Some(5i).serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
@@ -643,7 +645,7 @@ mod tests {
             TupleEnd,
         );
 
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
         (5i, "a").serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
@@ -669,7 +671,7 @@ mod tests {
             TupleEnd,
         );
 
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
         ((), (), (5i, "a")).serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
@@ -684,7 +686,7 @@ mod tests {
             StructEnd,
         );
 
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
         Outer { inner: vec!() }.serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
@@ -713,7 +715,7 @@ mod tests {
             StructEnd,
         );
 
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
 
         let mut map = HashMap::new();
         map.insert("abc".to_string(), Some('c'));
@@ -737,7 +739,7 @@ mod tests {
             EnumEnd,
         );
 
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
         Dog.serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
 
@@ -751,7 +753,7 @@ mod tests {
             EnumEnd,
         );
 
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
         Frog("Henry".to_string(), 349).serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
@@ -763,7 +765,7 @@ mod tests {
             SeqEnd,
         );
 
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
         let v: Vec<int> = vec!();
         v.serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
@@ -779,7 +781,7 @@ mod tests {
             SeqEnd,
         );
 
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
         (vec!(5i, 6, 7)).serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
@@ -805,7 +807,7 @@ mod tests {
             SeqEnd,
         );
 
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
         (vec!(vec!(1i), vec!(2, 3), vec!(4, 5, 6))).serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
@@ -822,7 +824,7 @@ mod tests {
             MapEnd,
         );
 
-        let mut serializer = AssertSerializer::new(tokens.move_iter());
+        let mut serializer = AssertSerializer::new(tokens.into_iter());
 
         let mut map = TreeMap::new();
         map.insert(5i, "a".to_string());

From 7ccb7fbf374c95074929be1740515005824c6195 Mon Sep 17 00:00:00 2001
From: kvark <kvark@seemeroll.in>
Date: Sat, 4 Oct 2014 22:05:29 -0400
Subject: [PATCH 3/4] Fixed ranged match arm syntax

---
 src/json/mod.rs | 44 ++++++++++++++++++++++----------------------
 1 file changed, 22 insertions(+), 22 deletions(-)

diff --git a/src/json/mod.rs b/src/json/mod.rs
index 16bcb08c..561de243 100644
--- a/src/json/mod.rs
+++ b/src/json/mod.rs
@@ -1748,14 +1748,14 @@ impl<Iter: Iterator<char>> Parser<Iter> {
 
                 // There can be only one leading '0'.
                 match self.ch_or_null() {
-                    '0' .. '9' => return self.error(InvalidNumber),
+                    '0' ... '9' => return self.error(InvalidNumber),
                     _ => ()
                 }
             },
-            '1' .. '9' => {
+            '1' ... '9' => {
                 while !self.eof() {
                     match self.ch_or_null() {
-                        c @ '0' .. '9' => {
+                        c @ '0' ... '9' => {
                             res *= 10;
                             res += (c as i64) - ('0' as i64);
                             self.bump();
@@ -1775,7 +1775,7 @@ impl<Iter: Iterator<char>> Parser<Iter> {
 
         // Make sure a digit follows the decimal place.
         match self.ch_or_null() {
-            '0' .. '9' => (),
+            '0' ... '9' => (),
              _ => return self.error(InvalidNumber)
         }
 
@@ -1783,7 +1783,7 @@ impl<Iter: Iterator<char>> Parser<Iter> {
         let mut dec = 1.0;
         while !self.eof() {
             match self.ch_or_null() {
-                c @ '0' .. '9' => {
+                c @ '0' ... '9' => {
                     dec /= 10.0;
                     res += (((c as int) - ('0' as int)) as f64) * dec;
                     self.bump();
@@ -1810,12 +1810,12 @@ impl<Iter: Iterator<char>> Parser<Iter> {
 
         // Make sure a digit follows the exponent place.
         match self.ch_or_null() {
-            '0' .. '9' => (),
+            '0' ... '9' => (),
             _ => return self.error(InvalidNumber)
         }
         while !self.eof() {
             match self.ch_or_null() {
-                c @ '0' .. '9' => {
+                c @ '0' ... '9' => {
                     exp *= 10;
                     exp += (c as uint) - ('0' as uint);
 
@@ -1841,7 +1841,7 @@ impl<Iter: Iterator<char>> Parser<Iter> {
         while i < 4u && !self.eof() {
             self.bump();
             n = match self.ch_or_null() {
-                c @ '0' .. '9' => n * 16_u16 + ((c as u16) - ('0' as u16)),
+                c @ '0' ... '9' => n * 16_u16 + ((c as u16) - ('0' as u16)),
                 'a' | 'A' => n * 16_u16 + 10_u16,
                 'b' | 'B' => n * 16_u16 + 11_u16,
                 'c' | 'C' => n * 16_u16 + 12_u16,
@@ -1874,20 +1874,20 @@ impl<Iter: Iterator<char>> Parser<Iter> {
 
             if escape {
                 match self.ch_or_null() {
-                    '"' => res.push_char('"'),
-                    '\\' => res.push_char('\\'),
-                    '/' => res.push_char('/'),
-                    'b' => res.push_char('\x08'),
-                    'f' => res.push_char('\x0c'),
-                    'n' => res.push_char('\n'),
-                    'r' => res.push_char('\r'),
-                    't' => res.push_char('\t'),
+                    '"' => res.push('"'),
+                    '\\' => res.push('\\'),
+                    '/' => res.push('/'),
+                    'b' => res.push('\x08'),
+                    'f' => res.push('\x0c'),
+                    'n' => res.push('\n'),
+                    'r' => res.push('\r'),
+                    't' => res.push('\t'),
                     'u' => match try!(self.decode_hex_escape()) {
-                        0xDC00 .. 0xDFFF => return self.error(LoneLeadingSurrogateInHexEscape),
+                        0xDC00 ... 0xDFFF => return self.error(LoneLeadingSurrogateInHexEscape),
 
                         // Non-BMP characters are encoded as a sequence of
                         // two hex escapes, representing UTF-16 surrogates.
-                        n1 @ 0xD800 .. 0xDBFF => {
+                        n1 @ 0xD800 ... 0xDBFF => {
                             let c1 = self.next_char();
                             let c2 = self.next_char();
                             match (c1, c2) {
@@ -1897,13 +1897,13 @@ impl<Iter: Iterator<char>> Parser<Iter> {
 
                             let buf = [n1, try!(self.decode_hex_escape())];
                             match str::utf16_items(buf.as_slice()).next() {
-                                Some(ScalarValue(c)) => res.push_char(c),
+                                Some(ScalarValue(c)) => res.push(c),
                                 _ => return self.error(LoneLeadingSurrogateInHexEscape),
                             }
                         }
 
                         n => match char::from_u32(n as u32) {
-                            Some(c) => res.push_char(c),
+                            Some(c) => res.push(c),
                             None => return self.error(InvalidUnicodeCodePoint),
                         },
                     },
@@ -1918,7 +1918,7 @@ impl<Iter: Iterator<char>> Parser<Iter> {
                         self.bump();
                         return Ok(res);
                     },
-                    Some(c) => res.push_char(c),
+                    Some(c) => res.push(c),
                     None => unreachable!()
                 }
             }
@@ -2024,7 +2024,7 @@ impl<Iter: Iterator<char>> Parser<Iter> {
             'n' => self.parse_ident("ull", de::Null),
             't' => self.parse_ident("rue", de::Bool(true)),
             'f' => self.parse_ident("alse", de::Bool(false)),
-            '0' .. '9' | '-' => self.parse_number(),
+            '0' ... '9' | '-' => self.parse_number(),
             '"' => {
                 let s = try!(self.parse_string());
                 Ok(de::String(s))

From b08a647fc18bd4db603f0554bec48dd5c543ac45 Mon Sep 17 00:00:00 2001
From: kvark <kvark@seemeroll.in>
Date: Mon, 6 Oct 2014 23:22:18 -0400
Subject: [PATCH 4/4] Fixed the stack overflow with an Writer wrapper

---
 src/json/mod.rs | 14 ++++++++++++--
 1 file changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/json/mod.rs b/src/json/mod.rs
index 561de243..ef0b8646 100644
--- a/src/json/mod.rs
+++ b/src/json/mod.rs
@@ -482,10 +482,19 @@ impl Json {
     }
 }
 
+struct WriterFormatter<'a, 'b: 'a>(&'a mut fmt::Formatter<'b>);
+
+impl<'a, 'b> Writer for WriterFormatter<'a, 'b> {
+    fn write(&mut self, buf: &[u8]) -> IoResult<()> {
+        let WriterFormatter(ref mut f) = *self;
+        f.write(buf).map_err(|_| io::IoError::last_error())
+    }
+}
+
 impl fmt::Show for Json {
     /// Serializes a json value into a string
     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        self.to_writer(f as &mut Writer).map_err(|_| fmt::WriteError)
+        self.to_writer(WriterFormatter(f)).map_err(|_| fmt::WriteError)
     }
 }
 
@@ -1139,6 +1148,8 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
         V: Serializable<Serializer<W>, io::IoError>,
         Iter: Iterator<(K, V)>
     >(&mut self, mut iter: Iter) -> IoResult<()> {
+        //Warning: WriterFormatter was added to work around
+        // the stack overflow happening on this line
         try!(self.wr.write_str("{"));
         let mut first = true;
         for (key, value) in iter {
@@ -1150,7 +1161,6 @@ impl<W: Writer> ser::Serializer<io::IoError> for Serializer<W> {
             try!(key.serialize(self));
             try!(self.wr.write_str(":"));
             try!(value.serialize(self));
-
         }
         self.wr.write_str("}")
     }