remove int_uint feature from libcollections

Author: Gankra

src/libcollections/bit.rs

@@ -890,7 +890,7 @@ mod test {
     fn test_from_iter() {
         let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];
 
-        let set: BTreeSet<int> = xs.iter().map(|&x| x).collect();
+        let set: BTreeSet<_> = xs.iter().cloned().collect();
 
         for x in &xs {
             assert!(set.contains(x));
@@ -899,8 +899,8 @@ mod test {
 
     #[test]
     fn test_show() {
-        let mut set: BTreeSet<int> = BTreeSet::new();
-        let empty: BTreeSet<int> = BTreeSet::new();
+        let mut set = BTreeSet::new();
+        let empty = BTreeSet::<i32>::new();
 
         set.insert(1);
         set.insert(2);

src/libcollections/btree/set.rs

@@ -26,7 +26,6 @@
 #![feature(box_syntax)]
 #![feature(core)]
 #![feature(hash)]
-#![feature(int_uint)]
 #![feature(staged_api)]
 #![feature(unboxed_closures)]
 #![feature(unicode)]

src/libcollections/lib.rs

@@ -32,8 +32,8 @@ use std::cmp;
 
 use alloc::heap;
 
-static INITIAL_CAPACITY: usize = 7u; // 2^3 - 1
-static MINIMUM_CAPACITY: usize = 1u; // 2 - 1
+static INITIAL_CAPACITY: usize = 7; // 2^3 - 1
+static MINIMUM_CAPACITY: usize = 1; // 2 - 1
 
 /// `RingBuf` is a circular buffer, which can be used as a double-ended queue efficiently.
 #[stable(feature = "rust1", since = "1.0.0")]

src/libcollections/ring_buf.rs

@@ -1116,7 +1116,7 @@ pub trait SliceConcatExt<T: ?Sized, U> {
 
 impl<T: Clone, V: AsSlice<T>> SliceConcatExt<T, Vec<T>> for [V] {
     fn concat(&self) -> Vec<T> {
-        let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len());
+        let size = self.iter().fold(0, |acc, v| acc + v.as_slice().len());
         let mut result = Vec::with_capacity(size);
         for v in self {
             result.push_all(v.as_slice())
@@ -1125,7 +1125,7 @@ impl<T: Clone, V: AsSlice<T>> SliceConcatExt<T, Vec<T>> for [V] {
     }
 
     fn connect(&self, sep: &T) -> Vec<T> {
-        let size = self.iter().fold(0u, |acc, v| acc + v.as_slice().len());
+        let size = self.iter().fold(0, |acc, v| acc + v.as_slice().len());
         let mut result = Vec::with_capacity(size + self.len());
         let mut first = true;
         for v in self {
@@ -1301,7 +1301,7 @@ impl<T: Clone> Iterator for Permutations<T> {
 ////////////////////////////////////////////////////////////////////////////////
 
 fn insertion_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Ordering {
-    let len = v.len() as int;
+    let len = v.len() as isize;
     let buf_v = v.as_mut_ptr();
 
     // 1 <= i < len;
@@ -1371,7 +1371,7 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order
     let mut working_space = Vec::with_capacity(2 * len);
     // these both are buffers of length `len`.
     let mut buf_dat = working_space.as_mut_ptr();
-    let mut buf_tmp = unsafe {buf_dat.offset(len as int)};
+    let mut buf_tmp = unsafe {buf_dat.offset(len as isize)};
 
     // length `len`.
     let buf_v = v.as_ptr();
@@ -1387,17 +1387,17 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order
         // start <= i < len;
         for i in start..cmp::min(start + insertion, len) {
             // j satisfies: start <= j <= i;
-            let mut j = i as int;
+            let mut j = i as isize;
             unsafe {
                 // `i` is in bounds.
-                let read_ptr = buf_v.offset(i as int);
+                let read_ptr = buf_v.offset(i as isize);
 
                 // find where to insert, we need to do strict <,
                 // rather than <=, to maintain stability.
 
                 // start <= j - 1 < len, so .offset(j - 1) is in
                 // bounds.
-                while j > start as int &&
+                while j > start as isize &&
                         compare(&*read_ptr, &*buf_dat.offset(j - 1)) == Less {
                     j -= 1;
                 }
@@ -1431,24 +1431,24 @@ fn merge_sort<T, F>(v: &mut [T], mut compare: F) where F: FnMut(&T, &T) -> Order
                 // the end of the first run & start of the
                 // second. Offset of `len` is defined, since this is
                 // precisely one byte past the end of the object.
-                let right_start = buf_dat.offset(cmp::min(start + width, len) as int);
+                let right_start = buf_dat.offset(cmp::min(start + width, len) as isize);
                 // end of the second. Similar reasoning to the above re safety.
                 let right_end_idx = cmp::min(start + 2 * width, len);
-                let right_end = buf_dat.offset(right_end_idx as int);
+                let right_end = buf_dat.offset(right_end_idx as isize);
 
                 // the pointers to the elements under consideration
                 // from the two runs.
 
                 // both of these are in bounds.
-                let mut left = buf_dat.offset(start as int);
+                let mut left = buf_dat.offset(start as isize);
                 let mut right = right_start;
 
                 // where we're putting the results, it is a run of
                 // length `2*width`, so we step it once for each step
                 // of either `left` or `right`.  `buf_tmp` has length
                 // `len`, so these are in bounds.
-                let mut out = buf_tmp.offset(start as int);
-                let out_end = buf_tmp.offset(right_end_idx as int);
+                let mut out = buf_tmp.offset(start as isize);
+                let out_end = buf_tmp.offset(right_end_idx as isize);
 
                 while out < out_end {
                     // Either the left or the right run are exhausted,
@@ -1574,7 +1574,7 @@ mod tests {
 
     #[test]
     fn test_is_empty() {
-        let xs: [int; 0] = [];
+        let xs: [i32; 0] = [];
         assert!(xs.is_empty());
         assert!(![0].is_empty());
     }
@@ -1912,7 +1912,7 @@ mod tests {
     #[test]
     fn test_permutations() {
         {
-            let v: [int; 0] = [];
+            let v: [i32; 0] = [];
             let mut it = v.permutations();
             let (min_size, max_opt) = it.size_hint();
             assert_eq!(min_size, 1);
@@ -2373,7 +2373,7 @@ mod tests {
 
     #[test]
     fn test_mut_rev_iterator() {
-        let mut xs = [1u, 2, 3, 4, 5];
+        let mut xs = [1, 2, 3, 4, 5];
         for (i,x) in xs.iter_mut().rev().enumerate() {
             *x += i;
         }
@@ -2382,13 +2382,13 @@ mod tests {
 
     #[test]
     fn test_move_iterator() {
-        let xs = vec![1u,2,3,4,5];
+        let xs = vec![1,2,3,4,5];
         assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10*a + b), 12345);
     }
 
     #[test]
     fn test_move_rev_iterator() {
-        let xs = vec![1u,2,3,4,5];
+        let xs = vec![1,2,3,4,5];
         assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10*a + b), 54321);
     }
 
@@ -2592,7 +2592,7 @@ mod tests {
         test_show_vec!(empty, "[]");
         test_show_vec!(vec![1], "[1]");
         test_show_vec!(vec![1, 2, 3], "[1, 2, 3]");
-        test_show_vec!(vec![vec![], vec![1u], vec![1u, 1u]],
+        test_show_vec!(vec![vec![], vec![1], vec![1, 1]],
                        "[[], [1], [1, 1]]");
 
         let empty_mut: &mut [i32] = &mut[];
@@ -2601,7 +2601,7 @@ mod tests {
         test_show_vec!(v, "[1]");
         let v = &mut[1, 2, 3];
         test_show_vec!(v, "[1, 2, 3]");
-        let v: &mut[&mut[_]] = &mut[&mut[], &mut[1u], &mut[1u, 1u]];
+        let v: &mut[&mut[_]] = &mut[&mut[], &mut[1], &mut[1, 1]];
         test_show_vec!(v, "[[], [1], [1, 1]]");
     }
 
@@ -2677,7 +2677,7 @@ mod tests {
     fn test_iter_zero_sized() {
         let mut v = vec![Foo, Foo, Foo];
         assert_eq!(v.len(), 3);
-        let mut cnt = 0u;
+        let mut cnt = 0;
 
         for f in &v {
             assert!(*f == Foo);
@@ -3016,7 +3016,7 @@ mod bench {
         let mut rng = weak_rng();
         b.iter(|| {
             let mut v: Vec<_> = repeat((0, 0)).take(30).collect();
-            for _ in 0u..100 {
+            for _ in 0..100 {
                 let l = v.len();
                 v.insert(rng.gen::<usize>() % (l + 1),
                          (1, 1));
@@ -3028,7 +3028,7 @@ mod bench {
         let mut rng = weak_rng();
         b.iter(|| {
             let mut v: Vec<_> = repeat((0, 0)).take(130).collect();
-            for _ in 0u..100 {
+            for _ in 0..100 {
                 let l = v.len();
                 v.remove(rng.gen::<usize>() % l);
             }

src/libcollections/slice.rs

@@ -469,7 +469,7 @@ impl String {
             // Attempt to not use an intermediate buffer by just pushing bytes
             // directly onto this string.
             let slice = RawSlice {
-                data: self.vec.as_ptr().offset(cur_len as int),
+                data: self.vec.as_ptr().offset(cur_len as isize),
                 len: 4,
             };
             let used = ch.encode_utf8(mem::transmute(slice)).unwrap_or(0);
@@ -569,8 +569,8 @@ impl String {
 
         let CharRange { ch, next } = self.char_range_at(idx);
         unsafe {
-            ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as int),
-                             self.vec.as_ptr().offset(next as int),
+            ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as isize),
+                             self.vec.as_ptr().offset(next as isize),
                              len - next);
             self.vec.set_len(len - (next - idx));
         }
@@ -599,10 +599,10 @@ impl String {
         let amt = ch.encode_utf8(&mut bits).unwrap();
 
         unsafe {
-            ptr::copy_memory(self.vec.as_mut_ptr().offset((idx + amt) as int),
-                             self.vec.as_ptr().offset(idx as int),
+            ptr::copy_memory(self.vec.as_mut_ptr().offset((idx + amt) as isize),
+                             self.vec.as_ptr().offset(idx as isize),
                              len - idx);
-            ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as int),
+            ptr::copy_memory(self.vec.as_mut_ptr().offset(idx as isize),
                              bits.as_ptr(),
                              amt);
             self.vec.set_len(len + amt);

src/libcollections/string.rs

@@ -234,7 +234,7 @@ impl<T> Vec<T> {
     ///         mem::forget(v);
     ///
     ///         // Overwrite memory with 4, 5, 6
-    ///         for i in 0..len as int {
+    ///         for i in 0..len as isize {
     ///             ptr::write(p.offset(i), 4 + i);
     ///         }
     ///
@@ -457,7 +457,7 @@ impl<T> Vec<T> {
             let end = if mem::size_of::<T>() == 0 {
                 (ptr as usize + self.len()) as *const T
             } else {
-                ptr.offset(self.len() as int) as *const T
+                ptr.offset(self.len() as isize) as *const T
             };
             mem::forget(self);
             IntoIter { allocation: ptr, cap: cap, ptr: begin, end: end }
@@ -473,7 +473,7 @@ impl<T> Vec<T> {
     /// # Examples
     ///
     /// ```
-    /// let mut v = vec![1u, 2, 3, 4];
+    /// let mut v = vec![1, 2, 3, 4];
     /// unsafe {
     ///     v.set_len(1);
     /// }
@@ -539,7 +539,7 @@ impl<T> Vec<T> {
         unsafe { // infallible
             // The spot to put the new value
             {
-                let p = self.as_mut_ptr().offset(index as int);
+                let p = self.as_mut_ptr().offset(index as isize);
                 // Shift everything over to make space. (Duplicating the
                 // `index`th element into two consecutive places.)
                 ptr::copy_memory(p.offset(1), &*p, len - index);
@@ -573,7 +573,7 @@ impl<T> Vec<T> {
             let ret;
             {
                 // the place we are taking from.
-                let ptr = self.as_mut_ptr().offset(index as int);
+                let ptr = self.as_mut_ptr().offset(index as isize);
                 // copy it out, unsafely having a copy of the value on
                 // the stack and in the vector at the same time.
                 ret = ptr::read(ptr);
@@ -655,7 +655,7 @@ impl<T> Vec<T> {
         }
 
         unsafe {
-            let end = (*self.ptr).offset(self.len as int);
+            let end = (*self.ptr).offset(self.len as isize);
             ptr::write(&mut *end, value);
             self.len += 1;
         }
@@ -743,7 +743,7 @@ impl<T> Vec<T> {
             let end = if mem::size_of::<T>() == 0 {
                 (*self.ptr as usize + self.len()) as *const T
             } else {
-                (*self.ptr).offset(self.len() as int) as *const T
+                (*self.ptr).offset(self.len() as isize) as *const T
             };
             self.set_len(0);
             Drain {
@@ -835,7 +835,7 @@ impl<T> Vec<T> {
             // types are passed to the allocator by `Vec`.
             assert!(mem::min_align_of::<T>() == mem::min_align_of::<U>());
 
-            // This `as int` cast is safe, because the size of the elements of the
+            // This `as isize` cast is safe, because the size of the elements of the
             // vector is not 0, and:
             //
             // 1) If the size of the elements in the vector is 1, the `int` may
@@ -852,7 +852,7 @@ impl<T> Vec<T> {
             //
             // 2) If the size of the elements in the vector is >1, the `usize` ->
             //    `int` conversion can't overflow.
-            let offset = vec.len() as int;
+            let offset = vec.len() as isize;
             let start = vec.as_mut_ptr();
 
             let mut pv = PartialVecNonZeroSized {
@@ -1179,8 +1179,8 @@ impl<T: PartialEq> Vec<T> {
             let mut w = 1;
 
             while r < ln {
-                let p_r = p.offset(r as int);
-                let p_wm1 = p.offset((w - 1) as int);
+                let p_r = p.offset(r as isize);
+                let p_wm1 = p.offset((w - 1) as isize);
                 if *p_r != *p_wm1 {
                     if r != w {
                         let p_w = p_wm1.offset(1);
@@ -1648,7 +1648,7 @@ impl<T> Iterator for IntoIter<T> {
                     self.ptr = mem::transmute(self.ptr as usize + 1);
 
                     // Use a non-null pointer value
-                    Some(ptr::read(mem::transmute(1u)))
+                    Some(ptr::read(EMPTY as *mut T))
                 } else {
                     let old = self.ptr;
                     self.ptr = self.ptr.offset(1);
@@ -1681,7 +1681,7 @@ impl<T> DoubleEndedIterator for IntoIter<T> {
                     self.end = mem::transmute(self.end as usize - 1);
 
                     // Use a non-null pointer value
-                    Some(ptr::read(mem::transmute(1u)))
+                    Some(ptr::read(EMPTY as *mut T))
                 } else {
                     self.end = self.end.offset(-1);
 
@@ -1736,7 +1736,7 @@ impl<'a, T> Iterator for Drain<'a, T> {
                     self.ptr = mem::transmute(self.ptr as usize + 1);
 
                     // Use a non-null pointer value
-                    Some(ptr::read(mem::transmute(1u)))
+                    Some(ptr::read(EMPTY as *mut T))
                 } else {
                     let old = self.ptr;
                     self.ptr = self.ptr.offset(1);
@@ -1769,7 +1769,7 @@ impl<'a, T> DoubleEndedIterator for Drain<'a, T> {
                     self.end = mem::transmute(self.end as usize - 1);
 
                     // Use a non-null pointer value
-                    Some(ptr::read(mem::transmute(1u)))
+                    Some(ptr::read(EMPTY as *mut T))
                 } else {
                     self.end = self.end.offset(-1);
 
@@ -2146,10 +2146,10 @@ mod tests {
 
     #[test]
     fn test_partition() {
-        assert_eq!(vec![].into_iter().partition(|x: &int| *x < 3), (vec![], vec![]));
-        assert_eq!(vec![1, 2, 3].into_iter().partition(|x: &int| *x < 4), (vec![1, 2, 3], vec![]));
-        assert_eq!(vec![1, 2, 3].into_iter().partition(|x: &int| *x < 2), (vec![1], vec![2, 3]));
-        assert_eq!(vec![1, 2, 3].into_iter().partition(|x: &int| *x < 0), (vec![], vec![1, 2, 3]));
+        assert_eq!(vec![].into_iter().partition(|x: &i32| *x < 3), (vec![], vec![]));
+        assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 4), (vec![1, 2, 3], vec![]));
+        assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 2), (vec![1], vec![2, 3]));
+        assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 0), (vec![], vec![1, 2, 3]));
     }
 
     #[test]
@@ -2183,7 +2183,7 @@ mod tests {
     #[test]
     fn test_vec_truncate_drop() {
         static mut drops: u32 = 0;
-        struct Elem(int);
+        struct Elem(i32);
         impl Drop for Elem {
             fn drop(&mut self) {
                 unsafe { drops += 1; }