Rollup merge of #35977 - frewsxcv:usize-isize, r=eddyb

Manishearth · web-flow · commit 90df078344ae · 2016-08-27T21:29:06.000+05:30
Rename {int,uint} methods to {isize,usize}.

None
diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs
@@ -726,7 +726,7 @@ pub mod reader {
         fn read_u8(&mut self) -> DecodeResult<u8> {
             Ok(doc_as_u8(self.next_doc(EsU8)?))
         }
-        fn read_uint(&mut self) -> DecodeResult<usize> {
+        fn read_usize(&mut self) -> DecodeResult<usize> {
             let v = self._next_int(EsU8, EsU64)?;
             if v > (::std::usize::MAX as u64) {
                 Err(IntTooBig(v as usize))
@@ -747,7 +747,7 @@ pub mod reader {
         fn read_i8(&mut self) -> DecodeResult<i8> {
             Ok(doc_as_u8(self.next_doc(EsI8)?) as i8)
         }
-        fn read_int(&mut self) -> DecodeResult<isize> {
+        fn read_isize(&mut self) -> DecodeResult<isize> {
             let v = self._next_int(EsI8, EsI64)? as i64;
             if v > (isize::MAX as i64) || v < (isize::MIN as i64) {
                 debug!("FIXME \\#6122: Removing this makes this function miscompile");
@@ -1219,7 +1219,7 @@ pub mod writer {
             Ok(())
         }
 
-        fn emit_uint(&mut self, v: usize) -> EncodeResult {
+        fn emit_usize(&mut self, v: usize) -> EncodeResult {
             self.emit_u64(v as u64)
         }
         fn emit_u64(&mut self, v: u64) -> EncodeResult {
@@ -1247,7 +1247,7 @@ pub mod writer {
             self.wr_tagged_raw_u8(EsU8 as usize, v)
         }
 
-        fn emit_int(&mut self, v: isize) -> EncodeResult {
+        fn emit_isize(&mut self, v: isize) -> EncodeResult {
             self.emit_i64(v as i64)
         }
         fn emit_i64(&mut self, v: i64) -> EncodeResult {
diff --git a/src/librbml/opaque.rs b/src/librbml/opaque.rs
@@ -54,7 +54,7 @@ impl<'a> serialize::Encoder for Encoder<'a> {
         Ok(())
     }
 
-    fn emit_uint(&mut self, v: usize) -> EncodeResult {
+    fn emit_usize(&mut self, v: usize) -> EncodeResult {
         write_uleb128!(self, v)
     }
 
@@ -75,7 +75,7 @@ impl<'a> serialize::Encoder for Encoder<'a> {
         Ok(())
     }
 
-    fn emit_int(&mut self, v: isize) -> EncodeResult {
+    fn emit_isize(&mut self, v: isize) -> EncodeResult {
         write_sleb128!(self, v)
     }
 
@@ -120,7 +120,7 @@ impl<'a> serialize::Encoder for Encoder<'a> {
     }
 
     fn emit_str(&mut self, v: &str) -> EncodeResult {
-        self.emit_uint(v.len())?;
+        self.emit_usize(v.len())?;
         let _ = self.cursor.write_all(v.as_bytes());
         Ok(())
     }
@@ -139,7 +139,7 @@ impl<'a> serialize::Encoder for Encoder<'a> {
                             -> EncodeResult
         where F: FnOnce(&mut Self) -> EncodeResult
     {
-        self.emit_uint(v_id)?;
+        self.emit_usize(v_id)?;
         f(self)
     }
 
@@ -221,7 +221,7 @@ impl<'a> serialize::Encoder for Encoder<'a> {
     fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodeResult
         where F: FnOnce(&mut Encoder<'a>) -> EncodeResult
     {
-        self.emit_uint(len)?;
+        self.emit_usize(len)?;
         f(self)
     }
 
@@ -234,7 +234,7 @@ impl<'a> serialize::Encoder for Encoder<'a> {
     fn emit_map<F>(&mut self, len: usize, f: F) -> EncodeResult
         where F: FnOnce(&mut Encoder<'a>) -> EncodeResult
     {
-        self.emit_uint(len)?;
+        self.emit_usize(len)?;
         f(self)
     }
 
@@ -329,7 +329,7 @@ impl<'a> serialize::Decoder for Decoder<'a> {
         Ok(value)
     }
 
-    fn read_uint(&mut self) -> Result<usize, Self::Error> {
+    fn read_usize(&mut self) -> Result<usize, Self::Error> {
         read_uleb128!(self, usize)
     }
 
@@ -351,7 +351,7 @@ impl<'a> serialize::Decoder for Decoder<'a> {
         unsafe { Ok(::std::mem::transmute(as_u8)) }
     }
 
-    fn read_int(&mut self) -> Result<isize, Self::Error> {
+    fn read_isize(&mut self) -> Result<isize, Self::Error> {
         read_sleb128!(self, isize)
     }
 
@@ -376,7 +376,7 @@ impl<'a> serialize::Decoder for Decoder<'a> {
     }
 
     fn read_str(&mut self) -> Result<String, Self::Error> {
-        let len = self.read_uint()?;
+        let len = self.read_usize()?;
         let s = ::std::str::from_utf8(&self.data[self.position..self.position + len]).unwrap();
         self.position += len;
         Ok(s.to_string())
@@ -391,7 +391,7 @@ impl<'a> serialize::Decoder for Decoder<'a> {
     fn read_enum_variant<T, F>(&mut self, _: &[&str], mut f: F) -> Result<T, Self::Error>
         where F: FnMut(&mut Decoder<'a>, usize) -> Result<T, Self::Error>
     {
-        let disr = self.read_uint()?;
+        let disr = self.read_usize()?;
         f(self, disr)
     }
 
@@ -404,7 +404,7 @@ impl<'a> serialize::Decoder for Decoder<'a> {
     fn read_enum_struct_variant<T, F>(&mut self, _: &[&str], mut f: F) -> Result<T, Self::Error>
         where F: FnMut(&mut Decoder<'a>, usize) -> Result<T, Self::Error>
     {
-        let disr = self.read_uint()?;
+        let disr = self.read_usize()?;
         f(self, disr)
     }
 
@@ -483,7 +483,7 @@ impl<'a> serialize::Decoder for Decoder<'a> {
     fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error>
         where F: FnOnce(&mut Decoder<'a>, usize) -> Result<T, Self::Error>
     {
-        let len = self.read_uint()?;
+        let len = self.read_usize()?;
         f(self, len)
     }
 
@@ -496,7 +496,7 @@ impl<'a> serialize::Decoder for Decoder<'a> {
     fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error>
         where F: FnOnce(&mut Decoder<'a>, usize) -> Result<T, Self::Error>
     {
-        let len = self.read_uint()?;
+        let len = self.read_usize()?;
         f(self, len)
     }
 
diff --git a/src/libserialize/collection_impls.rs b/src/libserialize/collection_impls.rs
@@ -136,15 +136,15 @@ impl<
         for item in self {
             bits |= item.to_usize();
         }
-        s.emit_uint(bits)
+        s.emit_usize(bits)
     }
 }
 
 impl<
     T: Decodable + CLike
 > Decodable for EnumSet<T> {
     fn decode<D: Decoder>(d: &mut D) -> Result<EnumSet<T>, D::Error> {
-        let bits = d.read_uint()?;
+        let bits = d.read_usize()?;
         let mut set = EnumSet::new();
         for bit in 0..(mem::size_of::<usize>()*8) {
             if bits & (1 << bit) != 0 {
diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
@@ -495,13 +495,13 @@ impl<'a> ::Encoder for Encoder<'a> {
         Ok(())
     }
 
-    fn emit_uint(&mut self, v: usize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
+    fn emit_usize(&mut self, v: usize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
     fn emit_u64(&mut self, v: u64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
     fn emit_u32(&mut self, v: u32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
     fn emit_u16(&mut self, v: u16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
     fn emit_u8(&mut self, v: u8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 
-    fn emit_int(&mut self, v: isize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
+    fn emit_isize(&mut self, v: isize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
     fn emit_i64(&mut self, v: i64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
     fn emit_i32(&mut self, v: i32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
     fn emit_i16(&mut self, v: i16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
@@ -743,13 +743,13 @@ impl<'a> ::Encoder for PrettyEncoder<'a> {
         Ok(())
     }
 
-    fn emit_uint(&mut self, v: usize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
+    fn emit_usize(&mut self, v: usize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
     fn emit_u64(&mut self, v: u64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
     fn emit_u32(&mut self, v: u32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
     fn emit_u16(&mut self, v: u16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
     fn emit_u8(&mut self, v: u8) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
 
-    fn emit_int(&mut self, v: isize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
+    fn emit_isize(&mut self, v: isize) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
     fn emit_i64(&mut self, v: i64) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
     fn emit_i32(&mut self, v: i32) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
     fn emit_i16(&mut self, v: i16) -> EncodeResult { emit_enquoted_if_mapkey!(self, v) }
@@ -2137,12 +2137,12 @@ impl ::Decoder for Decoder {
         expect!(self.pop(), Null)
     }
 
-    read_primitive! { read_uint, usize }
+    read_primitive! { read_usize, usize }
     read_primitive! { read_u8, u8 }
     read_primitive! { read_u16, u16 }
     read_primitive! { read_u32, u32 }
     read_primitive! { read_u64, u64 }
-    read_primitive! { read_int, isize }
+    read_primitive! { read_isize, isize }
     read_primitive! { read_i8, i8 }
     read_primitive! { read_i16, i16 }
     read_primitive! { read_i32, i32 }
diff --git a/src/libserialize/serialize.rs b/src/libserialize/serialize.rs
@@ -24,12 +24,12 @@ pub trait Encoder {
 
     // Primitive types:
     fn emit_nil(&mut self) -> Result<(), Self::Error>;
-    fn emit_uint(&mut self, v: usize) -> Result<(), Self::Error>;
+    fn emit_usize(&mut self, v: usize) -> Result<(), Self::Error>;
     fn emit_u64(&mut self, v: u64) -> Result<(), Self::Error>;
     fn emit_u32(&mut self, v: u32) -> Result<(), Self::Error>;
     fn emit_u16(&mut self, v: u16) -> Result<(), Self::Error>;
     fn emit_u8(&mut self, v: u8) -> Result<(), Self::Error>;
-    fn emit_int(&mut self, v: isize) -> Result<(), Self::Error>;
+    fn emit_isize(&mut self, v: isize) -> Result<(), Self::Error>;
     fn emit_i64(&mut self, v: i64) -> Result<(), Self::Error>;
     fn emit_i32(&mut self, v: i32) -> Result<(), Self::Error>;
     fn emit_i16(&mut self, v: i16) -> Result<(), Self::Error>;
@@ -108,12 +108,12 @@ pub trait Decoder {
 
     // Primitive types:
     fn read_nil(&mut self) -> Result<(), Self::Error>;
-    fn read_uint(&mut self) -> Result<usize, Self::Error>;
+    fn read_usize(&mut self) -> Result<usize, Self::Error>;
     fn read_u64(&mut self) -> Result<u64, Self::Error>;
     fn read_u32(&mut self) -> Result<u32, Self::Error>;
     fn read_u16(&mut self) -> Result<u16, Self::Error>;
     fn read_u8(&mut self) -> Result<u8, Self::Error>;
-    fn read_int(&mut self) -> Result<isize, Self::Error>;
+    fn read_isize(&mut self) -> Result<isize, Self::Error>;
     fn read_i64(&mut self) -> Result<i64, Self::Error>;
     fn read_i32(&mut self) -> Result<i32, Self::Error>;
     fn read_i16(&mut self) -> Result<i16, Self::Error>;
@@ -200,13 +200,13 @@ pub trait Decodable: Sized {
 
 impl Encodable for usize {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_uint(*self)
+        s.emit_usize(*self)
     }
 }
 
 impl Decodable for usize {
     fn decode<D: Decoder>(d: &mut D) -> Result<usize, D::Error> {
-        d.read_uint()
+        d.read_usize()
     }
 }
 
@@ -260,13 +260,13 @@ impl Decodable for u64 {
 
 impl Encodable for isize {
     fn encode<S: Encoder>(&self, s: &mut S) -> Result<(), S::Error> {
-        s.emit_int(*self)
+        s.emit_isize(*self)
     }
 }
 
 impl Decodable for isize {
     fn decode<D: Decoder>(d: &mut D) -> Result<isize, D::Error> {
-        d.read_int()
+        d.read_isize()
     }
 }
 

Original file line number	Diff line number	Diff line change
`@@ -726,7 +726,7 @@ pub mod reader {`
`726`	`726`	`fn read_u8(&mut self) -> DecodeResult<u8> {`
`727`	`727`	`Ok(doc_as_u8(self.next_doc(EsU8)?))`
`728`	`728`	`}`
`729`		`- fn read_uint(&mut self) -> DecodeResult<usize> {`
	`729`	`+ fn read_usize(&mut self) -> DecodeResult<usize> {`
`730`	`730`	`let v = self._next_int(EsU8, EsU64)?;`
`731`	`731`	`if v > (::std::usize::MAX as u64) {`
`732`	`732`	`Err(IntTooBig(v as usize))`
`@@ -747,7 +747,7 @@ pub mod reader {`
`747`	`747`	`fn read_i8(&mut self) -> DecodeResult<i8> {`
`748`	`748`	`Ok(doc_as_u8(self.next_doc(EsI8)?) as i8)`
`749`	`749`	`}`
`750`		`- fn read_int(&mut self) -> DecodeResult<isize> {`
	`750`	`+ fn read_isize(&mut self) -> DecodeResult<isize> {`
`751`	`751`	`let v = self._next_int(EsI8, EsI64)? as i64;`
`752`	`752`	`if v > (isize::MAX as i64) \|\| v < (isize::MIN as i64) {`
`753`	`753`	`debug!("FIXME \\#6122: Removing this makes this function miscompile");`
`@@ -1219,7 +1219,7 @@ pub mod writer {`
`1219`	`1219`	`Ok(())`
`1220`	`1220`	`}`
`1221`	`1221`
`1222`		`- fn emit_uint(&mut self, v: usize) -> EncodeResult {`
	`1222`	`+ fn emit_usize(&mut self, v: usize) -> EncodeResult {`
`1223`	`1223`	`self.emit_u64(v as u64)`
`1224`	`1224`	`}`
`1225`	`1225`	`fn emit_u64(&mut self, v: u64) -> EncodeResult {`
`@@ -1247,7 +1247,7 @@ pub mod writer {`
`1247`	`1247`	`self.wr_tagged_raw_u8(EsU8 as usize, v)`
`1248`	`1248`	`}`
`1249`	`1249`
`1250`		`- fn emit_int(&mut self, v: isize) -> EncodeResult {`
	`1250`	`+ fn emit_isize(&mut self, v: isize) -> EncodeResult {`
`1251`	`1251`	`self.emit_i64(v as i64)`
`1252`	`1252`	`}`
`1253`	`1253`	`fn emit_i64(&mut self, v: i64) -> EncodeResult {`
Original file line number	Diff line number	Diff line change
`@@ -54,7 +54,7 @@ impl<'a> serialize::Encoder for Encoder<'a> {`
`54`	`54`	`Ok(())`
`55`	`55`	`}`
`56`	`56`
`57`		`- fn emit_uint(&mut self, v: usize) -> EncodeResult {`
	`57`	`+ fn emit_usize(&mut self, v: usize) -> EncodeResult {`
`58`	`58`	`write_uleb128!(self, v)`
`59`	`59`	`}`
`60`	`60`
`@@ -75,7 +75,7 @@ impl<'a> serialize::Encoder for Encoder<'a> {`
`75`	`75`	`Ok(())`
`76`	`76`	`}`
`77`	`77`
`78`		`- fn emit_int(&mut self, v: isize) -> EncodeResult {`
	`78`	`+ fn emit_isize(&mut self, v: isize) -> EncodeResult {`
`79`	`79`	`write_sleb128!(self, v)`
`80`	`80`	`}`
`81`	`81`
`@@ -120,7 +120,7 @@ impl<'a> serialize::Encoder for Encoder<'a> {`
`120`	`120`	`}`
`121`	`121`
`122`	`122`	`fn emit_str(&mut self, v: &str) -> EncodeResult {`
`123`		`- self.emit_uint(v.len())?;`
	`123`	`+ self.emit_usize(v.len())?;`
`124`	`124`	`let _ = self.cursor.write_all(v.as_bytes());`
`125`	`125`	`Ok(())`
`126`	`126`	`}`
`@@ -139,7 +139,7 @@ impl<'a> serialize::Encoder for Encoder<'a> {`
`139`	`139`	`-> EncodeResult`
`140`	`140`	`where F: FnOnce(&mut Self) -> EncodeResult`
`141`	`141`	`{`
`142`		`- self.emit_uint(v_id)?;`
	`142`	`+ self.emit_usize(v_id)?;`
`143`	`143`	`f(self)`
`144`	`144`	`}`
`145`	`145`
`@@ -221,7 +221,7 @@ impl<'a> serialize::Encoder for Encoder<'a> {`
`221`	`221`	`fn emit_seq<F>(&mut self, len: usize, f: F) -> EncodeResult`
`222`	`222`	`where F: FnOnce(&mut Encoder<'a>) -> EncodeResult`
`223`	`223`	`{`
`224`		`- self.emit_uint(len)?;`
	`224`	`+ self.emit_usize(len)?;`
`225`	`225`	`f(self)`
`226`	`226`	`}`
`227`	`227`
`@@ -234,7 +234,7 @@ impl<'a> serialize::Encoder for Encoder<'a> {`
`234`	`234`	`fn emit_map<F>(&mut self, len: usize, f: F) -> EncodeResult`
`235`	`235`	`where F: FnOnce(&mut Encoder<'a>) -> EncodeResult`
`236`	`236`	`{`
`237`		`- self.emit_uint(len)?;`
	`237`	`+ self.emit_usize(len)?;`
`238`	`238`	`f(self)`
`239`	`239`	`}`
`240`	`240`
`@@ -329,7 +329,7 @@ impl<'a> serialize::Decoder for Decoder<'a> {`
`329`	`329`	`Ok(value)`
`330`	`330`	`}`
`331`	`331`
`332`		`- fn read_uint(&mut self) -> Result<usize, Self::Error> {`
	`332`	`+ fn read_usize(&mut self) -> Result<usize, Self::Error> {`
`333`	`333`	`read_uleb128!(self, usize)`
`334`	`334`	`}`
`335`	`335`
`@@ -351,7 +351,7 @@ impl<'a> serialize::Decoder for Decoder<'a> {`
`351`	`351`	`unsafe { Ok(::std::mem::transmute(as_u8)) }`
`352`	`352`	`}`
`353`	`353`
`354`		`- fn read_int(&mut self) -> Result<isize, Self::Error> {`
	`354`	`+ fn read_isize(&mut self) -> Result<isize, Self::Error> {`
`355`	`355`	`read_sleb128!(self, isize)`
`356`	`356`	`}`
`357`	`357`
`@@ -376,7 +376,7 @@ impl<'a> serialize::Decoder for Decoder<'a> {`
`376`	`376`	`}`
`377`	`377`
`378`	`378`	`fn read_str(&mut self) -> Result<String, Self::Error> {`
`379`		`- let len = self.read_uint()?;`
	`379`	`+ let len = self.read_usize()?;`
`380`	`380`	`let s = ::std::str::from_utf8(&self.data[self.position..self.position + len]).unwrap();`
`381`	`381`	`self.position += len;`
`382`	`382`	`Ok(s.to_string())`
`@@ -391,7 +391,7 @@ impl<'a> serialize::Decoder for Decoder<'a> {`
`391`	`391`	`fn read_enum_variant<T, F>(&mut self, _: &[&str], mut f: F) -> Result<T, Self::Error>`
`392`	`392`	`where F: FnMut(&mut Decoder<'a>, usize) -> Result<T, Self::Error>`
`393`	`393`	`{`
`394`		`- let disr = self.read_uint()?;`
	`394`	`+ let disr = self.read_usize()?;`
`395`	`395`	`f(self, disr)`
`396`	`396`	`}`
`397`	`397`
`@@ -404,7 +404,7 @@ impl<'a> serialize::Decoder for Decoder<'a> {`
`404`	`404`	`fn read_enum_struct_variant<T, F>(&mut self, _: &[&str], mut f: F) -> Result<T, Self::Error>`
`405`	`405`	`where F: FnMut(&mut Decoder<'a>, usize) -> Result<T, Self::Error>`
`406`	`406`	`{`
`407`		`- let disr = self.read_uint()?;`
	`407`	`+ let disr = self.read_usize()?;`
`408`	`408`	`f(self, disr)`
`409`	`409`	`}`
`410`	`410`
`@@ -483,7 +483,7 @@ impl<'a> serialize::Decoder for Decoder<'a> {`
`483`	`483`	`fn read_seq<T, F>(&mut self, f: F) -> Result<T, Self::Error>`
`484`	`484`	`where F: FnOnce(&mut Decoder<'a>, usize) -> Result<T, Self::Error>`
`485`	`485`	`{`
`486`		`- let len = self.read_uint()?;`
	`486`	`+ let len = self.read_usize()?;`
`487`	`487`	`f(self, len)`
`488`	`488`	`}`
`489`	`489`
`@@ -496,7 +496,7 @@ impl<'a> serialize::Decoder for Decoder<'a> {`
`496`	`496`	`fn read_map<T, F>(&mut self, f: F) -> Result<T, Self::Error>`
`497`	`497`	`where F: FnOnce(&mut Decoder<'a>, usize) -> Result<T, Self::Error>`
`498`	`498`	`{`
`499`		`- let len = self.read_uint()?;`
	`499`	`+ let len = self.read_usize()?;`
`500`	`500`	`f(self, len)`
`501`	`501`	`}`
`502`	`502`
Original file line number	Diff line number	Diff line change
`@@ -136,15 +136,15 @@ impl<`
`136`	`136`	`for item in self {`
`137`	`137`	`bits \|= item.to_usize();`
`138`	`138`	`}`
`139`		`- s.emit_uint(bits)`
	`139`	`+ s.emit_usize(bits)`
`140`	`140`	`}`
`141`	`141`	`}`
`142`	`142`
`143`	`143`	`impl<`
`144`	`144`	`T: Decodable + CLike`
`145`	`145`	`> Decodable for EnumSet<T> {`
`146`	`146`	`fn decode<D: Decoder>(d: &mut D) -> Result<EnumSet<T>, D::Error> {`
`147`		`- let bits = d.read_uint()?;`
	`147`	`+ let bits = d.read_usize()?;`
`148`	`148`	`let mut set = EnumSet::new();`
`149`	`149`	`for bit in 0..(mem::size_of::<usize>()*8) {`
`150`	`150`	`if bits & (1 << bit) != 0 {`