Follow rust std: int, uint were renamed to isize, usize

benches/bench_enum.rs

@@ -21,7 +21,7 @@ use Animal::{Dog, Frog};
 #[derive_deserialize]
 enum Animal {
     Dog,
-    Frog(String, int)
+    Frog(String, isize)
 }
 
 //////////////////////////////////////////////////////////////////////////////
@@ -41,11 +41,11 @@ mod decoder {
     use super::{Animal, Error};
     use super::Animal::{Dog, Frog};
     use super::Error::{SyntaxError, OtherError};
-    use self::State::{AnimalState, IntState, StringState};
+    use self::State::{AnimalState, IsizeState, StringState};
 
     enum State {
         AnimalState(Animal),
-        IntState(int),
+        IsizeState(isize),
         StringState(String),
     }
 
@@ -72,15 +72,15 @@ mod decoder {
 
         // Primitive types:
         fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
-        fn read_usize(&mut self) -> Result<uint, Error> { Err(SyntaxError) }
+        fn read_usize(&mut self) -> Result<usize, Error> { Err(SyntaxError) }
         fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
         fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
         fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
         fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
         #[inline]
-        fn read_isize(&mut self) -> Result<int, Error> {
+        fn read_isize(&mut self) -> Result<isize, Error> {
             match self.stack.pop() {
-                Some(IntState(x)) => Ok(x),
+                Some(IsizeState(x)) => Ok(x),
                 _ => Err(SyntaxError),
             }
         }
@@ -120,12 +120,12 @@ mod decoder {
 
         #[inline]
         fn read_enum_variant<T, F>(&mut self, names: &[&str], f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
         {
             let name = match self.stack.pop() {
                 Some(AnimalState(Dog)) => "Dog",
                 Some(AnimalState(Frog(x0, x1))) => {
-                    self.stack.push(IntState(x1));
+                    self.stack.push(IsizeState(x1));
                     self.stack.push(StringState(x0));
                     "Frog"
                 }
@@ -141,55 +141,55 @@ mod decoder {
         }
 
         #[inline]
-        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: uint, f: F) -> Result<T, Error> where
+        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, f: F) -> Result<T, Error> where
             F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
         {
             f(self)
         }
 
         fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: uint, _f: F) -> Result<T, Error> where
+        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_struct<T, F>(&mut self, _s_name: &str, _len: uint, _f: F) -> Result<T, Error> where
+        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: uint, _f: F) -> Result<T, Error> where
+        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple<T, F>(&mut self, _len: uint, _f: F) -> Result<T, Error> where
+        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple_arg<T, F>(&mut self, _a_idx: uint, _f: F) -> Result<T, Error> where
+        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: uint, _f: F) -> Result<T, Error> where
+        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: uint, _f: F) -> Result<T, Error> where
+        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
@@ -204,31 +204,31 @@ mod decoder {
 
         #[inline]
         fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
         {
             f(self, 3)
         }
 
         #[inline]
-        fn read_seq_elt<T, F>(&mut self, _idx: uint, f: F) -> Result<T, Error> where
+        fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
             F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
         {
             f(self)
         }
 
         fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
         {
             Err(SyntaxError)
         }
 
-        fn read_map_elt_key<T, F>(&mut self, _idx: uint, _f: F) -> Result<T, Error> where
+        fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
         {
             Err(SyntaxError)
         }
 
-        fn read_map_elt_val<T, F>(&mut self, _idx: uint, _f: F) -> Result<T, Error> where
+        fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
         {
             Err(SyntaxError)
@@ -242,13 +242,13 @@ mod deserializer {
     use super::{Animal, Error};
     use super::Animal::{Dog, Frog};
     use super::Error::{EndOfStream, SyntaxError};
-    use self::State::{AnimalState, IntState, StringState, EndState};
+    use self::State::{AnimalState, IsizeState, StringState, EndState};
 
     use serde::de;
 
     enum State {
         AnimalState(Animal),
-        IntState(int),
+        IsizeState(isize),
         StringState(String),
         EndState,
 
@@ -279,12 +279,12 @@ mod deserializer {
                 }
                 Some(AnimalState(Frog(x0, x1))) => {
                     self.stack.push(EndState);
-                    self.stack.push(IntState(x1));
+                    self.stack.push(IsizeState(x1));
                     self.stack.push(StringState(x0));
                     Some(Ok(de::Token::EnumStart("Animal", "Frog", 2)))
                 }
-                Some(IntState(x)) => {
-                    Some(Ok(de::Token::Int(x)))
+                Some(IsizeState(x)) => {
+                    Some(Ok(de::Token::Isize(x)))
                 }
                 Some(StringState(x)) => {
                     Some(Ok(de::Token::String(x)))

benches/bench_log.rs

@@ -46,7 +46,7 @@ enum HttpProtocol {
 
 impl rustc_serialize::Encodable for HttpProtocol {
     fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (*self as uint).encode(s)
+        (*self as usize).encode(s)
     }
 }
 
@@ -62,7 +62,7 @@ impl rustc_serialize::Decodable for HttpProtocol {
 impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for HttpProtocol {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
-        s.serialize_uint(*self as uint)
+        s.serialize_usize(*self as usize)
     }
 }
 
@@ -90,7 +90,7 @@ enum HttpMethod {
 
 impl rustc_serialize::Encodable for HttpMethod {
     fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (*self as uint).encode(s)
+        (*self as usize).encode(s)
     }
 }
 
@@ -98,7 +98,7 @@ impl rustc_serialize::Decodable for HttpMethod {
     fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<HttpMethod, D::Error> {
         match FromPrimitive::from_uint(try!(d.read_usize())) {
             Some(value) => Ok(value),
-            None => Err(d.error("cannot convert from uint")),
+            None => Err(d.error("cannot convert from usize")),
         }
     }
 }
@@ -106,7 +106,7 @@ impl rustc_serialize::Decodable for HttpMethod {
 impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for HttpMethod {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
-        s.serialize_uint(*self as uint)
+        s.serialize_usize(*self as usize)
     }
 }
 
@@ -127,7 +127,7 @@ enum CacheStatus {
 
 impl rustc_serialize::Encodable for CacheStatus {
     fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (*self as uint).encode(s)
+        (*self as usize).encode(s)
     }
 }
 
@@ -135,7 +135,7 @@ impl rustc_serialize::Decodable for CacheStatus {
     fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<CacheStatus, D::Error> {
         match FromPrimitive::from_uint(try!(d.read_usize())) {
             Some(value) => Ok(value),
-            None => Err(d.error("cannot convert from uint")),
+            None => Err(d.error("cannot convert from usize")),
         }
     }
 }
@@ -143,7 +143,7 @@ impl rustc_serialize::Decodable for CacheStatus {
 impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for CacheStatus {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
-        s.serialize_uint(*self as uint)
+        s.serialize_usize(*self as usize)
     }
 }
 
@@ -173,7 +173,7 @@ enum OriginProtocol {
 
 impl rustc_serialize::Encodable for OriginProtocol {
     fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (*self as uint).encode(s)
+        (*self as usize).encode(s)
     }
 }
 
@@ -181,7 +181,7 @@ impl rustc_serialize::Decodable for OriginProtocol {
     fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<OriginProtocol, D::Error> {
         match FromPrimitive::from_uint(try!(d.read_usize())) {
             Some(value) => Ok(value),
-            None => Err(d.error("cannot convert from uint")),
+            None => Err(d.error("cannot convert from usize")),
         }
     }
 }
@@ -189,7 +189,7 @@ impl rustc_serialize::Decodable for OriginProtocol {
 impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for OriginProtocol {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
-        s.serialize_uint(*self as uint)
+        s.serialize_usize(*self as usize)
     }
 }
 
@@ -211,7 +211,7 @@ enum ZonePlan {
 
 impl rustc_serialize::Encodable for ZonePlan {
     fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (*self as uint).encode(s)
+        (*self as usize).encode(s)
     }
 }
 
@@ -219,7 +219,7 @@ impl rustc_serialize::Decodable for ZonePlan {
     fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<ZonePlan, D::Error> {
         match FromPrimitive::from_uint(try!(d.read_usize())) {
             Some(value) => Ok(value),
-            None => Err(d.error("cannot convert from uint")),
+            None => Err(d.error("cannot convert from usize")),
         }
     }
 }
@@ -227,7 +227,7 @@ impl rustc_serialize::Decodable for ZonePlan {
 impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for ZonePlan {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
-        s.serialize_uint(*self as uint)
+        s.serialize_usize(*self as usize)
     }
 }
 
@@ -500,7 +500,7 @@ enum Country {
 
 impl rustc_serialize::Encodable for Country {
     fn encode<S: rustc_serialize::Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        (*self as uint).encode(s)
+        (*self as usize).encode(s)
     }
 }
 
@@ -508,7 +508,7 @@ impl rustc_serialize::Decodable for Country {
     fn decode<D: rustc_serialize::Decoder>(d: &mut D) -> Result<Country, D::Error> {
         match FromPrimitive::from_uint(try!(d.read_usize())) {
             Some(value) => Ok(value),
-            None => Err(d.error("cannot convert from uint")),
+            None => Err(d.error("cannot convert from usize")),
         }
     }
 }
@@ -516,7 +516,7 @@ impl rustc_serialize::Decodable for Country {
 impl<S: ser::Serializer<E>, E> ser::Serialize<S, E> for Country {
     #[inline]
     fn serialize(&self, s: &mut S) -> Result<(), E> {
-        s.serialize_uint(*self as uint)
+        s.serialize_usize(*self as usize)
     }
 }
 
@@ -610,7 +610,7 @@ struct MyMemWriter0 {
 }
 
 impl MyMemWriter0 {
-    pub fn with_capacity(cap: uint) -> MyMemWriter0 {
+    pub fn with_capacity(cap: usize) -> MyMemWriter0 {
         MyMemWriter0 {
             buf: Vec::with_capacity(cap)
         }
@@ -631,7 +631,7 @@ struct MyMemWriter1 {
 }
 
 impl MyMemWriter1 {
-    pub fn with_capacity(cap: uint) -> MyMemWriter1 {
+    pub fn with_capacity(cap: usize) -> MyMemWriter1 {
         MyMemWriter1 {
             buf: Vec::with_capacity(cap)
         }
@@ -652,7 +652,7 @@ fn push_all_bytes(dst: &mut Vec<u8>, src: &[u8]) {
         dst.set_len(dst_len + src_len);
 
         ::std::ptr::copy_nonoverlapping_memory(
-            dst.as_mut_ptr().offset(dst_len as int),
+            dst.as_mut_ptr().offset(dst_len as isize),
             src.as_ptr(),
             src_len);
     }
@@ -847,10 +847,10 @@ fn manual_serialize_no_escape<W: Writer>(wr: &mut W, log: &Log) {
     wr.write_str(",\"zone_id\":").unwrap();
     (write!(wr, "{}", log.zone_id)).unwrap();
     wr.write_str(",\"zone_plan\":").unwrap();
-    (write!(wr, "{}", log.zone_plan as uint)).unwrap();
+    (write!(wr, "{}", log.zone_plan as usize)).unwrap();
 
     wr.write_str(",\"http\":{\"protocol\":").unwrap();
-    (write!(wr, "{}", log.http.protocol as uint)).unwrap();
+    (write!(wr, "{}", log.http.protocol as usize)).unwrap();
     wr.write_str(",\"status\":").unwrap();
     (write!(wr, "{}", log.http.status)).unwrap();
     wr.write_str(",\"host_status\":").unwrap();
@@ -858,7 +858,7 @@ fn manual_serialize_no_escape<W: Writer>(wr: &mut W, log: &Log) {
     wr.write_str(",\"up_status\":").unwrap();
     (write!(wr, "{}", log.http.up_status)).unwrap();
     wr.write_str(",\"method\":").unwrap();
-    (write!(wr, "{}", log.http.method as uint)).unwrap();
+    (write!(wr, "{}", log.http.method as usize)).unwrap();
     wr.write_str(",\"content_type\":").unwrap();
     (write!(wr, "\"{}\"", log.http.content_type)).unwrap();
     wr.write_str(",\"user_agent\":").unwrap();
@@ -878,12 +878,12 @@ fn manual_serialize_no_escape<W: Writer>(wr: &mut W, log: &Log) {
     (write!(wr, "\"{}\"", log.origin.hostname)).unwrap();
 
     wr.write_str(",\"protocol\":").unwrap();
-    (write!(wr, "{}", log.origin.protocol as uint)).unwrap();
+    (write!(wr, "{}", log.origin.protocol as usize)).unwrap();
 
     wr.write_str("},\"country\":").unwrap();
-    (write!(wr, "{}", log.country as uint)).unwrap();
+    (write!(wr, "{}", log.country as usize)).unwrap();
     wr.write_str(",\"cache_status\":").unwrap();
-    (write!(wr, "{}", log.cache_status as uint)).unwrap();
+    (write!(wr, "{}", log.cache_status as usize)).unwrap();
     wr.write_str(",\"server_ip\":").unwrap();
     (write!(wr, "\"{}\"", log.server_ip)).unwrap();
     wr.write_str(",\"server_name\":").unwrap();
@@ -910,14 +910,14 @@ fn manual_serialize_escape<W: Writer>(wr: &mut W, log: &Log) {
     wr.write_str(",").unwrap();
     escape_str(wr, "zone_plan").unwrap();
     wr.write_str(":").unwrap();
-    (write!(wr, "{}", log.zone_plan as int)).unwrap();
+    (write!(wr, "{}", log.zone_plan as isize)).unwrap();
 
     wr.write_str(",").unwrap();
     escape_str(wr, "http").unwrap();
     wr.write_str(":{").unwrap();
     escape_str(wr, "protocol").unwrap();
     wr.write_str(":").unwrap();
-    (write!(wr, "{}", log.http.protocol as uint)).unwrap();
+    (write!(wr, "{}", log.http.protocol as usize)).unwrap();
     wr.write_str(",").unwrap();
     escape_str(wr, "status").unwrap();
     wr.write_str(":").unwrap();
@@ -933,7 +933,7 @@ fn manual_serialize_escape<W: Writer>(wr: &mut W, log: &Log) {
     wr.write_str(",").unwrap();
     escape_str(wr, "method").unwrap();
     wr.write_str(":").unwrap();
-    (write!(wr, "{}", log.http.method as uint)).unwrap();
+    (write!(wr, "{}", log.http.method as usize)).unwrap();
     wr.write_str(",").unwrap();
     escape_str(wr, "content_type").unwrap();
     wr.write_str(":").unwrap();
@@ -969,16 +969,16 @@ fn manual_serialize_escape<W: Writer>(wr: &mut W, log: &Log) {
     wr.write_str(",").unwrap();
     escape_str(wr, "protocol").unwrap();
     wr.write_str(":").unwrap();
-    (write!(wr, "{}", log.origin.protocol as uint)).unwrap();
+    (write!(wr, "{}", log.origin.protocol as usize)).unwrap();
 
     wr.write_str("},").unwrap();
     escape_str(wr, "country").unwrap();
     wr.write_str(":").unwrap();
-    (write!(wr, "{}", log.country as uint)).unwrap();
+    (write!(wr, "{}", log.country as usize)).unwrap();
     wr.write_str(",").unwrap();
     escape_str(wr, "cache_status").unwrap();
     wr.write_str(":").unwrap();
-    (write!(wr, "{}", log.cache_status as uint)).unwrap();
+    (write!(wr, "{}", log.cache_status as usize)).unwrap();
     wr.write_str(",").unwrap();
     escape_str(wr, "server_ip").unwrap();
     wr.write_str(":").unwrap();
@@ -1167,11 +1167,11 @@ fn direct<W: Writer>(wr: &mut W, log: &Log) {
 
     serializer.serialize_struct_elt("timestamp", &log.timestamp).unwrap();
     serializer.serialize_struct_elt("zone_id", &log.zone_id).unwrap();
-    serializer.serialize_struct_elt("zone_plan", &(log.zone_plan as uint)).unwrap();
+    serializer.serialize_struct_elt("zone_plan", &(log.zone_plan as usize)).unwrap();
     serializer.serialize_struct_elt("http", &log.http).unwrap();
     serializer.serialize_struct_elt("origin", &log.origin).unwrap();
-    serializer.serialize_struct_elt("country", &(log.country as uint)).unwrap();
-    serializer.serialize_struct_elt("cache_status", &(log.cache_status as uint)).unwrap();
+    serializer.serialize_struct_elt("country", &(log.country as usize)).unwrap();
+    serializer.serialize_struct_elt("cache_status", &(log.cache_status as usize)).unwrap();
     serializer.serialize_struct_elt("server_ip", &log.server_ip.as_slice()).unwrap();
     serializer.serialize_struct_elt("server_name", &log.server_name.as_slice()).unwrap();
     serializer.serialize_struct_elt("remote_ip", &log.remote_ip.as_slice()).unwrap();
@@ -1589,7 +1589,7 @@ fn bench_deserializers(b: &mut Bencher) {
 
     b.bytes = s.len() as u64;
 
-    for _ in range(0i, 10000) {
+    for _ in range(0is, 10000) {
         let _log: Log = json::from_str(s).unwrap();
     }
 }
@@ -1618,7 +1618,7 @@ fn bench_reader_manual_reader_deserializer(b: &mut Bencher) {
 fn bench_reader_manual_reader_deserializers(b: &mut Bencher) {
     b.bytes = JSON_STR.len() as u64;
 
-    for _ in range(0i, 100000) {
+    for _ in range(0is, 100000) {
         let mut rdr = JSON_STR.as_bytes();
         let _ = manual_reader_deserialize(&mut rdr);
     }
@@ -1646,7 +1646,7 @@ fn bench_iter_manual_iter_deserializer(b: &mut Bencher) {
 fn bench_iter_manual_iter_deserializers(b: &mut Bencher) {
     b.bytes = JSON_STR.len() as u64;
 
-    for _ in range(0i, 10000) {
+    for _ in range(0is, 10000) {
         let _ = manual_iter_deserialize(JSON_STR.bytes());
     }
 }
@@ -1681,7 +1681,7 @@ fn bench_iter_manual_reader_as_iter_deserializer(b: &mut Bencher) {
 fn bench_iter_manual_reader_as_iter_deserializers(b: &mut Bencher) {
     b.bytes = JSON_STR.len() as u64;
 
-    for _ in range(0i, 10000) {
+    for _ in range(0is, 10000) {
         let mut rdr = JSON_STR.as_bytes();
         let iter = Bytes::new(&mut rdr)
             .map(|x| x.unwrap());

benches/bench_map.rs

@@ -33,23 +33,23 @@ mod decoder {
 
     use super::Error;
     use super::Error::{EndOfStream, SyntaxError, OtherError};
-    use self::Value::{StringValue, IntValue};
+    use self::Value::{StringValue, IsizeValue};
 
     enum Value {
         StringValue(String),
-        IntValue(int),
+        IsizeValue(isize),
     }
 
-    pub struct IntDecoder {
-        len: uint,
-        iter: IntoIter<String, int>,
+    pub struct IsizeDecoder {
+        len: usize,
+        iter: IntoIter<String, isize>,
         stack: Vec<Value>,
     }
 
-    impl IntDecoder {
+    impl IsizeDecoder {
         #[inline]
-        pub fn new(values: HashMap<String, int>) -> IntDecoder {
-            IntDecoder {
+        pub fn new(values: HashMap<String, isize>) -> IsizeDecoder {
+            IsizeDecoder {
                 len: values.len(),
                 iter: values.into_iter(),
                 stack: vec!(),
@@ -57,7 +57,7 @@ mod decoder {
         }
     }
 
-    impl rustc_serialize::Decoder for IntDecoder {
+    impl rustc_serialize::Decoder for IsizeDecoder {
         type Error = Error;
 
         fn error(&mut self, msg: &str) -> Error {
@@ -66,15 +66,15 @@ mod decoder {
 
         // Primitive types:
         fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
-        fn read_usize(&mut self) -> Result<uint, Error> { Err(SyntaxError) }
+        fn read_usize(&mut self) -> Result<usize, Error> { Err(SyntaxError) }
         fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
         fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
         fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
         fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
         #[inline]
-        fn read_isize(&mut self) -> Result<int, Error> {
+        fn read_isize(&mut self) -> Result<isize, Error> {
             match self.stack.pop() {
-                Some(IntValue(x)) => Ok(x),
+                Some(IsizeValue(x)) => Ok(x),
                 Some(_) => Err(SyntaxError),
                 None => Err(EndOfStream),
             }
@@ -98,104 +98,104 @@ mod decoder {
 
         // Compound types:
         fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
         fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
         fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_struct<T, F>(&mut self, _s_name: &str, _len: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple<T, F>(&mut self, _len: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple_arg<T, F>(&mut self, _a_idx: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
         // Specialized types:
         fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder, bool) -> Result<T, Error>,
+            F: FnOnce(&mut IsizeDecoder, bool) -> Result<T, Error>,
         {
             Err(SyntaxError)
         }
 
         fn read_seq<T, F>(&mut self, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
         {
             Err(SyntaxError)
         }
 
-        fn read_seq_elt<T, F>(&mut self, _idx: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_seq_elt<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(SyntaxError)
         }
 
         #[inline]
         fn read_map<T, F>(&mut self, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
         {
             let len = self.len;
             f(self, len)
         }
         #[inline]
-        fn read_map_elt_key<T, F>(&mut self, _idx: uint, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             match self.iter.next() {
                 Some((key, value)) => {
-                    self.stack.push(IntValue(value));
+                    self.stack.push(IsizeValue(value));
                     self.stack.push(StringValue(key));
                     f(self)
                 }
@@ -206,8 +206,8 @@ mod decoder {
         }
 
         #[inline]
-        fn read_map_elt_val<T, F>(&mut self, _idx: uint, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             f(self)
         }
@@ -230,20 +230,20 @@ mod deserializer {
     enum State {
         StartState,
         KeyOrEndState,
-        ValueState(int),
+        ValueState(isize),
         EndState,
     }
 
-    pub struct IntDeserializer {
+    pub struct IsizeDeserializer {
         stack: Vec<State>,
-        len: uint,
-        iter: IntoIter<String, int>,
+        len: usize,
+        iter: IntoIter<String, isize>,
     }
 
-    impl IntDeserializer {
+    impl IsizeDeserializer {
         #[inline]
-        pub fn new(values: HashMap<String, int>) -> IntDeserializer {
-            IntDeserializer {
+        pub fn new(values: HashMap<String, isize>) -> IsizeDeserializer {
+            IsizeDeserializer {
                 stack: vec!(StartState),
                 len: values.len(),
                 iter: values.into_iter(),
@@ -251,7 +251,7 @@ mod deserializer {
         }
     }
 
-    impl Iterator for IntDeserializer {
+    impl Iterator for IsizeDeserializer {
         type Item = Result<de::Token, Error>;
 
         #[inline]
@@ -275,7 +275,7 @@ mod deserializer {
                 }
                 Some(ValueState(x)) => {
                     self.stack.push(KeyOrEndState);
-                    Some(Ok(de::Token::Int(x)))
+                    Some(Ok(de::Token::Isize(x)))
                 }
                 Some(EndState) => {
                     None
@@ -287,7 +287,7 @@ mod deserializer {
         }
     }
 
-    impl de::Deserializer<Error> for IntDeserializer {
+    impl de::Deserializer<Error> for IsizeDeserializer {
         #[inline]
         fn end_of_stream_error(&mut self) -> Error {
             EndOfStream
@@ -310,7 +310,7 @@ mod deserializer {
 
         #[inline]
         fn missing_field<
-            T: de::Deserialize<IntDeserializer, Error>
+            T: de::Deserialize<IsizeDeserializer, Error>
         >(&mut self, _field: &'static str) -> Result<T, Error> {
             Err(SyntaxError)
         }
@@ -331,30 +331,30 @@ fn run_decoder<
 #[bench]
 fn bench_decoder_000(b: &mut Bencher) {
     b.iter(|| {
-        let m: HashMap<String, int> = HashMap::new();
-        run_decoder(decoder::IntDecoder::new(m.clone()), m)
+        let m: HashMap<String, isize> = HashMap::new();
+        run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
     })
 }
 
 #[bench]
 fn bench_decoder_003(b: &mut Bencher) {
     b.iter(|| {
-        let mut m: HashMap<String, int> = HashMap::new();
-        for i in range(0i, 3) {
+        let mut m: HashMap<String, isize> = HashMap::new();
+        for i in range(0is, 3) {
             m.insert(i.to_string(), i);
         }
-        run_decoder(decoder::IntDecoder::new(m.clone()), m)
+        run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
     })
 }
 
 #[bench]
 fn bench_decoder_100(b: &mut Bencher) {
     b.iter(|| {
-        let mut m: HashMap<String, int> = HashMap::new();
-        for i in range(0i, 100) {
+        let mut m: HashMap<String, isize> = HashMap::new();
+        for i in range(0is, 100) {
             m.insert(i.to_string(), i);
         }
-        run_decoder(decoder::IntDecoder::new(m.clone()), m)
+        run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
     })
 }
 
@@ -371,29 +371,29 @@ fn run_deserializer<
 #[bench]
 fn bench_deserializer_000(b: &mut Bencher) {
     b.iter(|| {
-        let m: HashMap<String, int> = HashMap::new();
-        run_deserializer(deserializer::IntDeserializer::new(m.clone()), m)
+        let m: HashMap<String, isize> = HashMap::new();
+        run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
     })
 }
 
 #[bench]
 fn bench_deserializer_003(b: &mut Bencher) {
     b.iter(|| {
-        let mut m: HashMap<String, int> = HashMap::new();
-        for i in range(0i, 3) {
+        let mut m: HashMap<String, isize> = HashMap::new();
+        for i in range(0is, 3) {
             m.insert(i.to_string(), i);
         }
-        run_deserializer(deserializer::IntDeserializer::new(m.clone()), m)
+        run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
     })
 }
 
 #[bench]
 fn bench_deserializer_100(b: &mut Bencher) {
     b.iter(|| {
-        let mut m: HashMap<String, int> = HashMap::new();
-        for i in range(0i, 100) {
+        let mut m: HashMap<String, isize> = HashMap::new();
+        for i in range(0is, 100) {
             m.insert(i.to_string(), i);
         }
-        run_deserializer(deserializer::IntDeserializer::new(m.clone()), m)
+        run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
     })
 }

benches/bench_struct.rs

@@ -20,7 +20,7 @@ use serde::de::{Deserializer, Deserialize};
 #[derive_deserialize]
 struct Inner {
     a: (),
-    b: uint,
+    b: usize,
     c: HashMap<String, Option<char>>,
 }
 
@@ -54,7 +54,7 @@ mod decoder {
         OuterState,
         InnerState,
         NullState,
-        UintState,
+        UsizeState,
         CharState,
         StringState,
         FieldState,
@@ -68,7 +68,7 @@ mod decoder {
         OuterState(Outer),
         InnerState(Inner),
         NullState,
-        UintState(uint),
+        UsizeState(usize),
         CharState(char),
         StringState(String),
         FieldState(&'static str),
@@ -107,9 +107,9 @@ mod decoder {
             }
         }
         #[inline]
-        fn read_usize(&mut self) -> Result<uint, Error> {
+        fn read_usize(&mut self) -> Result<usize, Error> {
             match self.stack.pop() {
-                Some(UintState(value)) => Ok(value),
+                Some(UsizeState(value)) => Ok(value),
                 _ => Err(Error::SyntaxError("UintState".to_string())),
             }
         }
@@ -117,7 +117,7 @@ mod decoder {
         fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::SyntaxError("".to_string())) }
         fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::SyntaxError("".to_string())) }
         fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::SyntaxError("".to_string())) }
-        fn read_isize(&mut self) -> Result<int, Error> { Err(Error::SyntaxError("".to_string())) }
+        fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::SyntaxError("".to_string())) }
         fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::SyntaxError("".to_string())) }
         fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::SyntaxError("".to_string())) }
         fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::SyntaxError("".to_string())) }
@@ -148,31 +148,31 @@ mod decoder {
         }
 
         fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
         {
             Err(Error::SyntaxError("".to_string()))
         }
 
-        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: uint, _f: F) -> Result<T, Error> where
+        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError("".to_string()))
         }
 
         fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
         {
             Err(Error::SyntaxError("".to_string()))
         }
 
-        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: uint, _f: F) -> Result<T, Error> where
+        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError("".to_string()))
         }
 
         #[inline]
-        fn read_struct<T, F>(&mut self, s_name: &str, _len: uint, f: F) -> Result<T, Error> where
+        fn read_struct<T, F>(&mut self, s_name: &str, _len: usize, f: F) -> Result<T, Error> where
             F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
         {
             match self.stack.pop() {
@@ -190,7 +190,7 @@ mod decoder {
                         self.stack.push(MapState(c));
                         self.stack.push(FieldState("c"));
 
-                        self.stack.push(UintState(b));
+                        self.stack.push(UsizeState(b));
                         self.stack.push(FieldState("b"));
 
                         self.stack.push(NullState);
@@ -204,7 +204,7 @@ mod decoder {
             }
         }
         #[inline]
-        fn read_struct_field<T, F>(&mut self, f_name: &str, _f_idx: uint, f: F) -> Result<T, Error> where
+        fn read_struct_field<T, F>(&mut self, f_name: &str, _f_idx: usize, f: F) -> Result<T, Error> where
             F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
         {
             match self.stack.pop() {
@@ -219,25 +219,25 @@ mod decoder {
             }
         }
 
-        fn read_tuple<T, F>(&mut self, _len: uint, _f: F) -> Result<T, Error> where
+        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError("".to_string()))
         }
 
-        fn read_tuple_arg<T, F>(&mut self, _a_idx: uint, _f: F) -> Result<T, Error> where
+        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError("".to_string()))
         }
 
-        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: uint, _f: F) -> Result<T, Error> where
+        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError("".to_string()))
         }
 
-        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: uint, _f: F) -> Result<T, Error> where
+        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError("".to_string()))
@@ -256,7 +256,7 @@ mod decoder {
 
         #[inline]
         fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
         {
             match self.stack.pop() {
                 Some(VecState(value)) => {
@@ -270,7 +270,7 @@ mod decoder {
             }
         }
         #[inline]
-        fn read_seq_elt<T, F>(&mut self, _idx: uint, f: F) -> Result<T, Error> where
+        fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
             F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
         {
             f(self)
@@ -278,7 +278,7 @@ mod decoder {
 
         #[inline]
         fn read_map<T, F>(&mut self, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
         {
             match self.stack.pop() {
                 Some(MapState(map)) => {
@@ -301,14 +301,14 @@ mod decoder {
             }
         }
         #[inline]
-        fn read_map_elt_key<T, F>(&mut self, _idx: uint, f: F) -> Result<T, Error> where
+        fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
             F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
         {
             f(self)
         }
 
         #[inline]
-        fn read_map_elt_val<T, F>(&mut self, _idx: uint, f: F) -> Result<T, Error> where
+        fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
             F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
         {
             f(self)
@@ -329,11 +329,11 @@ mod deserializer {
         InnerState,
         FieldState,
         NullState,
-        UintState,
+        UsizeState,
         CharState,
         StringState,
         OptionState,
-        //TupleState(uint),
+        //TupleState(usize),
         VecState,
         MapState,
         EndState,
@@ -345,7 +345,7 @@ mod deserializer {
         InnerState(Inner),
         FieldState(&'static str),
         NullState,
-        UintState(uint),
+        UsizeState(usize),
         CharState(char),
         StringState(String),
         OptionState(bool),
@@ -385,7 +385,7 @@ mod deserializer {
                     self.stack.push(MapState(c));
                     self.stack.push(FieldState("c"));
 
-                    self.stack.push(UintState(b));
+                    self.stack.push(UsizeState(b));
                     self.stack.push(FieldState("b"));
 
                     self.stack.push(NullState);
@@ -420,7 +420,7 @@ mod deserializer {
                 }
                 //Some(TupleState(len)) => Some(Ok(de::Token::TupleStart(len))),
                 Some(NullState) => Some(Ok(de::Token::Null)),
-                Some(UintState(x)) => Some(Ok(de::Token::Uint(x))),
+                Some(UsizeState(x)) => Some(Ok(de::Token::Usize(x))),
                 Some(CharState(x)) => Some(Ok(de::Token::Char(x))),
                 Some(StringState(x)) => Some(Ok(de::Token::String(x))),
                 Some(OptionState(x)) => Some(Ok(de::Token::Option(x))),

benches/bench_vec.rs

@@ -32,22 +32,22 @@ mod decoder {
     use super::Error;
     use super::Error::{EndOfStream, SyntaxError, OtherError};
 
-    pub struct IntDecoder {
-        len: uint,
-        iter: vec::IntoIter<int>,
+    pub struct IsizeDecoder {
+        len: usize,
+        iter: vec::IntoIter<isize>,
     }
 
-    impl IntDecoder {
+    impl IsizeDecoder {
         #[inline]
-        pub fn new(values: Vec<int>) -> IntDecoder {
-            IntDecoder {
+        pub fn new(values: Vec<isize>) -> IsizeDecoder {
+            IsizeDecoder {
                 len: values.len(),
                 iter: values.into_iter(),
             }
         }
     }
 
-    impl rustc_serialize::Decoder for IntDecoder {
+    impl rustc_serialize::Decoder for IsizeDecoder {
         type Error = Error;
 
         fn error(&mut self, msg: &str) -> Error {
@@ -56,13 +56,13 @@ mod decoder {
 
         // Primitive types:
         fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
-        fn read_usize(&mut self) -> Result<uint, Error> { Err(SyntaxError) }
+        fn read_usize(&mut self) -> Result<usize, Error> { Err(SyntaxError) }
         fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
         fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
         fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
         fn read_u8(&mut self) -> Result<u8, Error> { Err(SyntaxError) }
         #[inline]
-        fn read_isize(&mut self) -> Result<int, Error> {
+        fn read_isize(&mut self) -> Result<isize, Error> {
             match self.iter.next() {
                 Some(value) => Ok(value),
                 None => Err(EndOfStream),
@@ -80,106 +80,106 @@ mod decoder {
 
         // Compound types:
         fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
         fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
         fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_struct<T, F>(&mut self, _s_name: &str, _len: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple<T, F>(&mut self, _len: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple_arg<T, F>(&mut self, _a_idx: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
         // Specialized types:
         fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder, bool) -> Result<T, Error>,
+            F: FnOnce(&mut IsizeDecoder, bool) -> Result<T, Error>,
         {
             Err(SyntaxError)
         }
 
         #[inline]
         fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
         {
             let len = self.len;
             f(self, len)
         }
         #[inline]
-        fn read_seq_elt<T, F>(&mut self, _idx: uint, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             f(self)
         }
 
         fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
         {
             Err(SyntaxError)
         }
 
-        fn read_map_elt_key<T, F>(&mut self, _idx: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(SyntaxError)
         }
 
-        fn read_map_elt_val<T, F>(&mut self, _idx: uint, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IntDecoder) -> Result<T, Error>,
+        fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
+            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
         {
             Err(SyntaxError)
         }
@@ -187,7 +187,7 @@ mod decoder {
 
 
     pub struct U8Decoder {
-        len: uint,
+        len: usize,
         iter: vec::IntoIter<u8>,
     }
 
@@ -210,7 +210,7 @@ mod decoder {
 
         // Primitive types:
         fn read_nil(&mut self) -> Result<(), Error> { Err(SyntaxError) }
-        fn read_usize(&mut self) -> Result<uint, Error> { Err(SyntaxError) }
+        fn read_usize(&mut self) -> Result<usize, Error> { Err(SyntaxError) }
         fn read_u64(&mut self) -> Result<u64, Error> { Err(SyntaxError) }
         fn read_u32(&mut self) -> Result<u32, Error> { Err(SyntaxError) }
         fn read_u16(&mut self) -> Result<u16, Error> { Err(SyntaxError) }
@@ -222,7 +222,7 @@ mod decoder {
             }
         }
         #[inline]
-        fn read_isize(&mut self) -> Result<int, Error> { Err(SyntaxError) }
+        fn read_isize(&mut self) -> Result<isize, Error> { Err(SyntaxError) }
         fn read_i64(&mut self) -> Result<i64, Error> { Err(SyntaxError) }
         fn read_i32(&mut self) -> Result<i32, Error> { Err(SyntaxError) }
         fn read_i16(&mut self) -> Result<i16, Error> { Err(SyntaxError) }
@@ -241,60 +241,60 @@ mod decoder {
         }
 
         fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: uint, _f: F) -> Result<T, Error> where
+        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
         fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: uint, _f: F) -> Result<T, Error> where
+        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_struct<T, F>(&mut self, _s_name: &str, _len: uint, _f: F) -> Result<T, Error> where
+        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: uint, _f: F) -> Result<T, Error> where
+        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple<T, F>(&mut self, _len: uint, _f: F) -> Result<T, Error> where
+        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple_arg<T, F>(&mut self, _a_idx: uint, _f: F) -> Result<T, Error> where
+        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: uint, _f: F) -> Result<T, Error> where
+        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
         }
 
-        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: uint, _f: F) -> Result<T, Error> where
+        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
         {
             Err(Error::SyntaxError)
@@ -309,31 +309,31 @@ mod decoder {
 
         #[inline]
         fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
         {
             let len = self.len;
             f(self, len)
         }
         #[inline]
-        fn read_seq_elt<T, F>(&mut self, _idx: uint, f: F) -> Result<T, Error> where
+        fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
             F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
         {
             f(self)
         }
 
         fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder, uint) -> Result<T, Error>,
+            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
         {
             Err(SyntaxError)
         }
 
-        fn read_map_elt_key<T, F>(&mut self, _idx: uint, _f: F) -> Result<T, Error> where
+        fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
         {
             Err(SyntaxError)
         }
 
-        fn read_map_elt_val<T, F>(&mut self, _idx: uint, _f: F) -> Result<T, Error> where
+        fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
             F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
         {
             Err(SyntaxError)
@@ -360,16 +360,16 @@ mod deserializer {
         EndState,
     }
 
-    pub struct IntDeserializer {
+    pub struct IsizeDeserializer {
         state: State,
-        len: uint,
-        iter: vec::IntoIter<int>,
+        len: usize,
+        iter: vec::IntoIter<isize>,
     }
 
-    impl IntDeserializer {
+    impl IsizeDeserializer {
         #[inline]
-        pub fn new(values: Vec<int>) -> IntDeserializer {
-            IntDeserializer {
+        pub fn new(values: Vec<isize>) -> IsizeDeserializer {
+            IsizeDeserializer {
                 state: StartState,
                 len: values.len(),
                 iter: values.into_iter(),
@@ -377,7 +377,7 @@ mod deserializer {
         }
     }
 
-    impl Iterator for IntDeserializer {
+    impl Iterator for IsizeDeserializer {
         type Item = Result<de::Token, Error>;
 
         #[inline]
@@ -390,7 +390,7 @@ mod deserializer {
                 SepOrEndState => {
                     match self.iter.next() {
                         Some(value) => {
-                            Some(Ok(de::Token::Int(value)))
+                            Some(Ok(de::Token::Isize(value)))
                         }
                         None => {
                             self.state = EndState;
@@ -405,7 +405,7 @@ mod deserializer {
         }
     }
 
-    impl de::Deserializer<Error> for IntDeserializer {
+    impl de::Deserializer<Error> for IsizeDeserializer {
         #[inline]
         fn end_of_stream_error(&mut self) -> Error {
             EndOfStream
@@ -428,7 +428,7 @@ mod deserializer {
 
         #[inline]
         fn missing_field<
-            T: de::Deserialize<IntDeserializer, Error>
+            T: de::Deserialize<IsizeDeserializer, Error>
         >(&mut self, _field: &'static str) -> Result<T, Error> {
             Err(SyntaxError)
         }
@@ -436,7 +436,7 @@ mod deserializer {
 
     pub struct U8Deserializer {
         state: State,
-        len: uint,
+        len: usize,
         iter: vec::IntoIter<u8>,
     }
 
@@ -533,24 +533,24 @@ fn run_deserializer<
 #[bench]
 fn bench_decoder_int_000(b: &mut Bencher) {
     b.iter(|| {
-        let v: Vec<int> = vec!();
-        run_decoder(decoder::IntDecoder::new(v.clone()), v)
+        let v: Vec<isize> = vec!();
+        run_decoder(decoder::IsizeDecoder::new(v.clone()), v)
     })
 }
 
 #[bench]
 fn bench_decoder_int_003(b: &mut Bencher) {
     b.iter(|| {
-        let v: Vec<int> = vec!(1, 2, 3);
-        run_decoder(decoder::IntDecoder::new(v.clone()), v)
+        let v: Vec<isize> = vec!(1, 2, 3);
+        run_decoder(decoder::IsizeDecoder::new(v.clone()), v)
     })
 }
 
 #[bench]
 fn bench_decoder_int_100(b: &mut Bencher) {
     b.iter(|| {
-        let v: Vec<int> = range(0i, 100).collect();
-        run_decoder(decoder::IntDecoder::new(v.clone()), v)
+        let v: Vec<isize> = range(0is, 100).collect();
+        run_decoder(decoder::IsizeDecoder::new(v.clone()), v)
     })
 }
 
@@ -581,24 +581,24 @@ fn bench_decoder_u8_100(b: &mut Bencher) {
 #[bench]
 fn bench_deserializer_int_000(b: &mut Bencher) {
     b.iter(|| {
-        let v: Vec<int> = vec!();
-        run_deserializer(deserializer::IntDeserializer::new(v.clone()), v)
+        let v: Vec<isize> = vec!();
+        run_deserializer(deserializer::IsizeDeserializer::new(v.clone()), v)
     })
 }
 
 #[bench]
 fn bench_deserializer_int_003(b: &mut Bencher) {
     b.iter(|| {
-        let v: Vec<int> = vec!(1, 2, 3);
-        run_deserializer(deserializer::IntDeserializer::new(v.clone()), v)
+        let v: Vec<isize> = vec!(1, 2, 3);
+        run_deserializer(deserializer::IsizeDeserializer::new(v.clone()), v)
     })
 }
 
 #[bench]
 fn bench_deserializer_int_100(b: &mut Bencher) {
     b.iter(|| {
-        let v: Vec<int> = range(0i, 100).collect();
-        run_deserializer(deserializer::IntDeserializer::new(v.clone()), v)
+        let v: Vec<isize> = range(0is, 100).collect();
+        run_deserializer(deserializer::IsizeDeserializer::new(v.clone()), v)
     })
 }
 

serde2/benches/bench_log.rs

@@ -918,7 +918,7 @@ struct MyMemWriter0 {
 }
 
 impl MyMemWriter0 {
-    pub fn with_capacity(cap: uint) -> MyMemWriter0 {
+    pub fn with_capacity(cap: usize) -> MyMemWriter0 {
         MyMemWriter0 {
             buf: Vec::with_capacity(cap)
         }
@@ -939,7 +939,7 @@ struct MyMemWriter1 {
 }
 
 impl MyMemWriter1 {
-    pub fn with_capacity(cap: uint) -> MyMemWriter1 {
+    pub fn with_capacity(cap: usize) -> MyMemWriter1 {
         MyMemWriter1 {
             buf: Vec::with_capacity(cap)
         }
@@ -960,7 +960,7 @@ fn push_all_bytes(dst: &mut Vec<u8>, src: &[u8]) {
         dst.set_len(dst_len + src_len);
 
         ::std::ptr::copy_nonoverlapping_memory(
-            dst.as_mut_ptr().offset(dst_len as int),
+            dst.as_mut_ptr().offset(dst_len as isize),
             src.as_ptr(),
             src_len);
     }
@@ -1157,10 +1157,10 @@ fn manual_serialize_no_escape<W: Writer>(wr: &mut W, log: &Log) {
     wr.write_str(",\"zone_id\":").unwrap();
     (write!(wr, "{}", log.zone_id)).unwrap();
     wr.write_str(",\"zone_plan\":").unwrap();
-    (write!(wr, "{}", log.zone_plan as uint)).unwrap();
+    (write!(wr, "{}", log.zone_plan as usize)).unwrap();
 
     wr.write_str(",\"http\":{\"protocol\":").unwrap();
-    (write!(wr, "{}", log.http.protocol as uint)).unwrap();
+    (write!(wr, "{}", log.http.protocol as usize)).unwrap();
     wr.write_str(",\"status\":").unwrap();
     (write!(wr, "{}", log.http.status)).unwrap();
     wr.write_str(",\"host_status\":").unwrap();
@@ -1168,7 +1168,7 @@ fn manual_serialize_no_escape<W: Writer>(wr: &mut W, log: &Log) {
     wr.write_str(",\"up_status\":").unwrap();
     (write!(wr, "{}", log.http.up_status)).unwrap();
     wr.write_str(",\"method\":").unwrap();
-    (write!(wr, "{}", log.http.method as uint)).unwrap();
+    (write!(wr, "{}", log.http.method as usize)).unwrap();
     wr.write_str(",\"content_type\":").unwrap();
     (write!(wr, "\"{}\"", log.http.content_type)).unwrap();
     wr.write_str(",\"user_agent\":").unwrap();
@@ -1188,12 +1188,12 @@ fn manual_serialize_no_escape<W: Writer>(wr: &mut W, log: &Log) {
     (write!(wr, "\"{}\"", log.origin.hostname)).unwrap();
 
     wr.write_str(",\"protocol\":").unwrap();
-    (write!(wr, "{}", log.origin.protocol as uint)).unwrap();
+    (write!(wr, "{}", log.origin.protocol as usize)).unwrap();
 
     wr.write_str("},\"country\":").unwrap();
-    (write!(wr, "{}", log.country as uint)).unwrap();
+    (write!(wr, "{}", log.country as usize)).unwrap();
     wr.write_str(",\"cache_status\":").unwrap();
-    (write!(wr, "{}", log.cache_status as uint)).unwrap();
+    (write!(wr, "{}", log.cache_status as usize)).unwrap();
     wr.write_str(",\"server_ip\":").unwrap();
     (write!(wr, "\"{}\"", log.server_ip)).unwrap();
     wr.write_str(",\"server_name\":").unwrap();
@@ -1220,14 +1220,14 @@ fn manual_serialize_escape<W: Writer>(wr: &mut W, log: &Log) {
     wr.write_str(",").unwrap();
     escape_str(wr, "zone_plan").unwrap();
     wr.write_str(":").unwrap();
-    (write!(wr, "{}", log.zone_plan as int)).unwrap();
+    (write!(wr, "{}", log.zone_plan as isize)).unwrap();
 
     wr.write_str(",").unwrap();
     escape_str(wr, "http").unwrap();
     wr.write_str(":{").unwrap();
     escape_str(wr, "protocol").unwrap();
     wr.write_str(":").unwrap();
-    (write!(wr, "{}", log.http.protocol as uint)).unwrap();
+    (write!(wr, "{}", log.http.protocol as usize)).unwrap();
     wr.write_str(",").unwrap();
     escape_str(wr, "status").unwrap();
     wr.write_str(":").unwrap();
@@ -1243,7 +1243,7 @@ fn manual_serialize_escape<W: Writer>(wr: &mut W, log: &Log) {
     wr.write_str(",").unwrap();
     escape_str(wr, "method").unwrap();
     wr.write_str(":").unwrap();
-    (write!(wr, "{}", log.http.method as uint)).unwrap();
+    (write!(wr, "{}", log.http.method as usize)).unwrap();
     wr.write_str(",").unwrap();
     escape_str(wr, "content_type").unwrap();
     wr.write_str(":").unwrap();
@@ -1279,16 +1279,16 @@ fn manual_serialize_escape<W: Writer>(wr: &mut W, log: &Log) {
     wr.write_str(",").unwrap();
     escape_str(wr, "protocol").unwrap();
     wr.write_str(":").unwrap();
-    (write!(wr, "{}", log.origin.protocol as uint)).unwrap();
+    (write!(wr, "{}", log.origin.protocol as usize)).unwrap();
 
     wr.write_str("},").unwrap();
     escape_str(wr, "country").unwrap();
     wr.write_str(":").unwrap();
-    (write!(wr, "{}", log.country as uint)).unwrap();
+    (write!(wr, "{}", log.country as usize)).unwrap();
     wr.write_str(",").unwrap();
     escape_str(wr, "cache_status").unwrap();
     wr.write_str(":").unwrap();
-    (write!(wr, "{}", log.cache_status as uint)).unwrap();
+    (write!(wr, "{}", log.cache_status as usize)).unwrap();
     wr.write_str(",").unwrap();
     escape_str(wr, "server_ip").unwrap();
     wr.write_str(":").unwrap();

src/de.rs

@@ -22,12 +22,12 @@ use std::sync::Arc;
 pub enum Token {
     Null,
     Bool(bool),
-    Int(int),
+    Isize(isize),
     I8(i8),
     I16(i16),
     I32(i32),
     I64(i64),
-    Uint(uint),
+    Usize(usize),
     U8(u8),
     U16(u16),
     U32(u32),
@@ -39,11 +39,11 @@ pub enum Token {
     String(String),
     Option(bool),
 
-    TupleStart(uint),
-    StructStart(&'static str, uint),
-    EnumStart(&'static str, &'static str, uint),
-    SeqStart(uint),
-    MapStart(uint),
+    TupleStart(usize),
+    StructStart(&'static str, usize),
+    EnumStart(&'static str, &'static str, usize),
+    SeqStart(usize),
+    MapStart(usize),
 
     End,
 }
@@ -53,12 +53,12 @@ impl Token {
         match *self {
             Token::Null => TokenKind::NullKind,
             Token::Bool(_) => TokenKind::BoolKind,
-            Token::Int(_) => TokenKind::IntKind,
+            Token::Isize(_) => TokenKind::IsizeKind,
             Token::I8(_) => TokenKind::I8Kind,
             Token::I16(_) => TokenKind::I16Kind,
             Token::I32(_) => TokenKind::I32Kind,
             Token::I64(_) => TokenKind::I64Kind,
-            Token::Uint(_) => TokenKind::UintKind,
+            Token::Usize(_) => TokenKind::UsizeKind,
             Token::U8(_) => TokenKind::U8Kind,
             Token::U16(_) => TokenKind::U16Kind,
             Token::U32(_) => TokenKind::U32Kind,
@@ -83,12 +83,12 @@ impl Token {
 pub enum TokenKind {
     NullKind,
     BoolKind,
-    IntKind,
+    IsizeKind,
     I8Kind,
     I16Kind,
     I32Kind,
     I64Kind,
-    UintKind,
+    UsizeKind,
     U8Kind,
     U16Kind,
     U32Kind,
@@ -110,12 +110,12 @@ pub enum TokenKind {
 }
 
 static PRIMITIVE_TOKEN_KINDS: &'static [TokenKind] = &[
-    TokenKind::IntKind,
+    TokenKind::IsizeKind,
     TokenKind::I8Kind,
     TokenKind::I16Kind,
     TokenKind::I32Kind,
     TokenKind::I64Kind,
-    TokenKind::UintKind,
+    TokenKind::UsizeKind,
     TokenKind::U8Kind,
     TokenKind::U16Kind,
     TokenKind::U32Kind,
@@ -143,12 +143,12 @@ impl ::std::fmt::Show for TokenKind {
         match *self {
             TokenKind::NullKind => "Null".fmt(f),
             TokenKind::BoolKind => "Bool".fmt(f),
-            TokenKind::IntKind => "Int".fmt(f),
+            TokenKind::IsizeKind => "Isize".fmt(f),
             TokenKind::I8Kind => "I8".fmt(f),
             TokenKind::I16Kind => "I16".fmt(f),
             TokenKind::I32Kind => "I32".fmt(f),
             TokenKind::I64Kind => "I64".fmt(f),
-            TokenKind::UintKind => "Uint".fmt(f),
+            TokenKind::UsizeKind => "Usize".fmt(f),
             TokenKind::U8Kind => "U8".fmt(f),
             TokenKind::U16Kind => "U16".fmt(f),
             TokenKind::U32Kind => "U32".fmt(f),
@@ -253,12 +253,12 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
     #[inline]
     fn expect_num<T: num::NumCast>(&mut self, token: Token) -> Result<T, E> {
         match token {
-            Token::Int(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
+            Token::Isize(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
             Token::I8(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
             Token::I16(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
             Token::I32(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
             Token::I64(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
-            Token::Uint(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
+            Token::Usize(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
             Token::U8(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
             Token::U16(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
             Token::U32(x) => to_result!(num::cast(x), self.syntax_error(token, PRIMITIVE_TOKEN_KINDS)),
@@ -272,12 +272,12 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
     #[inline]
     fn expect_from_primitive<T: FromPrimitive>(&mut self, token: Token) -> Result<T, E> {
         match token {
-            Token::Int(x) => to_result!(num::from_int(x), self.conversion_error(token)),
+            Token::Isize(x) => to_result!(num::from_int(x), self.conversion_error(token)),
             Token::I8(x) => to_result!(num::from_i8(x), self.conversion_error(token)),
             Token::I16(x) => to_result!(num::from_i16(x), self.conversion_error(token)),
             Token::I32(x) => to_result!(num::from_i32(x), self.conversion_error(token)),
             Token::I64(x) => to_result!(num::from_i64(x), self.conversion_error(token)),
-            Token::Uint(x) => to_result!(num::from_uint(x), self.conversion_error(token)),
+            Token::Usize(x) => to_result!(num::from_uint(x), self.conversion_error(token)),
             Token::U8(x) => to_result!(num::from_u8(x), self.conversion_error(token)),
             Token::U16(x) => to_result!(num::from_u16(x), self.conversion_error(token)),
             Token::U32(x) => to_result!(num::from_u32(x), self.conversion_error(token)),
@@ -345,7 +345,7 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
     }
 
     #[inline]
-    fn expect_tuple_start(&mut self, token: Token) -> Result<uint, E> {
+    fn expect_tuple_start(&mut self, token: Token) -> Result<usize, E> {
         match token {
             Token::TupleStart(len) => Ok(len),
             Token::SeqStart(len) => Ok(len),
@@ -401,7 +401,7 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
     #[inline]
     fn expect_struct_field_or_end(&mut self,
                                   fields: &'static [&'static str]
-                                 ) -> Result<option::Option<option::Option<uint>>, E> {
+                                 ) -> Result<option::Option<option::Option<usize>>, E> {
         match try!(self.expect_token()) {
             Token::End => {
                 Ok(None)
@@ -439,7 +439,7 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
     }
 
     #[inline]
-    fn expect_enum_start(&mut self, token: Token, name: &str, variants: &[&str]) -> Result<uint, E> {
+    fn expect_enum_start(&mut self, token: Token, name: &str, variants: &[&str]) -> Result<usize, E> {
         match token {
             Token::EnumStart(n, v, _) => {
                 if name == n {
@@ -481,7 +481,7 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
     }
 
     #[inline]
-    fn expect_seq_start(&mut self, token: Token) -> Result<uint, E> {
+    fn expect_seq_start(&mut self, token: Token) -> Result<usize, E> {
         match token {
             Token::TupleStart(len) => Ok(len),
             Token::SeqStart(len) => Ok(len),
@@ -533,7 +533,7 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
     }
 
     #[inline]
-    fn expect_map_start(&mut self, token: Token) -> Result<uint, E> {
+    fn expect_map_start(&mut self, token: Token) -> Result<usize, E> {
         match token {
             Token::MapStart(len) => Ok(len),
             _ => {
@@ -590,7 +590,7 @@ pub trait Deserializer<E>: Iterator<Item=Result<Token, E>> + Sized {
 
 struct SeqDeserializer<'a, D: 'a, E: 'a, T> {
     d: &'a mut D,
-    len: uint,
+    len: usize,
     err: &'a mut Option<E>,
 }
 
@@ -617,7 +617,7 @@ impl<
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, option::Option<uint>) {
+    fn size_hint(&self) -> (usize, option::Option<usize>) {
         (self.len, Some(self.len))
     }
 }
@@ -626,7 +626,7 @@ impl<
 
 struct MapDeserializer<'a, D:'a, E: 'a, K, V> {
     d: &'a mut D,
-    len: uint,
+    len: usize,
     err: &'a mut option::Option<E>,
 }
 
@@ -651,7 +651,7 @@ impl<
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, option::Option<uint>) {
+    fn size_hint(&self) -> (usize, option::Option<usize>) {
         (self.len, Some(self.len))
     }
 }
@@ -682,12 +682,12 @@ macro_rules! impl_deserialize {
 }
 
 impl_deserialize!(bool, expect_bool);
-impl_deserialize!(int, expect_num);
+impl_deserialize!(isize, expect_num);
 impl_deserialize!(i8, expect_num);
 impl_deserialize!(i16, expect_num);
 impl_deserialize!(i32, expect_num);
 impl_deserialize!(i64, expect_num);
-impl_deserialize!(uint, expect_num);
+impl_deserialize!(usize, expect_num);
 impl_deserialize!(u8, expect_num);
 impl_deserialize!(u16, expect_num);
 impl_deserialize!(u32, expect_num);
@@ -1094,7 +1094,7 @@ mod tests {
     #[derive(Clone, PartialEq, Show, RustcDecodable)]
     struct Inner {
         a: (),
-        b: uint,
+        b: usize,
         c: BTreeMap<string::String, option::Option<char>>,
     }
 
@@ -1169,7 +1169,7 @@ mod tests {
     #[derive(Clone, PartialEq, Show, RustcDecodable)]
     enum Animal {
         Dog,
-        Frog(string::String, int)
+        Frog(string::String, isize)
     }
 
     impl<D: Deserializer<E>, E> Deserialize<D, E> for Animal {
@@ -1271,12 +1271,12 @@ mod tests {
         vec!(Token::Null) => (), (),
         vec!(Token::Bool(true)) => true, bool,
         vec!(Token::Bool(false)) => false, bool,
-        vec!(Token::Int(5)) => 5, int,
+        vec!(Token::Isize(5)) => 5, isize,
         vec!(Token::I8(5)) => 5, i8,
         vec!(Token::I16(5)) => 5, i16,
         vec!(Token::I32(5)) => 5, i32,
         vec!(Token::I64(5)) => 5, i64,
-        vec!(Token::Uint(5)) => 5, uint,
+        vec!(Token::Usize(5)) => 5, usize,
         vec!(Token::U8(5)) => 5, u8,
         vec!(Token::U16(5)) => 5, u16,
         vec!(Token::U32(5)) => 5, u32,
@@ -1296,11 +1296,11 @@ mod tests {
 
         vec!(
             Token::TupleStart(2),
-                Token::Int(5),
+                Token::Isize(5),
 
                 Token::Str("a"),
             Token::End,
-        ) => (5, "a"), (int, &'static str),
+        ) => (5, "a"), (isize, &'static str),
 
         vec!(
             Token::TupleStart(3),
@@ -1310,21 +1310,21 @@ mod tests {
                 Token::End,
 
                 Token::TupleStart(2),
-                    Token::Int(5),
+                    Token::Isize(5),
 
                     Token::Str("a"),
                 Token::End,
             Token::End,
-        ) => ((), (), (5, "a")), ((), (), (int, &'static str))
+        ) => ((), (), (5, "a")), ((), (), (isize, &'static str))
     ]);
 
     test_value!(test_options, [
-        vec!(Token::Option(false)) => None, option::Option<int>,
+        vec!(Token::Option(false)) => None, option::Option<isize>,
 
         vec!(
             Token::Option(true),
-            Token::Int(5),
-        ) => Some(5), option::Option<int>
+            Token::Isize(5),
+        ) => Some(5), option::Option<isize>
     ]);
 
     test_value!(test_structs, [
@@ -1345,7 +1345,7 @@ mod tests {
                         Token::Null,
 
                         Token::Str("b"),
-                        Token::Uint(5),
+                        Token::Usize(5),
 
                         Token::Str("c"),
                         Token::MapStart(1),
@@ -1377,7 +1377,7 @@ mod tests {
         vec!(
             Token::EnumStart("Animal", "Frog", 2),
                 Token::String("Henry".to_string()),
-                Token::Int(349),
+                Token::Isize(349),
             Token::End,
         ) => Animal::Frog("Henry".to_string(), 349), Animal
     ]);
@@ -1386,57 +1386,57 @@ mod tests {
         vec!(
             Token::SeqStart(0),
             Token::End,
-        ) => vec!(), Vec<int>,
+        ) => vec!(), Vec<isize>,
 
         vec!(
             Token::SeqStart(3),
-                Token::Int(5),
+                Token::Isize(5),
 
-                Token::Int(6),
+                Token::Isize(6),
 
-                Token::Int(7),
+                Token::Isize(7),
             Token::End,
-        ) => vec!(5, 6, 7), Vec<int>,
+        ) => vec!(5, 6, 7), Vec<isize>,
 
 
         vec!(
             Token::SeqStart(3),
                 Token::SeqStart(1),
-                    Token::Int(1),
+                    Token::Isize(1),
                 Token::End,
 
                 Token::SeqStart(2),
-                    Token::Int(2),
+                    Token::Isize(2),
 
-                    Token::Int(3),
+                    Token::Isize(3),
                 Token::End,
 
                 Token::SeqStart(3),
-                    Token::Int(4),
+                    Token::Isize(4),
 
-                    Token::Int(5),
+                    Token::Isize(5),
 
-                    Token::Int(6),
+                    Token::Isize(6),
                 Token::End,
             Token::End,
-        ) => vec!(vec!(1), vec!(2, 3), vec!(4, 5, 6)), Vec<Vec<int>>
+        ) => vec!(vec!(1), vec!(2, 3), vec!(4, 5, 6)), Vec<Vec<isize>>
     ]);
 
     test_value!(test_treemaps, [
         vec!(
             Token::MapStart(0),
             Token::End,
-        ) => treemap!(), BTreeMap<int, string::String>,
+        ) => treemap!(), BTreeMap<isize, string::String>,
 
         vec!(
             Token::MapStart(2),
-                Token::Int(5),
+                Token::Isize(5),
                 Token::String("a".to_string()),
 
-                Token::Int(6),
+                Token::Isize(6),
                 Token::String("b".to_string()),
             Token::End,
-        ) => treemap!(5i => "a".to_string(), 6i => "b".to_string()), BTreeMap<int, string::
+        ) => treemap!(5is => "a".to_string(), 6is => "b".to_string()), BTreeMap<isize, string::
         String>
     ]);
 }

src/json/builder.rs

@@ -93,22 +93,22 @@ mod tests {
         assert_eq!(value, Value::Array(Vec::new()));
 
         let value = ArrayBuilder::new()
-            .push(1i)
-            .push(2i)
-            .push(3i)
+            .push(1is)
+            .push(2is)
+            .push(3is)
             .unwrap();
         assert_eq!(value, Value::Array(vec!(Value::Integer(1), Value::Integer(2), Value::Integer(3))));
 
         let value = ArrayBuilder::new()
-            .push_array(|bld| bld.push(1i).push(2i).push(3i))
+            .push_array(|bld| bld.push(1is).push(2is).push(3is))
             .unwrap();
         assert_eq!(value, Value::Array(vec!(Value::Array(vec!(Value::Integer(1), Value::Integer(2), Value::Integer(3))))));
 
         let value = ArrayBuilder::new()
             .push_object(|bld|
                 bld
-                    .insert("a".to_string(), 1i)
-                    .insert("b".to_string(), 2i))
+                    .insert("a".to_string(), 1is)
+                    .insert("b".to_string(), 2is))
             .unwrap();
 
         let mut map = BTreeMap::new();
@@ -123,8 +123,8 @@ mod tests {
         assert_eq!(value, Value::Object(BTreeMap::new()));
 
         let value = ObjectBuilder::new()
-            .insert("a".to_string(), 1i)
-            .insert("b".to_string(), 2i)
+            .insert("a".to_string(), 1is)
+            .insert("b".to_string(), 2is)
             .unwrap();
 
         let mut map = BTreeMap::new();

src/json/de.rs

@@ -30,8 +30,8 @@ enum State {
 pub struct Parser<Iter> {
     rdr: Iter,
     ch: Option<u8>,
-    line: uint,
-    col: uint,
+    line: usize,
+    col: usize,
     // A state machine is kept to make it possible to interupt and resume parsing.
     state_stack: Vec<State>,
     buf: Vec<u8>,
@@ -261,7 +261,7 @@ impl<Iter: Iterator<Item=u8>> Parser<Iter> {
             match self.ch_or_null() {
                 c @ b'0' ... b'9' => {
                     dec /= 10.0;
-                    res += (((c as int) - (b'0' as int)) as f64) * dec;
+                    res += (((c as isize) - (b'0' as isize)) as f64) * dec;
                     self.bump();
                 }
                 _ => break,
@@ -275,7 +275,7 @@ impl<Iter: Iterator<Item=u8>> Parser<Iter> {
     fn parse_exponent(&mut self, mut res: f64) -> Result<f64, Error> {
         self.bump();
 
-        let mut exp = 0u;
+        let mut exp = 0us;
         let mut neg_exp = false;
 
         if self.ch_is(b'+') {
@@ -294,7 +294,7 @@ impl<Iter: Iterator<Item=u8>> Parser<Iter> {
             match self.ch_or_null() {
                 c @ b'0' ... b'9' => {
                     exp *= 10;
-                    exp += (c as uint) - (b'0' as uint);
+                    exp += (c as usize) - (b'0' as usize);
 
                     self.bump();
                 }
@@ -314,9 +314,9 @@ impl<Iter: Iterator<Item=u8>> Parser<Iter> {
 
     #[inline]
     fn decode_hex_escape(&mut self) -> Result<u16, Error> {
-        let mut i = 0u;
+        let mut i = 0us;
         let mut n = 0u16;
-        while i < 4u && !self.eof() {
+        while i < 4us && !self.eof() {
             self.bump();
             n = match self.ch_or_null() {
                 c @ b'0' ... b'9' => n * 16_u16 + ((c as u16) - (b'0' as u16)),
@@ -329,11 +329,11 @@ impl<Iter: Iterator<Item=u8>> Parser<Iter> {
                 _ => { return Err(self.error(ErrorCode::InvalidEscape)); }
             };
 
-            i += 1u;
+            i += 1us;
         }
 
         // Error out if we didn't parse 4 digits.
-        if i != 4u {
+        if i != 4us {
             return Err(self.error(ErrorCode::InvalidEscape));
         }
 
@@ -562,7 +562,7 @@ impl<Iter: Iterator<Item=u8>> de::Deserializer<Error> for Parser<Iter> {
     fn expect_enum_start(&mut self,
                          token: de::Token,
                          _name: &str,
-                         variants: &[&str]) -> Result<uint, Error> {
+                         variants: &[&str]) -> Result<usize, Error> {
         match token {
             de::Token::MapStart(_) => { }
             _ => { return Err(self.error(ErrorCode::ExpectedEnumMapStart)); }
@@ -615,7 +615,7 @@ impl<Iter: Iterator<Item=u8>> de::Deserializer<Error> for Parser<Iter> {
     #[inline]
     fn expect_struct_field_or_end(&mut self,
                                   fields: &'static [&'static str]
-                                 ) -> Result<Option<Option<uint>>, Error> {
+                                 ) -> Result<Option<Option<usize>>, Error> {
         let result = match self.state_stack.pop() {
             Some(State::ObjectStart) => {
                 try!(self.parse_object_start())

src/json/error.rs

@@ -81,7 +81,7 @@ impl fmt::Show for ErrorCode {
 #[derive(Clone, PartialEq, Show)]
 pub enum Error {
     /// msg, line, col
-    SyntaxError(ErrorCode, uint, uint),
+    SyntaxError(ErrorCode, usize, usize),
     IoError(io::IoError),
     ExpectedError(String, String),
     MissingFieldError(String),

src/json/mod.rs

@@ -362,7 +362,7 @@ mod tests {
     #[derive_deserialize]
     enum Animal {
         Dog,
-        Frog(String, Vec<int>)
+        Frog(String, Vec<isize>)
     }
 
     impl ToJson for Animal {
@@ -391,7 +391,7 @@ mod tests {
     #[derive_deserialize]
     struct Inner {
         a: (),
-        b: uint,
+        b: usize,
         c: Vec<string::String>,
     }
 
@@ -464,9 +464,9 @@ mod tests {
     #[test]
     fn test_write_i64() {
         let tests = &[
-            (3i, "3"),
-            (-2i, "-2"),
-            (-1234i, "-1234"),
+            (3is, "3"),
+            (-2is, "-2"),
+            (-1234is, "-1234"),
         ];
         test_encode_ok(tests);
         test_pretty_encode_ok(tests);
@@ -643,14 +643,14 @@ mod tests {
     fn test_write_tuple() {
         test_encode_ok(&[
             (
-                (5i,),
+                (5is,),
                 "[5]",
             ),
         ]);
 
         test_pretty_encode_ok(&[
             (
-                (5i,),
+                (5is,),
                 concat!(
                     "[\n",
                     "  5\n",
@@ -661,14 +661,14 @@ mod tests {
 
         test_encode_ok(&[
             (
-                (5i, (6i, "abc")),
+                (5is, (6is, "abc")),
                 "[5,[6,\"abc\"]]",
             ),
         ]);
 
         test_pretty_encode_ok(&[
             (
-                (5i, (6i, "abc")),
+                (5is, (6is, "abc")),
                 concat!(
                     "[\n",
                     "  5,\n",
@@ -964,19 +964,19 @@ mod tests {
         ]);
 
         test_parse_ok(&[
-            ("[3,1]", vec!(3i, 1)),
-            ("[ 3 , 1 ]", vec!(3i, 1)),
+            ("[3,1]", vec!(3is, 1)),
+            ("[ 3 , 1 ]", vec!(3is, 1)),
         ]);
 
         test_parse_ok(&[
-            ("[[3], [1, 2]]", vec!(vec!(3i), vec!(1, 2))),
+            ("[[3], [1, 2]]", vec!(vec!(3is), vec!(1, 2))),
         ]);
 
         let v: () = from_str("[]").unwrap();
         assert_eq!(v, ());
 
         test_parse_ok(&[
-            ("[1, 2, 3]", (1u, 2u, 3u)),
+            ("[1, 2, 3]", (1us, 2us, 3us)),
         ]);
     }
 
@@ -992,17 +992,17 @@ mod tests {
         ]);
 
         test_json_deserialize_ok(&[
-            vec!(3i, 1),
+            vec!(3is, 1),
         ]);
 
         test_json_deserialize_ok(&[
-            vec!(vec!(3i), vec!(1, 2)),
+            vec!(vec!(3is), vec!(1, 2)),
         ]);
     }
 
     #[test]
     fn test_parse_object() {
-        test_parse_err::<BTreeMap<string::String, int>>(&[
+        test_parse_err::<BTreeMap<string::String, isize>>(&[
             ("{", SyntaxError(EOFWhileParsingString, 1, 2)),
             ("{ ", SyntaxError(EOFWhileParsingString, 1, 3)),
             ("{1", SyntaxError(KeyMustBeAString, 1, 2)),
@@ -1022,26 +1022,26 @@ mod tests {
             ("{ }", treemap!()),
             (
                 "{\"a\":3}",
-                treemap!("a".to_string() => 3i)
+                treemap!("a".to_string() => 3is)
             ),
             (
                 "{ \"a\" : 3 }",
-                treemap!("a".to_string() => 3i)
+                treemap!("a".to_string() => 3is)
             ),
             (
                 "{\"a\":3,\"b\":4}",
-                treemap!("a".to_string() => 3i, "b".to_string() => 4)
+                treemap!("a".to_string() => 3is, "b".to_string() => 4)
             ),
             (
                 "{ \"a\" : 3 , \"b\" : 4 }",
-                treemap!("a".to_string() => 3i, "b".to_string() => 4),
+                treemap!("a".to_string() => 3is, "b".to_string() => 4),
             ),
         ]);
 
         test_parse_ok(&[
             (
                 "{\"a\": {\"b\": 3, \"c\": 4}}",
-                treemap!("a".to_string() => treemap!("b".to_string() => 3i, "c".to_string() => 4i)),
+                treemap!("a".to_string() => treemap!("b".to_string() => 3is, "c".to_string() => 4is)),
             ),
         ]);
     }
@@ -1050,12 +1050,12 @@ mod tests {
     fn test_json_deserialize_object() {
         test_json_deserialize_ok(&[
             treemap!(),
-            treemap!("a".to_string() => 3i),
-            treemap!("a".to_string() => 3i, "b".to_string() => 4),
+            treemap!("a".to_string() => 3is),
+            treemap!("a".to_string() => 3is, "b".to_string() => 4),
         ]);
 
         test_json_deserialize_ok(&[
-            treemap!("a".to_string() => treemap!("b".to_string() => 3i, "c".to_string() => 4)),
+            treemap!("a".to_string() => treemap!("b".to_string() => 3is, "c".to_string() => 4)),
         ]);
     }
 
@@ -1107,7 +1107,7 @@ mod tests {
         #[derive_serialize]
         #[derive_deserialize]
         struct Foo {
-            x: Option<int>,
+            x: Option<isize>,
         }
 
         let value: Foo = from_str("{}").unwrap();
@@ -1172,7 +1172,7 @@ mod tests {
     #[test]
     fn test_multiline_errors() {
         test_parse_err::<BTreeMap<string::String, string::String>>(&[
-            ("{\n  \"foo\":\n \"bar\"", SyntaxError(EOFWhileParsingObject, 3u, 8u)),
+            ("{\n  \"foo\":\n \"bar\"", SyntaxError(EOFWhileParsingObject, 3us, 8us)),
         ]);
     }
 
@@ -1371,7 +1371,7 @@ mod tests {
     fn test_encode_hashmap_with_numeric_key() {
         use std::str::from_utf8;
         use std::collections::HashMap;
-        let mut hm: HashMap<uint, bool> = HashMap::new();
+        let mut hm: HashMap<usize, bool> = HashMap::new();
         hm.insert(1, true);
         let mut mem_buf = MemWriter::new();
         {
@@ -1386,7 +1386,7 @@ mod tests {
     fn test_prettyencode_hashmap_with_numeric_key() {
         use std::str::from_utf8;
         use std::collections::HashMap;
-        let mut hm: HashMap<uint, bool> = HashMap::new();
+        let mut hm: HashMap<usize, bool> = HashMap::new();
         hm.insert(1, true);
         let mut mem_buf = MemWriter::new();
         {
@@ -1402,7 +1402,7 @@ mod tests {
     fn test_hashmap_with_numeric_key_can_handle_double_quote_delimited_key() {
         use std::collections::HashMap;
         let json_str = "{\"1\":true}";
-        let map: HashMap<uint, bool> = from_str(json_str).unwrap();
+        let map: HashMap<usize, bool> = from_str(json_str).unwrap();
         let mut m = HashMap::new();
         m.insert(1u, true);
         assert_eq!(map, m);
@@ -1715,7 +1715,7 @@ mod bench {
         })
     }
 
-    fn json_str(count: uint) -> string::String {
+    fn json_str(count: usize) -> 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]},"#);
@@ -1724,7 +1724,7 @@ mod bench {
         src
     }
 
-    fn pretty_json_str(count: uint) -> string::String {
+    fn pretty_json_str(count: usize) -> string::String {
         let mut src = "[\n".to_string();
         for _ in range(0, count) {
             src.push_str(
@@ -1747,7 +1747,7 @@ mod bench {
         src
     }
 
-    fn encoder_json(count: uint) -> serialize::json::Json {
+    fn encoder_json(count: usize) -> serialize::json::Json {
         use serialize::json::Json;
 
         let mut list = vec!();
@@ -1768,7 +1768,7 @@ mod bench {
         Json::Array(list)
     }
 
-    fn serializer_json(count: uint) -> Value {
+    fn serializer_json(count: usize) -> Value {
         let mut list = vec!();
         for _ in range(0, count) {
             list.push(Value::Object(treemap!(
@@ -1787,7 +1787,7 @@ mod bench {
         Value::Array(list)
     }
 
-    fn bench_encoder(b: &mut Bencher, count: uint) {
+    fn bench_encoder(b: &mut Bencher, count: usize) {
         let src = json_str(count);
         let json = encoder_json(count);
 
@@ -1796,7 +1796,7 @@ mod bench {
         });
     }
 
-    fn bench_encoder_pretty(b: &mut Bencher, count: uint) {
+    fn bench_encoder_pretty(b: &mut Bencher, count: usize) {
         let src = pretty_json_str(count);
         let json = encoder_json(count);
 
@@ -1805,7 +1805,7 @@ mod bench {
         });
     }
 
-    fn bench_serializer(b: &mut Bencher, count: uint) {
+    fn bench_serializer(b: &mut Bencher, count: usize) {
         let src = json_str(count);
         let json = serializer_json(count);
 
@@ -1814,7 +1814,7 @@ mod bench {
         });
     }
 
-    fn bench_serializer_pretty(b: &mut Bencher, count: uint) {
+    fn bench_serializer_pretty(b: &mut Bencher, count: usize) {
         let src = pretty_json_str(count);
         let json = serializer_json(count);
 
@@ -1823,7 +1823,7 @@ mod bench {
         });
     }
 
-    fn bench_decoder(b: &mut Bencher, count: uint) {
+    fn bench_decoder(b: &mut Bencher, count: usize) {
         let src = json_str(count);
         let json = encoder_json(count);
         b.iter(|| {
@@ -1831,7 +1831,7 @@ mod bench {
         });
     }
 
-    fn bench_deserializer(b: &mut Bencher, count: uint) {
+    fn bench_deserializer(b: &mut Bencher, count: usize) {
         let src = json_str(count);
         let json = encoder_json(count);
         b.iter(|| {
@@ -1839,7 +1839,7 @@ mod bench {
         });
     }
 
-    fn bench_decoder_streaming(b: &mut Bencher, count: uint) {
+    fn bench_decoder_streaming(b: &mut Bencher, count: usize) {
         let src = json_str(count);
 
         b.iter( || {
@@ -1878,7 +1878,7 @@ mod bench {
         });
     }
 
-    fn bench_deserializer_streaming(b: &mut Bencher, count: uint) {
+    fn bench_deserializer_streaming(b: &mut Bencher, count: usize) {
         let src = json_str(count);
 
         b.iter( || {

src/json/ser.rs

@@ -64,8 +64,8 @@ fn fmt_f64_or_null<W: Writer>(wr: &mut W, v: f64) -> IoResult<()> {
     }
 }
 
-fn spaces<W: Writer>(wr: &mut W, mut n: uint) -> IoResult<()> {
-    const LEN: uint = 16;
+fn spaces<W: Writer>(wr: &mut W, mut n: usize) -> IoResult<()> {
+    const LEN: usize = 16;
     const BUF: &'static [u8; LEN] = &[b' '; LEN];
 
     while n >= LEN {
@@ -128,7 +128,7 @@ impl<W: Writer> ser::Serializer<IoError> for Serializer<W> {
     }
 
     #[inline]
-    fn serialize_int(&mut self, v: int) -> IoResult<()> {
+    fn serialize_isize(&mut self, v: isize) -> IoResult<()> {
         write!(&mut self.wr, "{}", v)
     }
 
@@ -153,7 +153,7 @@ impl<W: Writer> ser::Serializer<IoError> for Serializer<W> {
     }
 
     #[inline]
-    fn serialize_uint(&mut self, v: uint) -> IoResult<()> {
+    fn serialize_usize(&mut self, v: usize) -> IoResult<()> {
         write!(&mut self.wr, "{}", v)
     }
 
@@ -198,7 +198,7 @@ impl<W: Writer> ser::Serializer<IoError> for Serializer<W> {
     }
 
     #[inline]
-    fn serialize_tuple_start(&mut self, _len: uint) -> IoResult<()> {
+    fn serialize_tuple_start(&mut self, _len: usize) -> IoResult<()> {
         self.first = true;
         self.wr.write_str("[")
     }
@@ -221,7 +221,7 @@ impl<W: Writer> ser::Serializer<IoError> for Serializer<W> {
     }
 
     #[inline]
-    fn serialize_struct_start(&mut self, _name: &str, _len: uint) -> IoResult<()> {
+    fn serialize_struct_start(&mut self, _name: &str, _len: usize) -> IoResult<()> {
         self.first = true;
         self.wr.write_str("{")
     }
@@ -246,7 +246,7 @@ impl<W: Writer> ser::Serializer<IoError> for Serializer<W> {
     }
 
     #[inline]
-    fn serialize_enum_start(&mut self, _name: &str, variant: &str, _len: uint) -> IoResult<()> {
+    fn serialize_enum_start(&mut self, _name: &str, variant: &str, _len: usize) -> IoResult<()> {
         self.first = true;
         try!(self.wr.write_str("{"));
         try!(self.serialize_str(variant));
@@ -329,7 +329,7 @@ impl<W: Writer> ser::Serializer<IoError> for Serializer<W> {
 /// compact data
 pub struct PrettySerializer<W> {
     wr: W,
-    indent: uint,
+    indent: usize,
     first: bool,
 }
 
@@ -391,7 +391,7 @@ impl<W: Writer> ser::Serializer<IoError> for PrettySerializer<W> {
     }
 
     #[inline]
-    fn serialize_int(&mut self, v: int) -> IoResult<()> {
+    fn serialize_isize(&mut self, v: isize) -> IoResult<()> {
         write!(&mut self.wr, "{}", v)
     }
 
@@ -416,7 +416,7 @@ impl<W: Writer> ser::Serializer<IoError> for PrettySerializer<W> {
     }
 
     #[inline]
-    fn serialize_uint(&mut self, v: uint) -> IoResult<()> {
+    fn serialize_usize(&mut self, v: usize) -> IoResult<()> {
         write!(&mut self.wr, "{}", v)
     }
 
@@ -461,7 +461,7 @@ impl<W: Writer> ser::Serializer<IoError> for PrettySerializer<W> {
     }
 
     #[inline]
-    fn serialize_tuple_start(&mut self, _len: uint) -> IoResult<()> {
+    fn serialize_tuple_start(&mut self, _len: usize) -> IoResult<()> {
         self.first = true;
         self.wr.write_str("[")
     }
@@ -480,7 +480,7 @@ impl<W: Writer> ser::Serializer<IoError> for PrettySerializer<W> {
     }
 
     #[inline]
-    fn serialize_struct_start(&mut self, _name: &str, _len: uint) -> IoResult<()> {
+    fn serialize_struct_start(&mut self, _name: &str, _len: usize) -> IoResult<()> {
         self.first = true;
         self.wr.write_str("{")
     }
@@ -501,7 +501,7 @@ impl<W: Writer> ser::Serializer<IoError> for PrettySerializer<W> {
     }
 
     #[inline]
-    fn serialize_enum_start(&mut self, _name: &str, variant: &str, _len: uint) -> IoResult<()> {
+    fn serialize_enum_start(&mut self, _name: &str, variant: &str, _len: usize) -> IoResult<()> {
         self.first = true;
         try!(self.wr.write_str("{"));
         try!(self.serialize_sep());

src/json/value.rs

@@ -269,12 +269,12 @@ impl<D: de::Deserializer<E>, E> de::Deserialize<D, E> for Value {
         match token {
             Token::Null => Ok(Value::Null),
             Token::Bool(x) => Ok(Value::Boolean(x)),
-            Token::Int(x) => Ok(Value::Integer(x as i64)),
+            Token::Isize(x) => Ok(Value::Integer(x as i64)),
             Token::I8(x) => Ok(Value::Integer(x as i64)),
             Token::I16(x) => Ok(Value::Integer(x as i64)),
             Token::I32(x) => Ok(Value::Integer(x as i64)),
             Token::I64(x) => Ok(Value::Integer(x)),
-            Token::Uint(x) => Ok(Value::Integer(x as i64)),
+            Token::Usize(x) => Ok(Value::Integer(x as i64)),
             Token::U8(x) => Ok(Value::Integer(x as i64)),
             Token::U16(x) => Ok(Value::Integer(x as i64)),
             Token::U32(x) => Ok(Value::Integer(x as i64)),
@@ -439,7 +439,7 @@ impl de::Deserializer<Error> for Deserializer {
     fn expect_enum_start(&mut self,
                          token: Token,
                          _name: &str,
-                         variants: &[&str]) -> Result<uint, Error> {
+                         variants: &[&str]) -> Result<usize, Error> {
         let variant = match token {
             Token::MapStart(_) => {
                 let state = match self.stack.pop() {
@@ -536,7 +536,7 @@ impl ToJson for Value {
     fn to_json(&self) -> Value { (*self).clone() }
 }
 
-impl ToJson for int {
+impl ToJson for isize {
     fn to_json(&self) -> Value { Value::Integer(*self as i64) }
 }
 
@@ -556,7 +556,7 @@ impl ToJson for i64 {
     fn to_json(&self) -> Value { Value::Integer(*self as i64) }
 }
 
-impl ToJson for uint {
+impl ToJson for usize {
     fn to_json(&self) -> Value { Value::Integer(*self as i64) }
 }
 

src/ser.rs

@@ -22,7 +22,7 @@ pub trait Serializer<E> {
     fn serialize_bool(&mut self, v: bool) -> Result<(), E>;
 
     #[inline]
-    fn serialize_int(&mut self, v: int) -> Result<(), E> {
+    fn serialize_isize(&mut self, v: isize) -> Result<(), E> {
         self.serialize_i64(v as i64)
     }
 
@@ -45,7 +45,7 @@ pub trait Serializer<E> {
     fn serialize_i64(&mut self, v: i64) -> Result<(), E>;
 
     #[inline]
-    fn serialize_uint(&mut self, v: uint) -> Result<(), E> {
+    fn serialize_usize(&mut self, v: usize) -> Result<(), E> {
         self.serialize_u64(v as u64)
     }
 
@@ -78,19 +78,19 @@ pub trait Serializer<E> {
 
     fn serialize_str(&mut self, v: &str) -> Result<(), E>;
 
-    fn serialize_tuple_start(&mut self, len: uint) -> Result<(), E>;
+    fn serialize_tuple_start(&mut self, len: usize) -> Result<(), E>;
     fn serialize_tuple_elt<
         T: Serialize<Self, E>
     >(&mut self, v: &T) -> Result<(), E>;
     fn serialize_tuple_end(&mut self) -> Result<(), E>;
 
-    fn serialize_struct_start(&mut self, name: &str, len: uint) -> Result<(), E>;
+    fn serialize_struct_start(&mut self, name: &str, len: usize) -> Result<(), E>;
     fn serialize_struct_elt<
         T: Serialize<Self, E>
     >(&mut self, name: &str, v: &T) -> Result<(), E>;
     fn serialize_struct_end(&mut self) -> Result<(), E>;
 
-    fn serialize_enum_start(&mut self, name: &str, variant: &str, len: uint) -> Result<(), E>;
+    fn serialize_enum_start(&mut self, name: &str, variant: &str, len: usize) -> Result<(), E>;
     fn serialize_enum_elt<
         T: Serialize<Self, E>
     >(&mut self, v: &T) -> Result<(), E>;
@@ -132,12 +132,12 @@ macro_rules! impl_serialize {
 }
 
 impl_serialize!(bool, serialize_bool);
-impl_serialize!(int, serialize_int);
+impl_serialize!(isize, serialize_isize);
 impl_serialize!(i8, serialize_i8);
 impl_serialize!(i16, serialize_i16);
 impl_serialize!(i32, serialize_i32);
 impl_serialize!(i64, serialize_i64);
-impl_serialize!(uint, serialize_uint);
+impl_serialize!(usize, serialize_usize);
 impl_serialize!(u8, serialize_u8);
 impl_serialize!(u16, serialize_u16);
 impl_serialize!(u32, serialize_u32);
@@ -332,7 +332,7 @@ mod tests {
     #[derive_serialize]
     struct Inner {
         a: (),
-        b: uint,
+        b: usize,
         c: HashMap<string::String, option::Option<char>>,
     }
 
@@ -350,7 +350,7 @@ mod tests {
     #[derive_serialize]
     enum Animal {
         Dog,
-        Frog(String, int)
+        Frog(String, isize)
     }
 
     //////////////////////////////////////////////////////////////////////////////
@@ -359,12 +359,12 @@ mod tests {
     pub enum Token<'a> {
         Null,
         Bool(bool),
-        Int(int),
+        Isize(isize),
         I8(i8),
         I16(i16),
         I32(i32),
         I64(i64),
-        Uint(uint),
+        Usize(usize),
         U8(u8),
         U16(u16),
         U32(u32),
@@ -374,24 +374,24 @@ mod tests {
         Char(char),
         Str(&'a str),
 
-        TupleStart(uint),
+        TupleStart(usize),
         TupleSep,
         TupleEnd,
 
-        StructStart(&'a str, uint),
+        StructStart(&'a str, usize),
         StructSep(&'a str),
         StructEnd,
 
-        EnumStart(&'a str, &'a str, uint),
+        EnumStart(&'a str, &'a str, usize),
         EnumSep,
         EnumEnd,
 
         Option(bool),
 
-        SeqStart(uint),
+        SeqStart(usize),
         SeqEnd,
 
-        MapStart(uint),
+        MapStart(usize),
         MapEnd,
     }
 
@@ -434,8 +434,8 @@ mod tests {
         fn serialize_bool(&mut self, v: bool) -> Result<(), Error> {
             self.serialize(Token::Bool(v))
         }
-        fn serialize_int(&mut self, v: int) -> Result<(), Error> {
-            self.serialize(Token::Int(v))
+        fn serialize_isize(&mut self, v: isize) -> Result<(), Error> {
+            self.serialize(Token::Isize(v))
         }
 
         fn serialize_i8(&mut self, v: i8) -> Result<(), Error> {
@@ -454,8 +454,8 @@ mod tests {
             self.serialize(Token::I64(v))
         }
 
-        fn serialize_uint(&mut self, v: uint) -> Result<(), Error> {
-            self.serialize(Token::Uint(v))
+        fn serialize_usize(&mut self, v: usize) -> Result<(), Error> {
+            self.serialize(Token::Usize(v))
         }
 
         fn serialize_u8(&mut self, v: u8) -> Result<(), Error> {
@@ -490,7 +490,7 @@ mod tests {
             self.serialize(Token::Str(v))
         }
 
-        fn serialize_tuple_start(&mut self, len: uint) -> Result<(), Error> {
+        fn serialize_tuple_start(&mut self, len: usize) -> Result<(), Error> {
             self.serialize(Token::TupleStart(len))
         }
 
@@ -505,7 +505,7 @@ mod tests {
             self.serialize(Token::TupleEnd)
         }
 
-        fn serialize_struct_start(&mut self, name: &str, len: uint) -> Result<(), Error> {
+        fn serialize_struct_start(&mut self, name: &str, len: usize) -> Result<(), Error> {
             self.serialize(Token::StructStart(name, len))
         }
 
@@ -520,7 +520,7 @@ mod tests {
             self.serialize(Token::StructEnd)
         }
 
-        fn serialize_enum_start(&mut self, name: &str, variant: &str, len: uint) -> Result<(), Error> {
+        fn serialize_enum_start(&mut self, name: &str, variant: &str, len: usize) -> Result<(), Error> {
             self.serialize(Token::EnumStart(name, variant, len))
         }
 
@@ -581,10 +581,10 @@ mod tests {
     #[test]
     fn test_tokens_int() {
         let tokens = vec!(
-            Token::Int(5)
+            Token::Isize(5)
         );
         let mut serializer = AssertSerializer::new(tokens.into_iter());
-        5i.serialize(&mut serializer).unwrap();
+        5is.serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
 
@@ -617,7 +617,7 @@ mod tests {
         );
 
         let mut serializer = AssertSerializer::new(tokens.into_iter());
-        None::<int>.serialize(&mut serializer).unwrap();
+        None::<isize>.serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
 
@@ -625,11 +625,11 @@ mod tests {
     fn test_tokens_option_some() {
         let tokens = vec!(
             Token::Option(true),
-            Token::Int(5),
+            Token::Isize(5),
         );
 
         let mut serializer = AssertSerializer::new(tokens.into_iter());
-        Some(5i).serialize(&mut serializer).unwrap();
+        Some(5is).serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
 
@@ -638,7 +638,7 @@ mod tests {
         let tokens = vec!(
             Token::TupleStart(2),
                 Token::TupleSep,
-                Token::Int(5),
+                Token::Isize(5),
 
                 Token::TupleSep,
                 Token::Str("a"),
@@ -646,7 +646,7 @@ mod tests {
         );
 
         let mut serializer = AssertSerializer::new(tokens.into_iter());
-        (5i, "a").serialize(&mut serializer).unwrap();
+        (5is, "a").serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
 
@@ -663,7 +663,7 @@ mod tests {
                 Token::TupleSep,
                 Token::TupleStart(2),
                     Token::TupleSep,
-                    Token::Int(5),
+                    Token::Isize(5),
 
                     Token::TupleSep,
                     Token::Str("a"),
@@ -672,7 +672,7 @@ mod tests {
         );
 
         let mut serializer = AssertSerializer::new(tokens.into_iter());
-        ((), (), (5i, "a")).serialize(&mut serializer).unwrap();
+        ((), (), (5is, "a")).serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
 
@@ -702,7 +702,7 @@ mod tests {
                         Token::Null,
 
                         Token::StructSep("b"),
-                        Token::Uint(5),
+                        Token::Usize(5),
 
                         Token::StructSep("c"),
                         Token::MapStart(1),
@@ -749,7 +749,7 @@ mod tests {
                 Token::Str("Henry"),
 
                 Token::EnumSep,
-                Token::Int(349),
+                Token::Isize(349),
             Token::EnumEnd,
         );
 
@@ -766,7 +766,7 @@ mod tests {
         );
 
         let mut serializer = AssertSerializer::new(tokens.into_iter());
-        let v: Vec<int> = vec!();
+        let v: Vec<isize> = vec!();
         v.serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
@@ -775,14 +775,14 @@ mod tests {
     fn test_tokens_vec() {
         let tokens = vec!(
             Token::SeqStart(3),
-                Token::Int(5),
-                Token::Int(6),
-                Token::Int(7),
+                Token::Isize(5),
+                Token::Isize(6),
+                Token::Isize(7),
             Token::SeqEnd,
         );
 
         let mut serializer = AssertSerializer::new(tokens.into_iter());
-        (vec!(5i, 6, 7)).serialize(&mut serializer).unwrap();
+        (vec!(5is, 6, 7)).serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
 
@@ -791,24 +791,24 @@ mod tests {
         let tokens = vec!(
             Token::SeqStart(3),
                 Token::SeqStart(1),
-                    Token::Int(1),
+                    Token::Isize(1),
                 Token::SeqEnd,
 
                 Token::SeqStart(2),
-                    Token::Int(2),
-                    Token::Int(3),
+                    Token::Isize(2),
+                    Token::Isize(3),
                 Token::SeqEnd,
 
                 Token::SeqStart(3),
-                    Token::Int(4),
-                    Token::Int(5),
-                    Token::Int(6),
+                    Token::Isize(4),
+                    Token::Isize(5),
+                    Token::Isize(6),
                 Token::SeqEnd,
             Token::SeqEnd,
         );
 
         let mut serializer = AssertSerializer::new(tokens.into_iter());
-        (vec!(vec!(1i), vec!(2, 3), vec!(4, 5, 6))).serialize(&mut serializer).unwrap();
+        (vec!(vec!(1is), vec!(2, 3), vec!(4, 5, 6))).serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);
     }
 
@@ -816,10 +816,10 @@ mod tests {
     fn test_tokens_treemap() {
         let tokens = vec!(
             Token::MapStart(2),
-                Token::Int(5),
+                Token::Isize(5),
                 Token::Str("a"),
 
-                Token::Int(6),
+                Token::Isize(6),
                 Token::Str("b"),
             Token::MapEnd,
         );
@@ -827,8 +827,8 @@ mod tests {
         let mut serializer = AssertSerializer::new(tokens.into_iter());
 
         let mut map = BTreeMap::new();
-        map.insert(5i, "a".to_string());
-        map.insert(6i, "b".to_string());
+        map.insert(5is, "a".to_string());
+        map.insert(6is, "b".to_string());
 
         map.serialize(&mut serializer).unwrap();
         assert_eq!(serializer.iter.next(), None);

tests/json_struct.rs

@@ -12,7 +12,7 @@ struct Test {
     schema: String,
     title: String,
     #[serial_name = "type"]
-    ty: int
+    ty: isize
 }
 
 #[test]