diff options
| author | Tobias Bucher <tobiasbucher5991@gmail.com> | 2015-01-25 22:05:03 +0100 |
|---|---|---|
| committer | Tobias Bucher <tobiasbucher5991@gmail.com> | 2015-01-30 04:38:54 +0100 |
| commit | 7f64fe4e27555c256cb228feb05d4181a2287125 (patch) | |
| tree | c1fd374d345905c7c4c9b1e7df160d3394edbec5 | |
| parent | 52c74e63dacd49017b19330e0cbecbac0a3fe62e (diff) | |
| download | rust-7f64fe4e27555c256cb228feb05d4181a2287125.tar.gz rust-7f64fe4e27555c256cb228feb05d4181a2287125.zip | |
Remove all `i` suffixes
474 files changed, 1991 insertions, 1991 deletions
diff --git a/src/liballoc/arc.rs b/src/liballoc/arc.rs index f9f6de2df58..71f33feb8e1 100644 --- a/src/liballoc/arc.rs +++ b/src/liballoc/arc.rs @@ -35,7 +35,7 @@ //! use std::sync::Arc; //! use std::thread::Thread; //! -//! let five = Arc::new(5i); +//! let five = Arc::new(5); //! //! for _ in 0u..10 { //! let five = five.clone(); @@ -52,7 +52,7 @@ //! use std::sync::{Arc, Mutex}; //! use std::thread::Thread; //! -//! let five = Arc::new(Mutex::new(5i)); +//! let five = Arc::new(Mutex::new(5)); //! //! for _ in 0u..10 { //! let five = five.clone(); @@ -154,7 +154,7 @@ impl<T> Arc<T> { /// ``` /// use std::sync::Arc; /// - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// ``` #[inline] #[stable(feature = "rust1", since = "1.0.0")] @@ -176,7 +176,7 @@ impl<T> Arc<T> { /// ``` /// use std::sync::Arc; /// - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// /// let weak_five = five.downgrade(); /// ``` @@ -221,7 +221,7 @@ impl<T> Clone for Arc<T> { /// ``` /// use std::sync::Arc; /// - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// /// five.clone(); /// ``` @@ -268,7 +268,7 @@ impl<T: Send + Sync + Clone> Arc<T> { /// ``` /// use std::sync::Arc; /// - /// let mut five = Arc::new(5i); + /// let mut five = Arc::new(5); /// /// let mut_five = five.make_unique(); /// ``` @@ -304,14 +304,14 @@ impl<T: Sync + Send> Drop for Arc<T> { /// use std::sync::Arc; /// /// { - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// /// // stuff /// /// drop(five); // explict drop /// } /// { - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// /// // stuff /// @@ -371,7 +371,7 @@ impl<T: Sync + Send> Weak<T> { /// ``` /// use std::sync::Arc; /// - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// /// let weak_five = five.downgrade(); /// @@ -408,7 +408,7 @@ impl<T: Sync + Send> Clone for Weak<T> { /// ``` /// use std::sync::Arc; /// - /// let weak_five = Arc::new(5i).downgrade(); + /// let weak_five = Arc::new(5).downgrade(); /// /// weak_five.clone(); /// ``` @@ -433,7 +433,7 @@ impl<T: Sync + Send> Drop for Weak<T> { /// use std::sync::Arc; /// /// { - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// let weak_five = five.downgrade(); /// /// // stuff @@ -441,7 +441,7 @@ impl<T: Sync + Send> Drop for Weak<T> { /// drop(weak_five); // explict drop /// } /// { - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// let weak_five = five.downgrade(); /// /// // stuff @@ -475,9 +475,9 @@ impl<T: PartialEq> PartialEq for Arc<T> { /// ``` /// use std::sync::Arc; /// - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// - /// five == Arc::new(5i); + /// five == Arc::new(5); /// ``` fn eq(&self, other: &Arc<T>) -> bool { *(*self) == *(*other) } @@ -490,9 +490,9 @@ impl<T: PartialEq> PartialEq for Arc<T> { /// ``` /// use std::sync::Arc; /// - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// - /// five != Arc::new(5i); + /// five != Arc::new(5); /// ``` fn ne(&self, other: &Arc<T>) -> bool { *(*self) != *(*other) } } @@ -507,9 +507,9 @@ impl<T: PartialOrd> PartialOrd for Arc<T> { /// ``` /// use std::sync::Arc; /// - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// - /// five.partial_cmp(&Arc::new(5i)); + /// five.partial_cmp(&Arc::new(5)); /// ``` fn partial_cmp(&self, other: &Arc<T>) -> Option<Ordering> { (**self).partial_cmp(&**other) @@ -524,9 +524,9 @@ impl<T: PartialOrd> PartialOrd for Arc<T> { /// ``` /// use std::sync::Arc; /// - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// - /// five < Arc::new(5i); + /// five < Arc::new(5); /// ``` fn lt(&self, other: &Arc<T>) -> bool { *(*self) < *(*other) } @@ -539,9 +539,9 @@ impl<T: PartialOrd> PartialOrd for Arc<T> { /// ``` /// use std::sync::Arc; /// - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// - /// five <= Arc::new(5i); + /// five <= Arc::new(5); /// ``` fn le(&self, other: &Arc<T>) -> bool { *(*self) <= *(*other) } @@ -554,9 +554,9 @@ impl<T: PartialOrd> PartialOrd for Arc<T> { /// ``` /// use std::sync::Arc; /// - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// - /// five > Arc::new(5i); + /// five > Arc::new(5); /// ``` fn gt(&self, other: &Arc<T>) -> bool { *(*self) > *(*other) } @@ -569,9 +569,9 @@ impl<T: PartialOrd> PartialOrd for Arc<T> { /// ``` /// use std::sync::Arc; /// - /// let five = Arc::new(5i); + /// let five = Arc::new(5); /// - /// five >= Arc::new(5i); + /// five >= Arc::new(5); /// ``` fn ge(&self, other: &Arc<T>) -> bool { *(*self) >= *(*other) } } @@ -719,14 +719,14 @@ mod tests { #[test] fn test_live() { - let x = Arc::new(5i); + let x = Arc::new(5); let y = x.downgrade(); assert!(y.upgrade().is_some()); } #[test] fn test_dead() { - let x = Arc::new(5i); + let x = Arc::new(5); let y = x.downgrade(); drop(x); assert!(y.upgrade().is_none()); diff --git a/src/liballoc/boxed_test.rs b/src/liballoc/boxed_test.rs index c47a771f60d..4ffb94e7a61 100644 --- a/src/liballoc/boxed_test.rs +++ b/src/liballoc/boxed_test.rs @@ -20,7 +20,7 @@ use std::boxed::BoxAny; #[test] fn test_owned_clone() { - let a = Box::new(5i); + let a = Box::new(5); let b: Box<int> = a.clone(); assert!(a == b); } diff --git a/src/liballoc/heap.rs b/src/liballoc/heap.rs index 1fb6290c7a3..1d5637a6ad6 100644 --- a/src/liballoc/heap.rs +++ b/src/liballoc/heap.rs @@ -403,7 +403,7 @@ mod test { #[bench] fn alloc_owned_small(b: &mut Bencher) { b.iter(|| { - box 10i + box 10 }) } } diff --git a/src/liballoc/rc.rs b/src/liballoc/rc.rs index d41673f56ed..8a542e1b8cb 100644 --- a/src/liballoc/rc.rs +++ b/src/liballoc/rc.rs @@ -192,7 +192,7 @@ impl<T> Rc<T> { /// ``` /// use std::rc::Rc; /// - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn new(value: T) -> Rc<T> { @@ -217,7 +217,7 @@ impl<T> Rc<T> { /// ``` /// use std::rc::Rc; /// - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// /// let weak_five = five.downgrade(); /// ``` @@ -247,7 +247,7 @@ pub fn strong_count<T>(this: &Rc<T>) -> uint { this.strong() } /// use std::rc; /// use std::rc::Rc; /// -/// let five = Rc::new(5i); +/// let five = Rc::new(5); /// /// rc::is_unique(&five); /// ``` @@ -329,7 +329,7 @@ impl<T: Clone> Rc<T> { /// ``` /// use std::rc::Rc; /// - /// let mut five = Rc::new(5i); + /// let mut five = Rc::new(5); /// /// let mut_five = five.make_unique(); /// ``` @@ -378,14 +378,14 @@ impl<T> Drop for Rc<T> { /// use std::rc::Rc; /// /// { - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// /// // stuff /// /// drop(five); // explict drop /// } /// { - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// /// // stuff /// @@ -425,7 +425,7 @@ impl<T> Clone for Rc<T> { /// ``` /// use std::rc::Rc; /// - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// /// five.clone(); /// ``` @@ -466,9 +466,9 @@ impl<T: PartialEq> PartialEq for Rc<T> { /// ``` /// use std::rc::Rc; /// - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// - /// five == Rc::new(5i); + /// five == Rc::new(5); /// ``` #[inline(always)] fn eq(&self, other: &Rc<T>) -> bool { **self == **other } @@ -482,9 +482,9 @@ impl<T: PartialEq> PartialEq for Rc<T> { /// ``` /// use std::rc::Rc; /// - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// - /// five != Rc::new(5i); + /// five != Rc::new(5); /// ``` #[inline(always)] fn ne(&self, other: &Rc<T>) -> bool { **self != **other } @@ -504,9 +504,9 @@ impl<T: PartialOrd> PartialOrd for Rc<T> { /// ``` /// use std::rc::Rc; /// - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// - /// five.partial_cmp(&Rc::new(5i)); + /// five.partial_cmp(&Rc::new(5)); /// ``` #[inline(always)] fn partial_cmp(&self, other: &Rc<T>) -> Option<Ordering> { @@ -522,9 +522,9 @@ impl<T: PartialOrd> PartialOrd for Rc<T> { /// ``` /// use std::rc::Rc; /// - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// - /// five < Rc::new(5i); + /// five < Rc::new(5); /// ``` #[inline(always)] fn lt(&self, other: &Rc<T>) -> bool { **self < **other } @@ -538,9 +538,9 @@ impl<T: PartialOrd> PartialOrd for Rc<T> { /// ``` /// use std::rc::Rc; /// - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// - /// five <= Rc::new(5i); + /// five <= Rc::new(5); /// ``` #[inline(always)] fn le(&self, other: &Rc<T>) -> bool { **self <= **other } @@ -554,9 +554,9 @@ impl<T: PartialOrd> PartialOrd for Rc<T> { /// ``` /// use std::rc::Rc; /// - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// - /// five > Rc::new(5i); + /// five > Rc::new(5); /// ``` #[inline(always)] fn gt(&self, other: &Rc<T>) -> bool { **self > **other } @@ -570,9 +570,9 @@ impl<T: PartialOrd> PartialOrd for Rc<T> { /// ``` /// use std::rc::Rc; /// - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// - /// five >= Rc::new(5i); + /// five >= Rc::new(5); /// ``` #[inline(always)] fn ge(&self, other: &Rc<T>) -> bool { **self >= **other } @@ -589,9 +589,9 @@ impl<T: Ord> Ord for Rc<T> { /// ``` /// use std::rc::Rc; /// - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// - /// five.partial_cmp(&Rc::new(5i)); + /// five.partial_cmp(&Rc::new(5)); /// ``` #[inline] fn cmp(&self, other: &Rc<T>) -> Ordering { (**self).cmp(&**other) } @@ -653,7 +653,7 @@ impl<T> Weak<T> { /// ``` /// use std::rc::Rc; /// - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// /// let weak_five = five.downgrade(); /// @@ -682,7 +682,7 @@ impl<T> Drop for Weak<T> { /// use std::rc::Rc; /// /// { - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// let weak_five = five.downgrade(); /// /// // stuff @@ -690,7 +690,7 @@ impl<T> Drop for Weak<T> { /// drop(weak_five); // explict drop /// } /// { - /// let five = Rc::new(5i); + /// let five = Rc::new(5); /// let weak_five = five.downgrade(); /// /// // stuff @@ -726,7 +726,7 @@ impl<T> Clone for Weak<T> { /// ``` /// use std::rc::Rc; /// - /// let weak_five = Rc::new(5i).downgrade(); + /// let weak_five = Rc::new(5).downgrade(); /// /// weak_five.clone(); /// ``` @@ -789,7 +789,7 @@ mod tests { #[test] fn test_clone() { - let x = Rc::new(RefCell::new(5i)); + let x = Rc::new(RefCell::new(5)); let y = x.clone(); *x.borrow_mut() = 20; assert_eq!(*y.borrow(), 20); @@ -797,13 +797,13 @@ mod tests { #[test] fn test_simple() { - let x = Rc::new(5i); + let x = Rc::new(5); assert_eq!(*x, 5); } #[test] fn test_simple_clone() { - let x = Rc::new(5i); + let x = Rc::new(5); let y = x.clone(); assert_eq!(*x, 5); assert_eq!(*y, 5); @@ -811,20 +811,20 @@ mod tests { #[test] fn test_destructor() { - let x = Rc::new(box 5i); + let x = Rc::new(box 5); assert_eq!(**x, 5); } #[test] fn test_live() { - let x = Rc::new(5i); + let x = Rc::new(5); let y = x.downgrade(); assert!(y.upgrade().is_some()); } #[test] fn test_dead() { - let x = Rc::new(5i); + let x = Rc::new(5); let y = x.downgrade(); drop(x); assert!(y.upgrade().is_none()); diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs index f717fc6075d..91ef2d17baa 100644 --- a/src/libcollections/binary_heap.rs +++ b/src/libcollections/binary_heap.rs @@ -212,7 +212,7 @@ impl<T: Ord> BinaryHeap<T> { /// /// ``` /// use std::collections::BinaryHeap; - /// let heap = BinaryHeap::from_vec(vec![9i, 1, 2, 7, 3, 2]); + /// let heap = BinaryHeap::from_vec(vec![9, 1, 2, 7, 3, 2]); /// ``` pub fn from_vec(vec: Vec<T>) -> BinaryHeap<T> { let mut heap = BinaryHeap { data: vec }; @@ -231,7 +231,7 @@ impl<T: Ord> BinaryHeap<T> { /// /// ``` /// use std::collections::BinaryHeap; - /// let heap = BinaryHeap::from_vec(vec![1i, 2, 3, 4]); + /// let heap = BinaryHeap::from_vec(vec![1, 2, 3, 4]); /// /// // Print 1, 2, 3, 4 in arbitrary order /// for x in heap.iter() { @@ -251,7 +251,7 @@ impl<T: Ord> BinaryHeap<T> { /// /// ``` /// use std::collections::BinaryHeap; - /// let heap = BinaryHeap::from_vec(vec![1i, 2, 3, 4]); + /// let heap = BinaryHeap::from_vec(vec![1, 2, 3, 4]); /// /// // Print 1, 2, 3, 4 in arbitrary order /// for x in heap.into_iter() { @@ -273,7 +273,7 @@ impl<T: Ord> BinaryHeap<T> { /// let mut heap = BinaryHeap::new(); /// assert_eq!(heap.peek(), None); /// - /// heap.push(1i); + /// heap.push(1); /// heap.push(5); /// heap.push(2); /// assert_eq!(heap.peek(), Some(&5)); @@ -356,7 +356,7 @@ impl<T: Ord> BinaryHeap<T> { /// /// ``` /// use std::collections::BinaryHeap; - /// let mut heap = BinaryHeap::from_vec(vec![1i, 3]); + /// let mut heap = BinaryHeap::from_vec(vec![1, 3]); /// /// assert_eq!(heap.pop(), Some(3)); /// assert_eq!(heap.pop(), Some(1)); @@ -380,7 +380,7 @@ impl<T: Ord> BinaryHeap<T> { /// ``` /// use std::collections::BinaryHeap; /// let mut heap = BinaryHeap::new(); - /// heap.push(3i); + /// heap.push(3); /// heap.push(5); /// heap.push(1); /// @@ -402,7 +402,7 @@ impl<T: Ord> BinaryHeap<T> { /// ``` /// use std::collections::BinaryHeap; /// let mut heap = BinaryHeap::new(); - /// heap.push(1i); + /// heap.push(1); /// heap.push(5); /// /// assert_eq!(heap.push_pop(3), 5); @@ -434,7 +434,7 @@ impl<T: Ord> BinaryHeap<T> { /// use std::collections::BinaryHeap; /// let mut heap = BinaryHeap::new(); /// - /// assert_eq!(heap.replace(1i), None); + /// assert_eq!(heap.replace(1), None); /// assert_eq!(heap.replace(3), Some(1)); /// assert_eq!(heap.len(), 1); /// assert_eq!(heap.peek(), Some(&3)); @@ -457,7 +457,7 @@ impl<T: Ord> BinaryHeap<T> { /// /// ``` /// use std::collections::BinaryHeap; - /// let heap = BinaryHeap::from_vec(vec![1i, 2, 3, 4, 5, 6, 7]); + /// let heap = BinaryHeap::from_vec(vec![1, 2, 3, 4, 5, 6, 7]); /// let vec = heap.into_vec(); /// /// // Will print in some order @@ -475,12 +475,12 @@ impl<T: Ord> BinaryHeap<T> { /// ``` /// use std::collections::BinaryHeap; /// - /// let mut heap = BinaryHeap::from_vec(vec![1i, 2, 4, 5, 7]); + /// let mut heap = BinaryHeap::from_vec(vec![1, 2, 4, 5, 7]); /// heap.push(6); /// heap.push(3); /// /// let vec = heap.into_sorted_vec(); - /// assert_eq!(vec, vec![1i, 2, 3, 4, 5, 6, 7]); + /// assert_eq!(vec, vec![1, 2, 3, 4, 5, 6, 7]); /// ``` pub fn into_sorted_vec(mut self) -> Vec<T> { let mut end = self.len(); @@ -676,8 +676,8 @@ mod tests { #[test] fn test_iterator() { - let data = vec!(5i, 9, 3); - let iterout = [9i, 5, 3]; + let data = vec!(5, 9, 3); + let iterout = [9, 5, 3]; let heap = BinaryHeap::from_vec(data); let mut i = 0; for el in heap.iter() { @@ -688,8 +688,8 @@ mod tests { #[test] fn test_iterator_reverse() { - let data = vec!(5i, 9, 3); - let iterout = vec!(3i, 5, 9); + let data = vec!(5, 9, 3); + let iterout = vec!(3, 5, 9); let pq = BinaryHeap::from_vec(data); let v: Vec<int> = pq.iter().rev().map(|&x| x).collect(); @@ -698,8 +698,8 @@ mod tests { #[test] fn test_move_iter() { - let data = vec!(5i, 9, 3); - let iterout = vec!(9i, 5, 3); + let data = vec!(5, 9, 3); + let iterout = vec!(9, 5, 3); let pq = BinaryHeap::from_vec(data); let v: Vec<int> = pq.into_iter().collect(); @@ -708,16 +708,16 @@ mod tests { #[test] fn test_move_iter_size_hint() { - let data = vec!(5i, 9); + let data = vec!(5, 9); let pq = BinaryHeap::from_vec(data); let mut it = pq.into_iter(); assert_eq!(it.size_hint(), (2, Some(2))); - assert_eq!(it.next(), Some(9i)); + assert_eq!(it.next(), Some(9)); assert_eq!(it.size_hint(), (1, Some(1))); - assert_eq!(it.next(), Some(5i)); + assert_eq!(it.next(), Some(5)); assert_eq!(it.size_hint(), (0, Some(0))); assert_eq!(it.next(), None); @@ -725,8 +725,8 @@ mod tests { #[test] fn test_move_iter_reverse() { - let data = vec!(5i, 9, 3); - let iterout = vec!(3i, 5, 9); + let data = vec!(5, 9, 3); + let iterout = vec!(3, 5, 9); let pq = BinaryHeap::from_vec(data); let v: Vec<int> = pq.into_iter().rev().collect(); @@ -747,7 +747,7 @@ mod tests { #[test] fn test_push() { - let mut heap = BinaryHeap::from_vec(vec!(2i, 4, 9)); + let mut heap = BinaryHeap::from_vec(vec!(2, 4, 9)); assert_eq!(heap.len(), 3); assert!(*heap.peek().unwrap() == 9); heap.push(11); @@ -769,7 +769,7 @@ mod tests { #[test] fn test_push_unique() { - let mut heap = BinaryHeap::from_vec(vec!(box 2i, box 4, box 9)); + let mut heap = BinaryHeap::from_vec(vec!(box 2, box 4, box 9)); assert_eq!(heap.len(), 3); assert!(*heap.peek().unwrap() == box 9); heap.push(box 11); @@ -791,7 +791,7 @@ mod tests { #[test] fn test_push_pop() { - let mut heap = BinaryHeap::from_vec(vec!(5i, 5, 2, 1, 3)); + let mut heap = BinaryHeap::from_vec(vec!(5, 5, 2, 1, 3)); assert_eq!(heap.len(), 5); assert_eq!(heap.push_pop(6), 6); assert_eq!(heap.len(), 5); @@ -805,7 +805,7 @@ mod tests { #[test] fn test_replace() { - let mut heap = BinaryHeap::from_vec(vec!(5i, 5, 2, 1, 3)); + let mut heap = BinaryHeap::from_vec(vec!(5, 5, 2, 1, 3)); assert_eq!(heap.len(), 5); assert_eq!(heap.replace(6).unwrap(), 5); assert_eq!(heap.len(), 5); @@ -830,18 +830,18 @@ mod tests { #[test] fn test_to_vec() { check_to_vec(vec!()); - check_to_vec(vec!(5i)); - check_to_vec(vec!(3i, 2)); - check_to_vec(vec!(2i, 3)); - check_to_vec(vec!(5i, 1, 2)); - check_to_vec(vec!(1i, 100, 2, 3)); - check_to_vec(vec!(1i, 3, 5, 7, 9, 2, 4, 6, 8, 0)); - check_to_vec(vec!(2i, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1)); - check_to_vec(vec!(9i, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0)); - check_to_vec(vec!(0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)); - check_to_vec(vec!(10i, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)); - check_to_vec(vec!(0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2)); - check_to_vec(vec!(5i, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1)); + check_to_vec(vec!(5)); + check_to_vec(vec!(3, 2)); + check_to_vec(vec!(2, 3)); + check_to_vec(vec!(5, 1, 2)); + check_to_vec(vec!(1, 100, 2, 3)); + check_to_vec(vec!(1, 3, 5, 7, 9, 2, 4, 6, 8, 0)); + check_to_vec(vec!(2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1)); + check_to_vec(vec!(9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0)); + check_to_vec(vec!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10)); + check_to_vec(vec!(10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0)); + check_to_vec(vec!(0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2)); + check_to_vec(vec!(5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1)); } #[test] diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs index 4f2c2cb6028..2ab2a499e73 100644 --- a/src/libcollections/btree/map.rs +++ b/src/libcollections/btree/map.rs @@ -1782,7 +1782,7 @@ mod test { #[test] fn test_entry(){ - let xs = [(1i, 10i), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)]; + let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)]; let mut map: BTreeMap<int, int> = xs.iter().map(|&x| x).collect(); diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs index a090e4f24ce..a99af5a549d 100644 --- a/src/libcollections/btree/set.rs +++ b/src/libcollections/btree/set.rs @@ -282,7 +282,7 @@ impl<T: Ord> BTreeSet<T> { /// /// let mut v = BTreeSet::new(); /// assert_eq!(v.len(), 0); - /// v.insert(1i); + /// v.insert(1); /// assert_eq!(v.len(), 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -297,7 +297,7 @@ impl<T: Ord> BTreeSet<T> { /// /// let mut v = BTreeSet::new(); /// assert!(v.is_empty()); - /// v.insert(1i); + /// v.insert(1); /// assert!(!v.is_empty()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -311,7 +311,7 @@ impl<T: Ord> BTreeSet<T> { /// use std::collections::BTreeSet; /// /// let mut v = BTreeSet::new(); - /// v.insert(1i); + /// v.insert(1); /// v.clear(); /// assert!(v.is_empty()); /// ``` @@ -331,7 +331,7 @@ impl<T: Ord> BTreeSet<T> { /// ``` /// use std::collections::BTreeSet; /// - /// let set: BTreeSet<int> = [1i, 2, 3].iter().map(|&x| x).collect(); + /// let set: BTreeSet<int> = [1, 2, 3].iter().map(|&x| x).collect(); /// assert_eq!(set.contains(&1), true); /// assert_eq!(set.contains(&4), false); /// ``` @@ -348,7 +348,7 @@ impl<T: Ord> BTreeSet<T> { /// ``` /// use std::collections::BTreeSet; /// - /// let a: BTreeSet<int> = [1i, 2, 3].iter().map(|&x| x).collect(); + /// let a: BTreeSet<int> = [1, 2, 3].iter().map(|&x| x).collect(); /// let mut b: BTreeSet<int> = BTreeSet::new(); /// /// assert_eq!(a.is_disjoint(&b), true); @@ -369,7 +369,7 @@ impl<T: Ord> BTreeSet<T> { /// ``` /// use std::collections::BTreeSet; /// - /// let sup: BTreeSet<int> = [1i, 2, 3].iter().map(|&x| x).collect(); + /// let sup: BTreeSet<int> = [1, 2, 3].iter().map(|&x| x).collect(); /// let mut set: BTreeSet<int> = BTreeSet::new(); /// /// assert_eq!(set.is_subset(&sup), true); @@ -411,7 +411,7 @@ impl<T: Ord> BTreeSet<T> { /// ``` /// use std::collections::BTreeSet; /// - /// let sub: BTreeSet<int> = [1i, 2].iter().map(|&x| x).collect(); + /// let sub: BTreeSet<int> = [1, 2].iter().map(|&x| x).collect(); /// let mut set: BTreeSet<int> = BTreeSet::new(); /// /// assert_eq!(set.is_superset(&sub), false); @@ -438,8 +438,8 @@ impl<T: Ord> BTreeSet<T> { /// /// let mut set = BTreeSet::new(); /// - /// assert_eq!(set.insert(2i), true); - /// assert_eq!(set.insert(2i), false); + /// assert_eq!(set.insert(2), true); + /// assert_eq!(set.insert(2), false); /// assert_eq!(set.len(), 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -461,7 +461,7 @@ impl<T: Ord> BTreeSet<T> { /// /// let mut set = BTreeSet::new(); /// - /// set.insert(2i); + /// set.insert(2); /// assert_eq!(set.remove(&2), true); /// assert_eq!(set.remove(&2), false); /// ``` @@ -731,7 +731,7 @@ mod test { fn test_clone_eq() { let mut m = BTreeSet::new(); - m.insert(1i); + m.insert(1); m.insert(2); assert!(m.clone() == m); @@ -742,11 +742,11 @@ mod test { let mut x = BTreeSet::new(); let mut y = BTreeSet::new(); - x.insert(1i); + x.insert(1); x.insert(2); x.insert(3); - y.insert(3i); + y.insert(3); y.insert(2); y.insert(1); @@ -874,7 +874,7 @@ mod test { #[test] fn test_from_iter() { - let xs = [1i, 2, 3, 4, 5, 6, 7, 8, 9]; + let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9]; let set: BTreeSet<int> = xs.iter().map(|&x| x).collect(); diff --git a/src/libcollections/dlist.rs b/src/libcollections/dlist.rs index aded4b8a7ac..57867b44893 100644 --- a/src/libcollections/dlist.rs +++ b/src/libcollections/dlist.rs @@ -235,9 +235,9 @@ impl<T> DList<T> { /// /// let mut a = DList::new(); /// let mut b = DList::new(); - /// a.push_back(1i); + /// a.push_back(1); /// a.push_back(2); - /// b.push_back(3i); + /// b.push_back(3); /// b.push_back(4); /// /// a.append(&mut b); @@ -529,7 +529,7 @@ impl<T> DList<T> { /// use std::collections::DList; /// /// let mut d = DList::new(); - /// d.push_back(1i); + /// d.push_back(1); /// d.push_back(3); /// assert_eq!(3, *d.back().unwrap()); /// ``` @@ -548,7 +548,7 @@ impl<T> DList<T> { /// /// let mut d = DList::new(); /// assert_eq!(d.pop_back(), None); - /// d.push_back(1i); + /// d.push_back(1); /// d.push_back(3); /// assert_eq!(d.pop_back(), Some(3)); /// ``` @@ -766,7 +766,7 @@ impl<'a, A> IterMut<'a, A> { /// } /// { /// let vec: Vec<int> = list.into_iter().collect(); - /// assert_eq!(vec, vec![1i, 2, 3, 4]); + /// assert_eq!(vec, vec![1, 2, 3, 4]); /// } /// ``` #[inline] @@ -964,7 +964,7 @@ mod tests { assert_eq!(m.pop_front(), Some(box 1)); let mut n = DList::new(); - n.push_front(2i); + n.push_front(2); n.push_front(3); { assert_eq!(n.front().unwrap(), &3); @@ -984,7 +984,7 @@ mod tests { #[cfg(test)] fn generate_test() -> DList<int> { - list_from(&[0i,1,2,3,4,5,6]) + list_from(&[0,1,2,3,4,5,6]) } #[cfg(test)] @@ -1007,7 +1007,7 @@ mod tests { { let mut m = DList::new(); let mut n = DList::new(); - n.push_back(2i); + n.push_back(2); m.append(&mut n); check_links(&m); assert_eq!(m.len(), 1); @@ -1019,7 +1019,7 @@ mod tests { { let mut m = DList::new(); let mut n = DList::new(); - m.push_back(2i); + m.push_back(2); m.append(&mut n); check_links(&m); assert_eq!(m.len(), 1); @@ -1028,8 +1028,8 @@ mod tests { } // Non-empty to non-empty - let v = vec![1i,2,3,4,5]; - let u = vec![9i,8,1,2,3,4,5]; + let v = vec![1,2,3,4,5]; + let u = vec![9,8,1,2,3,4,5]; let mut m = list_from(v.as_slice()); let mut n = list_from(u.as_slice()); m.append(&mut n); @@ -1054,7 +1054,7 @@ mod tests { // singleton { let mut m = DList::new(); - m.push_back(1i); + m.push_back(1); let p = m.split_off(0); assert_eq!(m.len(), 0); @@ -1065,29 +1065,29 @@ mod tests { // not singleton, forwards { - let u = vec![1i,2,3,4,5]; + let u = vec![1,2,3,4,5]; let mut m = list_from(u.as_slice()); let mut n = m.split_off(2); assert_eq!(m.len(), 2); assert_eq!(n.len(), 3); - for elt in 1i..3 { + for elt in 1..3 { assert_eq!(m.pop_front(), Some(elt)); } - for elt in 3i..6 { + for elt in 3..6 { assert_eq!(n.pop_front(), Some(elt)); } } // not singleton, backwards { - let u = vec![1i,2,3,4,5]; + let u = vec![1,2,3,4,5]; let mut m = list_from(u.as_slice()); let mut n = m.split_off(4); assert_eq!(m.len(), 4); assert_eq!(n.len(), 1); - for elt in 1i..5 { + for elt in 1..5 { assert_eq!(m.pop_front(), Some(elt)); } - for elt in 5i..6 { + for elt in 5..6 { assert_eq!(n.pop_front(), Some(elt)); } } @@ -1102,7 +1102,7 @@ mod tests { } let mut n = DList::new(); assert_eq!(n.iter().next(), None); - n.push_front(4i); + n.push_front(4); let mut it = n.iter(); assert_eq!(it.size_hint(), (1, Some(1))); assert_eq!(it.next().unwrap(), &4); @@ -1113,7 +1113,7 @@ mod tests { #[test] fn test_iterator_clone() { let mut n = DList::new(); - n.push_back(2i); + n.push_back(2); n.push_back(3); n.push_back(4); let mut it = n.iter(); @@ -1128,7 +1128,7 @@ mod tests { fn test_iterator_double_end() { let mut n = DList::new(); assert_eq!(n.iter().next(), None); - n.push_front(4i); + n.push_front(4); n.push_front(5); n.push_front(6); let mut it = n.iter(); @@ -1150,7 +1150,7 @@ mod tests { } let mut n = DList::new(); assert_eq!(n.iter().rev().next(), None); - n.push_front(4i); + n.push_front(4); let mut it = n.iter().rev(); assert_eq!(it.size_hint(), (1, Some(1))); assert_eq!(it.next().unwrap(), &4); @@ -1169,7 +1169,7 @@ mod tests { assert_eq!(len, 0); let mut n = DList::new(); assert!(n.iter_mut().next().is_none()); - n.push_front(4i); + n.push_front(4); n.push_back(5); let mut it = n.iter_mut(); assert_eq!(it.size_hint(), (2, Some(2))); @@ -1183,7 +1183,7 @@ mod tests { fn test_iterator_mut_double_end() { let mut n = DList::new(); assert!(n.iter_mut().next_back().is_none()); - n.push_front(4i); + n.push_front(4); n.push_front(5); n.push_front(6); let mut it = n.iter_mut(); @@ -1199,7 +1199,7 @@ mod tests { #[test] fn test_insert_prev() { - let mut m = list_from(&[0i,2,4,6,8]); + let mut m = list_from(&[0,2,4,6,8]); let len = m.len(); { let mut it = m.iter_mut(); @@ -1232,7 +1232,7 @@ mod tests { } let mut n = DList::new(); assert!(n.iter_mut().rev().next().is_none()); - n.push_front(4i); + n.push_front(4); let mut it = n.iter_mut().rev(); assert!(it.next().is_some()); assert!(it.next().is_none()); @@ -1240,7 +1240,7 @@ mod tests { #[test] fn test_send() { - let n = list_from(&[1i,2,3]); + let n = list_from(&[1,2,3]); Thread::scoped(move || { check_links(&n); let a: &[_] = &[&1,&2,&3]; @@ -1258,8 +1258,8 @@ mod tests { m.push_back(1); assert!(n == m); - let n = list_from(&[2i,3,4]); - let m = list_from(&[1i,2,3]); + let n = list_from(&[2,3,4]); + let m = list_from(&[1,2,3]); assert!(n != m); } @@ -1270,11 +1270,11 @@ mod tests { assert!(hash::hash::<_, SipHasher>(&x) == hash::hash::<_, SipHasher>(&y)); - x.push_back(1i); + x.push_back(1); x.push_back(2); x.push_back(3); - y.push_front(3i); + y.push_front(3); y.push_front(2); y.push_front(1); @@ -1284,7 +1284,7 @@ mod tests { #[test] fn test_ord() { let n: DList<int> = list_from(&[]); - let m = list_from(&[1i,2,3]); + let m = list_from(&[1,2,3]); assert!(n < m); assert!(m > n); assert!(n <= n); @@ -1334,7 +1334,7 @@ mod tests { #[test] fn test_show() { - let list: DList<int> = (0i..10).collect(); + let list: DList<i32> = (0..10).collect(); assert_eq!(format!("{:?}", list), "DList [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"); let list: DList<&str> = vec!["just", "one", "test", "more"].iter() @@ -1384,7 +1384,7 @@ mod tests { #[bench] fn bench_collect_into(b: &mut test::Bencher) { - let v = &[0i; 64]; + let v = &[0; 64]; b.iter(|| { let _: DList<int> = v.iter().map(|x| *x).collect(); }) @@ -1426,7 +1426,7 @@ mod tests { #[bench] fn bench_iter(b: &mut test::Bencher) { - let v = &[0i; 128]; + let v = &[0; 128]; let m: DList<int> = v.iter().map(|&x|x).collect(); b.iter(|| { assert!(m.iter().count() == 128); @@ -1434,7 +1434,7 @@ mod tests { } #[bench] fn bench_iter_mut(b: &mut test::Bencher) { - let v = &[0i; 128]; + let v = &[0; 128]; let mut m: DList<int> = v.iter().map(|&x|x).collect(); b.iter(|| { assert!(m.iter_mut().count() == 128); @@ -1442,7 +1442,7 @@ mod tests { } #[bench] fn bench_iter_rev(b: &mut test::Bencher) { - let v = &[0i; 128]; + let v = &[0; 128]; let m: DList<int> = v.iter().map(|&x|x).collect(); b.iter(|| { assert!(m.iter().rev().count() == 128); @@ -1450,7 +1450,7 @@ mod tests { } #[bench] fn bench_iter_mut_rev(b: &mut test::Bencher) { - let v = &[0i; 128]; + let v = &[0; 128]; let mut m: DList<int> = v.iter().map(|&x|x).collect(); b.iter(|| { assert!(m.iter_mut().rev().count() == 128); diff --git a/src/libcollections/ring_buf.rs b/src/libcollections/ring_buf.rs index 34910f59fe0..c1855a469c1 100644 --- a/src/libcollections/ring_buf.rs +++ b/src/libcollections/ring_buf.rs @@ -186,7 +186,7 @@ impl<T> RingBuf<T> { /// use std::collections::RingBuf; /// /// let mut buf = RingBuf::new(); - /// buf.push_back(3i); + /// buf.push_back(3); /// buf.push_back(4); /// buf.push_back(5); /// assert_eq!(buf.get(1).unwrap(), &4); @@ -209,7 +209,7 @@ impl<T> RingBuf<T> { /// use std::collections::RingBuf; /// /// let mut buf = RingBuf::new(); - /// buf.push_back(3i); + /// buf.push_back(3); /// buf.push_back(4); /// buf.push_back(5); /// match buf.get_mut(1) { @@ -243,7 +243,7 @@ impl<T> RingBuf<T> { /// use std::collections::RingBuf; /// /// let mut buf = RingBuf::new(); - /// buf.push_back(3i); + /// buf.push_back(3); /// buf.push_back(4); /// buf.push_back(5); /// buf.swap(0, 2); @@ -269,7 +269,7 @@ impl<T> RingBuf<T> { /// ``` /// use std::collections::RingBuf; /// - /// let buf: RingBuf<int> = RingBuf::with_capacity(10); + /// let buf: RingBuf<i32> = RingBuf::with_capacity(10); /// assert!(buf.capacity() >= 10); /// ``` #[inline] @@ -292,7 +292,7 @@ impl<T> RingBuf<T> { /// ``` /// use std::collections::RingBuf; /// - /// let mut buf: RingBuf<int> = vec![1].into_iter().collect(); + /// let mut buf: RingBuf<i32> = vec![1].into_iter().collect(); /// buf.reserve_exact(10); /// assert!(buf.capacity() >= 11); /// ``` @@ -313,7 +313,7 @@ impl<T> RingBuf<T> { /// ``` /// use std::collections::RingBuf; /// - /// let mut buf: RingBuf<int> = vec![1].into_iter().collect(); + /// let mut buf: RingBuf<i32> = vec![1].into_iter().collect(); /// buf.reserve(10); /// assert!(buf.capacity() >= 11); /// ``` @@ -473,8 +473,8 @@ impl<T> RingBuf<T> { /// use std::collections::RingBuf; /// /// let mut buf = RingBuf::new(); - /// buf.push_back(5i); - /// buf.push_back(10i); + /// buf.push_back(5); + /// buf.push_back(10); /// buf.push_back(15); /// buf.truncate(1); /// assert_eq!(buf.len(), 1); @@ -496,11 +496,11 @@ impl<T> RingBuf<T> { /// use std::collections::RingBuf; /// /// let mut buf = RingBuf::new(); - /// buf.push_back(5i); + /// buf.push_back(5); /// buf.push_back(3); /// buf.push_back(4); /// let b: &[_] = &[&5, &3, &4]; - /// assert_eq!(buf.iter().collect::<Vec<&int>>().as_slice(), b); + /// assert_eq!(buf.iter().collect::<Vec<&i32>>().as_slice(), b); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn iter(&self) -> Iter<T> { @@ -519,14 +519,14 @@ impl<T> RingBuf<T> { /// use std::collections::RingBuf; /// /// let mut buf = RingBuf::new(); - /// buf.push_back(5i); + /// buf.push_back(5); /// buf.push_back(3); /// buf.push_back(4); /// for num in buf.iter_mut() { /// *num = *num - 2; /// } /// let b: &[_] = &[&mut 3, &mut 1, &mut 2]; - /// assert_eq!(&buf.iter_mut().collect::<Vec<&mut int>>()[], b); + /// assert_eq!(&buf.iter_mut().collect::<Vec<&mut i32>>()[], b); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn iter_mut<'a>(&'a mut self) -> IterMut<'a, T> { @@ -600,7 +600,7 @@ impl<T> RingBuf<T> { /// /// let mut v = RingBuf::new(); /// assert_eq!(v.len(), 0); - /// v.push_back(1i); + /// v.push_back(1); /// assert_eq!(v.len(), 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -615,7 +615,7 @@ impl<T> RingBuf<T> { /// /// let mut v = RingBuf::new(); /// assert!(v.is_empty()); - /// v.push_front(1i); + /// v.push_front(1); /// assert!(!v.is_empty()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -630,7 +630,7 @@ impl<T> RingBuf<T> { /// use std::collections::RingBuf; /// /// let mut v = RingBuf::new(); - /// v.push_back(1i); + /// v.push_back(1); /// assert_eq!(v.drain().next(), Some(1)); /// assert!(v.is_empty()); /// ``` @@ -651,7 +651,7 @@ impl<T> RingBuf<T> { /// use std::collections::RingBuf; /// /// let mut v = RingBuf::new(); - /// v.push_back(1i); + /// v.push_back(1); /// v.clear(); /// assert!(v.is_empty()); /// ``` @@ -672,9 +672,9 @@ impl<T> RingBuf<T> { /// let mut d = RingBuf::new(); /// assert_eq!(d.front(), None); /// - /// d.push_back(1i); - /// d.push_back(2i); - /// assert_eq!(d.front(), Some(&1i)); + /// d.push_back(1); + /// d.push_back(2); + /// assert_eq!(d.front(), Some(&1)); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn front(&self) -> Option<&T> { @@ -692,13 +692,13 @@ impl<T> RingBuf<T> { /// let mut d = RingBuf::new(); /// assert_eq!(d.front_mut(), None); /// - /// d.push_back(1i); - /// d.push_back(2i); + /// d.push_back(1); + /// d.push_back(2); /// match d.front_mut() { - /// Some(x) => *x = 9i, + /// Some(x) => *x = 9, /// None => (), /// } - /// assert_eq!(d.front(), Some(&9i)); + /// assert_eq!(d.front(), Some(&9)); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn front_mut(&mut self) -> Option<&mut T> { @@ -716,9 +716,9 @@ impl<T> RingBuf<T> { /// let mut d = RingBuf::new(); /// assert_eq!(d.back(), None); /// - /// d.push_back(1i); - /// d.push_back(2i); - /// assert_eq!(d.back(), Some(&2i)); + /// d.push_back(1); + /// d.push_back(2); + /// assert_eq!(d.back(), Some(&2)); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn back(&self) -> Option<&T> { @@ -736,13 +736,13 @@ impl<T> RingBuf<T> { /// let mut d = RingBuf::new(); /// assert_eq!(d.back(), None); /// - /// d.push_back(1i); - /// d.push_back(2i); + /// d.push_back(1); + /// d.push_back(2); /// match d.back_mut() { - /// Some(x) => *x = 9i, + /// Some(x) => *x = 9, /// None => (), /// } - /// assert_eq!(d.back(), Some(&9i)); + /// assert_eq!(d.back(), Some(&9)); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn back_mut(&mut self) -> Option<&mut T> { @@ -759,11 +759,11 @@ impl<T> RingBuf<T> { /// use std::collections::RingBuf; /// /// let mut d = RingBuf::new(); - /// d.push_back(1i); - /// d.push_back(2i); + /// d.push_back(1); + /// d.push_back(2); /// - /// assert_eq!(d.pop_front(), Some(1i)); - /// assert_eq!(d.pop_front(), Some(2i)); + /// assert_eq!(d.pop_front(), Some(1)); + /// assert_eq!(d.pop_front(), Some(2)); /// assert_eq!(d.pop_front(), None); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -785,9 +785,9 @@ impl<T> RingBuf<T> { /// use std::collections::RingBuf; /// /// let mut d = RingBuf::new(); - /// d.push_front(1i); - /// d.push_front(2i); - /// assert_eq!(d.front(), Some(&2i)); + /// d.push_front(1); + /// d.push_front(2); + /// assert_eq!(d.front(), Some(&2)); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn push_front(&mut self, t: T) { @@ -809,7 +809,7 @@ impl<T> RingBuf<T> { /// use std::collections::RingBuf; /// /// let mut buf = RingBuf::new(); - /// buf.push_back(1i); + /// buf.push_back(1); /// buf.push_back(3); /// assert_eq!(3, *buf.back().unwrap()); /// ``` @@ -835,7 +835,7 @@ impl<T> RingBuf<T> { /// /// let mut buf = RingBuf::new(); /// assert_eq!(buf.pop_back(), None); - /// buf.push_back(1i); + /// buf.push_back(1); /// buf.push_back(3); /// assert_eq!(buf.pop_back(), Some(3)); /// ``` @@ -869,7 +869,7 @@ impl<T> RingBuf<T> { /// /// let mut buf = RingBuf::new(); /// assert_eq!(buf.swap_back_remove(0), None); - /// buf.push_back(5i); + /// buf.push_back(5); /// buf.push_back(99); /// buf.push_back(15); /// buf.push_back(20); @@ -902,11 +902,11 @@ impl<T> RingBuf<T> { /// /// let mut buf = RingBuf::new(); /// assert_eq!(buf.swap_front_remove(0), None); - /// buf.push_back(15i); + /// buf.push_back(15); /// buf.push_back(5); /// buf.push_back(10); /// buf.push_back(99); - /// buf.push_back(20i); + /// buf.push_back(20); /// assert_eq!(buf.swap_front_remove(3), Some(99)); /// ``` #[unstable(feature = "collections", @@ -934,7 +934,7 @@ impl<T> RingBuf<T> { /// use std::collections::RingBuf; /// /// let mut buf = RingBuf::new(); - /// buf.push_back(10i); + /// buf.push_back(10); /// buf.push_back(12); /// buf.insert(1,11); /// assert_eq!(Some(&11), buf.get(1)); @@ -1136,9 +1136,9 @@ impl<T> RingBuf<T> { /// use std::collections::RingBuf; /// /// let mut buf = RingBuf::new(); - /// buf.push_back(5i); - /// buf.push_back(10i); - /// buf.push_back(12i); + /// buf.push_back(5); + /// buf.push_back(10); + /// buf.push_back(12); /// buf.push_back(15); /// buf.remove(2); /// assert_eq!(Some(&15), buf.get(2)); @@ -1301,8 +1301,8 @@ impl<T: Clone> RingBuf<T> { /// use std::collections::RingBuf; /// /// let mut buf = RingBuf::new(); - /// buf.push_back(5i); - /// buf.push_back(10i); + /// buf.push_back(5); + /// buf.push_back(10); /// buf.push_back(15); /// buf.resize(2, 0); /// buf.resize(6, 20); @@ -1650,8 +1650,8 @@ mod tests { fn test_simple() { let mut d = RingBuf::new(); assert_eq!(d.len(), 0u); - d.push_front(17i); - d.push_front(42i); + d.push_front(17); + d.push_front(42); d.push_back(137); assert_eq!(d.len(), 3u); d.push_back(137); @@ -1769,7 +1769,7 @@ mod tests { fn bench_push_back_100(b: &mut test::Bencher) { let mut deq = RingBuf::with_capacity(101); b.iter(|| { - for i in 0i..100 { + for i in 0..100 { deq.push_back(i); } deq.head = 0; @@ -1781,7 +1781,7 @@ mod tests { fn bench_push_front_100(b: &mut test::Bencher) { let mut deq = RingBuf::with_capacity(101); b.iter(|| { - for i in 0i..100 { + for i in 0..100 { deq.push_front(i); } deq.head = 0; @@ -1791,7 +1791,7 @@ mod tests { #[bench] fn bench_pop_back_100(b: &mut test::Bencher) { - let mut deq: RingBuf<int> = RingBuf::with_capacity(101); + let mut deq: RingBuf<i32> = RingBuf::with_capacity(101); b.iter(|| { deq.head = 100; @@ -1804,7 +1804,7 @@ mod tests { #[bench] fn bench_pop_front_100(b: &mut test::Bencher) { - let mut deq: RingBuf<int> = RingBuf::with_capacity(101); + let mut deq: RingBuf<i32> = RingBuf::with_capacity(101); b.iter(|| { deq.head = 100; @@ -1819,7 +1819,7 @@ mod tests { fn bench_grow_1025(b: &mut test::Bencher) { b.iter(|| { let mut deq = RingBuf::new(); - for i in 0i..1025 { + for i in 0..1025 { deq.push_front(i); } test::black_box(deq); @@ -1828,7 +1828,7 @@ mod tests { #[bench] fn bench_iter_1000(b: &mut test::Bencher) { - let ring: RingBuf<int> = (0i..1000).collect(); + let ring: RingBuf<i32> = (0..1000).collect(); b.iter(|| { let mut sum = 0; @@ -1841,7 +1841,7 @@ mod tests { #[bench] fn bench_mut_iter_1000(b: &mut test::Bencher) { - let mut ring: RingBuf<int> = (0i..1000).collect(); + let mut ring: RingBuf<i32> = (0..1000).collect(); b.iter(|| { let mut sum = 0; @@ -1854,28 +1854,28 @@ mod tests { #[derive(Clone, PartialEq, Debug)] enum Taggy { - One(int), - Two(int, int), - Three(int, int, int), + One(i32), + Two(i32, i32), + Three(i32, i32, i32), } #[derive(Clone, PartialEq, Debug)] enum Taggypar<T> { - Onepar(int), - Twopar(int, int), - Threepar(int, int, int), + Onepar(i32), + Twopar(i32, i32), + Threepar(i32, i32, i32), } #[derive(Clone, PartialEq, Debug)] struct RecCy { - x: int, - y: int, + x: i32, + y: i32, t: Taggy } #[test] fn test_param_int() { - test_parameterized::<int>(5, 72, 64, 175); + test_parameterized::<i32>(5, 72, 64, 175); } #[test] @@ -1885,10 +1885,10 @@ mod tests { #[test] fn test_param_taggypar() { - test_parameterized::<Taggypar<int>>(Onepar::<int>(1), - Twopar::<int>(1, 2), - Threepar::<int>(1, 2, 3), - Twopar::<int>(17, 42)); + test_parameterized::<Taggypar<i32>>(Onepar::<i32>(1), + Twopar::<i32>(1, 2), + Threepar::<i32>(1, 2, 3), + Twopar::<i32>(17, 42)); } #[test] @@ -1903,17 +1903,17 @@ mod tests { #[test] fn test_with_capacity() { let mut d = RingBuf::with_capacity(0); - d.push_back(1i); + d.push_back(1); assert_eq!(d.len(), 1); let mut d = RingBuf::with_capacity(50); - d.push_back(1i); + d.push_back(1); assert_eq!(d.len(), 1); } #[test] fn test_with_capacity_non_power_two() { let mut d3 = RingBuf::with_capacity(3); - d3.push_back(1i); + d3.push_back(1); // X = None, | = lo // [|1, X, X] @@ -1977,10 +1977,10 @@ mod tests { #[test] fn test_swap() { - let mut d: RingBuf<int> = (0i..5).collect(); + let mut d: RingBuf<i32> = (0..5).collect(); d.pop_front(); d.swap(0, 3); - assert_eq!(d.iter().map(|&x|x).collect::<Vec<int>>(), vec!(4, 2, 3, 1)); + assert_eq!(d.iter().map(|&x|x).collect::<Vec<i32>>(), vec!(4, 2, 3, 1)); } #[test] @@ -1989,20 +1989,20 @@ mod tests { assert_eq!(d.iter().next(), None); assert_eq!(d.iter().size_hint(), (0, Some(0))); - for i in 0i..5 { + for i in 0..5 { d.push_back(i); } { let b: &[_] = &[&0,&1,&2,&3,&4]; - assert_eq!(d.iter().collect::<Vec<&int>>(), b); + assert_eq!(d.iter().collect::<Vec<&i32>>(), b); } - for i in 6i..9 { + for i in 6..9 { d.push_front(i); } { let b: &[_] = &[&8,&7,&6,&0,&1,&2,&3,&4]; - assert_eq!(d.iter().collect::<Vec<&int>>(), b); + assert_eq!(d.iter().collect::<Vec<&i32>>(), b); } let mut it = d.iter(); @@ -2020,19 +2020,19 @@ mod tests { let mut d = RingBuf::new(); assert_eq!(d.iter().rev().next(), None); - for i in 0i..5 { + for i in 0..5 { d.push_back(i); } { let b: &[_] = &[&4,&3,&2,&1,&0]; - assert_eq!(d.iter().rev().collect::<Vec<&int>>(), b); + assert_eq!(d.iter().rev().collect::<Vec<&i32>>(), b); } - for i in 6i..9 { + for i in 6..9 { d.push_front(i); } let b: &[_] = &[&4,&3,&2,&1,&0,&6,&7,&8]; - assert_eq!(d.iter().rev().collect::<Vec<&int>>(), b); + assert_eq!(d.iter().rev().collect::<Vec<&i32>>(), b); } #[test] @@ -2040,13 +2040,13 @@ mod tests { let mut d = RingBuf::with_capacity(3); assert!(d.iter_mut().rev().next().is_none()); - d.push_back(1i); + d.push_back(1); d.push_back(2); d.push_back(3); assert_eq!(d.pop_front(), Some(1)); d.push_back(4); - assert_eq!(d.iter_mut().rev().map(|x| *x).collect::<Vec<int>>(), + assert_eq!(d.iter_mut().rev().map(|x| *x).collect::<Vec<i32>>(), vec!(4, 3, 2)); } @@ -2101,7 +2101,7 @@ mod tests { // Empty iter { - let d: RingBuf<int> = RingBuf::new(); + let d: RingBuf<i32> = RingBuf::new(); let mut iter = d.into_iter(); assert_eq!(iter.size_hint(), (0, Some(0))); @@ -2112,35 +2112,35 @@ mod tests { // simple iter { let mut d = RingBuf::new(); - for i in 0i..5 { + for i in 0..5 { d.push_back(i); } let b = vec![0,1,2,3,4]; - assert_eq!(d.into_iter().collect::<Vec<int>>(), b); + assert_eq!(d.into_iter().collect::<Vec<i32>>(), b); } // wrapped iter { let mut d = RingBuf::new(); - for i in 0i..5 { + for i in 0..5 { d.push_back(i); } - for i in 6i..9 { + for i in 6..9 { d.push_front(i); } let b = vec![8,7,6,0,1,2,3,4]; - assert_eq!(d.into_iter().collect::<Vec<int>>(), b); + assert_eq!(d.into_iter().collect::<Vec<i32>>(), b); } // partially used { let mut d = RingBuf::new(); - for i in 0i..5 { + for i in 0..5 { d.push_back(i); } - for i in 6i..9 { + for i in 6..9 { d.push_front(i); } @@ -2160,7 +2160,7 @@ mod tests { // Empty iter { - let mut d: RingBuf<int> = RingBuf::new(); + let mut d: RingBuf<i32> = RingBuf::new(); { let mut iter = d.drain(); @@ -2176,32 +2176,32 @@ mod tests { // simple iter { let mut d = RingBuf::new(); - for i in 0i..5 { + for i in 0..5 { d.push_back(i); } - assert_eq!(d.drain().collect::<Vec<int>>(), [0, 1, 2, 3, 4]); + assert_eq!(d.drain().collect::<Vec<i32>>(), [0, 1, 2, 3, 4]); assert!(d.is_empty()); } // wrapped iter { let mut d = RingBuf::new(); - for i in 0i..5 { + for i in 0..5 { d.push_back(i); } for i in 6i..9 { d.push_front(i); } - assert_eq!(d.drain().collect::<Vec<int>>(), [8,7,6,0,1,2,3,4]); + assert_eq!(d.drain().collect::<Vec<i32>>(), [8,7,6,0,1,2,3,4]); assert!(d.is_empty()); } // partially used { let mut d = RingBuf::new(); - for i in 0i..5 { + for i in 0..5 { d.push_back(i); } for i in 6i..9 { @@ -2225,9 +2225,9 @@ mod tests { #[test] fn test_from_iter() { use core::iter; - let v = vec!(1i,2,3,4,5,6,7); - let deq: RingBuf<int> = v.iter().map(|&x| x).collect(); - let u: Vec<int> = deq.iter().map(|&x| x).collect(); + let v = vec!(1,2,3,4,5,6,7); + let deq: RingBuf<i32> = v.iter().map(|&x| x).collect(); + let u: Vec<i32> = deq.iter().map(|&x| x).collect(); assert_eq!(u, v); let seq = iter::count(0u, 2).take(256); @@ -2241,7 +2241,7 @@ mod tests { #[test] fn test_clone() { let mut d = RingBuf::new(); - d.push_front(17i); + d.push_front(17); d.push_front(42); d.push_back(137); d.push_back(137); @@ -2259,7 +2259,7 @@ mod tests { fn test_eq() { let mut d = RingBuf::new(); assert!(d == RingBuf::with_capacity(0)); - d.push_front(137i); + d.push_front(137); d.push_front(17); d.push_front(42); d.push_back(137); @@ -2281,12 +2281,12 @@ mod tests { let mut x = RingBuf::new(); let mut y = RingBuf::new(); - x.push_back(1i); + x.push_back(1); x.push_back(2); x.push_back(3); - y.push_back(0i); - y.push_back(1i); + y.push_back(0); + y.push_back(1); y.pop_front(); y.push_back(2); y.push_back(3); @@ -2298,7 +2298,7 @@ mod tests { fn test_ord() { let x = RingBuf::new(); let mut y = RingBuf::new(); - y.push_back(1i); + y.push_back(1); y.push_back(2); y.push_back(3); assert!(x < y); @@ -2309,7 +2309,7 @@ mod tests { #[test] fn test_show() { - let ringbuf: RingBuf<int> = (0i..10).collect(); + let ringbuf: RingBuf<i32> = (0..10).collect(); assert_eq!(format!("{:?}", ringbuf), "RingBuf [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]"); let ringbuf: RingBuf<&str> = vec!["just", "one", "test", "more"].iter() @@ -2389,41 +2389,41 @@ mod tests { // test growth path A // [T o o H] -> [T o o H . . . . ] let mut ring = RingBuf::with_capacity(4); - for i in 0i..3 { + for i in 0..3 { ring.push_back(i); } ring.reserve(7); - for i in 0i..3 { + for i in 0..3 { assert_eq!(ring.pop_front(), Some(i)); } // test growth path B // [H T o o] -> [. T o o H . . . ] let mut ring = RingBuf::with_capacity(4); - for i in 0i..1 { + for i in 0..1 { ring.push_back(i); assert_eq!(ring.pop_front(), Some(i)); } - for i in 0i..3 { + for i in 0..3 { ring.push_back(i); } ring.reserve(7); - for i in 0i..3 { + for i in 0..3 { assert_eq!(ring.pop_front(), Some(i)); } // test growth path C // [o o H T] -> [o o H . . . . T ] let mut ring = RingBuf::with_capacity(4); - for i in 0i..3 { + for i in 0..3 { ring.push_back(i); assert_eq!(ring.pop_front(), Some(i)); } - for i in 0i..3 { + for i in 0..3 { ring.push_back(i); } ring.reserve(7); - for i in 0i..3 { + for i in 0..3 { assert_eq!(ring.pop_front(), Some(i)); } } @@ -2431,7 +2431,7 @@ mod tests { #[test] fn test_get() { let mut ring = RingBuf::new(); - ring.push_back(0i); + ring.push_back(0); assert_eq!(ring.get(0), Some(&0)); assert_eq!(ring.get(1), None); @@ -2463,7 +2463,7 @@ mod tests { #[test] fn test_get_mut() { let mut ring = RingBuf::new(); - for i in 0i..3 { + for i in 0..3 { ring.push_back(i); } @@ -2633,8 +2633,8 @@ mod tests { #[test] fn test_front() { let mut ring = RingBuf::new(); - ring.push_back(10i); - ring.push_back(20i); + ring.push_back(10); + ring.push_back(20); assert_eq!(ring.front(), Some(&10)); ring.pop_front(); assert_eq!(ring.front(), Some(&20)); @@ -2644,7 +2644,7 @@ mod tests { #[test] fn test_as_slices() { - let mut ring: RingBuf<int> = RingBuf::with_capacity(127); + let mut ring: RingBuf<i32> = RingBuf::with_capacity(127); let cap = ring.capacity() as int; let first = cap/2; let last = cap - first; @@ -2672,7 +2672,7 @@ mod tests { #[test] fn test_as_mut_slices() { - let mut ring: RingBuf<int> = RingBuf::with_capacity(127); + let mut ring: RingBuf<i32> = RingBuf::with_capacity(127); let cap = ring.capacity() as int; let first = cap/2; let last = cap - first; diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs index ba1be09934f..3813edf790b 100644 --- a/src/libcollections/slice.rs +++ b/src/libcollections/slice.rs @@ -15,7 +15,7 @@ //! //! ```rust //! // slicing a Vec -//! let vec = vec!(1i, 2, 3); +//! let vec = vec!(1, 2, 3); //! let int_slice = vec.as_slice(); //! // coercing an array to a slice //! let str_slice: &[&str] = &["one", "two", "three"]; @@ -26,7 +26,7 @@ //! block of memory that a mutable slice points to: //! //! ```rust -//! let x: &mut[int] = &mut [1i, 2, 3]; +//! let x: &mut[int] = &mut [1, 2, 3]; //! x[1] = 7; //! assert_eq!(x[0], 1); //! assert_eq!(x[1], 7); @@ -54,9 +54,9 @@ //! ```rust //! #![feature(slicing_syntax)] //! fn main() { -//! let numbers = [0i, 1i, 2i]; +//! let numbers = [0, 1, 2]; //! let last_numbers = &numbers[1..3]; -//! // last_numbers is now &[1i, 2i] +//! // last_numbers is now &[1, 2] //! } //! ``` //! @@ -76,7 +76,7 @@ //! type of the slice is `int`, the element type of the iterator is `&int`. //! //! ```rust -//! let numbers = [0i, 1i, 2i]; +//! let numbers = [0, 1, 2]; //! for &x in numbers.iter() { //! println!("{} is a number!", x); //! } @@ -134,7 +134,7 @@ pub trait SliceExt { /// # Examples /// /// ```rust - /// let mut v = [5i, 4, 1, 3, 2]; + /// let mut v = [5, 4, 1, 3, 2]; /// v.sort_by(|a, b| a.cmp(b)); /// assert!(v == [1, 2, 3, 4, 5]); /// @@ -160,11 +160,11 @@ pub trait SliceExt { /// # Examples /// /// ```rust - /// let mut a = [1i, 2, 3, 4, 5]; - /// let b = vec![6i, 7, 8]; + /// let mut a = [1, 2, 3, 4, 5]; + /// let b = vec![6, 7, 8]; /// let num_moved = a.move_from(b, 0, 3); /// assert_eq!(num_moved, 3); - /// assert!(a == [6i, 7, 8, 4, 5]); + /// assert!(a == [6, 7, 8, 4, 5]); /// ``` #[unstable(feature = "collections", reason = "uncertain about this API approach")] @@ -282,7 +282,7 @@ pub trait SliceExt { /// `[3,4]`): /// /// ```rust - /// let v = &[1i, 2, 3, 4]; + /// let v = &[1, 2, 3, 4]; /// for win in v.windows(2) { /// println!("{:?}", win); /// } @@ -305,7 +305,7 @@ pub trait SliceExt { /// `[3,4]`, `[5]`): /// /// ```rust - /// let v = &[1i, 2, 3, 4, 5]; + /// let v = &[1, 2, 3, 4, 5]; /// for win in v.chunks(2) { /// println!("{:?}", win); /// } @@ -396,7 +396,7 @@ pub trait SliceExt { /// found; the fourth could match any position in `[1,4]`. /// /// ```rust - /// let s = [0i, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]; + /// let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]; /// let s = s.as_slice(); /// /// let seek = 13; @@ -418,7 +418,7 @@ pub trait SliceExt { /// # Example /// /// ``` - /// let a = [1i, 2, 3]; + /// let a = [1, 2, 3]; /// assert_eq!(a.len(), 3); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -429,7 +429,7 @@ pub trait SliceExt { /// # Example /// /// ``` - /// let a = [1i, 2, 3]; + /// let a = [1, 2, 3]; /// assert!(!a.is_empty()); /// ``` #[inline] @@ -551,24 +551,24 @@ pub trait SliceExt { /// # Example /// /// ```rust - /// let mut v = [1i, 2, 3, 4, 5, 6]; + /// let mut v = [1, 2, 3, 4, 5, 6]; /// /// // scoped to restrict the lifetime of the borrows /// { /// let (left, right) = v.split_at_mut(0); /// assert!(left == []); - /// assert!(right == [1i, 2, 3, 4, 5, 6]); + /// assert!(right == [1, 2, 3, 4, 5, 6]); /// } /// /// { /// let (left, right) = v.split_at_mut(2); - /// assert!(left == [1i, 2]); - /// assert!(right == [3i, 4, 5, 6]); + /// assert!(left == [1, 2]); + /// assert!(right == [3, 4, 5, 6]); /// } /// /// { /// let (left, right) = v.split_at_mut(6); - /// assert!(left == [1i, 2, 3, 4, 5, 6]); + /// assert!(left == [1, 2, 3, 4, 5, 6]); /// assert!(right == []); /// } /// ``` @@ -580,9 +580,9 @@ pub trait SliceExt { /// # Example /// /// ```rust - /// let mut v = [1i, 2, 3]; + /// let mut v = [1, 2, 3]; /// v.reverse(); - /// assert!(v == [3i, 2, 1]); + /// assert!(v == [3, 2, 1]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn reverse(&mut self); @@ -612,7 +612,7 @@ pub trait SliceExt { /// # Examples /// /// ```rust - /// let v = [1i, 2, 3]; + /// let v = [1, 2, 3]; /// let mut perms = v.permutations(); /// /// for p in perms { @@ -623,12 +623,12 @@ pub trait SliceExt { /// Iterating through permutations one by one. /// /// ```rust - /// let v = [1i, 2, 3]; + /// let v = [1, 2, 3]; /// let mut perms = v.permutations(); /// - /// assert_eq!(Some(vec![1i, 2, 3]), perms.next()); - /// assert_eq!(Some(vec![1i, 3, 2]), perms.next()); - /// assert_eq!(Some(vec![3i, 1, 2]), perms.next()); + /// assert_eq!(Some(vec![1, 2, 3]), perms.next()); + /// assert_eq!(Some(vec![1, 3, 2]), perms.next()); + /// assert_eq!(Some(vec![3, 1, 2]), perms.next()); /// ``` #[unstable(feature = "collections")] fn permutations(&self) -> Permutations<Self::Item> where Self::Item: Clone; @@ -640,15 +640,15 @@ pub trait SliceExt { /// # Example /// /// ```rust - /// let mut dst = [0i, 0, 0]; - /// let src = [1i, 2]; + /// let mut dst = [0, 0, 0]; + /// let src = [1, 2]; /// /// assert!(dst.clone_from_slice(&src) == 2); /// assert!(dst == [1, 2, 0]); /// - /// let src2 = [3i, 4, 5, 6]; + /// let src2 = [3, 4, 5, 6]; /// assert!(dst.clone_from_slice(&src2) == 3); - /// assert!(dst == [3i, 4, 5]); + /// assert!(dst == [3, 4, 5]); /// ``` #[unstable(feature = "collections")] fn clone_from_slice(&mut self, &[Self::Item]) -> uint where Self::Item: Clone; @@ -660,10 +660,10 @@ pub trait SliceExt { /// # Examples /// /// ```rust - /// let mut v = [-5i, 4, 1, -3, 2]; + /// let mut v = [-5, 4, 1, -3, 2]; /// /// v.sort(); - /// assert!(v == [-5i, -3, 1, 2, 4]); + /// assert!(v == [-5, -3, 1, 2, 4]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] fn sort(&mut self) where Self::Item: Ord; @@ -682,7 +682,7 @@ pub trait SliceExt { /// found; the fourth could match any position in `[1,4]`. /// /// ```rust - /// let s = [0i, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]; + /// let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55]; /// let s = s.as_slice(); /// /// assert_eq!(s.binary_search(&13), Ok(9)); @@ -709,12 +709,12 @@ pub trait SliceExt { /// # Example /// /// ```rust - /// let v: &mut [_] = &mut [0i, 1, 2]; + /// let v: &mut [_] = &mut [0, 1, 2]; /// v.next_permutation(); - /// let b: &mut [_] = &mut [0i, 2, 1]; + /// let b: &mut [_] = &mut [0, 2, 1]; /// assert!(v == b); /// v.next_permutation(); - /// let b: &mut [_] = &mut [1i, 0, 2]; + /// let b: &mut [_] = &mut [1, 0, 2]; /// assert!(v == b); /// ``` #[unstable(feature = "collections", @@ -729,12 +729,12 @@ pub trait SliceExt { /// # Example /// /// ```rust - /// let v: &mut [_] = &mut [1i, 0, 2]; + /// let v: &mut [_] = &mut [1, 0, 2]; /// v.prev_permutation(); - /// let b: &mut [_] = &mut [0i, 2, 1]; + /// let b: &mut [_] = &mut [0, 2, 1]; /// assert!(v == b); /// v.prev_permutation(); - /// let b: &mut [_] = &mut [0i, 1, 2]; + /// let b: &mut [_] = &mut [0, 1, 2]; /// assert!(v == b); /// ``` #[unstable(feature = "collections", @@ -1576,7 +1576,7 @@ mod tests { fn test_is_empty() { let xs: [int; 0] = []; assert!(xs.is_empty()); - assert!(![0i].is_empty()); + assert!(![0].is_empty()); } #[test] @@ -1593,11 +1593,11 @@ mod tests { #[test] fn test_get() { - let mut a = vec![11i]; + let mut a = vec![11]; assert_eq!(a.get(1), None); - a = vec![11i, 12]; + a = vec![11, 12]; assert_eq!(a.get(1).unwrap(), &12); - a = vec![11i, 12, 13]; + a = vec![11, 12, 13]; assert_eq!(a.get(1).unwrap(), &12); } @@ -1605,9 +1605,9 @@ mod tests { fn test_first() { let mut a = vec![]; assert_eq!(a.first(), None); - a = vec![11i]; + a = vec![11]; assert_eq!(a.first().unwrap(), &11); - a = vec![11i, 12]; + a = vec![11, 12]; assert_eq!(a.first().unwrap(), &11); } @@ -1615,28 +1615,28 @@ mod tests { fn test_first_mut() { let mut a = vec![]; assert_eq!(a.first_mut(), None); - a = vec![11i]; + a = vec![11]; assert_eq!(*a.first_mut().unwrap(), 11); - a = vec![11i, 12]; + a = vec![11, 12]; assert_eq!(*a.first_mut().unwrap(), 11); } #[test] fn test_tail() { - let mut a = vec![11i]; + let mut a = vec![11]; let b: &[int] = &[]; assert_eq!(a.tail(), b); - a = vec![11i, 12]; + a = vec![11, 12]; let b: &[int] = &[12]; assert_eq!(a.tail(), b); } #[test] fn test_tail_mut() { - let mut a = vec![11i]; + let mut a = vec![11]; let b: &mut [int] = &mut []; assert!(a.tail_mut() == b); - a = vec![11i, 12]; + a = vec![11, 12]; let b: &mut [int] = &mut [12]; assert!(a.tail_mut() == b); } @@ -1657,20 +1657,20 @@ mod tests { #[test] fn test_init() { - let mut a = vec![11i]; + let mut a = vec![11]; let b: &[int] = &[]; assert_eq!(a.init(), b); - a = vec![11i, 12]; + a = vec![11, 12]; let b: &[int] = &[11]; assert_eq!(a.init(), b); } #[test] fn test_init_mut() { - let mut a = vec![11i]; + let mut a = vec![11]; let b: &mut [int] = &mut []; assert!(a.init_mut() == b); - a = vec![11i, 12]; + a = vec![11, 12]; let b: &mut [int] = &mut [11]; assert!(a.init_mut() == b); } @@ -1693,9 +1693,9 @@ mod tests { fn test_last() { let mut a = vec![]; assert_eq!(a.last(), None); - a = vec![11i]; + a = vec![11]; assert_eq!(a.last().unwrap(), &11); - a = vec![11i, 12]; + a = vec![11, 12]; assert_eq!(a.last().unwrap(), &12); } @@ -1703,16 +1703,16 @@ mod tests { fn test_last_mut() { let mut a = vec![]; assert_eq!(a.last_mut(), None); - a = vec![11i]; + a = vec![11]; assert_eq!(*a.last_mut().unwrap(), 11); - a = vec![11i, 12]; + a = vec![11, 12]; assert_eq!(*a.last_mut().unwrap(), 12); } #[test] fn test_slice() { // Test fixed length vector. - let vec_fixed = [1i, 2, 3, 4]; + let vec_fixed = [1, 2, 3, 4]; let v_a = vec_fixed[1u..vec_fixed.len()].to_vec(); assert_eq!(v_a.len(), 3u); let v_a = v_a.as_slice(); @@ -1721,7 +1721,7 @@ mod tests { assert_eq!(v_a[2], 4); // Test on stack. - let vec_stack: &[_] = &[1i, 2, 3]; + let vec_stack: &[_] = &[1, 2, 3]; let v_b = vec_stack[1u..3u].to_vec(); assert_eq!(v_b.len(), 2u); let v_b = v_b.as_slice(); @@ -1729,7 +1729,7 @@ mod tests { assert_eq!(v_b[1], 3); // Test `Box<[T]>` - let vec_unique = vec![1i, 2, 3, 4, 5, 6]; + let vec_unique = vec![1, 2, 3, 4, 5, 6]; let v_d = vec_unique[1u..6u].to_vec(); assert_eq!(v_d.len(), 5u); let v_d = v_d.as_slice(); @@ -1763,7 +1763,7 @@ mod tests { #[test] fn test_pop() { - let mut v = vec![5i]; + let mut v = vec![5]; let e = v.pop(); assert_eq!(v.len(), 0); assert_eq!(e, Some(5)); @@ -1775,19 +1775,19 @@ mod tests { #[test] fn test_swap_remove() { - let mut v = vec![1i, 2, 3, 4, 5]; + let mut v = vec![1, 2, 3, 4, 5]; let mut e = v.swap_remove(0); assert_eq!(e, 1); - assert_eq!(v, vec![5i, 2, 3, 4]); + assert_eq!(v, vec![5, 2, 3, 4]); e = v.swap_remove(3); assert_eq!(e, 4); - assert_eq!(v, vec![5i, 2, 3]); + assert_eq!(v, vec![5, 2, 3]); } #[test] #[should_fail] fn test_swap_remove_fail() { - let mut v = vec![1i]; + let mut v = vec![1]; let _ = v.swap_remove(0); let _ = v.swap_remove(0); } @@ -1811,12 +1811,12 @@ mod tests { fn test_push() { // Test on-stack push(). let mut v = vec![]; - v.push(1i); + v.push(1); assert_eq!(v.len(), 1u); assert_eq!(v.as_slice()[0], 1); // Test on-heap push(). - v.push(2i); + v.push(2); assert_eq!(v.len(), 2u); assert_eq!(v.as_slice()[0], 1); assert_eq!(v.as_slice()[1], 2); @@ -1824,7 +1824,7 @@ mod tests { #[test] fn test_truncate() { - let mut v = vec![box 6i,box 5,box 4]; + let mut v = vec![box 6,box 5,box 4]; v.truncate(1); let v = v.as_slice(); assert_eq!(v.len(), 1); @@ -1834,7 +1834,7 @@ mod tests { #[test] fn test_clear() { - let mut v = vec![box 6i,box 5,box 4]; + let mut v = vec![box 6,box 5,box 4]; v.clear(); assert_eq!(v.len(), 0); // If the unsafe block didn't drop things properly, we blow up here. @@ -1859,11 +1859,11 @@ mod tests { #[test] fn test_dedup_unique() { - let mut v0 = vec![box 1i, box 1, box 2, box 3]; + let mut v0 = vec![box 1, box 1, box 2, box 3]; v0.dedup(); - let mut v1 = vec![box 1i, box 2, box 2, box 3]; + let mut v1 = vec![box 1, box 2, box 2, box 3]; v1.dedup(); - let mut v2 = vec![box 1i, box 2, box 3, box 3]; + let mut v2 = vec![box 1, box 2, box 3, box 3]; v2.dedup(); /* * If the boxed pointers were leaked or otherwise misused, valgrind @@ -1873,11 +1873,11 @@ mod tests { #[test] fn test_dedup_shared() { - let mut v0 = vec![box 1i, box 1, box 2, box 3]; + let mut v0 = vec![box 1, box 1, box 2, box 3]; v0.dedup(); - let mut v1 = vec![box 1i, box 2, box 2, box 3]; + let mut v1 = vec![box 1, box 2, box 2, box 3]; v1.dedup(); - let mut v2 = vec![box 1i, box 2, box 3, box 3]; + let mut v2 = vec![box 1, box 2, box 3, box 3]; v2.dedup(); /* * If the pointers were leaked or otherwise misused, valgrind and/or @@ -1894,7 +1894,7 @@ mod tests { #[test] fn test_element_swaps() { - let mut v = [1i, 2, 3]; + let mut v = [1, 2, 3]; for (i, (a, b)) in ElementSwaps::new(v.len()).enumerate() { v.swap(a, b); match i { @@ -1930,7 +1930,7 @@ mod tests { assert_eq!(it.next(), None); } { - let v = [1i, 2, 3]; + let v = [1, 2, 3]; let mut it = v.permutations(); let (min_size, max_opt) = it.size_hint(); assert_eq!(min_size, 3*2); @@ -1964,7 +1964,7 @@ mod tests { #[test] fn test_lexicographic_permutations() { - let v : &mut[int] = &mut[1i, 2, 3, 4, 5]; + let v : &mut[int] = &mut[1, 2, 3, 4, 5]; assert!(v.prev_permutation() == false); assert!(v.next_permutation()); let b: &mut[int] = &mut[1, 2, 3, 5, 4]; @@ -1980,7 +1980,7 @@ mod tests { let b: &mut[int] = &mut[1, 2, 4, 5, 3]; assert!(v == b); - let v : &mut[int] = &mut[1i, 0, 0, 0]; + let v : &mut[int] = &mut[1, 0, 0, 0]; assert!(v.next_permutation() == false); assert!(v.prev_permutation()); let b: &mut[int] = &mut[0, 1, 0, 0]; @@ -2003,14 +2003,14 @@ mod tests { assert!(empty.prev_permutation() == false); assert!(empty == b); - let one_elem : &mut[int] = &mut[4i]; + let one_elem : &mut[int] = &mut[4]; assert!(one_elem.prev_permutation() == false); let b: &mut[int] = &mut[4]; assert!(one_elem == b); assert!(one_elem.next_permutation() == false); assert!(one_elem == b); - let two_elem : &mut[int] = &mut[1i, 2]; + let two_elem : &mut[int] = &mut[1, 2]; assert!(two_elem.prev_permutation() == false); let b : &mut[int] = &mut[1, 2]; let c : &mut[int] = &mut[2, 1]; @@ -2027,9 +2027,9 @@ mod tests { #[test] fn test_position_elem() { - assert!([].position_elem(&1i).is_none()); + assert!([].position_elem(&1).is_none()); - let v1 = vec![1i, 2, 3, 3, 2, 5]; + let v1 = vec![1, 2, 3, 3, 2, 5]; assert_eq!(v1.position_elem(&1), Some(0u)); assert_eq!(v1.position_elem(&2), Some(1u)); assert_eq!(v1.position_elem(&5), Some(5u)); @@ -2038,52 +2038,52 @@ mod tests { #[test] fn test_binary_search() { - assert_eq!([1i,2,3,4,5].binary_search(&5).ok(), Some(4)); - assert_eq!([1i,2,3,4,5].binary_search(&4).ok(), Some(3)); - assert_eq!([1i,2,3,4,5].binary_search(&3).ok(), Some(2)); - assert_eq!([1i,2,3,4,5].binary_search(&2).ok(), Some(1)); - assert_eq!([1i,2,3,4,5].binary_search(&1).ok(), Some(0)); + assert_eq!([1,2,3,4,5].binary_search(&5).ok(), Some(4)); + assert_eq!([1,2,3,4,5].binary_search(&4).ok(), Some(3)); + assert_eq!([1,2,3,4,5].binary_search(&3).ok(), Some(2)); + assert_eq!([1,2,3,4,5].binary_search(&2).ok(), Some(1)); + assert_eq!([1,2,3,4,5].binary_search(&1).ok(), Some(0)); - assert_eq!([2i,4,6,8,10].binary_search(&1).ok(), None); - assert_eq!([2i,4,6,8,10].binary_search(&5).ok(), None); - assert_eq!([2i,4,6,8,10].binary_search(&4).ok(), Some(1)); - assert_eq!([2i,4,6,8,10].binary_search(&10).ok(), Some(4)); + assert_eq!([2,4,6,8,10].binary_search(&1).ok(), None); + assert_eq!([2,4,6,8,10].binary_search(&5).ok(), None); + assert_eq!([2,4,6,8,10].binary_search(&4).ok(), Some(1)); + assert_eq!([2,4,6,8,10].binary_search(&10).ok(), Some(4)); - assert_eq!([2i,4,6,8].binary_search(&1).ok(), None); - assert_eq!([2i,4,6,8].binary_search(&5).ok(), None); - assert_eq!([2i,4,6,8].binary_search(&4).ok(), Some(1)); - assert_eq!([2i,4,6,8].binary_search(&8).ok(), Some(3)); + assert_eq!([2,4,6,8].binary_search(&1).ok(), None); + assert_eq!([2,4,6,8].binary_search(&5).ok(), None); + assert_eq!([2,4,6,8].binary_search(&4).ok(), Some(1)); + assert_eq!([2,4,6,8].binary_search(&8).ok(), Some(3)); - assert_eq!([2i,4,6].binary_search(&1).ok(), None); - assert_eq!([2i,4,6].binary_search(&5).ok(), None); - assert_eq!([2i,4,6].binary_search(&4).ok(), Some(1)); - assert_eq!([2i,4,6].binary_search(&6).ok(), Some(2)); + assert_eq!([2,4,6].binary_search(&1).ok(), None); + assert_eq!([2,4,6].binary_search(&5).ok(), None); + assert_eq!([2,4,6].binary_search(&4).ok(), Some(1)); + assert_eq!([2,4,6].binary_search(&6).ok(), Some(2)); - assert_eq!([2i,4].binary_search(&1).ok(), None); - assert_eq!([2i,4].binary_search(&5).ok(), None); - assert_eq!([2i,4].binary_search(&2).ok(), Some(0)); - assert_eq!([2i,4].binary_search(&4).ok(), Some(1)); + assert_eq!([2,4].binary_search(&1).ok(), None); + assert_eq!([2,4].binary_search(&5).ok(), None); + assert_eq!([2,4].binary_search(&2).ok(), Some(0)); + assert_eq!([2,4].binary_search(&4).ok(), Some(1)); - assert_eq!([2i].binary_search(&1).ok(), None); - assert_eq!([2i].binary_search(&5).ok(), None); - assert_eq!([2i].binary_search(&2).ok(), Some(0)); + assert_eq!([2].binary_search(&1).ok(), None); + assert_eq!([2].binary_search(&5).ok(), None); + assert_eq!([2].binary_search(&2).ok(), Some(0)); - assert_eq!([].binary_search(&1i).ok(), None); - assert_eq!([].binary_search(&5i).ok(), None); + assert_eq!([].binary_search(&1).ok(), None); + assert_eq!([].binary_search(&5).ok(), None); - assert!([1i,1,1,1,1].binary_search(&1).ok() != None); - assert!([1i,1,1,1,2].binary_search(&1).ok() != None); - assert!([1i,1,1,2,2].binary_search(&1).ok() != None); - assert!([1i,1,2,2,2].binary_search(&1).ok() != None); - assert_eq!([1i,2,2,2,2].binary_search(&1).ok(), Some(0)); + assert!([1,1,1,1,1].binary_search(&1).ok() != None); + assert!([1,1,1,1,2].binary_search(&1).ok() != None); + assert!([1,1,1,2,2].binary_search(&1).ok() != None); + assert!([1,1,2,2,2].binary_search(&1).ok() != None); + assert_eq!([1,2,2,2,2].binary_search(&1).ok(), Some(0)); - assert_eq!([1i,2,3,4,5].binary_search(&6).ok(), None); - assert_eq!([1i,2,3,4,5].binary_search(&0).ok(), None); + assert_eq!([1,2,3,4,5].binary_search(&6).ok(), None); + assert_eq!([1,2,3,4,5].binary_search(&0).ok(), None); } #[test] fn test_reverse() { - let mut v: Vec<int> = vec![10i, 20]; + let mut v: Vec<int> = vec![10, 20]; assert_eq!(v[0], 10); assert_eq!(v[1], 20); v.reverse(); @@ -2098,7 +2098,7 @@ mod tests { #[test] fn test_sort() { for len in 4u..25 { - for _ in 0i..100 { + for _ in 0..100 { let mut v = thread_rng().gen_iter::<uint>().take(len) .collect::<Vec<uint>>(); let mut v1 = v.clone(); @@ -2125,9 +2125,9 @@ mod tests { #[test] fn test_sort_stability() { - for len in 4i..25 { + for len in 4..25 { for _ in 0u..10 { - let mut counts = [0i; 10]; + let mut counts = [0; 10]; // create a vector like [(6, 1), (5, 1), (6, 2), ...], // where the first item of each tuple is random, but @@ -2159,21 +2159,21 @@ mod tests { let v: [Vec<int>; 0] = []; let c: Vec<int> = v.concat(); assert_eq!(c, []); - let d: Vec<int> = [vec![1i], vec![2i,3i]].concat(); - assert_eq!(d, vec![1i, 2, 3]); + let d: Vec<int> = [vec![1], vec![2,3]].concat(); + assert_eq!(d, vec![1, 2, 3]); let v: [&[int]; 2] = [&[1], &[2, 3]]; - assert_eq!(v.connect(&0), vec![1i, 0, 2, 3]); - let v: [&[int]; 3] = [&[1i], &[2], &[3]]; - assert_eq!(v.connect(&0), vec![1i, 0, 2, 0, 3]); + assert_eq!(v.connect(&0), vec![1, 0, 2, 3]); + let v: [&[int]; 3] = [&[1], &[2], &[3]]; + assert_eq!(v.connect(&0), vec![1, 0, 2, 0, 3]); } #[test] fn test_connect() { let v: [Vec<int>; 0] = []; assert_eq!(v.connect(&0), vec![]); - assert_eq!([vec![1i], vec![2i, 3]].connect(&0), vec![1, 0, 2, 3]); - assert_eq!([vec![1i], vec![2i], vec![3i]].connect(&0), vec![1, 0, 2, 0, 3]); + assert_eq!([vec![1], vec![2, 3]].connect(&0), vec![1, 0, 2, 3]); + assert_eq!([vec![1], vec![2], vec![3]].connect(&0), vec![1, 0, 2, 0, 3]); let v: [&[int]; 2] = [&[1], &[2, 3]]; assert_eq!(v.connect(&0), vec![1, 0, 2, 3]); @@ -2183,42 +2183,42 @@ mod tests { #[test] fn test_insert() { - let mut a = vec![1i, 2, 4]; + let mut a = vec![1, 2, 4]; a.insert(2, 3); assert_eq!(a, vec![1, 2, 3, 4]); - let mut a = vec![1i, 2, 3]; + let mut a = vec![1, 2, 3]; a.insert(0, 0); assert_eq!(a, vec![0, 1, 2, 3]); - let mut a = vec![1i, 2, 3]; + let mut a = vec![1, 2, 3]; a.insert(3, 4); assert_eq!(a, vec![1, 2, 3, 4]); let mut a = vec![]; - a.insert(0, 1i); + a.insert(0, 1); assert_eq!(a, vec![1]); } #[test] #[should_fail] fn test_insert_oob() { - let mut a = vec![1i, 2, 3]; + let mut a = vec![1, 2, 3]; a.insert(4, 5); } #[test] fn test_remove() { - let mut a = vec![1i,2,3,4]; + let mut a = vec![1,2,3,4]; assert_eq!(a.remove(2), 3); - assert_eq!(a, vec![1i,2,4]); + assert_eq!(a, vec![1,2,4]); assert_eq!(a.remove(2), 4); - assert_eq!(a, vec![1i,2]); + assert_eq!(a, vec![1,2]); assert_eq!(a.remove(0), 1); - assert_eq!(a, vec![2i]); + assert_eq!(a, vec![2]); assert_eq!(a.remove(0), 2); assert_eq!(a, vec![]); @@ -2227,7 +2227,7 @@ mod tests { #[test] #[should_fail] fn test_remove_fail() { - let mut a = vec![1i]; + let mut a = vec![1]; let _ = a.remove(0); let _ = a.remove(0); } @@ -2244,7 +2244,7 @@ mod tests { #[test] fn test_slice_2() { - let v = vec![1i, 2, 3, 4, 5]; + let v = vec![1, 2, 3, 4, 5]; let v = v.slice(1u, 3u); assert_eq!(v.len(), 2u); assert_eq!(v[0], 2); @@ -2254,8 +2254,8 @@ mod tests { #[test] #[should_fail] fn test_permute_fail() { - let v = [(box 0i, Rc::new(0i)), (box 0i, Rc::new(0i)), - (box 0i, Rc::new(0i)), (box 0i, Rc::new(0i))]; + let v = [(box 0, Rc::new(0)), (box 0, Rc::new(0)), + (box 0, Rc::new(0)), (box 0, Rc::new(0))]; let mut i = 0u; for _ in v.permutations() { if i == 2 { @@ -2281,7 +2281,7 @@ mod tests { #[test] fn test_iterator() { - let xs = [1i, 2, 5, 10, 11]; + let xs = [1, 2, 5, 10, 11]; let mut it = xs.iter(); assert_eq!(it.size_hint(), (5, Some(5))); assert_eq!(it.next().unwrap(), &1); @@ -2299,7 +2299,7 @@ mod tests { #[test] fn test_random_access_iterator() { - let xs = [1i, 2, 5, 10, 11]; + let xs = [1, 2, 5, 10, 11]; let mut it = xs.iter(); assert_eq!(it.indexable(), 5); @@ -2337,14 +2337,14 @@ mod tests { #[test] fn test_iter_size_hints() { - let mut xs = [1i, 2, 5, 10, 11]; + let mut xs = [1, 2, 5, 10, 11]; assert_eq!(xs.iter().size_hint(), (5, Some(5))); assert_eq!(xs.iter_mut().size_hint(), (5, Some(5))); } #[test] fn test_iter_clone() { - let xs = [1i, 2, 5]; + let xs = [1, 2, 5]; let mut it = xs.iter(); it.next(); let mut jt = it.clone(); @@ -2355,7 +2355,7 @@ mod tests { #[test] fn test_mut_iterator() { - let mut xs = [1i, 2, 3, 4, 5]; + let mut xs = [1, 2, 3, 4, 5]; for x in xs.iter_mut() { *x += 1; } @@ -2365,7 +2365,7 @@ mod tests { #[test] fn test_rev_iterator() { - let xs = [1i, 2, 5, 10, 11]; + let xs = [1, 2, 5, 10, 11]; let ys = [11, 10, 5, 2, 1]; let mut i = 0; for &x in xs.iter().rev() { @@ -2398,7 +2398,7 @@ mod tests { #[test] fn test_splitator() { - let xs = &[1i,2,3,4,5]; + let xs = &[1,2,3,4,5]; let splits: &[&[int]] = &[&[1], &[3], &[5]]; assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<&[int]>>(), @@ -2423,7 +2423,7 @@ mod tests { #[test] fn test_splitnator() { - let xs = &[1i,2,3,4,5]; + let xs = &[1,2,3,4,5]; let splits: &[&[int]] = &[&[1,2,3,4,5]]; assert_eq!(xs.splitn(0, |x| *x % 2 == 0).collect::<Vec<&[int]>>(), @@ -2442,7 +2442,7 @@ mod tests { #[test] fn test_splitnator_mut() { - let xs = &mut [1i,2,3,4,5]; + let xs = &mut [1,2,3,4,5]; let splits: &[&mut [int]] = &[&mut [1,2,3,4,5]]; assert_eq!(xs.splitn_mut(0, |x| *x % 2 == 0).collect::<Vec<&mut [int]>>(), @@ -2462,7 +2462,7 @@ mod tests { #[test] fn test_rsplitator() { - let xs = &[1i,2,3,4,5]; + let xs = &[1,2,3,4,5]; let splits: &[&[int]] = &[&[5], &[3], &[1]]; assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<&[int]>>(), @@ -2503,11 +2503,11 @@ mod tests { #[test] fn test_windowsator() { - let v = &[1i,2,3,4]; + let v = &[1,2,3,4]; let wins: &[&[int]] = &[&[1,2], &[2,3], &[3,4]]; assert_eq!(v.windows(2).collect::<Vec<&[int]>>(), wins); - let wins: &[&[int]] = &[&[1i,2,3], &[2,3,4]]; + let wins: &[&[int]] = &[&[1,2,3], &[2,3,4]]; assert_eq!(v.windows(3).collect::<Vec<&[int]>>(), wins); assert!(v.windows(6).next().is_none()); } @@ -2515,7 +2515,7 @@ mod tests { #[test] #[should_fail] fn test_windowsator_0() { - let v = &[1i,2,3,4]; + let v = &[1,2,3,4]; let _it = v.windows(0); } @@ -2523,18 +2523,18 @@ mod tests { fn test_chunksator() { use core::iter::ExactSizeIterator; - let v = &[1i,2,3,4,5]; + let v = &[1,2,3,4,5]; assert_eq!(v.chunks(2).len(), 3); - let chunks: &[&[int]] = &[&[1i,2], &[3,4], &[5]]; + let chunks: &[&[int]] = &[&[1,2], &[3,4], &[5]]; assert_eq!(v.chunks(2).collect::<Vec<&[int]>>(), chunks); - let chunks: &[&[int]] = &[&[1i,2,3], &[4,5]]; + let chunks: &[&[int]] = &[&[1,2,3], &[4,5]]; assert_eq!(v.chunks(3).collect::<Vec<&[int]>>(), chunks); - let chunks: &[&[int]] = &[&[1i,2,3,4,5]]; + let chunks: &[&[int]] = &[&[1,2,3,4,5]]; assert_eq!(v.chunks(6).collect::<Vec<&[int]>>(), chunks); - let chunks: &[&[int]] = &[&[5i], &[3,4], &[1,2]]; + let chunks: &[&[int]] = &[&[5], &[3,4], &[1,2]]; assert_eq!(v.chunks(2).rev().collect::<Vec<&[int]>>(), chunks); let mut it = v.chunks(2); assert_eq!(it.indexable(), 3); @@ -2550,33 +2550,33 @@ mod tests { #[test] #[should_fail] fn test_chunksator_0() { - let v = &[1i,2,3,4]; + let v = &[1,2,3,4]; let _it = v.chunks(0); } #[test] fn test_move_from() { - let mut a = [1i,2,3,4,5]; - let b = vec![6i,7,8]; + let mut a = [1,2,3,4,5]; + let b = vec![6,7,8]; assert_eq!(a.move_from(b, 0, 3), 3); - assert!(a == [6i,7,8,4,5]); - let mut a = [7i,2,8,1]; - let b = vec![3i,1,4,1,5,9]; + assert!(a == [6,7,8,4,5]); + let mut a = [7,2,8,1]; + let b = vec![3,1,4,1,5,9]; assert_eq!(a.move_from(b, 0, 6), 4); - assert!(a == [3i,1,4,1]); - let mut a = [1i,2,3,4]; - let b = vec![5i,6,7,8,9,0]; + assert!(a == [3,1,4,1]); + let mut a = [1,2,3,4]; + let b = vec![5,6,7,8,9,0]; assert_eq!(a.move_from(b, 2, 3), 1); - assert!(a == [7i,2,3,4]); - let mut a = [1i,2,3,4,5]; - let b = vec![5i,6,7,8,9,0]; + assert!(a == [7,2,3,4]); + let mut a = [1,2,3,4,5]; + let b = vec![5,6,7,8,9,0]; assert_eq!(a[2..4].move_from(b,1,6), 2); - assert!(a == [1i,2,6,7,5]); + assert!(a == [1,2,6,7,5]); } #[test] fn test_reverse_part() { - let mut values = [1i,2,3,4,5]; + let mut values = [1,2,3,4,5]; values[1..4].reverse(); assert!(values == [1,4,3,2,5]); } @@ -2592,8 +2592,8 @@ mod tests { } let empty: Vec<int> = vec![]; test_show_vec!(empty, "[]"); - test_show_vec!(vec![1i], "[1]"); - test_show_vec!(vec![1i, 2, 3], "[1, 2, 3]"); + 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]], "[[], [1], [1, 1]]"); @@ -2635,16 +2635,16 @@ mod tests { fn test_overflow_does_not_cause_segfault() { let mut v = vec![]; v.reserve_exact(-1); - v.push(1i); + v.push(1); v.push(2); } #[test] #[should_fail] fn test_overflow_does_not_cause_segfault_managed() { - let mut v = vec![Rc::new(1i)]; + let mut v = vec![Rc::new(1)]; v.reserve_exact(-1); - v.push(Rc::new(2i)); + v.push(Rc::new(2)); } #[test] @@ -2717,13 +2717,13 @@ mod tests { #[test] fn test_shrink_to_fit() { let mut xs = vec![0, 1, 2, 3]; - for i in 4i..100 { + for i in 4..100 { xs.push(i) } assert_eq!(xs.capacity(), 128); xs.shrink_to_fit(); assert_eq!(xs.capacity(), 100); - assert_eq!(xs, (0i..100i).collect::<Vec<_>>()); + assert_eq!(xs, (0..100).collect::<Vec<_>>()); } #[test] @@ -2756,14 +2756,14 @@ mod tests { #[test] fn test_mut_splitator() { - let mut xs = [0i,1,0,2,3,0,0,4,5,0]; + let mut xs = [0,1,0,2,3,0,0,4,5,0]; assert_eq!(xs.split_mut(|x| *x == 0).count(), 6); for slice in xs.split_mut(|x| *x == 0) { slice.reverse(); } assert!(xs == [0,1,0,3,2,0,0,5,4,0]); - let mut xs = [0i,1,0,2,3,0,0,4,5,0,6,7]; + let mut xs = [0,1,0,2,3,0,0,4,5,0,6,7]; for slice in xs.split_mut(|x| *x == 0).take(5) { slice.reverse(); } @@ -2772,7 +2772,7 @@ mod tests { #[test] fn test_mut_splitator_rev() { - let mut xs = [1i,2,0,3,4,0,0,5,6,0]; + let mut xs = [1,2,0,3,4,0,0,5,6,0]; for slice in xs.split_mut(|x| *x == 0).rev().take(4) { slice.reverse(); } @@ -2781,7 +2781,7 @@ mod tests { #[test] fn test_get_mut() { - let mut v = [0i,1,2]; + let mut v = [0,1,2]; assert_eq!(v.get_mut(3), None); v.get_mut(1).map(|e| *e = 7); assert_eq!(v[1], 7); @@ -2819,13 +2819,13 @@ mod tests { #[test] #[should_fail] fn test_mut_chunks_0() { - let mut v = [1i, 2, 3, 4]; + let mut v = [1, 2, 3, 4]; let _it = v.chunks_mut(0); } #[test] fn test_mut_last() { - let mut x = [1i, 2, 3, 4, 5]; + let mut x = [1, 2, 3, 4, 5]; let h = x.last_mut(); assert_eq!(*h.unwrap(), 5); @@ -2868,10 +2868,10 @@ mod bench { #[bench] fn mut_iterator(b: &mut Bencher) { - let mut v = repeat(0i).take(100).collect::<Vec<_>>(); + let mut v = repeat(0).take(100).collect::<Vec<_>>(); b.iter(|| { - let mut i = 0i; + let mut i = 0; for x in v.iter_mut() { *x = i; i += 1; @@ -3007,7 +3007,7 @@ mod bench { v.set_len(1024); } for x in v.iter_mut() { - *x = 0i; + *x = 0; } v }); diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs index 8f7920fe1c4..56f266b7ca6 100644 --- a/src/libcollections/string.rs +++ b/src/libcollections/string.rs @@ -1291,8 +1291,8 @@ mod tests { #[test] fn test_simple_types() { - assert_eq!(1i.to_string(), "1"); - assert_eq!((-1i).to_string(), "-1"); + assert_eq!(1.to_string(), "1"); + assert_eq!((-1).to_string(), "-1"); assert_eq!(200u.to_string(), "200"); assert_eq!(2u8.to_string(), "2"); assert_eq!(true.to_string(), "true"); @@ -1304,9 +1304,9 @@ mod tests { fn test_vectors() { let x: Vec<int> = vec![]; assert_eq!(format!("{:?}", x), "[]"); - assert_eq!(format!("{:?}", vec![1i]), "[1]"); - assert_eq!(format!("{:?}", vec![1i, 2, 3]), "[1, 2, 3]"); - assert!(format!("{:?}", vec![vec![], vec![1i], vec![1i, 1]]) == + assert_eq!(format!("{:?}", vec![1]), "[1]"); + assert_eq!(format!("{:?}", vec![1, 2, 3]), "[1, 2, 3]"); + assert!(format!("{:?}", vec![vec![], vec![1], vec![1, 1]]) == "[[], [1], [1, 1]]"); } diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs index 336a3d7521a..8be29c45851 100644 --- a/src/libcollections/vec.rs +++ b/src/libcollections/vec.rs @@ -73,8 +73,8 @@ use core::uint; /// /// ``` /// let mut vec = Vec::new(); -/// vec.push(1i); -/// vec.push(2i); +/// vec.push(1); +/// vec.push(2); /// /// assert_eq!(vec.len(), 2); /// assert_eq!(vec[0], 1); @@ -82,7 +82,7 @@ use core::uint; /// assert_eq!(vec.pop(), Some(2)); /// assert_eq!(vec.len(), 1); /// -/// vec[0] = 7i; +/// vec[0] = 7; /// assert_eq!(vec[0], 7); /// /// vec.push_all(&[1, 2, 3]); @@ -90,13 +90,13 @@ use core::uint; /// for x in vec.iter() { /// println!("{}", x); /// } -/// assert_eq!(vec, vec![7i, 1, 2, 3]); +/// assert_eq!(vec, vec![7, 1, 2, 3]); /// ``` /// /// The `vec!` macro is provided to make initialization more convenient: /// /// ``` -/// let mut vec = vec![1i, 2i, 3i]; +/// let mut vec = vec![1, 2, 3]; /// vec.push(4); /// assert_eq!(vec, vec![1, 2, 3, 4]); /// ``` @@ -106,9 +106,9 @@ use core::uint; /// ``` /// let mut stack = Vec::new(); /// -/// stack.push(1i); -/// stack.push(2i); -/// stack.push(3i); +/// stack.push(1); +/// stack.push(2); +/// stack.push(3); /// /// loop { /// let top = match stack.pop() { @@ -186,7 +186,7 @@ impl<T> Vec<T> { /// assert_eq!(vec.len(), 0); /// /// // These are all done without reallocating... - /// for i in 0i..10 { + /// for i in 0..10 { /// vec.push(i); /// } /// @@ -220,7 +220,7 @@ impl<T> Vec<T> { /// use std::mem; /// /// fn main() { - /// let mut v = vec![1i, 2, 3]; + /// let mut v = vec![1, 2, 3]; /// /// // Pull out the various important pieces of information about `v` /// let p = v.as_mut_ptr(); @@ -239,7 +239,7 @@ impl<T> Vec<T> { /// /// // Put everything back together into a Vec /// let rebuilt = Vec::from_raw_parts(p, len, cap); - /// assert_eq!(rebuilt, vec![4i, 5i, 6i]); + /// assert_eq!(rebuilt, vec![4, 5, 6]); /// } /// } /// ``` @@ -395,7 +395,7 @@ impl<T> Vec<T> { /// # Examples /// /// ``` - /// let mut vec = vec![1i, 2, 3, 4]; + /// let mut vec = vec![1, 2, 3, 4]; /// vec.truncate(2); /// assert_eq!(vec, vec![1, 2]); /// ``` @@ -419,7 +419,7 @@ impl<T> Vec<T> { /// ``` /// fn foo(slice: &mut [int]) {} /// - /// let mut vec = vec![1i, 2]; + /// let mut vec = vec![1, 2]; /// foo(vec.as_mut_slice()); /// ``` #[inline] @@ -522,7 +522,7 @@ impl<T> Vec<T> { /// # Examples /// /// ``` - /// let mut vec = vec![1i, 2, 3]; + /// let mut vec = vec![1, 2, 3]; /// vec.insert(1, 4); /// assert_eq!(vec, vec![1, 4, 2, 3]); /// vec.insert(4, 5); @@ -560,7 +560,7 @@ impl<T> Vec<T> { /// # Examples /// /// ``` - /// let mut v = vec![1i, 2, 3]; + /// let mut v = vec![1, 2, 3]; /// assert_eq!(v.remove(1), 2); /// assert_eq!(v, vec![1, 3]); /// ``` @@ -594,7 +594,7 @@ impl<T> Vec<T> { /// # Examples /// /// ``` - /// let mut vec = vec![1i, 2, 3, 4]; + /// let mut vec = vec![1, 2, 3, 4]; /// vec.retain(|&x| x%2 == 0); /// assert_eq!(vec, vec![2, 4]); /// ``` @@ -627,7 +627,7 @@ impl<T> Vec<T> { /// # Examples /// /// ```rust - /// let mut vec = vec!(1i, 2); + /// let mut vec = vec!(1, 2); /// vec.push(3); /// assert_eq!(vec, vec!(1, 2, 3)); /// ``` @@ -665,7 +665,7 @@ impl<T> Vec<T> { /// # Examples /// /// ```rust - /// let mut vec = vec![1i, 2, 3]; + /// let mut vec = vec![1, 2, 3]; /// assert_eq!(vec.pop(), Some(3)); /// assert_eq!(vec, vec![1, 2]); /// ``` @@ -758,7 +758,7 @@ impl<T> Vec<T> { /// # Examples /// /// ``` - /// let mut v = vec![1i, 2, 3]; + /// let mut v = vec![1, 2, 3]; /// /// v.clear(); /// @@ -775,7 +775,7 @@ impl<T> Vec<T> { /// # Examples /// /// ``` - /// let a = vec![1i, 2, 3]; + /// let a = vec![1, 2, 3]; /// assert_eq!(a.len(), 3); /// ``` #[inline] @@ -790,7 +790,7 @@ impl<T> Vec<T> { /// let mut v = Vec::new(); /// assert!(v.is_empty()); /// - /// v.push(1i); + /// v.push(1); /// assert!(!v.is_empty()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] @@ -1045,7 +1045,7 @@ impl<T: Clone> Vec<T> { /// vec.resize(3, "world"); /// assert_eq!(vec, vec!["hello", "world", "world"]); /// - /// let mut vec = vec![1i, 2, 3, 4]; + /// let mut vec = vec![1, 2, 3, 4]; /// vec.resize(2, 0); /// assert_eq!(vec, vec![1, 2]); /// ``` @@ -1069,8 +1069,8 @@ impl<T: Clone> Vec<T> { /// # Examples /// /// ``` - /// let mut vec = vec![1i]; - /// vec.push_all(&[2i, 3, 4]); + /// let mut vec = vec![1]; + /// vec.push_all(&[2, 3, 4]); /// assert_eq!(vec, vec![1, 2, 3, 4]); /// ``` #[inline] @@ -1103,11 +1103,11 @@ impl<T: PartialEq> Vec<T> { /// # Examples /// /// ``` - /// let mut vec = vec![1i, 2, 2, 3, 2]; + /// let mut vec = vec![1, 2, 2, 3, 2]; /// /// vec.dedup(); /// - /// assert_eq!(vec, vec![1i, 2, 3, 2]); + /// assert_eq!(vec, vec![1, 2, 3, 2]); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn dedup(&mut self) { @@ -1487,7 +1487,7 @@ impl<T> AsSlice<T> for Vec<T> { /// ``` /// fn foo(slice: &[int]) {} /// - /// let vec = vec![1i, 2]; + /// let vec = vec![1, 2]; /// foo(vec.as_slice()); /// ``` #[inline] @@ -1969,7 +1969,7 @@ mod tests { v.reserve(2); assert!(v.capacity() >= 2); - for i in 0i..16 { + for i in 0..16 { v.push(i); } @@ -1988,13 +1988,13 @@ mod tests { let mut v = Vec::new(); let mut w = Vec::new(); - v.extend(0i..3); - for i in 0i..3 { w.push(i) } + v.extend(0..3); + for i in 0..3 { w.push(i) } assert_eq!(v, w); - v.extend(3i..10); - for i in 3i..10 { w.push(i) } + v.extend(3..10); + for i in 3..10 { w.push(i) } assert_eq!(v, w); } @@ -2055,7 +2055,7 @@ mod tests { #[test] fn test_clone() { let v: Vec<int> = vec!(); - let w = vec!(1i, 2, 3); + let w = vec!(1, 2, 3); assert_eq!(v, v.clone()); @@ -2068,8 +2068,8 @@ mod tests { #[test] fn test_clone_from() { let mut v = vec!(); - let three = vec!(box 1i, box 2, box 3); - let two = vec!(box 4i, box 5); + let three = vec!(box 1, box 2, box 3); + let two = vec!(box 4, box 5); // zero, long v.clone_from(&three); assert_eq!(v, three); @@ -2128,14 +2128,14 @@ mod tests { #[test] fn test_partition() { assert_eq!(vec![].into_iter().partition(|x: &int| *x < 3), (vec![], vec![])); - assert_eq!(vec![1i, 2, 3].into_iter().partition(|x: &int| *x < 4), (vec![1, 2, 3], vec![])); - assert_eq!(vec![1i, 2, 3].into_iter().partition(|x: &int| *x < 2), (vec![1], vec![2, 3])); - assert_eq!(vec![1i, 2, 3].into_iter().partition(|x: &int| *x < 0), (vec![], vec![1, 2, 3])); + 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])); } #[test] fn test_zip_unzip() { - let z1 = vec![(1i, 4i), (2, 5), (3, 6)]; + let z1 = vec![(1, 4), (2, 5), (3, 6)]; let (left, right): (Vec<_>, Vec<_>) = z1.iter().map(|&x| x).unzip(); @@ -2148,13 +2148,13 @@ mod tests { fn test_unsafe_ptrs() { unsafe { // Test on-stack copy-from-buf. - let a = [1i, 2, 3]; + let a = [1, 2, 3]; let ptr = a.as_ptr(); let b = Vec::from_raw_buf(ptr, 3u); assert_eq!(b, vec![1, 2, 3]); // Test on-heap copy-from-buf. - let c = vec![1i, 2, 3, 4, 5]; + let c = vec![1, 2, 3, 4, 5]; let ptr = c.as_ptr(); let d = Vec::from_raw_buf(ptr, 5u); assert_eq!(d, vec![1, 2, 3, 4, 5]); @@ -2198,14 +2198,14 @@ mod tests { #[test] fn test_index() { - let vec = vec!(1i, 2, 3); + let vec = vec!(1, 2, 3); assert!(vec[1] == 2); } #[test] #[should_fail] fn test_index_out_of_bounds() { - let vec = vec!(1i, 2, 3); + let vec = vec!(1, 2, 3); let _ = vec[3]; } @@ -2273,7 +2273,7 @@ mod tests { #[test] fn test_map_in_place() { let v = vec![0u, 1, 2]; - assert_eq!(v.map_in_place(|i: uint| i as int - 1), [-1i, 0, 1]); + assert_eq!(v.map_in_place(|i: uint| i as int - 1), [-1, 0, 1]); } #[test] diff --git a/src/libcollections/vec_map.rs b/src/libcollections/vec_map.rs index 9f83b91fc9b..5022a96b9b0 100644 --- a/src/libcollections/vec_map.rs +++ b/src/libcollections/vec_map.rs @@ -768,7 +768,7 @@ mod test_map { #[test] fn test_get_mut() { let mut m = VecMap::new(); - assert!(m.insert(1, 12i).is_none()); + assert!(m.insert(1, 12).is_none()); assert!(m.insert(2, 8).is_none()); assert!(m.insert(5, 14).is_none()); let new = 100; @@ -783,7 +783,7 @@ mod test_map { let mut map = VecMap::new(); assert_eq!(map.len(), 0); assert!(map.is_empty()); - assert!(map.insert(5, 20i).is_none()); + assert!(map.insert(5, 20).is_none()); assert_eq!(map.len(), 1); assert!(!map.is_empty()); assert!(map.insert(11, 12).is_none()); @@ -797,7 +797,7 @@ mod test_map { #[test] fn test_clear() { let mut map = VecMap::new(); - assert!(map.insert(5, 20i).is_none()); + assert!(map.insert(5, 20).is_none()); assert!(map.insert(11, 12).is_none()); assert!(map.insert(14, 22).is_none()); map.clear(); @@ -810,15 +810,15 @@ mod test_map { #[test] fn test_insert() { let mut m = VecMap::new(); - assert_eq!(m.insert(1, 2i), None); - assert_eq!(m.insert(1, 3i), Some(2)); - assert_eq!(m.insert(1, 4i), Some(3)); + assert_eq!(m.insert(1, 2), None); + assert_eq!(m.insert(1, 3), Some(2)); + assert_eq!(m.insert(1, 4), Some(3)); } #[test] fn test_remove() { let mut m = VecMap::new(); - m.insert(1, 2i); + m.insert(1, 2); assert_eq!(m.remove(&1), Some(2)); assert_eq!(m.remove(&1), None); } @@ -853,7 +853,7 @@ mod test_map { fn test_iterator() { let mut m = VecMap::new(); - assert!(m.insert(0, 1i).is_none()); + assert!(m.insert(0, 1).is_none()); assert!(m.insert(1, 2).is_none()); assert!(m.insert(3, 5).is_none()); assert!(m.insert(6, 10).is_none()); @@ -878,7 +878,7 @@ mod test_map { fn test_iterator_size_hints() { let mut m = VecMap::new(); - assert!(m.insert(0, 1i).is_none()); + assert!(m.insert(0, 1).is_none()); assert!(m.insert(1, 2).is_none()); assert!(m.insert(3, 5).is_none()); assert!(m.insert(6, 10).is_none()); @@ -894,7 +894,7 @@ mod test_map { fn test_mut_iterator() { let mut m = VecMap::new(); - assert!(m.insert(0, 1i).is_none()); + assert!(m.insert(0, 1).is_none()); assert!(m.insert(1, 2).is_none()); assert!(m.insert(3, 5).is_none()); assert!(m.insert(6, 10).is_none()); @@ -917,7 +917,7 @@ mod test_map { fn test_rev_iterator() { let mut m = VecMap::new(); - assert!(m.insert(0, 1i).is_none()); + assert!(m.insert(0, 1).is_none()); assert!(m.insert(1, 2).is_none()); assert!(m.insert(3, 5).is_none()); assert!(m.insert(6, 10).is_none()); @@ -936,7 +936,7 @@ mod test_map { fn test_mut_rev_iterator() { let mut m = VecMap::new(); - assert!(m.insert(0, 1i).is_none()); + assert!(m.insert(0, 1).is_none()); assert!(m.insert(1, 2).is_none()); assert!(m.insert(3, 5).is_none()); assert!(m.insert(6, 10).is_none()); @@ -958,13 +958,13 @@ mod test_map { #[test] fn test_move_iter() { let mut m = VecMap::new(); - m.insert(1, box 2i); + m.insert(1, box 2); let mut called = false; for (k, v) in m.into_iter() { assert!(!called); called = true; assert_eq!(k, 1); - assert_eq!(v, box 2i); + assert_eq!(v, box 2); } assert!(called); } @@ -987,8 +987,8 @@ mod test_map { let mut map = VecMap::new(); let empty = VecMap::<int>::new(); - map.insert(1, 2i); - map.insert(3, 4i); + map.insert(1, 2); + map.insert(3, 4); let map_str = format!("{:?}", map); assert!(map_str == "VecMap {1: 2, 3: 4}" || map_str == "{3: 4, 1: 2}"); @@ -1012,9 +1012,9 @@ mod test_map { let mut b = VecMap::new(); assert!(a == b); - assert!(a.insert(0, 5i).is_none()); + assert!(a.insert(0, 5).is_none()); assert!(a != b); - assert!(b.insert(0, 4i).is_none()); + assert!(b.insert(0, 4).is_none()); assert!(a != b); assert!(a.insert(5, 19).is_none()); assert!(a != b); @@ -1034,7 +1034,7 @@ mod test_map { let mut b = VecMap::new(); assert!(!(a < b) && !(b < a)); - assert!(b.insert(2u, 5i).is_none()); + assert!(b.insert(2u, 5).is_none()); assert!(a < b); assert!(a.insert(2, 7).is_none()); assert!(!(a < b) && b < a); @@ -1052,7 +1052,7 @@ mod test_map { let mut b = VecMap::new(); assert!(a <= b && a >= b); - assert!(a.insert(1u, 1i).is_none()); + assert!(a.insert(1u, 1).is_none()); assert!(a > b && a >= b); assert!(b < a && b <= a); assert!(b.insert(2, 2).is_none()); diff --git a/src/libcoretest/any.rs b/src/libcoretest/any.rs index 7c71c733662..5ad3833a5ef 100644 --- a/src/libcoretest/any.rs +++ b/src/libcoretest/any.rs @@ -123,7 +123,7 @@ fn any_fixed_vec() { #[bench] fn bench_downcast_ref(b: &mut Bencher) { b.iter(|| { - let mut x = 0i; + let mut x = 0; let mut y = &mut x as &mut Any; test::black_box(&mut y); test::black_box(y.downcast_ref::<int>() == Some(&0)); diff --git a/src/libcoretest/cell.rs b/src/libcoretest/cell.rs index 8bd2ed95ed5..5815dbc0acc 100644 --- a/src/libcoretest/cell.rs +++ b/src/libcoretest/cell.rs @@ -14,14 +14,14 @@ use std::mem::drop; #[test] fn smoketest_cell() { - let x = Cell::new(10i); + let x = Cell::new(10); assert!(x == Cell::new(10)); assert!(x.get() == 10); x.set(20); assert!(x == Cell::new(20)); assert!(x.get() == 20); - let y = Cell::new((30i, 40i)); + let y = Cell::new((30, 40)); assert!(y == Cell::new((30, 40))); assert!(y.get() == (30, 40)); } @@ -50,35 +50,35 @@ fn ref_and_refmut_have_sensible_show() { #[test] fn double_imm_borrow() { - let x = RefCell::new(0i); + let x = RefCell::new(0); let _b1 = x.borrow(); x.borrow(); } #[test] fn no_mut_then_imm_borrow() { - let x = RefCell::new(0i); + let x = RefCell::new(0); let _b1 = x.borrow_mut(); assert!(x.try_borrow().is_none()); } #[test] fn no_imm_then_borrow_mut() { - let x = RefCell::new(0i); + let x = RefCell::new(0); let _b1 = x.borrow(); assert!(x.try_borrow_mut().is_none()); } #[test] fn no_double_borrow_mut() { - let x = RefCell::new(0i); + let x = RefCell::new(0); let _b1 = x.borrow_mut(); assert!(x.try_borrow_mut().is_none()); } #[test] fn imm_release_borrow_mut() { - let x = RefCell::new(0i); + let x = RefCell::new(0); { let _b1 = x.borrow(); } @@ -87,7 +87,7 @@ fn imm_release_borrow_mut() { #[test] fn mut_release_borrow_mut() { - let x = RefCell::new(0i); + let x = RefCell::new(0); { let _b1 = x.borrow_mut(); } @@ -96,7 +96,7 @@ fn mut_release_borrow_mut() { #[test] fn double_borrow_single_release_no_borrow_mut() { - let x = RefCell::new(0i); + let x = RefCell::new(0); let _b1 = x.borrow(); { let _b2 = x.borrow(); @@ -107,7 +107,7 @@ fn double_borrow_single_release_no_borrow_mut() { #[test] #[should_fail] fn discard_doesnt_unborrow() { - let x = RefCell::new(0i); + let x = RefCell::new(0); let _b = x.borrow(); let _ = _b; let _b = x.borrow_mut(); @@ -115,7 +115,7 @@ fn discard_doesnt_unborrow() { #[test] fn clone_ref_updates_flag() { - let x = RefCell::new(0i); + let x = RefCell::new(0); { let b1 = x.borrow(); assert!(x.try_borrow_mut().is_none()); diff --git a/src/libcoretest/clone.rs b/src/libcoretest/clone.rs index 67c30d945d4..5ab6ab27ba1 100644 --- a/src/libcoretest/clone.rs +++ b/src/libcoretest/clone.rs @@ -10,7 +10,7 @@ #[test] fn test_borrowed_clone() { - let x = 5i; + let x = 5; let y: &int = &x; let z: &int = (&y).clone(); assert_eq!(*z, 5); @@ -18,8 +18,8 @@ fn test_borrowed_clone() { #[test] fn test_clone_from() { - let a = box 5i; - let mut b = box 10i; + let a = box 5; + let mut b = box 10; b.clone_from(&a); assert_eq!(*b, 5); } diff --git a/src/libcoretest/cmp.rs b/src/libcoretest/cmp.rs index 992c99f1f9f..6bc1f14cc5a 100644 --- a/src/libcoretest/cmp.rs +++ b/src/libcoretest/cmp.rs @@ -13,20 +13,20 @@ use core::cmp::Ordering::{Less, Greater, Equal}; #[test] fn test_int_totalord() { - assert_eq!(5i.cmp(&10), Less); - assert_eq!(10i.cmp(&5), Greater); - assert_eq!(5i.cmp(&5), Equal); - assert_eq!((-5i).cmp(&12), Less); - assert_eq!(12i.cmp(&-5), Greater); + assert_eq!(5.cmp(&10), Less); + assert_eq!(10.cmp(&5), Greater); + assert_eq!(5.cmp(&5), Equal); + assert_eq!((-5).cmp(&12), Less); + assert_eq!(12.cmp(&-5), Greater); } #[test] fn test_mut_int_totalord() { - assert_eq!((&mut 5i).cmp(&&mut 10), Less); - assert_eq!((&mut 10i).cmp(&&mut 5), Greater); - assert_eq!((&mut 5i).cmp(&&mut 5), Equal); - assert_eq!((&mut -5i).cmp(&&mut 12), Less); - assert_eq!((&mut 12i).cmp(&&mut -5), Greater); + assert_eq!((&mut 5).cmp(&&mut 10), Less); + assert_eq!((&mut 10).cmp(&&mut 5), Greater); + assert_eq!((&mut 5).cmp(&&mut 5), Equal); + assert_eq!((&mut -5).cmp(&&mut 12), Less); + assert_eq!((&mut 12).cmp(&&mut -5), Greater); } #[test] @@ -47,11 +47,11 @@ fn test_partial_min() { use core::f64::NAN; let data_integer = [ // a, b, result - (0i, 0i, Some(0i)), - (1i, 0i, Some(0i)), - (0i, 1i, Some(0i)), - (-1i, 0i, Some(-1i)), - (0i, -1i, Some(-1i)) + (0, 0, Some(0)), + (1, 0, Some(0)), + (0, 1, Some(0)), + (-1, 0, Some(-1)), + (0, -1, Some(-1)) ]; let data_float = [ @@ -80,11 +80,11 @@ fn test_partial_max() { use core::f64::NAN; let data_integer = [ // a, b, result - (0i, 0i, Some(0i)), - (1i, 0i, Some(1i)), - (0i, 1i, Some(1i)), - (-1i, 0i, Some(0i)), - (0i, -1i, Some(0i)) + (0, 0, Some(0)), + (1, 0, Some(1)), + (0, 1, Some(1)), + (-1, 0, Some(0)), + (0, -1, Some(0)) ]; let data_float = [ diff --git a/src/libcoretest/finally.rs b/src/libcoretest/finally.rs index 6ec87203e00..22917b09ce9 100644 --- a/src/libcoretest/finally.rs +++ b/src/libcoretest/finally.rs @@ -15,7 +15,7 @@ use std::thread::Thread; #[test] fn test_success() { - let mut i = 0i; + let mut i = 0; try_finally( &mut i, (), |i, ()| { @@ -32,7 +32,7 @@ fn test_success() { #[test] #[should_fail] fn test_fail() { - let mut i = 0i; + let mut i = 0; try_finally( &mut i, (), |i, ()| { @@ -47,7 +47,7 @@ fn test_fail() { #[test] fn test_retval() { - let mut closure = |&mut:| 10i; + let mut closure = |&mut:| 10; let i = closure.finally(|| { }); assert_eq!(i, 10); } diff --git a/src/libcoretest/hash/mod.rs b/src/libcoretest/hash/mod.rs index d48820aee06..f83b03d845b 100644 --- a/src/libcoretest/hash/mod.rs +++ b/src/libcoretest/hash/mod.rs @@ -56,7 +56,7 @@ fn test_writer_hasher() { assert_eq!(hash(&5i16), 5); assert_eq!(hash(&5i32), 5); assert_eq!(hash(&5i64), 5); - assert_eq!(hash(&5i), 5); + assert_eq!(hash(&5), 5); assert_eq!(hash(&false), 0); assert_eq!(hash(&true), 1); @@ -76,12 +76,12 @@ fn test_writer_hasher() { // FIXME (#18248) Add tests for hashing Rc<str> and Rc<[T]> unsafe { - let ptr: *const int = mem::transmute(5i); + let ptr: *const int = mem::transmute(5); assert_eq!(hash(&ptr), 5); } unsafe { - let ptr: *mut int = mem::transmute(5i); + let ptr: *mut int = mem::transmute(5); assert_eq!(hash(&ptr), 5); } } diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs index 8bcd4982fba..e6b0265576c 100644 --- a/src/libcoretest/iter.rs +++ b/src/libcoretest/iter.rs @@ -20,8 +20,8 @@ use test::Bencher; #[test] fn test_lt() { let empty: [int; 0] = []; - let xs = [1i,2,3]; - let ys = [1i,2,0]; + let xs = [1,2,3]; + let ys = [1,2,0]; assert!(!lt(xs.iter(), ys.iter())); assert!(!le(xs.iter(), ys.iter())); @@ -64,15 +64,15 @@ fn test_lt() { #[test] fn test_multi_iter() { - let xs = [1i,2,3,4]; - let ys = [4i,3,2,1]; + let xs = [1,2,3,4]; + let ys = [4,3,2,1]; assert!(eq(xs.iter(), ys.iter().rev())); assert!(lt(xs.iter(), xs.iter().skip(2))); } #[test] fn test_counter_from_iter() { - let it = count(0i, 5).take(10); + let it = count(0, 5).take(10); let xs: Vec<int> = FromIterator::from_iter(it); assert!(xs == vec![0, 5, 10, 15, 20, 25, 30, 35, 40, 45]); } @@ -304,7 +304,7 @@ fn test_cycle() { #[test] fn test_iterator_nth() { - let v: &[_] = &[0i, 1, 2, 3, 4]; + let v: &[_] = &[0, 1, 2, 3, 4]; for i in 0u..v.len() { assert_eq!(v.iter().nth(i).unwrap(), &v[i]); } @@ -313,14 +313,14 @@ fn test_iterator_nth() { #[test] fn test_iterator_last() { - let v: &[_] = &[0i, 1, 2, 3, 4]; + let v: &[_] = &[0, 1, 2, 3, 4]; assert_eq!(v.iter().last().unwrap(), &4); assert_eq!(v[..1].iter().last().unwrap(), &0); } #[test] fn test_iterator_len() { - let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; + let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; assert_eq!(v[..4].iter().count(), 4); assert_eq!(v[..10].iter().count(), 10); assert_eq!(v[..0].iter().count(), 0); @@ -328,7 +328,7 @@ fn test_iterator_len() { #[test] fn test_iterator_sum() { - let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; + let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; assert_eq!(v[..4].iter().map(|&x| x).sum(), 6); assert_eq!(v.iter().map(|&x| x).sum(), 55); assert_eq!(v[..0].iter().map(|&x| x).sum(), 0); @@ -336,7 +336,7 @@ fn test_iterator_sum() { #[test] fn test_iterator_product() { - let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; + let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; assert_eq!(v[..4].iter().map(|&x| x).product(), 0); assert_eq!(v[1..5].iter().map(|&x| x).product(), 24); assert_eq!(v[..0].iter().map(|&x| x).product(), 1); @@ -344,7 +344,7 @@ fn test_iterator_product() { #[test] fn test_iterator_max() { - let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; + let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; assert_eq!(v[..4].iter().map(|&x| x).max(), Some(3)); assert_eq!(v.iter().map(|&x| x).max(), Some(10)); assert_eq!(v[..0].iter().map(|&x| x).max(), None); @@ -352,7 +352,7 @@ fn test_iterator_max() { #[test] fn test_iterator_min() { - let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; + let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]; assert_eq!(v[..4].iter().map(|&x| x).min(), Some(0)); assert_eq!(v.iter().map(|&x| x).min(), Some(0)); assert_eq!(v[..0].iter().map(|&x| x).min(), None); @@ -360,9 +360,9 @@ fn test_iterator_min() { #[test] fn test_iterator_size_hint() { - let c = count(0i, 1); - let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9]; - let v2 = &[10i, 11, 12]; + let c = count(0, 1); + let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]; + let v2 = &[10, 11, 12]; let vi = v.iter(); assert_eq!(c.size_hint(), (uint::MAX, None)); @@ -375,10 +375,10 @@ fn test_iterator_size_hint() { assert_eq!(c.enumerate().size_hint(), (uint::MAX, None)); assert_eq!(c.chain(vi.map(|&i| i)).size_hint(), (uint::MAX, None)); assert_eq!(c.zip(vi).size_hint(), (10, Some(10))); - assert_eq!(c.scan(0i, |_,_| Some(0i)).size_hint(), (0, None)); + assert_eq!(c.scan(0, |_,_| Some(0)).size_hint(), (0, None)); assert_eq!(c.filter(|_| false).size_hint(), (0, None)); - assert_eq!(c.map(|_| 0i).size_hint(), (uint::MAX, None)); - assert_eq!(c.filter_map(|_| Some(0i)).size_hint(), (0, None)); + assert_eq!(c.map(|_| 0).size_hint(), (uint::MAX, None)); + assert_eq!(c.filter_map(|_| Some(0)).size_hint(), (0, None)); assert_eq!(vi.take(5).size_hint(), (5, Some(5))); assert_eq!(vi.take(12).size_hint(), (10, Some(10))); @@ -389,22 +389,22 @@ fn test_iterator_size_hint() { assert_eq!(vi.enumerate().size_hint(), (10, Some(10))); assert_eq!(vi.chain(v2.iter()).size_hint(), (13, Some(13))); assert_eq!(vi.zip(v2.iter()).size_hint(), (3, Some(3))); - assert_eq!(vi.scan(0i, |_,_| Some(0i)).size_hint(), (0, Some(10))); + assert_eq!(vi.scan(0, |_,_| Some(0)).size_hint(), (0, Some(10))); assert_eq!(vi.filter(|_| false).size_hint(), (0, Some(10))); assert_eq!(vi.map(|&i| i+1).size_hint(), (10, Some(10))); - assert_eq!(vi.filter_map(|_| Some(0i)).size_hint(), (0, Some(10))); + assert_eq!(vi.filter_map(|_| Some(0)).size_hint(), (0, Some(10))); } #[test] fn test_collect() { - let a = vec![1i, 2, 3, 4, 5]; + let a = vec![1, 2, 3, 4, 5]; let b: Vec<int> = a.iter().map(|&x| x).collect(); assert!(a == b); } #[test] fn test_all() { - let v: Box<[int]> = box [1i, 2, 3, 4, 5]; + let v: Box<[int]> = box [1, 2, 3, 4, 5]; assert!(v.iter().all(|&x| x < 10)); assert!(!v.iter().all(|&x| x % 2 == 0)); assert!(!v.iter().all(|&x| x > 100)); @@ -413,7 +413,7 @@ fn test_all() { #[test] fn test_any() { - let v: Box<[int]> = box [1i, 2, 3, 4, 5]; + let v: Box<[int]> = box [1, 2, 3, 4, 5]; assert!(v.iter().any(|&x| x < 10)); assert!(v.iter().any(|&x| x % 2 == 0)); assert!(!v.iter().any(|&x| x > 100)); @@ -422,7 +422,7 @@ fn test_any() { #[test] fn test_find() { - let v: &[int] = &[1i, 3, 9, 27, 103, 14, 11]; + let v: &[int] = &[1, 3, 9, 27, 103, 14, 11]; assert_eq!(*v.iter().find(|&&x| x & 1 == 0).unwrap(), 14); assert_eq!(*v.iter().find(|&&x| x % 3 == 0).unwrap(), 3); assert!(v.iter().find(|&&x| x % 12 == 0).is_none()); @@ -430,7 +430,7 @@ fn test_find() { #[test] fn test_position() { - let v = &[1i, 3, 9, 27, 103, 14, 11]; + let v = &[1, 3, 9, 27, 103, 14, 11]; assert_eq!(v.iter().position(|x| *x & 1 == 0).unwrap(), 5); assert_eq!(v.iter().position(|x| *x % 3 == 0).unwrap(), 1); assert!(v.iter().position(|x| *x % 12 == 0).is_none()); @@ -438,7 +438,7 @@ fn test_position() { #[test] fn test_count() { - let xs = &[1i, 2, 2, 1, 5, 9, 0, 2]; + let xs = &[1, 2, 2, 1, 5, 9, 0, 2]; assert_eq!(xs.iter().filter(|x| **x == 2).count(), 3); assert_eq!(xs.iter().filter(|x| **x == 5).count(), 1); assert_eq!(xs.iter().filter(|x| **x == 95).count(), 0); @@ -446,19 +446,19 @@ fn test_count() { #[test] fn test_max_by() { - let xs: &[int] = &[-3i, 0, 1, 5, -10]; + let xs: &[int] = &[-3, 0, 1, 5, -10]; assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10); } #[test] fn test_min_by() { - let xs: &[int] = &[-3i, 0, 1, 5, -10]; + let xs: &[int] = &[-3, 0, 1, 5, -10]; assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0); } #[test] fn test_by_ref() { - let mut xs = 0i..10; + let mut xs = 0..10; // sum the first five values let partial_sum = xs.by_ref().take(5).fold(0, |a, b| a + b); assert_eq!(partial_sum, 10); @@ -467,7 +467,7 @@ fn test_by_ref() { #[test] fn test_rev() { - let xs = [2i, 4, 6, 8, 10, 12, 14, 16]; + let xs = [2, 4, 6, 8, 10, 12, 14, 16]; let mut it = xs.iter(); it.next(); it.next(); @@ -494,7 +494,7 @@ fn test_cloned() { #[test] fn test_double_ended_map() { - let xs = [1i, 2, 3, 4, 5, 6]; + let xs = [1, 2, 3, 4, 5, 6]; let mut it = xs.iter().map(|&x| x * -1); assert_eq!(it.next(), Some(-1)); assert_eq!(it.next(), Some(-2)); @@ -507,7 +507,7 @@ fn test_double_ended_map() { #[test] fn test_double_ended_enumerate() { - let xs = [1i, 2, 3, 4, 5, 6]; + let xs = [1, 2, 3, 4, 5, 6]; let mut it = xs.iter().map(|&x| x).enumerate(); assert_eq!(it.next(), Some((0, 1))); assert_eq!(it.next(), Some((1, 2))); @@ -520,8 +520,8 @@ fn test_double_ended_enumerate() { #[test] fn test_double_ended_zip() { - let xs = [1i, 2, 3, 4, 5, 6]; - let ys = [1i, 2, 3, 7]; + let xs = [1, 2, 3, 4, 5, 6]; + let ys = [1, 2, 3, 7]; let a = xs.iter().map(|&x| x); let b = ys.iter().map(|&x| x); let mut it = a.zip(b); @@ -534,7 +534,7 @@ fn test_double_ended_zip() { #[test] fn test_double_ended_filter() { - let xs = [1i, 2, 3, 4, 5, 6]; + let xs = [1, 2, 3, 4, 5, 6]; let mut it = xs.iter().filter(|&x| *x & 1 == 0); assert_eq!(it.next_back().unwrap(), &6); assert_eq!(it.next_back().unwrap(), &4); @@ -544,7 +544,7 @@ fn test_double_ended_filter() { #[test] fn test_double_ended_filter_map() { - let xs = [1i, 2, 3, 4, 5, 6]; + let xs = [1, 2, 3, 4, 5, 6]; let mut it = xs.iter().filter_map(|&x| if x & 1 == 0 { Some(x * 2) } else { None }); assert_eq!(it.next_back().unwrap(), 12); assert_eq!(it.next_back().unwrap(), 8); @@ -554,8 +554,8 @@ fn test_double_ended_filter_map() { #[test] fn test_double_ended_chain() { - let xs = [1i, 2, 3, 4, 5]; - let ys = [7i, 9, 11]; + let xs = [1, 2, 3, 4, 5]; + let ys = [7, 9, 11]; let mut it = xs.iter().chain(ys.iter()).rev(); assert_eq!(it.next().unwrap(), &11); assert_eq!(it.next().unwrap(), &9); @@ -572,7 +572,7 @@ fn test_double_ended_chain() { fn test_rposition() { fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' } fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' } - let v = [(0i, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; + let v = [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')]; assert_eq!(v.iter().rposition(f), Some(3u)); assert!(v.iter().rposition(g).is_none()); @@ -581,9 +581,9 @@ fn test_rposition() { #[test] #[should_fail] fn test_rposition_panic() { - let v = [(box 0i, box 0i), (box 0i, box 0i), - (box 0i, box 0i), (box 0i, box 0i)]; - let mut i = 0i; + let v = [(box 0, box 0), (box 0, box 0), + (box 0, box 0), (box 0, box 0)]; + let mut i = 0; v.iter().rposition(|_elt| { if i == 2 { panic!() @@ -635,8 +635,8 @@ fn test_double_ended_flat_map() { #[test] fn test_random_access_chain() { - let xs = [1i, 2, 3, 4, 5]; - let ys = [7i, 9, 11]; + let xs = [1, 2, 3, 4, 5]; + let ys = [7, 9, 11]; let mut it = xs.iter().chain(ys.iter()); assert_eq!(it.idx(0).unwrap(), &1); assert_eq!(it.idx(5).unwrap(), &7); @@ -656,13 +656,13 @@ fn test_random_access_chain() { #[test] fn test_random_access_enumerate() { - let xs = [1i, 2, 3, 4, 5]; + let xs = [1, 2, 3, 4, 5]; check_randacc_iter(xs.iter().enumerate(), xs.len()); } #[test] fn test_random_access_rev() { - let xs = [1i, 2, 3, 4, 5]; + let xs = [1, 2, 3, 4, 5]; check_randacc_iter(xs.iter().rev(), xs.len()); let mut it = xs.iter().rev(); it.next(); @@ -673,14 +673,14 @@ fn test_random_access_rev() { #[test] fn test_random_access_zip() { - let xs = [1i, 2, 3, 4, 5]; - let ys = [7i, 9, 11]; + let xs = [1, 2, 3, 4, 5]; + let ys = [7, 9, 11]; check_randacc_iter(xs.iter().zip(ys.iter()), cmp::min(xs.len(), ys.len())); } #[test] fn test_random_access_take() { - let xs = [1i, 2, 3, 4, 5]; + let xs = [1, 2, 3, 4, 5]; let empty: &[int] = &[]; check_randacc_iter(xs.iter().take(3), 3); check_randacc_iter(xs.iter().take(20), xs.len()); @@ -690,7 +690,7 @@ fn test_random_access_take() { #[test] fn test_random_access_skip() { - let xs = [1i, 2, 3, 4, 5]; + let xs = [1, 2, 3, 4, 5]; let empty: &[int] = &[]; check_randacc_iter(xs.iter().skip(2), xs.len() - 2); check_randacc_iter(empty.iter().skip(2), 0); @@ -698,7 +698,7 @@ fn test_random_access_skip() { #[test] fn test_random_access_inspect() { - let xs = [1i, 2, 3, 4, 5]; + let xs = [1, 2, 3, 4, 5]; // test .map and .inspect that don't implement Clone let mut it = xs.iter().inspect(|_| {}); @@ -711,7 +711,7 @@ fn test_random_access_inspect() { #[test] fn test_random_access_map() { - let xs = [1i, 2, 3, 4, 5]; + let xs = [1, 2, 3, 4, 5]; let mut it = xs.iter().map(|x| *x); assert_eq!(xs.len(), it.indexable()); @@ -722,7 +722,7 @@ fn test_random_access_map() { #[test] fn test_random_access_cycle() { - let xs = [1i, 2, 3, 4, 5]; + let xs = [1, 2, 3, 4, 5]; let empty: &[int] = &[]; check_randacc_iter(xs.iter().cycle().take(27), 27); check_randacc_iter(empty.iter().cycle(), 0); @@ -730,8 +730,8 @@ fn test_random_access_cycle() { #[test] fn test_double_ended_range() { - assert!((11i..14).rev().collect::<Vec<int>>() == vec![13i, 12, 11]); - for _ in (10i..0).rev() { + assert!((11..14).rev().collect::<Vec<int>>() == vec![13, 12, 11]); + for _ in (10..0).rev() { panic!("unreachable"); } @@ -743,73 +743,73 @@ fn test_double_ended_range() { #[test] fn test_range() { - assert!((0i..5).collect::<Vec<int>>() == vec![0i, 1, 2, 3, 4]); - assert!((-10i..-1).collect::<Vec<int>>() == + assert!((0..5).collect::<Vec<int>>() == vec![0, 1, 2, 3, 4]); + assert!((-10..-1).collect::<Vec<int>>() == vec![-10, -9, -8, -7, -6, -5, -4, -3, -2]); - assert!((0i..5).rev().collect::<Vec<int>>() == vec![4, 3, 2, 1, 0]); - assert_eq!((200i..-5).count(), 0); - assert_eq!((200i..-5).rev().count(), 0); - assert_eq!((200i..200).count(), 0); - assert_eq!((200i..200).rev().count(), 0); + assert!((0..5).rev().collect::<Vec<int>>() == vec![4, 3, 2, 1, 0]); + assert_eq!((200..-5).count(), 0); + assert_eq!((200..-5).rev().count(), 0); + assert_eq!((200..200).count(), 0); + assert_eq!((200..200).rev().count(), 0); - assert_eq!((0i..100).size_hint(), (100, Some(100))); + assert_eq!((0..100).size_hint(), (100, Some(100))); // this test is only meaningful when sizeof uint < sizeof u64 assert_eq!((uint::MAX - 1..uint::MAX).size_hint(), (1, Some(1))); - assert_eq!((-10i..-1).size_hint(), (9, Some(9))); + assert_eq!((-10..-1).size_hint(), (9, Some(9))); } #[test] fn test_range_inclusive() { - assert!(range_inclusive(0i, 5).collect::<Vec<int>>() == - vec![0i, 1, 2, 3, 4, 5]); - assert!(range_inclusive(0i, 5).rev().collect::<Vec<int>>() == - vec![5i, 4, 3, 2, 1, 0]); - assert_eq!(range_inclusive(200i, -5).count(), 0); - assert_eq!(range_inclusive(200i, -5).rev().count(), 0); - assert!(range_inclusive(200i, 200).collect::<Vec<int>>() == vec![200]); - assert!(range_inclusive(200i, 200).rev().collect::<Vec<int>>() == vec![200]); + assert!(range_inclusive(0, 5).collect::<Vec<int>>() == + vec![0, 1, 2, 3, 4, 5]); + assert!(range_inclusive(0, 5).rev().collect::<Vec<int>>() == + vec![5, 4, 3, 2, 1, 0]); + assert_eq!(range_inclusive(200, -5).count(), 0); + assert_eq!(range_inclusive(200, -5).rev().count(), 0); + assert!(range_inclusive(200, 200).collect::<Vec<int>>() == vec![200]); + assert!(range_inclusive(200, 200).rev().collect::<Vec<int>>() == vec![200]); } #[test] fn test_range_step() { - assert!(range_step(0i, 20, 5).collect::<Vec<int>>() == + assert!(range_step(0, 20, 5).collect::<Vec<int>>() == vec![0, 5, 10, 15]); - assert!(range_step(20i, 0, -5).collect::<Vec<int>>() == + assert!(range_step(20, 0, -5).collect::<Vec<int>>() == vec![20, 15, 10, 5]); - assert!(range_step(20i, 0, -6).collect::<Vec<int>>() == + assert!(range_step(20, 0, -6).collect::<Vec<int>>() == vec![20, 14, 8, 2]); assert!(range_step(200u8, 255, 50).collect::<Vec<u8>>() == vec![200u8, 250]); - assert!(range_step(200i, -5, 1).collect::<Vec<int>>() == vec![]); - assert!(range_step(200i, 200, 1).collect::<Vec<int>>() == vec![]); + assert!(range_step(200, -5, 1).collect::<Vec<int>>() == vec![]); + assert!(range_step(200, 200, 1).collect::<Vec<int>>() == vec![]); } #[test] fn test_range_step_inclusive() { - assert!(range_step_inclusive(0i, 20, 5).collect::<Vec<int>>() == + assert!(range_step_inclusive(0, 20, 5).collect::<Vec<int>>() == vec![0, 5, 10, 15, 20]); - assert!(range_step_inclusive(20i, 0, -5).collect::<Vec<int>>() == + assert!(range_step_inclusive(20, 0, -5).collect::<Vec<int>>() == vec![20, 15, 10, 5, 0]); - assert!(range_step_inclusive(20i, 0, -6).collect::<Vec<int>>() == + assert!(range_step_inclusive(20, 0, -6).collect::<Vec<int>>() == vec![20, 14, 8, 2]); assert!(range_step_inclusive(200u8, 255, 50).collect::<Vec<u8>>() == vec![200u8, 250]); - assert!(range_step_inclusive(200i, -5, 1).collect::<Vec<int>>() == + assert!(range_step_inclusive(200, -5, 1).collect::<Vec<int>>() == vec![]); - assert!(range_step_inclusive(200i, 200, 1).collect::<Vec<int>>() == + assert!(range_step_inclusive(200, 200, 1).collect::<Vec<int>>() == vec![200]); } #[test] fn test_reverse() { - let mut ys = [1i, 2, 3, 4, 5]; + let mut ys = [1, 2, 3, 4, 5]; ys.iter_mut().reverse_in_place(); assert!(ys == [5, 4, 3, 2, 1]); } #[test] fn test_peekable_is_empty() { - let a = [1i]; + let a = [1]; let mut it = a.iter().peekable(); assert!( !it.is_empty() ); it.next(); @@ -821,16 +821,16 @@ fn test_min_max() { let v: [int; 0] = []; assert_eq!(v.iter().min_max(), NoElements); - let v = [1i]; + let v = [1]; assert!(v.iter().min_max() == OneElement(&1)); - let v = [1i, 2, 3, 4, 5]; + let v = [1, 2, 3, 4, 5]; assert!(v.iter().min_max() == MinMax(&1, &5)); - let v = [1i, 2, 3, 4, 5, 6]; + let v = [1, 2, 3, 4, 5, 6]; assert!(v.iter().min_max() == MinMax(&1, &6)); - let v = [1i, 1, 1, 1]; + let v = [1, 1, 1, 1]; assert!(v.iter().min_max() == MinMax(&1, &1)); } @@ -839,10 +839,10 @@ fn test_min_max_result() { let r: MinMaxResult<int> = NoElements; assert_eq!(r.into_option(), None); - let r = OneElement(1i); + let r = OneElement(1); assert_eq!(r.into_option(), Some((1,1))); - let r = MinMax(1i,2); + let r = MinMax(1,2); assert_eq!(r.into_option(), Some((1,2))); } diff --git a/src/libcoretest/mem.rs b/src/libcoretest/mem.rs index 3dc209e6fcb..fd9dc696bdf 100644 --- a/src/libcoretest/mem.rs +++ b/src/libcoretest/mem.rs @@ -70,8 +70,8 @@ fn align_of_val_basic() { #[test] fn test_swap() { - let mut x = 31337i; - let mut y = 42i; + let mut x = 31337; + let mut y = 42; swap(&mut x, &mut y); assert_eq!(x, 42); assert_eq!(y, 31337); @@ -87,7 +87,7 @@ fn test_replace() { #[test] fn test_transmute_copy() { - assert_eq!(1u, unsafe { transmute_copy(&1i) }); + assert_eq!(1u, unsafe { transmute_copy(&1) }); } #[test] @@ -95,7 +95,7 @@ fn test_transmute() { trait Foo {} impl Foo for int {} - let a = box 100i as Box<Foo>; + let a = box 100 as Box<Foo>; unsafe { let x: ::core::raw::TraitObject = transmute(a); assert!(*(x.data as *const int) == 100); @@ -146,7 +146,7 @@ fn trait_static_method_call(b: &mut Bencher) { #[bench] fn match_option_some(b: &mut Bencher) { - let x = Some(10i); + let x = Some(10); b.iter(|| { match x { Some(y) => y, @@ -157,11 +157,11 @@ fn match_option_some(b: &mut Bencher) { #[bench] fn match_vec_pattern(b: &mut Bencher) { - let x = [1i,2,3,4,5,6]; + let x = [1,2,3,4,5,6]; b.iter(|| { match x { - [1,2,3,..] => 10i, - _ => 11i, + [1,2,3,..] => 10, + _ => 11, } }); } diff --git a/src/libcoretest/nonzero.rs b/src/libcoretest/nonzero.rs index ab2f6da1cf7..be4c83d23e8 100644 --- a/src/libcoretest/nonzero.rs +++ b/src/libcoretest/nonzero.rs @@ -16,7 +16,7 @@ use std::mem::size_of; #[test] fn test_create_nonzero_instance() { let _a = unsafe { - NonZero::new(21i) + NonZero::new(21) }; } @@ -28,14 +28,14 @@ fn test_size_nonzero_in_option() { #[test] fn test_match_on_nonzero_option() { let a = Some(unsafe { - NonZero::new(42i) + NonZero::new(42) }); match a { Some(val) => assert_eq!(*val, 42), None => panic!("unexpected None while matching on Some(NonZero(_))") } - match unsafe { Some(NonZero::new(43i)) } { + match unsafe { Some(NonZero::new(43)) } { Some(val) => assert_eq!(*val, 43), None => panic!("unexpected None while matching on Some(NonZero(_))") } @@ -52,9 +52,9 @@ fn test_match_option_empty_vec() { #[test] fn test_match_option_vec() { - let a = Some(vec![1i, 2, 3, 4]); + let a = Some(vec![1, 2, 3, 4]); match a { - Some(v) => assert_eq!(v, vec![1i, 2, 3, 4]), + Some(v) => assert_eq!(v, vec![1, 2, 3, 4]), None => panic!("unexpected None while matching on Some(vec![1, 2, 3, 4])") } } @@ -63,9 +63,9 @@ fn test_match_option_vec() { fn test_match_option_rc() { use std::rc::Rc; - let five = Rc::new(5i); + let five = Rc::new(5); match Some(five) { - Some(r) => assert_eq!(*r, 5i), + Some(r) => assert_eq!(*r, 5), None => panic!("unexpected None while matching on Some(Rc::new(5))") } } @@ -74,9 +74,9 @@ fn test_match_option_rc() { fn test_match_option_arc() { use std::sync::Arc; - let five = Arc::new(5i); + let five = Arc::new(5); match Some(five) { - Some(a) => assert_eq!(*a, 5i), + Some(a) => assert_eq!(*a, 5), None => panic!("unexpected None while matching on Some(Arc::new(5))") } } diff --git a/src/libcoretest/num/int_macros.rs b/src/libcoretest/num/int_macros.rs index b98432e26b2..f89733e766b 100644 --- a/src/libcoretest/num/int_macros.rs +++ b/src/libcoretest/num/int_macros.rs @@ -151,8 +151,8 @@ mod tests { #[test] fn test_signed_checked_div() { - assert!(10i.checked_div(2) == Some(5)); - assert!(5i.checked_div(0) == None); + assert!(10.checked_div(2) == Some(5)); + assert!(5.checked_div(0) == None); assert!(int::MIN.checked_div(-1) == None); } diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs index e0623bade5c..0b013359f7e 100644 --- a/src/libcoretest/num/mod.rs +++ b/src/libcoretest/num/mod.rs @@ -40,11 +40,11 @@ pub fn test_num<T>(ten: T, two: T) where + Rem<Output=T> + Debug + Copy { - assert_eq!(ten.add(two), cast(12i).unwrap()); - assert_eq!(ten.sub(two), cast(8i).unwrap()); - assert_eq!(ten.mul(two), cast(20i).unwrap()); - assert_eq!(ten.div(two), cast(5i).unwrap()); - assert_eq!(ten.rem(two), cast(0i).unwrap()); + assert_eq!(ten.add(two), cast(12).unwrap()); + assert_eq!(ten.sub(two), cast(8).unwrap()); + assert_eq!(ten.mul(two), cast(20).unwrap()); + assert_eq!(ten.div(two), cast(5).unwrap()); + assert_eq!(ten.rem(two), cast(0).unwrap()); assert_eq!(ten.add(two), ten + two); assert_eq!(ten.sub(two), ten - two); diff --git a/src/libcoretest/option.rs b/src/libcoretest/option.rs index bb9d1524786..b32ae68b5d3 100644 --- a/src/libcoretest/option.rs +++ b/src/libcoretest/option.rs @@ -16,7 +16,7 @@ use core::clone::Clone; #[test] fn test_get_ptr() { unsafe { - let x = box 0i; + let x = box 0; let addr_x: *const int = mem::transmute(&*x); let opt = Some(x); let y = opt.unwrap(); @@ -59,7 +59,7 @@ fn test_get_resource() { } } - let i = Rc::new(RefCell::new(0i)); + let i = Rc::new(RefCell::new(0)); { let x = r(i.clone()); let opt = Some(x); @@ -71,7 +71,7 @@ fn test_get_resource() { #[test] fn test_option_dance() { let x = Some(()); - let mut y = Some(5i); + let mut y = Some(5); let mut y2 = 0; for _x in x.iter() { y2 = y.take().unwrap(); @@ -89,12 +89,12 @@ fn test_option_too_much_dance() { #[test] fn test_and() { - let x: Option<int> = Some(1i); - assert_eq!(x.and(Some(2i)), Some(2)); + let x: Option<int> = Some(1); + assert_eq!(x.and(Some(2)), Some(2)); assert_eq!(x.and(None::<int>), None); let x: Option<int> = None; - assert_eq!(x.and(Some(2i)), None); + assert_eq!(x.and(Some(2)), None); assert_eq!(x.and(None::<int>), None); } @@ -133,7 +133,7 @@ fn test_or_else() { #[test] fn test_unwrap() { - assert_eq!(Some(1i).unwrap(), 1); + assert_eq!(Some(1).unwrap(), 1); let s = Some("hello".to_string()).unwrap(); assert_eq!(s, "hello"); } @@ -172,7 +172,7 @@ fn test_unwrap_or_else() { #[test] fn test_iter() { - let val = 5i; + let val = 5; let x = Some(val); let mut it = x.iter(); @@ -185,8 +185,8 @@ fn test_iter() { #[test] fn test_mut_iter() { - let val = 5i; - let new_val = 11i; + let val = 5; + let new_val = 11; let mut x = Some(val); { @@ -223,13 +223,13 @@ fn test_ord() { /* FIXME(#20575) #[test] fn test_collect() { - let v: Option<Vec<int>> = (0i..0).map(|_| Some(0i)).collect(); + let v: Option<Vec<int>> = (0..0).map(|_| Some(0i)).collect(); assert!(v == Some(vec![])); - let v: Option<Vec<int>> = (0i..3).map(|x| Some(x)).collect(); + let v: Option<Vec<int>> = (0..3).map(|x| Some(x)).collect(); assert!(v == Some(vec![0, 1, 2])); - let v: Option<Vec<int>> = (0i..3).map(|x| { + let v: Option<Vec<int>> = (0..3).map(|x| { if x > 1 { None } else { Some(x) } }).collect(); assert!(v == None); diff --git a/src/libcoretest/ptr.rs b/src/libcoretest/ptr.rs index 875affe0ac7..7f0b97c53d4 100644 --- a/src/libcoretest/ptr.rs +++ b/src/libcoretest/ptr.rs @@ -84,7 +84,7 @@ fn test_as_ref() { assert_eq!(q.as_ref().unwrap(), &2); // Lifetime inference - let u = 2i; + let u = 2; { let p: *const int = &u as *const _; assert_eq!(p.as_ref().unwrap(), &2); @@ -102,7 +102,7 @@ fn test_as_mut() { assert!(q.as_mut().unwrap() == &mut 2); // Lifetime inference - let mut u = 2i; + let mut u = 2; { let p: *mut int = &mut u as *mut _; assert!(p.as_mut().unwrap() == &mut 2); @@ -113,7 +113,7 @@ fn test_as_mut() { #[test] fn test_ptr_addition() { unsafe { - let xs = repeat(5i).take(16).collect::<Vec<_>>(); + let xs = repeat(5).take(16).collect::<Vec<_>>(); let mut ptr = xs.as_ptr(); let end = ptr.offset(16); @@ -131,7 +131,7 @@ fn test_ptr_addition() { m_ptr = m_ptr.offset(1); } - assert!(xs_mut == repeat(10i).take(16).collect::<Vec<_>>()); + assert!(xs_mut == repeat(10).take(16).collect::<Vec<_>>()); } } diff --git a/src/libcoretest/result.rs b/src/libcoretest/result.rs index d36228fa3d7..ab7b5101e72 100644 --- a/src/libcoretest/result.rs +++ b/src/libcoretest/result.rs @@ -13,11 +13,11 @@ pub fn op2() -> Result<int, &'static str> { Err("sadface") } #[test] pub fn test_and() { - assert_eq!(op1().and(Ok(667i)).unwrap(), 667); + assert_eq!(op1().and(Ok(667)).unwrap(), 667); assert_eq!(op1().and(Err::<i32, &'static str>("bad")).unwrap_err(), "bad"); - assert_eq!(op2().and(Ok(667i)).unwrap_err(), "sadface"); + assert_eq!(op2().and(Ok(667)).unwrap_err(), "sadface"); assert_eq!(op2().and(Err::<i32,&'static str>("bad")).unwrap_err(), "sadface"); } @@ -68,20 +68,20 @@ pub fn test_impl_map_err() { /* FIXME(#20575) #[test] fn test_collect() { - let v: Result<Vec<int>, ()> = (0i..0).map(|_| Ok::<int, ()>(0)).collect(); + let v: Result<Vec<int>, ()> = (0..0).map(|_| Ok::<int, ()>(0)).collect(); assert!(v == Ok(vec![])); - let v: Result<Vec<int>, ()> = (0i..3).map(|x| Ok::<int, ()>(x)).collect(); + let v: Result<Vec<int>, ()> = (0..3).map(|x| Ok::<int, ()>(x)).collect(); assert!(v == Ok(vec![0, 1, 2])); - let v: Result<Vec<int>, int> = (0i..3).map(|x| { + let v: Result<Vec<int>, int> = (0..3).map(|x| { if x > 1 { Err(x) } else { Ok(x) } }).collect(); assert!(v == Err(2)); // test that it does not take more elements than it needs let mut functions: [Box<Fn() -> Result<(), int>>; 3] = - [box || Ok(()), box || Err(1i), box || panic!()]; + [box || Ok(()), box || Err(1), box || panic!()]; let v: Result<Vec<()>, int> = functions.iter_mut().map(|f| (*f)()).collect(); assert!(v == Err(1)); @@ -101,7 +101,7 @@ pub fn test_fmt_default() { #[test] pub fn test_unwrap_or() { - let ok: Result<int, &'static str> = Ok(100i); + let ok: Result<int, &'static str> = Ok(100); let ok_err: Result<int, &'static str> = Err("Err"); assert_eq!(ok.unwrap_or(50), 100); @@ -112,7 +112,7 @@ pub fn test_unwrap_or() { pub fn test_unwrap_or_else() { fn handler(msg: &'static str) -> int { if msg == "I got this." { - 50i + 50 } else { panic!("BadBad") } @@ -130,7 +130,7 @@ pub fn test_unwrap_or_else() { pub fn test_unwrap_or_else_panic() { fn handler(msg: &'static str) -> int { if msg == "I got this." { - 50i + 50 } else { panic!("BadBad") } diff --git a/src/libcoretest/slice.rs b/src/libcoretest/slice.rs index 6fae384763f..6d5cc38ef0a 100644 --- a/src/libcoretest/slice.rs +++ b/src/libcoretest/slice.rs @@ -12,25 +12,25 @@ use core::result::Result::{Ok, Err}; #[test] fn binary_search_not_found() { - let b = [1i, 2, 4, 6, 8, 9]; + let b = [1, 2, 4, 6, 8, 9]; assert!(b.binary_search_by(|v| v.cmp(&6)) == Ok(3)); - let b = [1i, 2, 4, 6, 8, 9]; + let b = [1, 2, 4, 6, 8, 9]; assert!(b.binary_search_by(|v| v.cmp(&5)) == Err(3)); - let b = [1i, 2, 4, 6, 7, 8, 9]; + let b = [1, 2, 4, 6, 7, 8, 9]; assert!(b.binary_search_by(|v| v.cmp(&6)) == Ok(3)); - let b = [1i, 2, 4, 6, 7, 8, 9]; + let b = [1, 2, 4, 6, 7, 8, 9]; assert!(b.binary_search_by(|v| v.cmp(&5)) == Err(3)); - let b = [1i, 2, 4, 6, 8, 9]; + let b = [1, 2, 4, 6, 8, 9]; assert!(b.binary_search_by(|v| v.cmp(&8)) == Ok(4)); - let b = [1i, 2, 4, 6, 8, 9]; + let b = [1, 2, 4, 6, 8, 9]; assert!(b.binary_search_by(|v| v.cmp(&7)) == Err(4)); - let b = [1i, 2, 4, 6, 7, 8, 9]; + let b = [1, 2, 4, 6, 7, 8, 9]; assert!(b.binary_search_by(|v| v.cmp(&8)) == Ok(5)); - let b = [1i, 2, 4, 5, 6, 8, 9]; + let b = [1, 2, 4, 5, 6, 8, 9]; assert!(b.binary_search_by(|v| v.cmp(&7)) == Err(5)); - let b = [1i, 2, 4, 5, 6, 8, 9]; + let b = [1, 2, 4, 5, 6, 8, 9]; assert!(b.binary_search_by(|v| v.cmp(&0)) == Err(0)); - let b = [1i, 2, 4, 5, 6, 8]; + let b = [1, 2, 4, 5, 6, 8]; assert!(b.binary_search_by(|v| v.cmp(&9)) == Err(6)); } diff --git a/src/libcoretest/tuple.rs b/src/libcoretest/tuple.rs index e524d8de056..57844f5995f 100644 --- a/src/libcoretest/tuple.rs +++ b/src/libcoretest/tuple.rs @@ -12,7 +12,7 @@ use std::cmp::Ordering::{Equal, Less, Greater}; #[test] fn test_clone() { - let a = (1i, "2"); + let a = (1, "2"); let b = a.clone(); assert_eq!(a, b); } @@ -59,10 +59,10 @@ fn test_tuple_cmp() { #[test] fn test_show() { - let s = format!("{:?}", (1i,)); + let s = format!("{:?}", (1,)); assert_eq!(s, "(1,)"); - let s = format!("{:?}", (1i, true)); + let s = format!("{:?}", (1, true)); assert_eq!(s, "(1, true)"); - let s = format!("{:?}", (1i, "hi", true)); + let s = format!("{:?}", (1, "hi", true)); assert_eq!(s, "(1, \"hi\", true)"); } diff --git a/src/liblog/lib.rs b/src/liblog/lib.rs index 0e2ab008e13..bf7fdaeadf4 100644 --- a/src/liblog/lib.rs +++ b/src/liblog/lib.rs @@ -20,7 +20,7 @@ //! error!("this is printed by default"); //! //! if log_enabled!(log::INFO) { -//! let x = 3i * 4i; // expensive computation +//! let x = 3 * 4; // expensive computation //! info!("the answer was: {:?}", x); //! } //! } diff --git a/src/liblog/macros.rs b/src/liblog/macros.rs index 5249e971439..5c7085b7b6c 100644 --- a/src/liblog/macros.rs +++ b/src/liblog/macros.rs @@ -119,7 +119,7 @@ macro_rules! warn { /// #[macro_use] extern crate log; /// /// fn main() { -/// let ret = 3i; +/// let ret = 3; /// info!("this function is about to return: {}", ret); /// } /// ``` @@ -145,7 +145,7 @@ macro_rules! info { /// #[macro_use] extern crate log; /// /// fn main() { -/// debug!("x = {x}, y = {y}", x=10i, y=20i); +/// debug!("x = {x}, y = {y}", x=10, y=20); /// } /// ``` /// diff --git a/src/librand/distributions/mod.rs b/src/librand/distributions/mod.rs index 8d87a8e5f0e..1b5e5ae8398 100644 --- a/src/librand/distributions/mod.rs +++ b/src/librand/distributions/mod.rs @@ -311,36 +311,36 @@ mod tests { }} } - t!(vec!(Weighted { weight: 1, item: 10i}), [10]); + t!(vec!(Weighted { weight: 1, item: 10}), [10]); // skip some - t!(vec!(Weighted { weight: 0, item: 20i}, - Weighted { weight: 2, item: 21i}, - Weighted { weight: 0, item: 22i}, - Weighted { weight: 1, item: 23i}), + t!(vec!(Weighted { weight: 0, item: 20}, + Weighted { weight: 2, item: 21}, + Weighted { weight: 0, item: 22}, + Weighted { weight: 1, item: 23}), [21,21, 23]); // different weights - t!(vec!(Weighted { weight: 4, item: 30i}, - Weighted { weight: 3, item: 31i}), + t!(vec!(Weighted { weight: 4, item: 30}, + Weighted { weight: 3, item: 31}), [30,30,30,30, 31,31,31]); // check that we're binary searching // correctly with some vectors of odd // length. - t!(vec!(Weighted { weight: 1, item: 40i}, - Weighted { weight: 1, item: 41i}, - Weighted { weight: 1, item: 42i}, - Weighted { weight: 1, item: 43i}, - Weighted { weight: 1, item: 44i}), + t!(vec!(Weighted { weight: 1, item: 40}, + Weighted { weight: 1, item: 41}, + Weighted { weight: 1, item: 42}, + Weighted { weight: 1, item: 43}, + Weighted { weight: 1, item: 44}), [40, 41, 42, 43, 44]); - t!(vec!(Weighted { weight: 1, item: 50i}, - Weighted { weight: 1, item: 51i}, - Weighted { weight: 1, item: 52i}, - Weighted { weight: 1, item: 53i}, - Weighted { weight: 1, item: 54i}, - Weighted { weight: 1, item: 55i}, - Weighted { weight: 1, item: 56i}), + t!(vec!(Weighted { weight: 1, item: 50}, + Weighted { weight: 1, item: 51}, + Weighted { weight: 1, item: 52}, + Weighted { weight: 1, item: 53}, + Weighted { weight: 1, item: 54}, + Weighted { weight: 1, item: 55}, + Weighted { weight: 1, item: 56}), [50, 51, 52, 53, 54, 55, 56]); } @@ -350,15 +350,15 @@ mod tests { } #[test] #[should_fail] fn test_weighted_choice_zero_weight() { - WeightedChoice::new(&mut [Weighted { weight: 0, item: 0i}, - Weighted { weight: 0, item: 1i}]); + WeightedChoice::new(&mut [Weighted { weight: 0, item: 0}, + Weighted { weight: 0, item: 1}]); } #[test] #[should_fail] fn test_weighted_choice_weight_overflows() { let x = (-1) as uint / 2; // x + x + 2 is the overflow - WeightedChoice::new(&mut [Weighted { weight: x, item: 0i }, - Weighted { weight: 1, item: 1i }, - Weighted { weight: x, item: 2i }, - Weighted { weight: 1, item: 3i }]); + WeightedChoice::new(&mut [Weighted { weight: x, item: 0 }, + Weighted { weight: 1, item: 1 }, + Weighted { weight: x, item: 2 }, + Weighted { weight: 1, item: 3 }]); } } diff --git a/src/librand/distributions/range.rs b/src/librand/distributions/range.rs index e8dedeb8d60..16830c84c46 100644 --- a/src/librand/distributions/range.rs +++ b/src/librand/distributions/range.rs @@ -171,12 +171,12 @@ mod tests { #[should_fail] #[test] fn test_range_bad_limits_equal() { - Range::new(10i, 10i); + Range::new(10, 10); } #[should_fail] #[test] fn test_range_bad_limits_flipped() { - Range::new(10i, 5i); + Range::new(10, 5); } #[test] diff --git a/src/librand/lib.rs b/src/librand/lib.rs index 76258151850..395fcd047d6 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -152,7 +152,7 @@ pub trait Rng : Sized { // (3) adds more `unsafe` that needs to be checked, (4) // probably doesn't give much performance gain if // optimisations are on. - let mut count = 0i; + let mut count = 0; let mut num = 0; for byte in dest.iter_mut() { if count == 0 { @@ -269,7 +269,7 @@ pub trait Rng : Sized { /// ``` /// use std::rand::{thread_rng, Rng}; /// - /// let choices = [1i, 2, 4, 8, 16, 32]; + /// let choices = [1, 2, 4, 8, 16, 32]; /// let mut rng = thread_rng(); /// println!("{:?}", rng.choose(&choices)); /// assert_eq!(rng.choose(&choices[..0]), None); @@ -290,7 +290,7 @@ pub trait Rng : Sized { /// use std::rand::{thread_rng, Rng}; /// /// let mut rng = thread_rng(); - /// let mut y = [1i, 2, 3]; + /// let mut y = [1, 2, 3]; /// rng.shuffle(&mut y); /// println!("{:?}", y.as_slice()); /// rng.shuffle(&mut y); diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs index f13814527cd..5d77cfe1061 100644 --- a/src/librustc/lint/builtin.rs +++ b/src/librustc/lint/builtin.rs @@ -493,7 +493,7 @@ pub struct BoxPointers; impl BoxPointers { fn check_heap_type<'a, 'tcx>(&self, cx: &Context<'a, 'tcx>, span: Span, ty: Ty<'tcx>) { - let mut n_uniq = 0i; + let mut n_uniq = 0u; ty::fold_ty(cx.tcx, ty, |t| { match t.sty { ty::ty_uniq(_) => { diff --git a/src/librustc_trans/save/span_utils.rs b/src/librustc_trans/save/span_utils.rs index 97b3cda006b..2685f0cb5ce 100644 --- a/src/librustc_trans/save/span_utils.rs +++ b/src/librustc_trans/save/span_utils.rs @@ -236,7 +236,7 @@ impl<'a> SpanUtils<'a> { let mut toks = self.retokenise_span(span); // We keep track of how many brackets we're nested in - let mut bracket_count = 0i; + let mut bracket_count = 0; loop { let ts = toks.real_token(); if ts.tok == token::Eof { diff --git a/src/librustc_trans/trans/_match.rs b/src/librustc_trans/trans/_match.rs index 8d7eb5816c2..bdb579d1ffa 100644 --- a/src/librustc_trans/trans/_match.rs +++ b/src/librustc_trans/trans/_match.rs @@ -1078,7 +1078,7 @@ fn compile_submatch_continue<'a, 'p, 'blk, 'tcx>(mut bcx: Block<'blk, 'tcx>, let sw = if kind == Switch { build::Switch(bcx, test_val, else_cx.llbb, opts.len()) } else { - C_int(ccx, 0i) // Placeholder for when not using a switch + C_int(ccx, 0) // Placeholder for when not using a switch }; let defaults = enter_default(else_cx, dm, m, col, val); diff --git a/src/librustc_trans/trans/foreign.rs b/src/librustc_trans/trans/foreign.rs index 5965d396e87..6c017866ef0 100644 --- a/src/librustc_trans/trans/foreign.rs +++ b/src/librustc_trans/trans/foreign.rs @@ -973,9 +973,9 @@ pub fn lltype_for_foreign_fn<'a, 'tcx>(ccx: &CrateContext<'a, 'tcx>, fn add_argument_attributes(tys: &ForeignTypes, llfn: ValueRef) { let mut i = if tys.fn_ty.ret_ty.is_indirect() { - 1i + 1 } else { - 0i + 0 }; match tys.fn_ty.ret_ty.attr { diff --git a/src/librustc_trans/trans/tvec.rs b/src/librustc_trans/trans/tvec.rs index 06bc19f45a4..358e38a671d 100644 --- a/src/librustc_trans/trans/tvec.rs +++ b/src/librustc_trans/trans/tvec.rs @@ -499,7 +499,7 @@ pub fn iter_vec_raw<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>, CondBr(header_bcx, not_yet_at_end, body_bcx.llbb, next_bcx.llbb, DebugLoc::None); let body_bcx = f(body_bcx, data_ptr, vt.unit_ty); AddIncomingToPhi(data_ptr, InBoundsGEP(body_bcx, data_ptr, - &[C_int(bcx.ccx(), 1i)]), + &[C_int(bcx.ccx(), 1)]), body_bcx.llbb); Br(body_bcx, header_bcx.llbb, DebugLoc::None); next_bcx diff --git a/src/libserialize/hex.rs b/src/libserialize/hex.rs index d3c2ffa9544..c9b6af26ce0 100644 --- a/src/libserialize/hex.rs +++ b/src/libserialize/hex.rs @@ -116,7 +116,7 @@ impl FromHex for str { fn from_hex(&self) -> Result<Vec<u8>, FromHexError> { // This may be an overestimate if there is any whitespace let mut b = Vec::with_capacity(self.len() / 2); - let mut modulus = 0i; + let mut modulus = 0; let mut buf = 0u8; for (idx, byte) in self.bytes().enumerate() { diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs index 2e7a6fd4923..c16a6978620 100644 --- a/src/libserialize/json.rs +++ b/src/libserialize/json.rs @@ -3937,7 +3937,7 @@ mod tests { hash_map.insert("a".to_string(), 1u); hash_map.insert("b".to_string(), 2); assert_eq!(hash_map.to_json(), object); - assert_eq!(Some(15i).to_json(), I64(15)); + assert_eq!(Some(15).to_json(), I64(15)); assert_eq!(Some(15u).to_json(), U64(15)); assert_eq!(None::<int>.to_json(), Null); } @@ -3997,7 +3997,7 @@ mod tests { fn big_json() -> string::String { let mut src = "[\n".to_string(); - for _ in 0i..500 { + for _ in 0..500 { src.push_str(r#"{ "a": true, "b": null, "c":3.1415, "d": "Hello world", "e": \ [1,2,3]},"#); } diff --git a/src/libstd/collections/hash/bench.rs b/src/libstd/collections/hash/bench.rs index 28689767cb0..ce02648b8f2 100644 --- a/src/libstd/collections/hash/bench.rs +++ b/src/libstd/collections/hash/bench.rs @@ -32,7 +32,7 @@ fn new_insert_drop(b : &mut Bencher) { b.iter(|| { let mut m = HashMap::new(); - m.insert(0i, 0i); + m.insert(0, 0); assert_eq!(m.len(), 1); }) } @@ -43,7 +43,7 @@ fn grow_by_insertion(b: &mut Bencher) { let mut m = HashMap::new(); - for i in range_inclusive(1i, 1000) { + for i in range_inclusive(1, 1000) { m.insert(i, i); } @@ -61,12 +61,12 @@ fn find_existing(b: &mut Bencher) { let mut m = HashMap::new(); - for i in range_inclusive(1i, 1000) { + for i in range_inclusive(1, 1000) { m.insert(i, i); } b.iter(|| { - for i in range_inclusive(1i, 1000) { + for i in range_inclusive(1, 1000) { m.contains_key(&i); } }); @@ -78,12 +78,12 @@ fn find_nonexisting(b: &mut Bencher) { let mut m = HashMap::new(); - for i in range_inclusive(1i, 1000) { + for i in range_inclusive(1, 1000) { m.insert(i, i); } b.iter(|| { - for i in range_inclusive(1001i, 2000) { + for i in range_inclusive(1001, 2000) { m.contains_key(&i); } }); @@ -95,11 +95,11 @@ fn hashmap_as_queue(b: &mut Bencher) { let mut m = HashMap::new(); - for i in range_inclusive(1i, 1000) { + for i in range_inclusive(1, 1000) { m.insert(i, i); } - let mut k = 1i; + let mut k = 1; b.iter(|| { m.remove(&k); @@ -114,11 +114,11 @@ fn get_remove_insert(b: &mut Bencher) { let mut m = HashMap::new(); - for i in range_inclusive(1i, 1000) { + for i in range_inclusive(1, 1000) { m.insert(i, i); } - let mut k = 1i; + let mut k = 1; b.iter(|| { m.get(&(k + 400)); diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index a291ec16a62..0b81e119821 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -536,7 +536,7 @@ impl<K, V, S, H> HashMap<K, V, S> /// /// let s = RandomState::new(); /// let mut map = HashMap::with_hash_state(s); - /// map.insert(1i, 2u); + /// map.insert(1, 2u); /// ``` #[inline] #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")] @@ -564,7 +564,7 @@ impl<K, V, S, H> HashMap<K, V, S> /// /// let s = RandomState::new(); /// let mut map = HashMap::with_capacity_and_hash_state(10, s); - /// map.insert(1i, 2u); + /// map.insert(1, 2u); /// ``` #[inline] #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")] @@ -809,7 +809,7 @@ impl<K, V, S, H> HashMap<K, V, S> /// use std::collections::HashMap; /// /// let mut map = HashMap::new(); - /// map.insert("a", 1i); + /// map.insert("a", 1); /// map.insert("b", 2); /// map.insert("c", 3); /// @@ -834,7 +834,7 @@ impl<K, V, S, H> HashMap<K, V, S> /// use std::collections::HashMap; /// /// let mut map = HashMap::new(); - /// map.insert("a", 1i); + /// map.insert("a", 1); /// map.insert("b", 2); /// map.insert("c", 3); /// @@ -859,7 +859,7 @@ impl<K, V, S, H> HashMap<K, V, S> /// use std::collections::HashMap; /// /// let mut map = HashMap::new(); - /// map.insert("a", 1i); + /// map.insert("a", 1); /// map.insert("b", 2); /// map.insert("c", 3); /// @@ -882,7 +882,7 @@ impl<K, V, S, H> HashMap<K, V, S> /// use std::collections::HashMap; /// /// let mut map = HashMap::new(); - /// map.insert("a", 1i); + /// map.insert("a", 1); /// map.insert("b", 2); /// map.insert("c", 3); /// @@ -910,7 +910,7 @@ impl<K, V, S, H> HashMap<K, V, S> /// use std::collections::HashMap; /// /// let mut map = HashMap::new(); - /// map.insert("a", 1i); + /// map.insert("a", 1); /// map.insert("b", 2); /// map.insert("c", 3); /// @@ -1622,7 +1622,7 @@ mod test_map { fn test_create_capacity_zero() { let mut m = HashMap::with_capacity(0); - assert!(m.insert(1i, 1i).is_none()); + assert!(m.insert(1, 1).is_none()); assert!(m.contains_key(&1)); assert!(!m.contains_key(&0)); @@ -1632,9 +1632,9 @@ mod test_map { fn test_insert() { let mut m = HashMap::new(); assert_eq!(m.len(), 0); - assert!(m.insert(1i, 2i).is_none()); + assert!(m.insert(1, 2).is_none()); assert_eq!(m.len(), 1); - assert!(m.insert(2i, 4i).is_none()); + assert!(m.insert(2, 4).is_none()); assert_eq!(m.len(), 2); assert_eq!(*m.get(&1).unwrap(), 2); assert_eq!(*m.get(&2).unwrap(), 4); @@ -1674,7 +1674,7 @@ mod test_map { #[test] fn test_drops() { DROP_VECTOR.with(|slot| { - *slot.borrow_mut() = repeat(0i).take(200).collect(); + *slot.borrow_mut() = repeat(0).take(200).collect(); }); { @@ -1807,10 +1807,10 @@ mod test_map { // Try this a few times to make sure we never screw up the hashmap's // internal state. - for _ in 0i..10 { + for _ in 0..10 { assert!(m.is_empty()); - for i in range_inclusive(1i, 1000) { + for i in range_inclusive(1, 1000) { assert!(m.insert(i, i).is_none()); for j in range_inclusive(1, i) { @@ -1824,12 +1824,12 @@ mod test_map { } } - for i in range_inclusive(1001i, 2000) { + for i in range_inclusive(1001, 2000) { assert!(!m.contains_key(&i)); } // remove forwards - for i in range_inclusive(1i, 1000) { + for i in range_inclusive(1, 1000) { assert!(m.remove(&i).is_some()); for j in range_inclusive(1, i) { @@ -1841,16 +1841,16 @@ mod test_map { } } - for i in range_inclusive(1i, 1000) { + for i in range_inclusive(1, 1000) { assert!(!m.contains_key(&i)); } - for i in range_inclusive(1i, 1000) { + for i in range_inclusive(1, 1000) { assert!(m.insert(i, i).is_none()); } // remove backwards - for i in range_step_inclusive(1000i, 1, -1) { + for i in range_step_inclusive(1000, 1, -1) { assert!(m.remove(&i).is_some()); for j in range_inclusive(i, 1000) { @@ -1867,9 +1867,9 @@ mod test_map { #[test] fn test_find_mut() { let mut m = HashMap::new(); - assert!(m.insert(1i, 12i).is_none()); - assert!(m.insert(2i, 8i).is_none()); - assert!(m.insert(5i, 14i).is_none()); + assert!(m.insert(1, 12).is_none()); + assert!(m.insert(2, 8).is_none()); + assert!(m.insert(5, 14).is_none()); let new = 100; match m.get_mut(&5) { None => panic!(), Some(x) => *x = new @@ -1880,18 +1880,18 @@ mod test_map { #[test] fn test_insert_overwrite() { let mut m = HashMap::new(); - assert!(m.insert(1i, 2i).is_none()); + assert!(m.insert(1, 2).is_none()); assert_eq!(*m.get(&1).unwrap(), 2); - assert!(!m.insert(1i, 3i).is_none()); + assert!(!m.insert(1, 3).is_none()); assert_eq!(*m.get(&1).unwrap(), 3); } #[test] fn test_insert_conflicts() { let mut m = HashMap::with_capacity(4); - assert!(m.insert(1i, 2i).is_none()); - assert!(m.insert(5i, 3i).is_none()); - assert!(m.insert(9i, 4i).is_none()); + assert!(m.insert(1, 2).is_none()); + assert!(m.insert(5, 3).is_none()); + assert!(m.insert(9, 4).is_none()); assert_eq!(*m.get(&9).unwrap(), 4); assert_eq!(*m.get(&5).unwrap(), 3); assert_eq!(*m.get(&1).unwrap(), 2); @@ -1900,7 +1900,7 @@ mod test_map { #[test] fn test_conflict_remove() { let mut m = HashMap::with_capacity(4); - assert!(m.insert(1i, 2i).is_none()); + assert!(m.insert(1, 2).is_none()); assert_eq!(*m.get(&1).unwrap(), 2); assert!(m.insert(5, 3).is_none()); assert_eq!(*m.get(&1).unwrap(), 2); @@ -1917,7 +1917,7 @@ mod test_map { #[test] fn test_is_empty() { let mut m = HashMap::with_capacity(4); - assert!(m.insert(1i, 2i).is_none()); + assert!(m.insert(1, 2).is_none()); assert!(!m.is_empty()); assert!(m.remove(&1).is_some()); assert!(m.is_empty()); @@ -1926,7 +1926,7 @@ mod test_map { #[test] fn test_pop() { let mut m = HashMap::new(); - m.insert(1i, 2i); + m.insert(1, 2); assert_eq!(m.remove(&1), Some(2)); assert_eq!(m.remove(&1), None); } @@ -1950,7 +1950,7 @@ mod test_map { #[test] fn test_keys() { - let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')]; + let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')]; let map = vec.into_iter().collect::<HashMap<int, char>>(); let keys = map.keys().map(|&k| k).collect::<Vec<int>>(); assert_eq!(keys.len(), 3); @@ -1961,7 +1961,7 @@ mod test_map { #[test] fn test_values() { - let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')]; + let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')]; let map = vec.into_iter().collect::<HashMap<int, char>>(); let values = map.values().map(|&v| v).collect::<Vec<char>>(); assert_eq!(values.len(), 3); @@ -1973,8 +1973,8 @@ mod test_map { #[test] fn test_find() { let mut m = HashMap::new(); - assert!(m.get(&1i).is_none()); - m.insert(1i, 2i); + assert!(m.get(&1).is_none()); + m.insert(1, 2); match m.get(&1) { None => panic!(), Some(v) => assert_eq!(*v, 2) @@ -1984,17 +1984,17 @@ mod test_map { #[test] fn test_eq() { let mut m1 = HashMap::new(); - m1.insert(1i, 2i); - m1.insert(2i, 3i); - m1.insert(3i, 4i); + m1.insert(1, 2); + m1.insert(2, 3); + m1.insert(3, 4); let mut m2 = HashMap::new(); - m2.insert(1i, 2i); - m2.insert(2i, 3i); + m2.insert(1, 2); + m2.insert(2, 3); assert!(m1 != m2); - m2.insert(3i, 4i); + m2.insert(3, 4); assert_eq!(m1, m2); } @@ -2004,8 +2004,8 @@ mod test_map { let mut map: HashMap<int, int> = HashMap::new(); let empty: HashMap<int, int> = HashMap::new(); - map.insert(1i, 2i); - map.insert(3i, 4i); + map.insert(1, 2); + map.insert(3, 4); let map_str = format!("{:?}", map); @@ -2127,7 +2127,7 @@ mod test_map { #[test] fn test_from_iter() { - let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; + let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; let map: HashMap<int, int> = xs.iter().map(|&x| x).collect(); @@ -2138,7 +2138,7 @@ mod test_map { #[test] fn test_size_hint() { - let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; + let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; let map: HashMap<int, int> = xs.iter().map(|&x| x).collect(); @@ -2151,7 +2151,7 @@ mod test_map { #[test] fn test_iter_len() { - let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; + let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; let map: HashMap<int, int> = xs.iter().map(|&x| x).collect(); @@ -2164,7 +2164,7 @@ mod test_map { #[test] fn test_mut_size_hint() { - let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; + let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect(); @@ -2177,7 +2177,7 @@ mod test_map { #[test] fn test_iter_mut_len() { - let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; + let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)]; let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect(); @@ -2213,7 +2213,7 @@ mod test_map { #[test] fn test_entry(){ - let xs = [(1i, 10i), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)]; + let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)]; let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect(); diff --git a/src/libstd/collections/hash/set.rs b/src/libstd/collections/hash/set.rs index 2b15e50c6fa..3095c2c0e41 100644 --- a/src/libstd/collections/hash/set.rs +++ b/src/libstd/collections/hash/set.rs @@ -168,7 +168,7 @@ impl<T, S, H> HashSet<T, S> /// /// let s = RandomState::new(); /// let mut set = HashSet::with_capacity_and_hash_state(10u, s); - /// set.insert(1i); + /// set.insert(1); /// ``` #[inline] #[unstable(feature = "std_misc", reason = "hasher stuff is unclear")] @@ -290,8 +290,8 @@ impl<T, S, H> HashSet<T, S> /// /// ``` /// use std::collections::HashSet; - /// let a: HashSet<int> = [1i, 2, 3].iter().map(|&x| x).collect(); - /// let b: HashSet<int> = [4i, 2, 3, 4].iter().map(|&x| x).collect(); + /// let a: HashSet<int> = [1, 2, 3].iter().map(|&x| x).collect(); + /// let b: HashSet<int> = [4, 2, 3, 4].iter().map(|&x| x).collect(); /// /// // Can be seen as `a - b`. /// for x in a.difference(&b) { @@ -299,12 +299,12 @@ impl<T, S, H> HashSet<T, S> /// } /// /// let diff: HashSet<int> = a.difference(&b).map(|&x| x).collect(); - /// assert_eq!(diff, [1i].iter().map(|&x| x).collect()); + /// assert_eq!(diff, [1].iter().map(|&x| x).collect()); /// /// // Note that difference is not symmetric, /// // and `b - a` means something else: /// let diff: HashSet<int> = b.difference(&a).map(|&x| x).collect(); - /// assert_eq!(diff, [4i].iter().map(|&x| x).collect()); + /// assert_eq!(diff, [4].iter().map(|&x| x).collect()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn difference<'a>(&'a self, other: &'a HashSet<T, S>) -> Difference<'a, T, S> { @@ -320,8 +320,8 @@ impl<T, S, H> HashSet<T, S> /// /// ``` /// use std::collections::HashSet; - /// let a: HashSet<int> = [1i, 2, 3].iter().map(|&x| x).collect(); - /// let b: HashSet<int> = [4i, 2, 3, 4].iter().map(|&x| x).collect(); + /// let a: HashSet<int> = [1, 2, 3].iter().map(|&x| x).collect(); + /// let b: HashSet<int> = [4, 2, 3, 4].iter().map(|&x| x).collect(); /// /// // Print 1, 4 in arbitrary order. /// for x in a.symmetric_difference(&b) { @@ -332,7 +332,7 @@ impl<T, S, H> HashSet<T, S> /// let diff2: HashSet<int> = b.symmetric_difference(&a).map(|&x| x).collect(); /// /// assert_eq!(diff1, diff2); - /// assert_eq!(diff1, [1i, 4].iter().map(|&x| x).collect()); + /// assert_eq!(diff1, [1, 4].iter().map(|&x| x).collect()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn symmetric_difference<'a>(&'a self, other: &'a HashSet<T, S>) @@ -346,8 +346,8 @@ impl<T, S, H> HashSet<T, S> /// /// ``` /// use std::collections::HashSet; - /// let a: HashSet<int> = [1i, 2, 3].iter().map(|&x| x).collect(); - /// let b: HashSet<int> = [4i, 2, 3, 4].iter().map(|&x| x).collect(); + /// let a: HashSet<int> = [1, 2, 3].iter().map(|&x| x).collect(); + /// let b: HashSet<int> = [4, 2, 3, 4].iter().map(|&x| x).collect(); /// /// // Print 2, 3 in arbitrary order. /// for x in a.intersection(&b) { @@ -355,7 +355,7 @@ impl<T, S, H> HashSet<T, S> /// } /// /// let diff: HashSet<int> = a.intersection(&b).map(|&x| x).collect(); - /// assert_eq!(diff, [2i, 3].iter().map(|&x| x).collect()); + /// assert_eq!(diff, [2, 3].iter().map(|&x| x).collect()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn intersection<'a>(&'a self, other: &'a HashSet<T, S>) -> Intersection<'a, T, S> { @@ -371,8 +371,8 @@ impl<T, S, H> HashSet<T, S> /// /// ``` /// use std::collections::HashSet; - /// let a: HashSet<int> = [1i, 2, 3].iter().map(|&x| x).collect(); - /// let b: HashSet<int> = [4i, 2, 3, 4].iter().map(|&x| x).collect(); + /// let a: HashSet<int> = [1, 2, 3].iter().map(|&x| x).collect(); + /// let b: HashSet<int> = [4, 2, 3, 4].iter().map(|&x| x).collect(); /// /// // Print 1, 2, 3, 4 in arbitrary order. /// for x in a.union(&b) { @@ -380,7 +380,7 @@ impl<T, S, H> HashSet<T, S> /// } /// /// let diff: HashSet<int> = a.union(&b).map(|&x| x).collect(); - /// assert_eq!(diff, [1i, 2, 3, 4].iter().map(|&x| x).collect()); + /// assert_eq!(diff, [1, 2, 3, 4].iter().map(|&x| x).collect()); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn union<'a>(&'a self, other: &'a HashSet<T, S>) -> Union<'a, T, S> { @@ -955,8 +955,8 @@ mod test_set { let mut ys = HashSet::new(); assert!(xs.is_disjoint(&ys)); assert!(ys.is_disjoint(&xs)); - assert!(xs.insert(5i)); - assert!(ys.insert(11i)); + assert!(xs.insert(5)); + assert!(ys.insert(11)); assert!(xs.is_disjoint(&ys)); assert!(ys.is_disjoint(&xs)); assert!(xs.insert(7)); @@ -974,13 +974,13 @@ mod test_set { #[test] fn test_subset_and_superset() { let mut a = HashSet::new(); - assert!(a.insert(0i)); + assert!(a.insert(0)); assert!(a.insert(5)); assert!(a.insert(11)); assert!(a.insert(7)); let mut b = HashSet::new(); - assert!(b.insert(0i)); + assert!(b.insert(0)); assert!(b.insert(7)); assert!(b.insert(19)); assert!(b.insert(250)); @@ -1018,7 +1018,7 @@ mod test_set { let mut a = HashSet::new(); let mut b = HashSet::new(); - assert!(a.insert(11i)); + assert!(a.insert(11)); assert!(a.insert(1)); assert!(a.insert(3)); assert!(a.insert(77)); @@ -1026,7 +1026,7 @@ mod test_set { assert!(a.insert(5)); assert!(a.insert(-5)); - assert!(b.insert(2i)); + assert!(b.insert(2)); assert!(b.insert(11)); assert!(b.insert(77)); assert!(b.insert(-9)); @@ -1048,13 +1048,13 @@ mod test_set { let mut a = HashSet::new(); let mut b = HashSet::new(); - assert!(a.insert(1i)); + assert!(a.insert(1)); assert!(a.insert(3)); assert!(a.insert(5)); assert!(a.insert(9)); assert!(a.insert(11)); - assert!(b.insert(3i)); + assert!(b.insert(3)); assert!(b.insert(9)); let mut i = 0; @@ -1071,13 +1071,13 @@ mod test_set { let mut a = HashSet::new(); let mut b = HashSet::new(); - assert!(a.insert(1i)); + assert!(a.insert(1)); assert!(a.insert(3)); assert!(a.insert(5)); assert!(a.insert(9)); assert!(a.insert(11)); - assert!(b.insert(-2i)); + assert!(b.insert(-2)); assert!(b.insert(3)); assert!(b.insert(9)); assert!(b.insert(14)); @@ -1097,7 +1097,7 @@ mod test_set { let mut a = HashSet::new(); let mut b = HashSet::new(); - assert!(a.insert(1i)); + assert!(a.insert(1)); assert!(a.insert(3)); assert!(a.insert(5)); assert!(a.insert(9)); @@ -1106,7 +1106,7 @@ mod test_set { assert!(a.insert(19)); assert!(a.insert(24)); - assert!(b.insert(-2i)); + assert!(b.insert(-2)); assert!(b.insert(1)); assert!(b.insert(5)); assert!(b.insert(9)); @@ -1124,7 +1124,7 @@ mod test_set { #[test] fn test_from_iter() { - let xs = [1i, 2, 3, 4, 5, 6, 7, 8, 9]; + let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9]; let set: HashSet<int> = xs.iter().map(|&x| x).collect(); @@ -1154,13 +1154,13 @@ mod test_set { // I'm keeping them around to prevent a regression. let mut s1 = HashSet::new(); - s1.insert(1i); + s1.insert(1); s1.insert(2); s1.insert(3); let mut s2 = HashSet::new(); - s2.insert(1i); + s2.insert(1); s2.insert(2); assert!(s1 != s2); @@ -1175,7 +1175,7 @@ mod test_set { let mut set: HashSet<int> = HashSet::new(); let empty: HashSet<int> = HashSet::new(); - set.insert(1i); + set.insert(1); set.insert(2); let set_str = format!("{:?}", set); @@ -1201,7 +1201,7 @@ mod test_set { let mut s: HashSet<int> = (1is..100).collect(); // try this a bunch of times to make sure we don't screw up internal state. - for _ in 0i..20 { + for _ in 0..20 { assert_eq!(s.len(), 99); { diff --git a/src/libstd/collections/hash/table.rs b/src/libstd/collections/hash/table.rs index 9e6a45d8bf0..429923890ef 100644 --- a/src/libstd/collections/hash/table.rs +++ b/src/libstd/collections/hash/table.rs @@ -274,7 +274,7 @@ impl<K, V, M: Deref<Target=RawTable<K, V>>> Bucket<K, V, M> { // ... and it's zero at all other times. let maybe_wraparound_dist = (self.idx ^ (self.idx + 1)) & self.table.capacity(); // Finally, we obtain the offset 1 or the offset -cap + 1. - let dist = 1i - (maybe_wraparound_dist as int); + let dist = 1 - (maybe_wraparound_dist as int); self.idx += 1; diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs index 4ab43e875cd..1b93dc7119d 100644 --- a/src/libstd/fmt.rs +++ b/src/libstd/fmt.rs @@ -29,10 +29,10 @@ //! ``` //! format!("Hello"); // => "Hello" //! format!("Hello, {}!", "world"); // => "Hello, world!" -//! format!("The number is {}", 1i); // => "The number is 1" -//! format!("{:?}", (3i, 4i)); // => "(3i, 4i)" -//! format!("{value}", value=4i); // => "4" -//! format!("{} {}", 1i, 2u); // => "1 2" +//! format!("The number is {}", 1); // => "The number is 1" +//! format!("{:?}", (3, 4)); // => "(3, 4)" +//! format!("{value}", value=4); // => "4" +//! format!("{} {}", 1, 2u); // => "1 2" //! ``` //! //! From these, you can see that the first argument is a format string. It is @@ -55,7 +55,7 @@ //! the iterator advances. This leads to behavior like this: //! //! ```rust -//! format!("{1} {} {0} {}", 1i, 2i); // => "2 1 1 2" +//! format!("{1} {} {0} {}", 1, 2); // => "2 1 1 2" //! ``` //! //! The internal iterator over the argument has not been advanced by the time @@ -83,8 +83,8 @@ //! //! ``` //! format!("{argument}", argument = "test"); // => "test" -//! format!("{name} {}", 1i, name = 2i); // => "2 1" -//! format!("{a} {c} {b}", a="a", b='b', c=3i); // => "a 3 b" +//! format!("{name} {}", 1, name = 2); // => "2 1" +//! format!("{a} {c} {b}", a="a", b='b', c=3); // => "a 3 b" //! ``` //! //! It is illegal to put positional parameters (those without names) after @@ -206,7 +206,7 @@ //! let myvector = Vector2D { x: 3, y: 4 }; //! //! println!("{}", myvector); // => "(3, 4)" -//! println!("{:?}", myvector); // => "Vector2D {x: 3i, y:4i}" +//! println!("{:?}", myvector); // => "Vector2D {x: 3, y:4}" //! println!("{:10.3b}", myvector); // => " 5.000" //! } //! ``` diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs index 9c3285a9d08..e91e8241a55 100644 --- a/src/libstd/macros.rs +++ b/src/libstd/macros.rs @@ -32,7 +32,7 @@ /// # #![allow(unreachable_code)] /// panic!(); /// panic!("this is a terrible mistake!"); -/// panic!(4i); // panic with the value of 4 to be collected elsewhere +/// panic!(4); // panic with the value of 4 to be collected elsewhere /// panic!("this is a {} {message}", "fancy", message = "message"); /// ``` #[macro_export] @@ -68,7 +68,7 @@ macro_rules! panic { /// ``` /// format!("test"); /// format!("hello {}", "world!"); -/// format!("x = {}, y = {y}", 10i, y = 30i); +/// format!("x = {}, y = {y}", 10, y = 30); /// ``` #[macro_export] #[stable(feature = "rust1", since = "1.0.0")] @@ -282,7 +282,7 @@ pub mod builtin { /// # Example /// /// ``` - /// let s = concat!("test", 10i, 'b', true); + /// let s = concat!("test", 10, 'b', true); /// assert_eq!(s, "test10btrue"); /// ``` #[macro_export] diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index d010a5de622..a996ad1f5b3 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -356,11 +356,11 @@ pub fn test_num<T>(ten: T, two: T) where + Rem<Output=T> + Debug + Copy { - assert_eq!(ten.add(two), cast(12i).unwrap()); - assert_eq!(ten.sub(two), cast(8i).unwrap()); - assert_eq!(ten.mul(two), cast(20i).unwrap()); - assert_eq!(ten.div(two), cast(5i).unwrap()); - assert_eq!(ten.rem(two), cast(0i).unwrap()); + assert_eq!(ten.add(two), cast(12).unwrap()); + assert_eq!(ten.sub(two), cast(8).unwrap()); + assert_eq!(ten.mul(two), cast(20).unwrap()); + assert_eq!(ten.div(two), cast(5).unwrap()); + assert_eq!(ten.rem(two), cast(0).unwrap()); assert_eq!(ten.add(two), ten + two); assert_eq!(ten.sub(two), ten - two); @@ -393,7 +393,7 @@ mod tests { assert_eq!(20u16, _20.to_u16().unwrap()); assert_eq!(20u32, _20.to_u32().unwrap()); assert_eq!(20u64, _20.to_u64().unwrap()); - assert_eq!(20i, _20.to_int().unwrap()); + assert_eq!(20, _20.to_int().unwrap()); assert_eq!(20i8, _20.to_i8().unwrap()); assert_eq!(20i16, _20.to_i16().unwrap()); assert_eq!(20i32, _20.to_i32().unwrap()); @@ -406,7 +406,7 @@ mod tests { assert_eq!(_20, NumCast::from(20u16).unwrap()); assert_eq!(_20, NumCast::from(20u32).unwrap()); assert_eq!(_20, NumCast::from(20u64).unwrap()); - assert_eq!(_20, NumCast::from(20i).unwrap()); + assert_eq!(_20, NumCast::from(20).unwrap()); assert_eq!(_20, NumCast::from(20i8).unwrap()); assert_eq!(_20, NumCast::from(20i16).unwrap()); assert_eq!(_20, NumCast::from(20i32).unwrap()); @@ -419,7 +419,7 @@ mod tests { assert_eq!(_20, cast(20u16).unwrap()); assert_eq!(_20, cast(20u32).unwrap()); assert_eq!(_20, cast(20u64).unwrap()); - assert_eq!(_20, cast(20i).unwrap()); + assert_eq!(_20, cast(20).unwrap()); assert_eq!(_20, cast(20i8).unwrap()); assert_eq!(_20, cast(20i16).unwrap()); assert_eq!(_20, cast(20i32).unwrap()); @@ -438,7 +438,7 @@ mod tests { #[test] fn test_i16_cast() { test_cast_20!(20i16) } #[test] fn test_i32_cast() { test_cast_20!(20i32) } #[test] fn test_i64_cast() { test_cast_20!(20i64) } - #[test] fn test_int_cast() { test_cast_20!(20i) } + #[test] fn test_int_cast() { test_cast_20!(20) } #[test] fn test_f32_cast() { test_cast_20!(20f32) } #[test] fn test_f64_cast() { test_cast_20!(20f64) } @@ -831,23 +831,23 @@ mod tests { #[test] fn test_saturating_add_int() { use int::{MIN,MAX}; - assert_eq!(3i.saturating_add(5i), 8i); - assert_eq!(3i.saturating_add(MAX-1), MAX); + assert_eq!(3.saturating_add(5), 8); + assert_eq!(3.saturating_add(MAX-1), MAX); assert_eq!(MAX.saturating_add(MAX), MAX); assert_eq!((MAX-2).saturating_add(1), MAX-1); - assert_eq!(3i.saturating_add(-5i), -2i); - assert_eq!(MIN.saturating_add(-1i), MIN); - assert_eq!((-2i).saturating_add(-MAX), MIN); + assert_eq!(3.saturating_add(-5), -2); + assert_eq!(MIN.saturating_add(-1), MIN); + assert_eq!((-2).saturating_add(-MAX), MIN); } #[test] fn test_saturating_sub_int() { use int::{MIN,MAX}; - assert_eq!(3i.saturating_sub(5i), -2i); - assert_eq!(MIN.saturating_sub(1i), MIN); - assert_eq!((-2i).saturating_sub(MAX), MIN); - assert_eq!(3i.saturating_sub(-5i), 8i); - assert_eq!(3i.saturating_sub(-(MAX-1)), MAX); + assert_eq!(3.saturating_sub(5), -2); + assert_eq!(MIN.saturating_sub(1), MIN); + assert_eq!((-2).saturating_sub(MAX), MIN); + assert_eq!(3.saturating_sub(-5), 8); + assert_eq!(3.saturating_sub(-(MAX-1)), MAX); assert_eq!(MAX.saturating_sub(-MAX), MAX); assert_eq!((MAX-2).saturating_sub(-1), MAX-1); } @@ -1010,10 +1010,10 @@ mod tests { assert_eq!(result, naive_pow($num, $exp)); }} } - assert_pow!((3i, 0 ) => 1); - assert_pow!((5i, 1 ) => 5); - assert_pow!((-4i, 2 ) => 16); - assert_pow!((8i, 3 ) => 512); + assert_pow!((3, 0 ) => 1); + assert_pow!((5, 1 ) => 5); + assert_pow!((-4, 2 ) => 16); + assert_pow!((8, 3 ) => 512); assert_pow!((2u64, 50) => 1125899906842624); } } diff --git a/src/libstd/old_io/fs.rs b/src/libstd/old_io/fs.rs index 99c7e399b1c..d048cde2613 100644 --- a/src/libstd/old_io/fs.rs +++ b/src/libstd/old_io/fs.rs @@ -981,7 +981,7 @@ mod test { let initial_msg = "food-is-yummy"; let overwrite_msg = "-the-bar!!"; let final_msg = "foo-the-bar!!"; - let seek_idx = 3i; + let seek_idx = 3; let mut read_mem = [0; 13]; let tmpdir = tmpdir(); let filename = &tmpdir.join("file_rt_io_file_test_seek_and_write.txt"); @@ -1101,7 +1101,7 @@ mod test { let dir = &tmpdir.join("di_readdir"); check!(mkdir(dir, old_io::USER_RWX)); let prefix = "foo"; - for n in 0i..3 { + for n in 0..3 { let f = dir.join(format!("{}.txt", n)); let mut w = check!(File::create(&f)); let msg_str = format!("{}{}", prefix, n.to_string()); diff --git a/src/libstd/old_io/net/tcp.rs b/src/libstd/old_io/net/tcp.rs index e0feaa4e558..0f513dd8995 100644 --- a/src/libstd/old_io/net/tcp.rs +++ b/src/libstd/old_io/net/tcp.rs @@ -1160,7 +1160,7 @@ mod test { tx.send(TcpStream::connect(addr).unwrap()).unwrap(); }); let _l = rx.recv().unwrap(); - for i in 0i..1001 { + for i in 0..1001 { match a.accept() { Ok(..) => break, Err(ref e) if e.kind == TimedOut => {} @@ -1260,7 +1260,7 @@ mod test { assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut); s.set_timeout(Some(20)); - for i in 0i..1001 { + for i in 0..1001 { match s.write(&[0; 128 * 1024]) { Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {}, Err(IoError { kind: TimedOut, .. }) => break, @@ -1299,7 +1299,7 @@ mod test { assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut); tx.send(()).unwrap(); - for _ in 0i..100 { + for _ in 0..100 { assert!(s.write(&[0;128 * 1024]).is_ok()); } } @@ -1318,7 +1318,7 @@ mod test { let mut s = a.accept().unwrap(); s.set_write_timeout(Some(20)); - for i in 0i..1001 { + for i in 0..1001 { match s.write(&[0; 128 * 1024]) { Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {}, Err(IoError { kind: TimedOut, .. }) => break, @@ -1388,7 +1388,7 @@ mod test { }); // Try to ensure that the reading clone is indeed reading - for _ in 0i..50 { + for _ in 0..50 { ::thread::Thread::yield_now(); } diff --git a/src/libstd/old_io/process.rs b/src/libstd/old_io/process.rs index d3e60de2780..f3bf482ae25 100644 --- a/src/libstd/old_io/process.rs +++ b/src/libstd/old_io/process.rs @@ -1142,7 +1142,7 @@ mod tests { fn test_zero() { let mut p = sleeper(); p.signal_kill().unwrap(); - for _ in 0i..20 { + for _ in 0..20 { if p.signal(0).is_err() { assert!(!p.wait().unwrap().success()); return diff --git a/src/libstd/os.rs b/src/libstd/os.rs index 38c0a7b8f9b..600ca60349a 100644 --- a/src/libstd/os.rs +++ b/src/libstd/os.rs @@ -1484,7 +1484,7 @@ mod tests { #[ignore] fn test_getenv_big() { let mut s = "".to_string(); - let mut i = 0i; + let mut i = 0; while i < 100 { s.push_str("aaaaaaaaaa"); i += 1; diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs index 2969eec4737..211abc2fc83 100644 --- a/src/libstd/rand/mod.rs +++ b/src/libstd/rand/mod.rs @@ -427,7 +427,7 @@ pub fn random<T: Rand>() -> T { /// use std::rand::{thread_rng, sample}; /// /// let mut rng = thread_rng(); -/// let sample = sample(&mut rng, 1i..100, 5); +/// let sample = sample(&mut rng, 1..100, 5); /// println!("{:?}", sample); /// ``` pub fn sample<T, I: Iterator<Item=T>, R: Rng>(rng: &mut R, @@ -481,16 +481,16 @@ mod test { fn test_gen_range() { let mut r = thread_rng(); for _ in 0u..1000 { - let a = r.gen_range(-3i, 42); + let a = r.gen_range(-3, 42); assert!(a >= -3 && a < 42); - assert_eq!(r.gen_range(0i, 1), 0); - assert_eq!(r.gen_range(-12i, -11), -12); + assert_eq!(r.gen_range(0, 1), 0); + assert_eq!(r.gen_range(-12, -11), -12); } for _ in 0u..1000 { - let a = r.gen_range(10i, 42); + let a = r.gen_range(10, 42); assert!(a >= 10 && a < 42); - assert_eq!(r.gen_range(0i, 1), 0); + assert_eq!(r.gen_range(0, 1), 0); assert_eq!(r.gen_range(3_000_000, 3_000_001), 3_000_000); } @@ -500,7 +500,7 @@ mod test { #[should_fail] fn test_gen_range_panic_int() { let mut r = thread_rng(); - r.gen_range(5i, -2); + r.gen_range(5, -2); } #[test] @@ -544,7 +544,7 @@ mod test { #[test] fn test_choose() { let mut r = thread_rng(); - assert_eq!(r.choose(&[1i, 1, 1]).map(|&x|x), Some(1)); + assert_eq!(r.choose(&[1, 1, 1]).map(|&x|x), Some(1)); let v: &[int] = &[]; assert_eq!(r.choose(v), None); @@ -555,16 +555,16 @@ mod test { let mut r = thread_rng(); let empty: &mut [int] = &mut []; r.shuffle(empty); - let mut one = [1i]; + let mut one = [1]; r.shuffle(&mut one); let b: &[_] = &[1]; assert_eq!(one, b); - let mut two = [1i, 2]; + let mut two = [1, 2]; r.shuffle(&mut two); assert!(two == [1, 2] || two == [2, 1]); - let mut x = [1i, 1, 1]; + let mut x = [1, 1, 1]; r.shuffle(&mut x); let b: &[_] = &[1, 1, 1]; assert_eq!(x, b); @@ -574,7 +574,7 @@ mod test { fn test_thread_rng() { let mut r = thread_rng(); r.gen::<int>(); - let mut v = [1i, 1, 1]; + let mut v = [1, 1, 1]; r.shuffle(&mut v); let b: &[_] = &[1, 1, 1]; assert_eq!(v, b); @@ -597,8 +597,8 @@ mod test { #[test] fn test_sample() { - let min_val = 1i; - let max_val = 100i; + let min_val = 1; + let max_val = 100; let mut r = thread_rng(); let vals = (min_val..max_val).collect::<Vec<int>>(); diff --git a/src/libstd/sync/future.rs b/src/libstd/sync/future.rs index a79fb684f47..8340652d19a 100644 --- a/src/libstd/sync/future.rs +++ b/src/libstd/sync/future.rs @@ -193,7 +193,7 @@ mod test { #[test] fn test_get_ref_method() { - let mut f = Future::from_value(22i); + let mut f = Future::from_value(22); assert_eq!(*f.get_ref(), 22); } diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs index 6a43eccbaba..b77631935b9 100644 --- a/src/libstd/sync/mpsc/mod.rs +++ b/src/libstd/sync/mpsc/mod.rs @@ -59,9 +59,9 @@ //! // Create a simple streaming channel //! let (tx, rx) = channel(); //! Thread::spawn(move|| { -//! tx.send(10i).unwrap(); +//! tx.send(10).unwrap(); //! }); -//! assert_eq!(rx.recv().unwrap(), 10i); +//! assert_eq!(rx.recv().unwrap(), 10); //! ``` //! //! Shared usage: @@ -74,14 +74,14 @@ //! // where tx is the sending half (tx for transmission), and rx is the receiving //! // half (rx for receiving). //! let (tx, rx) = channel(); -//! for i in 0i..10i { +//! for i in 0..10 { //! let tx = tx.clone(); //! Thread::spawn(move|| { //! tx.send(i).unwrap(); //! }); //! } //! -//! for _ in 0i..10i { +//! for _ in 0..10 { //! let j = rx.recv().unwrap(); //! assert!(0 <= j && j < 10); //! } @@ -514,15 +514,15 @@ pub fn channel<T: Send>() -> (Sender<T>, Receiver<T>) { /// let (tx, rx) = sync_channel(1); /// /// // this returns immediately -/// tx.send(1i).unwrap(); +/// tx.send(1).unwrap(); /// /// Thread::spawn(move|| { /// // this will block until the previous message has been received -/// tx.send(2i).unwrap(); +/// tx.send(2).unwrap(); /// }); /// -/// assert_eq!(rx.recv().unwrap(), 1i); -/// assert_eq!(rx.recv().unwrap(), 2i); +/// assert_eq!(rx.recv().unwrap(), 1); +/// assert_eq!(rx.recv().unwrap(), 2); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn sync_channel<T: Send>(bound: uint) -> (SyncSender<T>, Receiver<T>) { @@ -562,11 +562,11 @@ impl<T: Send> Sender<T> { /// let (tx, rx) = channel(); /// /// // This send is always successful - /// tx.send(1i).unwrap(); + /// tx.send(1).unwrap(); /// /// // This send will fail because the receiver is gone /// drop(rx); - /// assert_eq!(tx.send(1i).err().unwrap().0, 1); + /// assert_eq!(tx.send(1).err().unwrap().0, 1); /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn send(&self, t: T) -> Result<(), SendError<T>> { @@ -1045,7 +1045,7 @@ mod test { #[test] fn drop_full() { let (tx, _rx) = channel(); - tx.send(box 1i).unwrap(); + tx.send(box 1).unwrap(); } #[test] @@ -1053,7 +1053,7 @@ mod test { let (tx, _rx) = channel(); drop(tx.clone()); drop(tx.clone()); - tx.send(box 1i).unwrap(); + tx.send(box 1).unwrap(); } #[test] @@ -1147,7 +1147,7 @@ mod test { fn stress() { let (tx, rx) = channel::<int>(); let t = Thread::scoped(move|| { - for _ in 0u..10000 { tx.send(1i).unwrap(); } + for _ in 0u..10000 { tx.send(1).unwrap(); } }); for _ in 0u..10000 { assert_eq!(rx.recv().unwrap(), 1); @@ -1187,13 +1187,13 @@ mod test { let (tx2, rx2) = channel::<int>(); let t1 = Thread::scoped(move|| { tx1.send(()).unwrap(); - for _ in 0i..40 { + for _ in 0..40 { assert_eq!(rx2.recv().unwrap(), 1); } }); rx1.recv().unwrap(); let t2 = Thread::scoped(move|| { - for _ in 0i..40 { + for _ in 0..40 { tx2.send(1).unwrap(); } }); @@ -1205,7 +1205,7 @@ mod test { fn recv_from_outside_runtime() { let (tx, rx) = channel::<int>(); let t = Thread::scoped(move|| { - for _ in 0i..40 { + for _ in 0..40 { assert_eq!(rx.recv().unwrap(), 1); } }); @@ -1391,9 +1391,9 @@ mod test { for _ in 0..stress_factor() { let (tx, rx) = channel(); let _t = Thread::spawn(move|| { - tx.send(box 10i).unwrap(); + tx.send(box 10).unwrap(); }); - assert!(rx.recv().unwrap() == box 10i); + assert!(rx.recv().unwrap() == box 10); } } @@ -1429,8 +1429,8 @@ mod test { fn recv_a_lot() { // Regression test that we don't run out of stack in scheduler context let (tx, rx) = channel(); - for _ in 0i..10000 { tx.send(()).unwrap(); } - for _ in 0i..10000 { rx.recv().unwrap(); } + for _ in 0..10000 { tx.send(()).unwrap(); } + for _ in 0..10000 { rx.recv().unwrap(); } } #[test] @@ -1567,7 +1567,7 @@ mod sync_tests { #[test] fn drop_full() { let (tx, _rx) = sync_channel(1); - tx.send(box 1i).unwrap(); + tx.send(box 1).unwrap(); } #[test] @@ -1855,9 +1855,9 @@ mod sync_tests { for _ in 0..stress_factor() { let (tx, rx) = sync_channel::<Box<int>>(0); let _t = Thread::spawn(move|| { - tx.send(box 10i).unwrap(); + tx.send(box 10).unwrap(); }); - assert!(rx.recv().unwrap() == box 10i); + assert!(rx.recv().unwrap() == box 10); } } diff --git a/src/libstd/sync/mpsc/mpsc_queue.rs b/src/libstd/sync/mpsc/mpsc_queue.rs index 53eba131674..3980d2a1fef 100644 --- a/src/libstd/sync/mpsc/mpsc_queue.rs +++ b/src/libstd/sync/mpsc/mpsc_queue.rs @@ -165,8 +165,8 @@ mod tests { #[test] fn test_full() { let q = Queue::new(); - q.push(box 1i); - q.push(box 2i); + q.push(box 1); + q.push(box 2); } #[test] diff --git a/src/libstd/sync/mpsc/select.rs b/src/libstd/sync/mpsc/select.rs index f70e2dee8ee..85c7572404b 100644 --- a/src/libstd/sync/mpsc/select.rs +++ b/src/libstd/sync/mpsc/select.rs @@ -32,15 +32,15 @@ //! let (tx1, rx1) = channel(); //! let (tx2, rx2) = channel(); //! -//! tx1.send(1i).unwrap(); -//! tx2.send(2i).unwrap(); +//! tx1.send(1).unwrap(); +//! tx2.send(2).unwrap(); //! //! select! { //! val = rx1.recv() => { -//! assert_eq!(val.unwrap(), 1i); +//! assert_eq!(val.unwrap(), 1); //! }, //! val = rx2.recv() => { -//! assert_eq!(val.unwrap(), 2i); +//! assert_eq!(val.unwrap(), 2); //! } //! } //! ``` diff --git a/src/libstd/sync/mpsc/spsc_queue.rs b/src/libstd/sync/mpsc/spsc_queue.rs index 45503f0b58e..c80aa567173 100644 --- a/src/libstd/sync/mpsc/spsc_queue.rs +++ b/src/libstd/sync/mpsc/spsc_queue.rs @@ -253,9 +253,9 @@ mod test { fn smoke() { unsafe { let queue = Queue::new(0); - queue.push(1i); + queue.push(1); queue.push(2); - assert_eq!(queue.pop(), Some(1i)); + assert_eq!(queue.pop(), Some(1)); assert_eq!(queue.pop(), Some(2)); assert_eq!(queue.pop(), None); queue.push(3); @@ -270,7 +270,7 @@ mod test { fn peek() { unsafe { let queue = Queue::new(0); - queue.push(vec![1i]); + queue.push(vec![1]); // Ensure the borrowchecker works match queue.peek() { @@ -290,8 +290,8 @@ mod test { fn drop_full() { unsafe { let q = Queue::new(0); - q.push(box 1i); - q.push(box 2i); + q.push(box 1); + q.push(box 2); } } @@ -299,7 +299,7 @@ mod test { fn smoke_bound() { unsafe { let q = Queue::new(0); - q.push(1i); + q.push(1); q.push(2); assert_eq!(q.pop(), Some(1)); assert_eq!(q.pop(), Some(2)); @@ -328,7 +328,7 @@ mod test { for _ in 0u..100000 { loop { match q2.pop() { - Some(1i) => break, + Some(1) => break, Some(_) => panic!(), None => {} } @@ -336,7 +336,7 @@ mod test { } tx.send(()).unwrap(); }); - for _ in 0i..100000 { + for _ in 0..100000 { q.push(1); } rx.recv().unwrap(); diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs index c31010c170d..7531d5b058d 100644 --- a/src/libstd/sync/mutex.rs +++ b/src/libstd/sync/mutex.rs @@ -428,7 +428,7 @@ mod test { #[test] fn test_arc_condvar_poison() { - let packet = Packet(Arc::new((Mutex::new(1i), Condvar::new()))); + let packet = Packet(Arc::new((Mutex::new(1), Condvar::new()))); let packet2 = Packet(packet.0.clone()); let (tx, rx) = channel(); @@ -457,7 +457,7 @@ mod test { #[test] fn test_mutex_arc_poison() { - let arc = Arc::new(Mutex::new(1i)); + let arc = Arc::new(Mutex::new(1)); let arc2 = arc.clone(); let _ = Thread::scoped(move|| { let lock = arc2.lock().unwrap(); @@ -470,7 +470,7 @@ mod test { fn test_mutex_arc_nested() { // Tests nested mutexes and access // to underlying data. - let arc = Arc::new(Mutex::new(1i)); + let arc = Arc::new(Mutex::new(1)); let arc2 = Arc::new(Mutex::new(arc)); let (tx, rx) = channel(); let _t = Thread::spawn(move|| { @@ -484,7 +484,7 @@ mod test { #[test] fn test_mutex_arc_access_in_unwind() { - let arc = Arc::new(Mutex::new(1i)); + let arc = Arc::new(Mutex::new(1)); let arc2 = arc.clone(); let _ = Thread::scoped(move|| -> () { struct Unwinder { diff --git a/src/libstd/sync/once.rs b/src/libstd/sync/once.rs index 0604003cecd..2df211f3768 100644 --- a/src/libstd/sync/once.rs +++ b/src/libstd/sync/once.rs @@ -134,7 +134,7 @@ mod test { #[test] fn smoke_once() { static O: Once = ONCE_INIT; - let mut a = 0i; + let mut a = 0; O.call_once(|| a += 1); assert_eq!(a, 1); O.call_once(|| a += 1); diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs index b5817ad64f6..95b570dd9c8 100644 --- a/src/libstd/sync/rwlock.rs +++ b/src/libstd/sync/rwlock.rs @@ -41,7 +41,7 @@ use sys_common::rwlock as sys; /// ``` /// use std::sync::RwLock; /// -/// let lock = RwLock::new(5i); +/// let lock = RwLock::new(5); /// /// // many reader locks can be held at once /// { @@ -437,7 +437,7 @@ mod tests { #[test] fn test_rw_arc_poison_wr() { - let arc = Arc::new(RwLock::new(1i)); + let arc = Arc::new(RwLock::new(1)); let arc2 = arc.clone(); let _: Result<uint, _> = Thread::scoped(move|| { let _lock = arc2.write().unwrap(); @@ -448,7 +448,7 @@ mod tests { #[test] fn test_rw_arc_poison_ww() { - let arc = Arc::new(RwLock::new(1i)); + let arc = Arc::new(RwLock::new(1)); let arc2 = arc.clone(); let _: Result<uint, _> = Thread::scoped(move|| { let _lock = arc2.write().unwrap(); @@ -459,7 +459,7 @@ mod tests { #[test] fn test_rw_arc_no_poison_rr() { - let arc = Arc::new(RwLock::new(1i)); + let arc = Arc::new(RwLock::new(1)); let arc2 = arc.clone(); let _: Result<uint, _> = Thread::scoped(move|| { let _lock = arc2.read().unwrap(); @@ -470,7 +470,7 @@ mod tests { } #[test] fn test_rw_arc_no_poison_rw() { - let arc = Arc::new(RwLock::new(1i)); + let arc = Arc::new(RwLock::new(1)); let arc2 = arc.clone(); let _: Result<uint, _> = Thread::scoped(move|| { let _lock = arc2.read().unwrap(); @@ -482,7 +482,7 @@ mod tests { #[test] fn test_rw_arc() { - let arc = Arc::new(RwLock::new(0i)); + let arc = Arc::new(RwLock::new(0)); let arc2 = arc.clone(); let (tx, rx) = channel(); @@ -520,7 +520,7 @@ mod tests { #[test] fn test_rw_arc_access_in_unwind() { - let arc = Arc::new(RwLock::new(1i)); + let arc = Arc::new(RwLock::new(1)); let arc2 = arc.clone(); let _ = Thread::scoped(move|| -> () { struct Unwinder { diff --git a/src/libstd/sys/unix/process.rs b/src/libstd/sys/unix/process.rs index 3fcca2f35e1..b004a47f8a3 100644 --- a/src/libstd/sys/unix/process.rs +++ b/src/libstd/sys/unix/process.rs @@ -509,7 +509,7 @@ impl Process { // which will wake up the other end at some point, so we just allow this // signal to be coalesced with the pending signals on the pipe. extern fn sigchld_handler(_signum: libc::c_int) { - let msg = 1i; + let msg = 1; match unsafe { libc::write(WRITE_FD, &msg as *const _ as *const libc::c_void, 1) } { diff --git a/src/libstd/sys/unix/stack_overflow.rs b/src/libstd/sys/unix/stack_overflow.rs index 2b5ced5085b..a526f3393f2 100644 --- a/src/libstd/sys/unix/stack_overflow.rs +++ b/src/libstd/sys/unix/stack_overflow.rs @@ -162,7 +162,7 @@ mod imp { pub static SIGSTKSZ: libc::size_t = 8192; - pub const SIG_DFL: sighandler_t = 0i as sighandler_t; + pub const SIG_DFL: sighandler_t = 0 as sighandler_t; // This definition is not as accurate as it could be, {si_addr} is // actually a giant union. Currently we're only interested in that field, @@ -214,7 +214,7 @@ mod imp { pub const SIGSTKSZ: libc::size_t = 131072; - pub const SIG_DFL: sighandler_t = 0i as sighandler_t; + pub const SIG_DFL: sighandler_t = 0 as sighandler_t; pub type sigset_t = u32; @@ -271,7 +271,7 @@ mod imp { } pub unsafe fn make_handler() -> super::Handler { - super::Handler { _data: 0i as *mut libc::c_void } + super::Handler { _data: 0 as *mut libc::c_void } } pub unsafe fn drop_handler(_handler: &mut super::Handler) { diff --git a/src/libstd/sys/windows/backtrace.rs b/src/libstd/sys/windows/backtrace.rs index a186465f234..1be1a412ffa 100644 --- a/src/libstd/sys/windows/backtrace.rs +++ b/src/libstd/sys/windows/backtrace.rs @@ -333,7 +333,7 @@ pub fn write(w: &mut Writer) -> IoResult<()> { let _c = Cleanup { handle: process, SymCleanup: SymCleanup }; // And now that we're done with all the setup, do the stack walking! - let mut i = 0i; + let mut i = 0; try!(write!(w, "stack backtrace:\n")); while StackWalk64(image, process, thread, &mut frame, &mut context, ptr::null_mut(), diff --git a/src/libstd/sys/windows/stack_overflow.rs b/src/libstd/sys/windows/stack_overflow.rs index e8b447022cb..0cb4c573ae3 100644 --- a/src/libstd/sys/windows/stack_overflow.rs +++ b/src/libstd/sys/windows/stack_overflow.rs @@ -81,7 +81,7 @@ pub unsafe fn make_handler() -> Handler { panic!("failed to reserve stack space for exception handling"); } - Handler { _data: 0i as *mut libc::c_void } + Handler { _data: 0 as *mut libc::c_void } } pub struct EXCEPTION_RECORD { diff --git a/src/libstd/sys/windows/thread_local.rs b/src/libstd/sys/windows/thread_local.rs index 655195a3c28..0f8ceed39a6 100644 --- a/src/libstd/sys/windows/thread_local.rs +++ b/src/libstd/sys/windows/thread_local.rs @@ -235,7 +235,7 @@ unsafe extern "system" fn on_tls_callback(h: LPVOID, unsafe fn run_dtors() { let mut any_run = true; - for _ in 0..5i { + for _ in 0..5 { if !any_run { break } any_run = false; let dtors = { diff --git a/src/libstd/tuple.rs b/src/libstd/tuple.rs index 2a911557765..988b13cd160 100644 --- a/src/libstd/tuple.rs +++ b/src/libstd/tuple.rs @@ -35,9 +35,9 @@ //! let x = ("colorless", "green", "ideas", "sleep", "furiously"); //! assert_eq!(x.3, "sleep"); //! -//! let v = (3i, 3i); -//! let u = (1i, -5i); -//! assert_eq!(v.0 * u.0 + v.1 * u.1, -12i); +//! let v = (3, 3); +//! let u = (1, -5); +//! assert_eq!(v.0 * u.0 + v.1 * u.1, -12); //! ``` //! //! Using traits implemented for tuples: @@ -45,8 +45,8 @@ //! ``` //! use std::default::Default; //! -//! let a = (1i, 2i); -//! let b = (3i, 4i); +//! let a = (1, 2); +//! let b = (3, 4); //! assert!(a != b); //! //! let c = b.clone(); diff --git a/src/test/auxiliary/issue-11224.rs b/src/test/auxiliary/issue-11224.rs index d66cfe9bf63..560844332a1 100644 --- a/src/test/auxiliary/issue-11224.rs +++ b/src/test/auxiliary/issue-11224.rs @@ -21,6 +21,6 @@ mod inner { } pub fn foo() { - let a = &1i as &inner::Trait; + let a = &1 as &inner::Trait; a.f(); } diff --git a/src/test/auxiliary/issue-8044.rs b/src/test/auxiliary/issue-8044.rs index 7096146a43a..7bfd2e79641 100644 --- a/src/test/auxiliary/issue-8044.rs +++ b/src/test/auxiliary/issue-8044.rs @@ -21,5 +21,5 @@ pub fn leaf<V>(value: V) -> TreeItem<V> { } fn main() { - BTree::<int> { node: leaf(1i) }; + BTree::<int> { node: leaf(1) }; } diff --git a/src/test/auxiliary/issue-9906.rs b/src/test/auxiliary/issue-9906.rs index c0cb501735d..1e746bf39db 100644 --- a/src/test/auxiliary/issue-9906.rs +++ b/src/test/auxiliary/issue-9906.rs @@ -22,6 +22,6 @@ mod other { } pub fn foo(){ - 1i+1; + 1+1; } } diff --git a/src/test/auxiliary/macro_crate_test.rs b/src/test/auxiliary/macro_crate_test.rs index e3e91e05f55..d545a42ae19 100644 --- a/src/test/auxiliary/macro_crate_test.rs +++ b/src/test/auxiliary/macro_crate_test.rs @@ -25,9 +25,9 @@ use syntax::ptr::P; use rustc::plugin::Registry; #[macro_export] -macro_rules! exported_macro { () => (2i) } +macro_rules! exported_macro { () => (2) } -macro_rules! unexported_macro { () => (3i) } +macro_rules! unexported_macro { () => (3) } #[plugin_registrar] pub fn plugin_registrar(reg: &mut Registry) { @@ -47,7 +47,7 @@ fn expand_make_a_1(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree]) if !tts.is_empty() { cx.span_fatal(sp, "make_a_1 takes no arguments"); } - MacExpr::new(quote_expr!(cx, 1i)) + MacExpr::new(quote_expr!(cx, 1)) } // See Issue #15750 diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs index 6d12d84f652..388868eee70 100644 --- a/src/test/bench/core-std.rs +++ b/src/test/bench/core-std.rs @@ -62,7 +62,7 @@ fn maybe_run_test<F>(argv: &[String], name: String, test: F) where F: FnOnce() { } fn shift_push() { - let mut v1 = repeat(1i).take(30000).collect::<Vec<_>>(); + let mut v1 = repeat(1).take(30000).collect::<Vec<_>>(); let mut v2 = Vec::new(); while v1.len() > 0 { diff --git a/src/test/bench/shootout-meteor.rs b/src/test/bench/shootout-meteor.rs index e6ef58cba35..11c471c40c5 100644 --- a/src/test/bench/shootout-meteor.rs +++ b/src/test/bench/shootout-meteor.rs @@ -150,16 +150,16 @@ fn mask(dy: int, dx: int, id: uint, p: &Vec<(int, int)>) -> Option<u64> { // (i/5, i%5). fn make_masks() -> Vec<Vec<Vec<u64> > > { let pieces = vec!( - vec!((0i,0i),(0,1),(0,2),(0,3),(1,3)), - vec!((0i,0i),(0,2),(0,3),(1,0),(1,1)), - vec!((0i,0i),(0,1),(0,2),(1,2),(2,1)), - vec!((0i,0i),(0,1),(0,2),(1,1),(2,1)), - vec!((0i,0i),(0,2),(1,0),(1,1),(2,1)), - vec!((0i,0i),(0,1),(0,2),(1,1),(1,2)), - vec!((0i,0i),(0,1),(1,1),(1,2),(2,1)), - vec!((0i,0i),(0,1),(0,2),(1,0),(1,2)), - vec!((0i,0i),(0,1),(0,2),(1,2),(1,3)), - vec!((0i,0i),(0,1),(0,2),(0,3),(1,2))); + vec!((0,0),(0,1),(0,2),(0,3),(1,3)), + vec!((0,0),(0,2),(0,3),(1,0),(1,1)), + vec!((0,0),(0,1),(0,2),(1,2),(2,1)), + vec!((0,0),(0,1),(0,2),(1,1),(2,1)), + vec!((0,0),(0,2),(1,0),(1,1),(2,1)), + vec!((0,0),(0,1),(0,2),(1,1),(1,2)), + vec!((0,0),(0,1),(1,1),(1,2),(2,1)), + vec!((0,0),(0,1),(0,2),(1,0),(1,2)), + vec!((0,0),(0,1),(0,2),(1,2),(1,3)), + vec!((0,0),(0,1),(0,2),(0,3),(1,2))); // To break the central symmetry of the problem, every // transformation must be taken except for one piece (piece 3 @@ -169,7 +169,7 @@ fn make_masks() -> Vec<Vec<Vec<u64> > > { .map(|(id, p)| transform(p, id != 3)) .collect(); - (0i..50).map(|yx| { + (0..50).map(|yx| { transforms.iter().enumerate().map(|(id, t)| { t.iter().filter_map(|p| mask(yx / 5, yx % 5, id, p)).collect() }).collect() diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs index 2f68262b608..dd3ae1699a9 100644 --- a/src/test/bench/shootout-pfib.rs +++ b/src/test/bench/shootout-pfib.rs @@ -66,9 +66,9 @@ fn parse_opts(argv: Vec<String> ) -> Config { } fn stress_task(id: int) { - let mut i = 0i; + let mut i = 0; loop { - let n = 15i; + let n = 15; assert_eq!(fib(n), fib(n)); i += 1; println!("{}: Completed {} iterations", id, i); diff --git a/src/test/debuginfo/basic-types-metadata.rs b/src/test/debuginfo/basic-types-metadata.rs index 5e2497043da..3b016f287fb 100644 --- a/src/test/debuginfo/basic-types-metadata.rs +++ b/src/test/debuginfo/basic-types-metadata.rs @@ -67,7 +67,7 @@ fn main() { let f32: f32 = 2.5; let f64: f64 = 3.5; _zzz(); // #break - if 1i == 1 { _yyy(); } + if 1 == 1 { _yyy(); } } fn _zzz() {()} diff --git a/src/test/debuginfo/box.rs b/src/test/debuginfo/box.rs index 0439e3dc34d..6db3dce4668 100644 --- a/src/test/debuginfo/box.rs +++ b/src/test/debuginfo/box.rs @@ -36,8 +36,8 @@ #![omit_gdb_pretty_printer_section] fn main() { - let a = box 1i; - let b = box() (2i, 3.5f64); + let a = box 1; + let b = box() (2, 3.5f64); zzz(); // #break } diff --git a/src/test/debuginfo/closure-in-generic-function.rs b/src/test/debuginfo/closure-in-generic-function.rs index f8b12569400..59428a2c06f 100644 --- a/src/test/debuginfo/closure-in-generic-function.rs +++ b/src/test/debuginfo/closure-in-generic-function.rs @@ -60,8 +60,8 @@ fn some_generic_fun<T1, T2>(a: T1, b: T2) -> (T2, T1) { } fn main() { - some_generic_fun(0.5f64, 10i); - some_generic_fun(&29i, box 110i); + some_generic_fun(0.5f64, 10); + some_generic_fun(&29, box 110); } fn zzz() { () } diff --git a/src/test/debuginfo/destructured-for-loop-variable.rs b/src/test/debuginfo/destructured-for-loop-variable.rs index 38f8f859d39..08062ce8966 100644 --- a/src/test/debuginfo/destructured-for-loop-variable.rs +++ b/src/test/debuginfo/destructured-for-loop-variable.rs @@ -202,7 +202,7 @@ fn main() { zzz(); // #break } - for i in 1234..1235i { + for i in 1234..1235 { zzz(); // #break } diff --git a/src/test/debuginfo/destructured-local.rs b/src/test/debuginfo/destructured-local.rs index 1fd598e18c1..22cc779aeca 100644 --- a/src/test/debuginfo/destructured-local.rs +++ b/src/test/debuginfo/destructured-local.rs @@ -278,7 +278,7 @@ fn main() { let Struct { a: k, b: l } = Struct { a: 12, b: 13 }; // ignored tuple element - let (m, _, n) = (14i, 15i, 16i); + let (m, _, n) = (14, 15, 16); // ignored struct field let Struct { b: o, .. } = Struct { a: 17, b: 18 }; @@ -291,25 +291,25 @@ fn main() { // complex nesting let ((u, v), ((w, (x, Struct { a: y, b: z})), Struct { a: ae, b: oe }), ue) = - ((25i, 26i), ((27i, (28i, Struct { a: 29, b: 30})), Struct { a: 31, b: 32 }), 33i); + ((25, 26), ((27, (28, Struct { a: 29, b: 30})), Struct { a: 31, b: 32 }), 33); // reference - let &aa = &(34i, 35i); + let &aa = &(34, 35); // reference - let &bb = &(36i, 37i); + let &bb = &(36, 37); // contained reference - let (&cc, _) = (&38i, 39i); + let (&cc, _) = (&38, 39); // unique pointer - let box dd = box() (40i, 41i, 42i); + let box dd = box() (40, 41, 42); // ref binding - let ref ee = (43i, 44i, 45i); + let ref ee = (43, 44, 45); // ref binding in tuple - let (ref ff, gg) = (46i, (47i, 48i)); + let (ref ff, gg) = (46, (47, 48)); // ref binding in struct let Struct { b: ref hh, .. } = Struct { a: 49, b: 50 }; diff --git a/src/test/debuginfo/function-arg-initialization.rs b/src/test/debuginfo/function-arg-initialization.rs index 38875c7656e..f9a2b2fef34 100644 --- a/src/test/debuginfo/function-arg-initialization.rs +++ b/src/test/debuginfo/function-arg-initialization.rs @@ -245,7 +245,7 @@ fn non_immediate_args(a: BigStruct, b: BigStruct) { } fn binding(a: i64, b: u64, c: f64) { - let x = 0i; // #break + let x = 0; // #break ::std::old_io::print("") } diff --git a/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs b/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs index 4692318b98f..8d456f33432 100644 --- a/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs +++ b/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs @@ -270,7 +270,7 @@ fn non_immediate_args(a: BigStruct, b: BigStruct) { #[no_stack_check] fn binding(a: i64, b: u64, c: f64) { - let x = 0i; + let x = 0; ::std::old_io::print(""); } diff --git a/src/test/debuginfo/function-prologue-stepping-regular.rs b/src/test/debuginfo/function-prologue-stepping-regular.rs index 799352911f6..14433fbcd23 100644 --- a/src/test/debuginfo/function-prologue-stepping-regular.rs +++ b/src/test/debuginfo/function-prologue-stepping-regular.rs @@ -148,7 +148,7 @@ fn non_immediate_args(a: BigStruct, b: BigStruct) { } fn binding(a: i64, b: u64, c: f64) { - let x = 0i; + let x = 0; } fn assignment(mut a: u64, b: u64, c: f64) { diff --git a/src/test/debuginfo/generic-function.rs b/src/test/debuginfo/generic-function.rs index b2fdb708db5..b9a09867a00 100644 --- a/src/test/debuginfo/generic-function.rs +++ b/src/test/debuginfo/generic-function.rs @@ -86,9 +86,9 @@ fn dup_tup<T0: Clone, T1: Clone>(t0: &T0, t1: &T1) -> ((T0, T1), (T1, T0)) { fn main() { - let _ = dup_tup(&1i, &2.5f64); + let _ = dup_tup(&1, &2.5f64); let _ = dup_tup(&3.5f64, &4_u16); - let _ = dup_tup(&5i, &Struct { a: 6, b: 7.5 }); + let _ = dup_tup(&5, &Struct { a: 6, b: 7.5 }); } fn zzz() {()} diff --git a/src/test/debuginfo/generic-functions-nested.rs b/src/test/debuginfo/generic-functions-nested.rs index 0f3fd556f18..9f6d8a45a99 100644 --- a/src/test/debuginfo/generic-functions-nested.rs +++ b/src/test/debuginfo/generic-functions-nested.rs @@ -74,7 +74,7 @@ #![omit_gdb_pretty_printer_section] fn outer<TA: Clone>(a: TA) { - inner(a.clone(), 1i); + inner(a.clone(), 1); inner(a.clone(), 2.5f64); fn inner<TX, TY>(x: TX, y: TY) { @@ -83,7 +83,7 @@ fn outer<TA: Clone>(a: TA) { } fn main() { - outer(-1i); + outer(-1); outer(-2.5f64); } diff --git a/src/test/debuginfo/generic-static-method-on-struct-and-enum.rs b/src/test/debuginfo/generic-static-method-on-struct-and-enum.rs index bf755d379a6..61843a20d05 100644 --- a/src/test/debuginfo/generic-static-method-on-struct-and-enum.rs +++ b/src/test/debuginfo/generic-static-method-on-struct-and-enum.rs @@ -61,8 +61,8 @@ impl Enum { } fn main() { - Struct::static_method(1i, 2i); - Enum::static_method(-3i, 4.5f64, 5i); + Struct::static_method(1, 2); + Enum::static_method(-3, 4.5f64, 5); } fn zzz() {()} diff --git a/src/test/debuginfo/generic-struct-style-enum.rs b/src/test/debuginfo/generic-struct-style-enum.rs index 992e7417913..2faafbd7634 100644 --- a/src/test/debuginfo/generic-struct-style-enum.rs +++ b/src/test/debuginfo/generic-struct-style-enum.rs @@ -76,7 +76,7 @@ fn main() { // 0b01011001 = 89 let case3: Regular<u16, i32, u64> = Case3 { a: 0, b: 6438275382588823897 }; - let univariant = TheOnlyCase { a: -1i }; + let univariant = TheOnlyCase { a: -1 }; zzz(); // #break } diff --git a/src/test/debuginfo/generic-struct.rs b/src/test/debuginfo/generic-struct.rs index a81230599fa..0eb65f2d80f 100644 --- a/src/test/debuginfo/generic-struct.rs +++ b/src/test/debuginfo/generic-struct.rs @@ -51,12 +51,12 @@ struct AGenericStruct<TKey, TValue> { fn main() { - let int_int = AGenericStruct { key: 0i, value: 1i }; - let int_float = AGenericStruct { key: 2i, value: 3.5f64 }; - let float_int = AGenericStruct { key: 4.5f64, value: 5i }; + let int_int = AGenericStruct { key: 0, value: 1 }; + let int_float = AGenericStruct { key: 2, value: 3.5f64 }; + let float_int = AGenericStruct { key: 4.5f64, value: 5 }; let float_int_float = AGenericStruct { key: 6.5f64, - value: AGenericStruct { key: 7i, value: 8.5f64 }, + value: AGenericStruct { key: 7, value: 8.5f64 }, }; zzz(); // #break diff --git a/src/test/debuginfo/lexical-scope-in-for-loop.rs b/src/test/debuginfo/lexical-scope-in-for-loop.rs index 3309ae13c9d..1fa54e47163 100644 --- a/src/test/debuginfo/lexical-scope-in-for-loop.rs +++ b/src/test/debuginfo/lexical-scope-in-for-loop.rs @@ -90,15 +90,15 @@ fn main() { - let range = [1i, 2, 3]; + let range = [1, 2, 3]; - let x = 1000000i; // wan meeeljen doollaars! + let x = 1000000; // wan meeeljen doollaars! for &x in range.iter() { zzz(); // #break sentinel(); - let x = -1i * x; + let x = -1 * x; zzz(); // #break sentinel(); diff --git a/src/test/debuginfo/lexical-scope-in-if.rs b/src/test/debuginfo/lexical-scope-in-if.rs index bc3a6945243..c885bfce216 100644 --- a/src/test/debuginfo/lexical-scope-in-if.rs +++ b/src/test/debuginfo/lexical-scope-in-if.rs @@ -138,8 +138,8 @@ fn main() { - let x = 999i; - let y = -1i; + let x = 999; + let y = -1; zzz(); // #break sentinel(); @@ -148,13 +148,13 @@ fn main() { zzz(); // #break sentinel(); - let x = 1001i; + let x = 1001; zzz(); // #break sentinel(); - let x = 1002i; - let y = 1003i; + let x = 1002; + let y = 1003; zzz(); // #break sentinel(); } else { @@ -170,8 +170,8 @@ fn main() { zzz(); // #break sentinel(); - let x = 1004i; - let y = 1005i; + let x = 1004; + let y = 1005; zzz(); // #break sentinel(); } diff --git a/src/test/debuginfo/lexical-scope-in-match.rs b/src/test/debuginfo/lexical-scope-in-match.rs index 37976ab3996..c596253560e 100644 --- a/src/test/debuginfo/lexical-scope-in-match.rs +++ b/src/test/debuginfo/lexical-scope-in-match.rs @@ -135,13 +135,13 @@ struct Struct { fn main() { - let shadowed = 231i; - let not_shadowed = 232i; + let shadowed = 231; + let not_shadowed = 232; zzz(); // #break sentinel(); - match (233i, 234i) { + match (233, 234) { (shadowed, local_to_arm) => { zzz(); // #break @@ -149,7 +149,7 @@ fn main() { } } - match (235i, 236i) { + match (235, 236) { // with literal (235, shadowed) => { @@ -186,7 +186,7 @@ fn main() { _ => {} } - match (243i, 244i) { + match (243, 244) { (shadowed, ref local_to_arm) => { zzz(); // #break diff --git a/src/test/debuginfo/lexical-scope-in-parameterless-closure.rs b/src/test/debuginfo/lexical-scope-in-parameterless-closure.rs index 107c5cb9782..5e04c81cefd 100644 --- a/src/test/debuginfo/lexical-scope-in-parameterless-closure.rs +++ b/src/test/debuginfo/lexical-scope-in-parameterless-closure.rs @@ -19,6 +19,6 @@ // Nothing to do here really, just make sure it compiles. See issue #8513. fn main() { let _ = |&:|(); - let _ = (1u..3).map(|_| 5i); + let _ = (1u..3).map(|_| 5); } diff --git a/src/test/debuginfo/lexical-scope-in-unconditional-loop.rs b/src/test/debuginfo/lexical-scope-in-unconditional-loop.rs index b295c6f37a7..6826bca695b 100644 --- a/src/test/debuginfo/lexical-scope-in-unconditional-loop.rs +++ b/src/test/debuginfo/lexical-scope-in-unconditional-loop.rs @@ -136,7 +136,7 @@ fn main() { - let mut x = 0i; + let mut x = 0; loop { if x >= 2 { @@ -160,7 +160,7 @@ fn main() { zzz(); // #break sentinel(); - let x = -987i; + let x = -987; zzz(); // #break sentinel(); diff --git a/src/test/debuginfo/lexical-scope-in-while.rs b/src/test/debuginfo/lexical-scope-in-while.rs index c7a36ef9b82..40280b469f7 100644 --- a/src/test/debuginfo/lexical-scope-in-while.rs +++ b/src/test/debuginfo/lexical-scope-in-while.rs @@ -136,7 +136,7 @@ fn main() { - let mut x = 0i; + let mut x = 0; while x < 2 { zzz(); // #break @@ -156,7 +156,7 @@ fn main() { zzz(); // #break sentinel(); - let x = -987i; + let x = -987; zzz(); // #break sentinel(); diff --git a/src/test/debuginfo/lexical-scope-with-macro.rs b/src/test/debuginfo/lexical-scope-with-macro.rs index 2aa31969a46..da941979fb6 100644 --- a/src/test/debuginfo/lexical-scope-with-macro.rs +++ b/src/test/debuginfo/lexical-scope-with-macro.rs @@ -123,7 +123,7 @@ macro_rules! no_new_scope { macro_rules! new_scope { () => ({ - let a = 890242i; + let a = 890242; zzz(); // #break sentinel(); }) @@ -151,8 +151,8 @@ macro_rules! dup_expr { fn main() { - let a = trivial!(10i); - let b = no_new_scope!(33i); + let a = trivial!(10); + let b = no_new_scope!(33); zzz(); // #break sentinel(); @@ -162,12 +162,12 @@ fn main() { zzz(); // #break sentinel(); - shadow_within_macro!(100i); + shadow_within_macro!(100); zzz(); // #break sentinel(); - let c = dup_expr!(10i * 20); + let c = dup_expr!(10 * 20); zzz(); // #break sentinel(); diff --git a/src/test/debuginfo/lexical-scopes-in-block-expression.rs b/src/test/debuginfo/lexical-scopes-in-block-expression.rs index 2f8b11ac283..118d096d31b 100644 --- a/src/test/debuginfo/lexical-scopes-in-block-expression.rs +++ b/src/test/debuginfo/lexical-scopes-in-block-expression.rs @@ -364,8 +364,8 @@ fn a_function(x: int) -> int { fn main() { - let val = -1i; - let ten = 10i; + let val = -1; + let ten = 10; // surrounded by struct expression let point = Point { @@ -417,7 +417,7 @@ fn main() { sentinel(); val - }, 0i); + }, 0); zzz(); // #break sentinel(); @@ -492,7 +492,7 @@ fn main() { sentinel(); // index expression - let a_vector = [10i; 20]; + let a_vector = [10; 20]; let _ = a_vector[{ zzz(); // #break sentinel(); diff --git a/src/test/debuginfo/limited-debuginfo.rs b/src/test/debuginfo/limited-debuginfo.rs index e1aec83714d..c8fe76fdbe5 100644 --- a/src/test/debuginfo/limited-debuginfo.rs +++ b/src/test/debuginfo/limited-debuginfo.rs @@ -47,7 +47,7 @@ fn zzz() {()} fn some_function(a: int, b: int) { let some_variable = Struct { a: 11, b: 22 }; - let some_other_variable = 23i; + let some_other_variable = 23; for x in 0..1 { zzz(); // #break diff --git a/src/test/debuginfo/multiple-functions-equal-var-names.rs b/src/test/debuginfo/multiple-functions-equal-var-names.rs index cb21c13426a..0b2f8ef8181 100644 --- a/src/test/debuginfo/multiple-functions-equal-var-names.rs +++ b/src/test/debuginfo/multiple-functions-equal-var-names.rs @@ -48,18 +48,18 @@ #![omit_gdb_pretty_printer_section] fn function_one() { - let abc = 10101i; + let abc = 10101; zzz(); // #break } fn function_two() { - let abc = 20202i; + let abc = 20202; zzz(); // #break } fn function_three() { - let abc = 30303i; + let abc = 30303; zzz(); // #break } diff --git a/src/test/debuginfo/multiple-functions.rs b/src/test/debuginfo/multiple-functions.rs index ef7c4ce2045..00698ae1dfb 100644 --- a/src/test/debuginfo/multiple-functions.rs +++ b/src/test/debuginfo/multiple-functions.rs @@ -48,18 +48,18 @@ #![omit_gdb_pretty_printer_section] fn function_one() { - let a = 10101i; + let a = 10101; zzz(); // #break } fn function_two() { - let b = 20202i; + let b = 20202; zzz(); // #break } fn function_three() { - let c = 30303i; + let c = 30303; zzz(); // #break } diff --git a/src/test/debuginfo/name-shadowing-and-scope-nesting.rs b/src/test/debuginfo/name-shadowing-and-scope-nesting.rs index d248c7e9819..8c1a5376dba 100644 --- a/src/test/debuginfo/name-shadowing-and-scope-nesting.rs +++ b/src/test/debuginfo/name-shadowing-and-scope-nesting.rs @@ -103,20 +103,20 @@ fn main() { zzz(); // #break sentinel(); - let x = 10i; + let x = 10; zzz(); // #break sentinel(); let x = 10.5f64; - let y = 20i; + let y = 20; zzz(); // #break sentinel(); { let x = true; - let y = 2220i; + let y = 2220; zzz(); // #break sentinel(); diff --git a/src/test/debuginfo/shadowed-argument.rs b/src/test/debuginfo/shadowed-argument.rs index c5c3664b07a..5b36d32e49f 100644 --- a/src/test/debuginfo/shadowed-argument.rs +++ b/src/test/debuginfo/shadowed-argument.rs @@ -65,13 +65,13 @@ fn a_function(x: bool, y: bool) { zzz(); // #break sentinel(); - let x = 10i; + let x = 10; zzz(); // #break sentinel(); let x = 10.5f64; - let y = 20i; + let y = 20; zzz(); // #break sentinel(); diff --git a/src/test/debuginfo/shadowed-variable.rs b/src/test/debuginfo/shadowed-variable.rs index f384b756da6..66fd656eaac 100644 --- a/src/test/debuginfo/shadowed-variable.rs +++ b/src/test/debuginfo/shadowed-variable.rs @@ -67,13 +67,13 @@ fn main() { zzz(); // #break sentinel(); - let x = 10i; + let x = 10; zzz(); // #break sentinel(); let x = 10.5f64; - let y = 20i; + let y = 20; zzz(); // #break sentinel(); diff --git a/src/test/debuginfo/simple-lexical-scope.rs b/src/test/debuginfo/simple-lexical-scope.rs index 5981c18494d..31441db20f1 100644 --- a/src/test/debuginfo/simple-lexical-scope.rs +++ b/src/test/debuginfo/simple-lexical-scope.rs @@ -91,7 +91,7 @@ fn main() { zzz(); // #break sentinel(); - let x = 10i; + let x = 10; zzz(); // #break sentinel(); diff --git a/src/test/debuginfo/type-names.rs b/src/test/debuginfo/type-names.rs index 156e5f12ad5..24b6df4e8f1 100644 --- a/src/test/debuginfo/type-names.rs +++ b/src/test/debuginfo/type-names.rs @@ -288,15 +288,15 @@ fn main() { let slice2 = vec2.as_slice(); // Trait Objects - let box_trait = (box 0i) as Box<Trait1>; - let ref_trait = &0i as &Trait1; - let mut mut_int1 = 0i; + let box_trait = (box 0) as Box<Trait1>; + let ref_trait = &0 as &Trait1; + let mut mut_int1 = 0; let mut_ref_trait = (&mut mut_int1) as &mut Trait1; - let generic_box_trait = (box 0i) as Box<Trait2<i32, Mod1::Struct2>>; - let generic_ref_trait = (&0i) as &Trait2<Struct1, Struct1>; + let generic_box_trait = (box 0) as Box<Trait2<i32, Mod1::Struct2>>; + let generic_ref_trait = (&0) as &Trait2<Struct1, Struct1>; - let mut generic_mut_ref_trait_impl = 0i; + let mut generic_mut_ref_trait_impl = 0; let generic_mut_ref_trait = (&mut generic_mut_ref_trait_impl) as &mut Trait2<Mod1::Mod2::Struct3, GenericStruct<usize, isize>>; diff --git a/src/test/debuginfo/vec.rs b/src/test/debuginfo/vec.rs index 92a490206b6..9ee18c0d77b 100644 --- a/src/test/debuginfo/vec.rs +++ b/src/test/debuginfo/vec.rs @@ -34,7 +34,7 @@ static mut VECT: [i32; 3] = [1, 2, 3]; fn main() { - let a = [1i, 2, 3]; + let a = [1, 2, 3]; unsafe { VECT[0] = 4; diff --git a/src/test/pretty/block-disambig.rs b/src/test/pretty/block-disambig.rs index 1e286c236a5..c9cb72d8af7 100644 --- a/src/test/pretty/block-disambig.rs +++ b/src/test/pretty/block-disambig.rs @@ -15,9 +15,9 @@ use std::cell::Cell; -fn test1() { let val = &0i; { } *val; } +fn test1() { let val = &0; { } *val; } -fn test2() -> int { let val = &0i; { } *val } +fn test2() -> int { let val = &0; { } *val } #[derive(Copy)] struct S { eax: int } @@ -35,13 +35,13 @@ fn test5() -> (int, int) { { } (0, 1) } fn test6() -> bool { { } (true || false) && true } fn test7() -> uint { - let regs = &0i; + let regs = &0; match true { true => { } _ => { } } (*regs < 2) as uint } fn test8() -> int { - let val = &0i; + let val = &0; match true { true => { } _ => { } @@ -54,12 +54,12 @@ fn test8() -> int { } fn test9() { - let regs = &Cell::new(0i); + let regs = &Cell::new(0); match true { true => { } _ => { } } regs.set(regs.get() + 1); } fn test10() -> int { - let regs = vec!(0i); + let regs = vec!(0); match true { true => { } _ => { } } regs[0] } diff --git a/src/test/pretty/issue-929.rs b/src/test/pretty/issue-929.rs index 377f4669ffc..75a6b919342 100644 --- a/src/test/pretty/issue-929.rs +++ b/src/test/pretty/issue-929.rs @@ -8,6 +8,6 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn f() { if (1i == panic!()) { } else { } } +fn f() { if (1 == panic!()) { } else { } } fn main() { } diff --git a/src/test/pretty/match-block-expr.rs b/src/test/pretty/match-block-expr.rs index 44771a29bb4..7751f155da4 100644 --- a/src/test/pretty/match-block-expr.rs +++ b/src/test/pretty/match-block-expr.rs @@ -11,6 +11,6 @@ // pp-exact fn main() { - let x = match { 5i } { 1 => 5i, 2 => 6, _ => 7, }; + let x = match { 5 } { 1 => 5, 2 => 6, _ => 7, }; assert_eq!(x , 7); } diff --git a/src/test/pretty/match-naked-expr-medium.rs b/src/test/pretty/match-naked-expr-medium.rs index d2f8157ef62..39af19dbf6f 100644 --- a/src/test/pretty/match-naked-expr-medium.rs +++ b/src/test/pretty/match-naked-expr-medium.rs @@ -11,7 +11,7 @@ // pp-exact fn main() { - let x = Some(3i); + let x = Some(3); let _y = match x { Some(_) => diff --git a/src/test/pretty/match-naked-expr.rs b/src/test/pretty/match-naked-expr.rs index 6b4f579f9c5..02bbf667d96 100644 --- a/src/test/pretty/match-naked-expr.rs +++ b/src/test/pretty/match-naked-expr.rs @@ -11,7 +11,7 @@ // pp-exact fn main() { - let x = Some(3i); + let x = Some(3); let _y = match x { Some(_) => "some(_)".to_string(), diff --git a/src/test/pretty/path-type-bounds.rs b/src/test/pretty/path-type-bounds.rs index 382394b1407..e27a3365a41 100644 --- a/src/test/pretty/path-type-bounds.rs +++ b/src/test/pretty/path-type-bounds.rs @@ -19,6 +19,6 @@ fn foo<'a>(x: Box<Tr+ Sync + 'a>) -> Box<Tr+ Sync + 'a> { x } fn main() { let x: Box<Tr+ Sync>; - Box::new(1i) as Box<Tr+ Sync>; + Box::new(1) as Box<Tr+ Sync>; } diff --git a/src/test/pretty/unary-op-disambig.rs b/src/test/pretty/unary-op-disambig.rs index 850904fe53e..1592e010aaf 100644 --- a/src/test/pretty/unary-op-disambig.rs +++ b/src/test/pretty/unary-op-disambig.rs @@ -18,10 +18,10 @@ fn block_nosemi() -> int { ({ 0 }) - 1 } fn if_semi() -> int { if true { f() } else { f() }; -1 } -fn if_nosemi() -> int { (if true { 0i } else { 0i }) - 1 } +fn if_nosemi() -> int { (if true { 0 } else { 0 }) - 1 } fn alt_semi() -> int { match true { true => { f() } _ => { } }; -1 } fn alt_no_semi() -> int { (match true { true => { 0 } _ => { 1 } }) - 1 } -fn stmt() { { f() }; -1i; } +fn stmt() { { f() }; -1; } diff --git a/src/test/pretty/vec-comments.pp b/src/test/pretty/vec-comments.pp index 401c63efbc4..dc2dae1044d 100644 --- a/src/test/pretty/vec-comments.pp +++ b/src/test/pretty/vec-comments.pp @@ -15,25 +15,25 @@ fn main() { let _v1 = [ // Comment - 0i, + 0, // Comment - 1i, + 1, // Comment - 2i]; + 2]; let _v2 = - [0i, // Comment - 1i, // Comment - 2i]; // Comment + [0, // Comment + 1, // Comment + 2]; // Comment let _v3 = [ /* Comment */ - 0i, + 0, /* Comment */ - 1i, + 1, /* Comment */ - 2i]; + 2]; let _v4 = - [0i, /* Comment */ - 1i, /* Comment */ - 2i]; /* Comment */ + [0, /* Comment */ + 1, /* Comment */ + 2]; /* Comment */ } diff --git a/src/test/pretty/vec-comments.rs b/src/test/pretty/vec-comments.rs index 401c63efbc4..dc2dae1044d 100644 --- a/src/test/pretty/vec-comments.rs +++ b/src/test/pretty/vec-comments.rs @@ -15,25 +15,25 @@ fn main() { let _v1 = [ // Comment - 0i, + 0, // Comment - 1i, + 1, // Comment - 2i]; + 2]; let _v2 = - [0i, // Comment - 1i, // Comment - 2i]; // Comment + [0, // Comment + 1, // Comment + 2]; // Comment let _v3 = [ /* Comment */ - 0i, + 0, /* Comment */ - 1i, + 1, /* Comment */ - 2i]; + 2]; let _v4 = - [0i, /* Comment */ - 1i, /* Comment */ - 2i]; /* Comment */ + [0, /* Comment */ + 1, /* Comment */ + 2]; /* Comment */ } diff --git a/src/test/run-fail/assert-eq-macro-panic.rs b/src/test/run-fail/assert-eq-macro-panic.rs index 69ed025070b..fd6d69efb4f 100644 --- a/src/test/run-fail/assert-eq-macro-panic.rs +++ b/src/test/run-fail/assert-eq-macro-panic.rs @@ -11,5 +11,5 @@ // error-pattern:assertion failed: `(left == right) && (right == left)` (left: `14`, right: `15`) fn main() { - assert_eq!(14i,15i); + assert_eq!(14,15); } diff --git a/src/test/run-fail/assert-macro-fmt.rs b/src/test/run-fail/assert-macro-fmt.rs index 223c60d6ae4..78239a2217e 100644 --- a/src/test/run-fail/assert-macro-fmt.rs +++ b/src/test/run-fail/assert-macro-fmt.rs @@ -11,5 +11,5 @@ // error-pattern:panicked at 'test-assert-fmt 42 rust' fn main() { - assert!(false, "test-assert-fmt {} {}", 42i, "rust"); + assert!(false, "test-assert-fmt {} {}", 42, "rust"); } diff --git a/src/test/run-fail/bounds-check-no-overflow.rs b/src/test/run-fail/bounds-check-no-overflow.rs index df9050e2186..be4ad0781f2 100644 --- a/src/test/run-fail/bounds-check-no-overflow.rs +++ b/src/test/run-fail/bounds-check-no-overflow.rs @@ -14,6 +14,6 @@ use std::uint; use std::mem::size_of; fn main() { - let xs = [1i, 2, 3]; + let xs = [1, 2, 3]; xs[uint::MAX / size_of::<int>() + 1]; } diff --git a/src/test/run-fail/divide-by-zero.rs b/src/test/run-fail/divide-by-zero.rs index c58d30f2729..de69b7b9fa6 100644 --- a/src/test/run-fail/divide-by-zero.rs +++ b/src/test/run-fail/divide-by-zero.rs @@ -10,6 +10,6 @@ // error-pattern:attempted to divide by zero fn main() { - let y = 0i; - let _z = 1i / y; + let y = 0; + let _z = 1 / y; } diff --git a/src/test/run-fail/dst-raw-slice.rs b/src/test/run-fail/dst-raw-slice.rs index 39bf899a023..77cec8b6327 100644 --- a/src/test/run-fail/dst-raw-slice.rs +++ b/src/test/run-fail/dst-raw-slice.rs @@ -12,7 +12,7 @@ // error-pattern:index out of bounds fn main() { - let a: *const [_] = &[1i, 2, 3]; + let a: *const [_] = &[1, 2, 3]; unsafe { let _b = (*a)[3]; } diff --git a/src/test/run-fail/explicit-panic-msg.rs b/src/test/run-fail/explicit-panic-msg.rs index ae6e72bdd4f..c9c04e5f2da 100644 --- a/src/test/run-fail/explicit-panic-msg.rs +++ b/src/test/run-fail/explicit-panic-msg.rs @@ -13,7 +13,7 @@ // error-pattern:wooooo fn main() { - let mut a = 1i; - if 1i == 1 { a = 2; } + let mut a = 1; + if 1 == 1 { a = 2; } panic!(format!("woooo{}", "o")); } diff --git a/src/test/run-fail/expr-if-panic.rs b/src/test/run-fail/expr-if-panic.rs index f04c94a3bf4..b6791271a11 100644 --- a/src/test/run-fail/expr-if-panic.rs +++ b/src/test/run-fail/expr-if-panic.rs @@ -10,4 +10,4 @@ // error-pattern:explicit panic -fn main() { let _x = if false { 0i } else if true { panic!() } else { 10i }; } +fn main() { let _x = if false { 0 } else if true { panic!() } else { 10 }; } diff --git a/src/test/run-fail/expr-match-panic.rs b/src/test/run-fail/expr-match-panic.rs index d5c005b7029..3a6bd59b3ac 100644 --- a/src/test/run-fail/expr-match-panic.rs +++ b/src/test/run-fail/expr-match-panic.rs @@ -10,4 +10,4 @@ // error-pattern:explicit panic -fn main() { let _x = match true { false => { 0i } true => { panic!() } }; } +fn main() { let _x = match true { false => { 0 } true => { panic!() } }; } diff --git a/src/test/run-fail/issue-12920.rs b/src/test/run-fail/issue-12920.rs index 8dbfc06152a..cbc92c640d2 100644 --- a/src/test/run-fail/issue-12920.rs +++ b/src/test/run-fail/issue-12920.rs @@ -11,5 +11,5 @@ // error-pattern:explicit panic pub fn main() { - panic!(); println!("{}", 1i); + panic!(); println!("{}", 1); } diff --git a/src/test/run-fail/issue-3029.rs b/src/test/run-fail/issue-3029.rs index 0846ba2e71a..4d048fe0fcf 100644 --- a/src/test/run-fail/issue-3029.rs +++ b/src/test/run-fail/issue-3029.rs @@ -16,7 +16,7 @@ // error-pattern:so long fn main() { let mut x = Vec::new(); - let y = vec!(3i); + let y = vec!(3); panic!("so long"); x.extend(y.into_iter()); } diff --git a/src/test/run-fail/mod-zero.rs b/src/test/run-fail/mod-zero.rs index 54415051708..76d4de7ecb0 100644 --- a/src/test/run-fail/mod-zero.rs +++ b/src/test/run-fail/mod-zero.rs @@ -10,6 +10,6 @@ // error-pattern:attempted remainder with a divisor of zero fn main() { - let y = 0i; - let _z = 1i % y; + let y = 0; + let _z = 1 % y; } diff --git a/src/test/run-fail/panic-macro-any.rs b/src/test/run-fail/panic-macro-any.rs index 231c57390b3..ce6a5d46cc7 100644 --- a/src/test/run-fail/panic-macro-any.rs +++ b/src/test/run-fail/panic-macro-any.rs @@ -14,5 +14,5 @@ #![feature(box_syntax)] fn main() { - panic!(box 413i as Box<::std::any::Any+Send>); + panic!(box 413 as Box<::std::any::Any+Send>); } diff --git a/src/test/run-fail/panic-macro-fmt.rs b/src/test/run-fail/panic-macro-fmt.rs index ac50f02cf33..50ad99c6747 100644 --- a/src/test/run-fail/panic-macro-fmt.rs +++ b/src/test/run-fail/panic-macro-fmt.rs @@ -11,5 +11,5 @@ // error-pattern:panicked at 'test-fail-fmt 42 rust' fn main() { - panic!("test-fail-fmt {} {}", 42i, "rust"); + panic!("test-fail-fmt {} {}", 42, "rust"); } diff --git a/src/test/run-fail/panic-task-name-none.rs b/src/test/run-fail/panic-task-name-none.rs index 9beee3b1843..816ee84a841 100644 --- a/src/test/run-fail/panic-task-name-none.rs +++ b/src/test/run-fail/panic-task-name-none.rs @@ -15,7 +15,7 @@ use std::thread::Thread; fn main() { let r: Result<int,_> = Thread::scoped(move|| { panic!("test"); - 1i + 1 }).join(); assert!(r.is_ok()); } diff --git a/src/test/run-fail/panic-task-name-owned.rs b/src/test/run-fail/panic-task-name-owned.rs index 714cec6fb3d..d48d282c9eb 100644 --- a/src/test/run-fail/panic-task-name-owned.rs +++ b/src/test/run-fail/panic-task-name-owned.rs @@ -15,7 +15,7 @@ use std::thread::Builder; fn main() { let r: Result<int,_> = Builder::new().name("owned name".to_string()).scoped(move|| { panic!("test"); - 1i + 1 }).join(); assert!(r.is_ok()); } diff --git a/src/test/run-fail/unwind-interleaved.rs b/src/test/run-fail/unwind-interleaved.rs index 5012ded28b5..91a33329a4f 100644 --- a/src/test/run-fail/unwind-interleaved.rs +++ b/src/test/run-fail/unwind-interleaved.rs @@ -15,8 +15,8 @@ fn a() { } fn b() { panic!(); } fn main() { - let _x = vec!(0i); + let _x = vec!(0); a(); - let _y = vec!(0i); + let _y = vec!(0); b(); } diff --git a/src/test/run-fail/unwind-unique.rs b/src/test/run-fail/unwind-unique.rs index f39ded8f98e..e1176b1bcdb 100644 --- a/src/test/run-fail/unwind-unique.rs +++ b/src/test/run-fail/unwind-unique.rs @@ -18,6 +18,6 @@ fn failfn() { } fn main() { - box 0i; + box 0; failfn(); } diff --git a/src/test/run-make/cannot-read-embedded-idents/create_and_compile.rs b/src/test/run-make/cannot-read-embedded-idents/create_and_compile.rs index f9dffdf8928..f7c581172e2 100644 --- a/src/test/run-make/cannot-read-embedded-idents/create_and_compile.rs +++ b/src/test/run-make/cannot-read-embedded-idents/create_and_compile.rs @@ -23,7 +23,7 @@ fn main() { let main_file = tmpdir.join("broken.rs"); let _ = File::create(&main_file).unwrap() .write_str("pub fn main() { - let \x00name_0,ctxt_0\x00 = 3i; + let \x00name_0,ctxt_0\x00 = 3; println!(\"{}\", \x00name_0,ctxt_0\x00); }"); diff --git a/src/test/run-make/static-unwinding/main.rs b/src/test/run-make/static-unwinding/main.rs index bd88cb19aa7..6d10a247143 100644 --- a/src/test/run-make/static-unwinding/main.rs +++ b/src/test/run-make/static-unwinding/main.rs @@ -25,7 +25,7 @@ fn main() { Thread::scoped(move|| { let _a = A; lib::callback(|| panic!()); - 1i + 1 }).join().err().unwrap(); unsafe { diff --git a/src/test/run-pass-fulldeps/issue-16992.rs b/src/test/run-pass-fulldeps/issue-16992.rs index 563b8394963..9e3ad8ee283 100644 --- a/src/test/run-pass-fulldeps/issue-16992.rs +++ b/src/test/run-pass-fulldeps/issue-16992.rs @@ -19,8 +19,8 @@ use syntax::ext::base::ExtCtxt; #[allow(dead_code)] fn foobar(cx: &mut ExtCtxt) { - quote_expr!(cx, 1i); - quote_expr!(cx, 2i); + quote_expr!(cx, 1); + quote_expr!(cx, 2); } fn main() { } diff --git a/src/test/run-pass-fulldeps/macro-crate-does-hygiene-work.rs b/src/test/run-pass-fulldeps/macro-crate-does-hygiene-work.rs index a8762234ad9..497afae6189 100644 --- a/src/test/run-pass-fulldeps/macro-crate-does-hygiene-work.rs +++ b/src/test/run-pass-fulldeps/macro-crate-does-hygiene-work.rs @@ -20,9 +20,9 @@ extern crate macro_crate_test; fn main() { - let x = 3i; + let x = 3; assert_eq!(3, identity!(x)); assert_eq!(6, identity!(x+x)); - let x = 4i; + let x = 4; assert_eq!(4, identity!(x)); } diff --git a/src/test/run-pass-fulldeps/quote-unused-sp-no-warning.rs b/src/test/run-pass-fulldeps/quote-unused-sp-no-warning.rs index 2d5bbd43e82..848ea738ed7 100644 --- a/src/test/run-pass-fulldeps/quote-unused-sp-no-warning.rs +++ b/src/test/run-pass-fulldeps/quote-unused-sp-no-warning.rs @@ -19,7 +19,7 @@ extern crate syntax; use syntax::ext::base::ExtCtxt; fn test(cx: &mut ExtCtxt) { - let foo = 10i; + let foo = 10; let _e = quote_expr!(cx, $foo); } diff --git a/src/test/run-pass/assert-eq-macro-success.rs b/src/test/run-pass/assert-eq-macro-success.rs index 8771ed7a742..e55a2d39cbf 100644 --- a/src/test/run-pass/assert-eq-macro-success.rs +++ b/src/test/run-pass/assert-eq-macro-success.rs @@ -15,7 +15,7 @@ struct Point { x : int } pub fn main() { - assert_eq!(14i,14i); + assert_eq!(14,14); assert_eq!("abc".to_string(),"abc".to_string()); assert_eq!(box Point{x:34},box Point{x:34}); assert_eq!(&Point{x:34},&Point{x:34}); diff --git a/src/test/run-pass/associated-types-binding-in-where-clause.rs b/src/test/run-pass/associated-types-binding-in-where-clause.rs index caf7d31a5fd..2f9a0b328b5 100644 --- a/src/test/run-pass/associated-types-binding-in-where-clause.rs +++ b/src/test/run-pass/associated-types-binding-in-where-clause.rs @@ -37,7 +37,7 @@ fn foo_uint<I: Foo<A=uint>>(x: I) -> uint { } pub fn main() { - let a = 42i; + let a = 42; foo_uint(a); let a = 'a'; diff --git a/src/test/run-pass/associated-types-bound.rs b/src/test/run-pass/associated-types-bound.rs index c34a19e1d82..9f97d69ce3f 100644 --- a/src/test/run-pass/associated-types-bound.rs +++ b/src/test/run-pass/associated-types-bound.rs @@ -8,44 +8,44 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -// Test equality constraints on associated types in a where clause. +// Test equality constrai32s on associated types in a where clause. -pub trait ToInt { - fn to_int(&self) -> int; +pub trait ToI32 { + fn to_i32(&self) -> i32; } -impl ToInt for int { - fn to_int(&self) -> int { *self } +impl ToI32 for i32 { + fn to_i32(&self) -> i32 { *self } } -impl ToInt for uint { - fn to_int(&self) -> int { *self as int } +impl ToI32 for u32 { + fn to_i32(&self) -> i32 { *self as i32 } } -pub trait GetToInt +pub trait GetToI32 { - type R : ToInt; + type R : ToI32; - fn get(&self) -> <Self as GetToInt>::R; + fn get(&self) -> <Self as GetToI32>::R; } -impl GetToInt for int { - type R = int; - fn get(&self) -> int { *self } +impl GetToI32 for i32 { + type R = i32; + fn get(&self) -> i32 { *self } } -impl GetToInt for uint { - type R = uint; - fn get(&self) -> uint { *self } +impl GetToI32 for u32 { + type R = u32; + fn get(&self) -> u32 { *self } } -fn foo<G>(g: G) -> int - where G : GetToInt +fn foo<G>(g: G) -> i32 + where G : GetToI32 { - ToInt::to_int(&g.get()) + ToI32::to_i32(&g.get()) } pub fn main() { - assert_eq!(foo(22i), 22i); - assert_eq!(foo(22u), 22i); + assert_eq!(foo(22i32), 22); + assert_eq!(foo(22u32), 22); } diff --git a/src/test/run-pass/associated-types-cc.rs b/src/test/run-pass/associated-types-cc.rs index 58aa351ba9c..948192f4fc0 100644 --- a/src/test/run-pass/associated-types-cc.rs +++ b/src/test/run-pass/associated-types-cc.rs @@ -22,5 +22,5 @@ fn foo<B:Bar>(b: B) -> <B as Bar>::T { } fn main() { - println!("{}", foo(3i)); + println!("{}", foo(3)); } diff --git a/src/test/run-pass/associated-types-nested-projections.rs b/src/test/run-pass/associated-types-nested-projections.rs index a907b9fcde5..e3227613159 100644 --- a/src/test/run-pass/associated-types-nested-projections.rs +++ b/src/test/run-pass/associated-types-nested-projections.rs @@ -45,6 +45,6 @@ fn bar<T, I, X>(x: X) where } fn main() { - foo(&[0i, 1, 2]); - bar(&[0i, 1, 2]); + foo(&[0, 1, 2]); + bar(&[0, 1, 2]); } diff --git a/src/test/run-pass/associated-types-ref-in-struct-literal.rs b/src/test/run-pass/associated-types-ref-in-struct-literal.rs index b51d44a0c24..022c8f4cd01 100644 --- a/src/test/run-pass/associated-types-ref-in-struct-literal.rs +++ b/src/test/run-pass/associated-types-ref-in-struct-literal.rs @@ -24,6 +24,6 @@ struct Thing<F: Foo> { } fn main() { - let thing = Thing{a: 1i, b: 2i}; + let thing = Thing{a: 1, b: 2}; assert_eq!(thing.a + 1, thing.b); } diff --git a/src/test/run-pass/associated-types-return.rs b/src/test/run-pass/associated-types-return.rs index b9b6d14f8a0..72290921854 100644 --- a/src/test/run-pass/associated-types-return.rs +++ b/src/test/run-pass/associated-types-return.rs @@ -42,11 +42,11 @@ fn foo2<I: Foo>(x: I) -> <I as Foo>::A { } pub fn main() { - let a = 42i; + let a = 42; assert!(foo2(a) == 42u); let a = Bar; - assert!(foo2(a) == 43i); + assert!(foo2(a) == 43); let a = 'a'; foo1(a); diff --git a/src/test/run-pass/associated-types-sugar-path.rs b/src/test/run-pass/associated-types-sugar-path.rs index 880554b61b2..ea1df6658fd 100644 --- a/src/test/run-pass/associated-types-sugar-path.rs +++ b/src/test/run-pass/associated-types-sugar-path.rs @@ -40,5 +40,5 @@ impl<T: Foo> C for B<T> { } pub fn main() { - let z: uint = bar(2i, 4u); + let z: uint = bar(2, 4u); } diff --git a/src/test/run-pass/auto-instantiate.rs b/src/test/run-pass/auto-instantiate.rs index 0e2f6ef056e..cd4c66cb321 100644 --- a/src/test/run-pass/auto-instantiate.rs +++ b/src/test/run-pass/auto-instantiate.rs @@ -15,6 +15,6 @@ struct Triple { x: int, y: int, z: int } fn f<T,U>(x: T, y: U) -> Pair<T, U> { return Pair {a: x, b: y}; } pub fn main() { - println!("{}", f(Triple {x: 3, y: 4, z: 5}, 4i).a.x); - println!("{}", f(5i, 6i).a); + println!("{}", f(Triple {x: 3, y: 4, z: 5}, 4).a.x); + println!("{}", f(5, 6).a); } diff --git a/src/test/run-pass/auto-loop.rs b/src/test/run-pass/auto-loop.rs index 88884dfeb50..e5f4d078749 100644 --- a/src/test/run-pass/auto-loop.rs +++ b/src/test/run-pass/auto-loop.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - let mut sum = 0i; + let mut sum = 0; let xs = vec!(1, 2, 3, 4, 5); for x in xs.iter() { sum += *x; diff --git a/src/test/run-pass/auto-ref-sliceable.rs b/src/test/run-pass/auto-ref-sliceable.rs index fd3ede07e21..652f21c2ae3 100644 --- a/src/test/run-pass/auto-ref-sliceable.rs +++ b/src/test/run-pass/auto-ref-sliceable.rs @@ -20,7 +20,7 @@ impl<T> Pushable<T> for Vec<T> { } pub fn main() { - let mut v = vec!(1i); + let mut v = vec!(1); v.push_val(2); v.push_val(3); assert_eq!(v, vec!(1, 2, 3)); diff --git a/src/test/run-pass/backtrace.rs b/src/test/run-pass/backtrace.rs index af1cc3b1f4d..e9a3ab6be35 100644 --- a/src/test/run-pass/backtrace.rs +++ b/src/test/run-pass/backtrace.rs @@ -21,7 +21,7 @@ use std::ops::{Drop, FnMut, FnOnce}; #[inline(never)] fn foo() { - let _v = vec![1i, 2, 3]; + let _v = vec![1, 2, 3]; if os::getenv("IS_TEST").is_some() { panic!() } @@ -77,7 +77,7 @@ fn runtest(me: &str) { assert!(!out.status.success()); let s = str::from_utf8(out.error.as_slice()).unwrap(); let mut i = 0; - for _ in 0i..2 { + for _ in 0..2 { i += s[i + 10..].find_str("stack backtrace").unwrap() + 10; } assert!(s[i + 10..].find_str("stack backtrace").is_none(), diff --git a/src/test/run-pass/binary-minus-without-space.rs b/src/test/run-pass/binary-minus-without-space.rs index 8235b91273b..dc3b142f233 100644 --- a/src/test/run-pass/binary-minus-without-space.rs +++ b/src/test/run-pass/binary-minus-without-space.rs @@ -11,6 +11,6 @@ // Check that issue #954 stays fixed pub fn main() { - match -1i { -1 => {}, _ => panic!("wat") } - assert_eq!(1i-1, 0i); + match -1 { -1 => {}, _ => panic!("wat") } + assert_eq!(1-1, 0); } diff --git a/src/test/run-pass/bitv-perf-test.rs b/src/test/run-pass/bitv-perf-test.rs index 167d0ace159..b6d428924e3 100644 --- a/src/test/run-pass/bitv-perf-test.rs +++ b/src/test/run-pass/bitv-perf-test.rs @@ -22,5 +22,5 @@ fn bitv_test() { } pub fn main() { - for _ in 0i..10000 { bitv_test(); } + for _ in 0..10000 { bitv_test(); } } diff --git a/src/test/run-pass/bitwise.rs b/src/test/run-pass/bitwise.rs index 251804e214b..8a57279e866 100644 --- a/src/test/run-pass/bitwise.rs +++ b/src/test/run-pass/bitwise.rs @@ -33,7 +33,7 @@ fn general() { assert_eq!(0xf0i | 0xf, 0xff); assert_eq!(0xfi << 4, 0xf0); assert_eq!(0xf0i >> 4, 0xf); - assert_eq!(-16i >> 2, -4); + assert_eq!(-16 >> 2, -4); assert_eq!(0b1010_1010i | 0b0101_0101, 0xff); } diff --git a/src/test/run-pass/block-expr-precedence.rs b/src/test/run-pass/block-expr-precedence.rs index 31d0d52f8b4..ace372dd2d3 100644 --- a/src/test/run-pass/block-expr-precedence.rs +++ b/src/test/run-pass/block-expr-precedence.rs @@ -58,9 +58,9 @@ pub fn main() { let num = 12; - assert_eq!(if (true) { 12i } else { 12 } - num, 0); - assert_eq!(12i - if (true) { 12i } else { 12 }, 0); - if (true) { 12i; } {-num}; - if (true) { 12i; }; {-num}; - if (true) { 12i; };;; -num; + assert_eq!(if (true) { 12 } else { 12 } - num, 0); + assert_eq!(12 - if (true) { 12 } else { 12 }, 0); + if (true) { 12; } {-num}; + if (true) { 12; }; {-num}; + if (true) { 12; };;; -num; } diff --git a/src/test/run-pass/block-iter-1.rs b/src/test/run-pass/block-iter-1.rs index 972bde5f29a..b5bd4d90c2e 100644 --- a/src/test/run-pass/block-iter-1.rs +++ b/src/test/run-pass/block-iter-1.rs @@ -11,8 +11,8 @@ fn iter_vec<T, F>(v: Vec<T> , mut f: F) where F: FnMut(&T) { for x in v.iter() { f(x); } } pub fn main() { - let v = vec!(1i, 2, 3, 4, 5, 6, 7); - let mut odds = 0i; + let v = vec![1i32, 2, 3, 4, 5, 6, 7]; + let mut odds = 0i32; iter_vec(v, |i| { if *i % 2 == 1 { odds += 1; diff --git a/src/test/run-pass/block-iter-2.rs b/src/test/run-pass/block-iter-2.rs index 1032fb486a1..348d9df6e7e 100644 --- a/src/test/run-pass/block-iter-2.rs +++ b/src/test/run-pass/block-iter-2.rs @@ -11,7 +11,7 @@ fn iter_vec<T, F>(v: Vec<T>, mut f: F) where F: FnMut(&T) { for x in v.iter() { f(x); } } pub fn main() { - let v = vec!(1i, 2, 3, 4, 5); + let v = vec![1i32, 2, 3, 4, 5]; let mut sum = 0; iter_vec(v.clone(), |i| { iter_vec(v.clone(), |j| { diff --git a/src/test/run-pass/borrow-tuple-fields.rs b/src/test/run-pass/borrow-tuple-fields.rs index a151a837f77..2e5688d8b74 100644 --- a/src/test/run-pass/borrow-tuple-fields.rs +++ b/src/test/run-pass/borrow-tuple-fields.rs @@ -11,13 +11,13 @@ struct Foo(int, int); fn main() { - let x = (1i, 2i); + let x = (1, 2); let a = &x.0; let b = &x.0; assert_eq!(*a, 1); assert_eq!(*b, 1); - let mut x = (1i, 2i); + let mut x = (1, 2); { let a = &x.0; let b = &mut x.1; @@ -28,13 +28,13 @@ fn main() { assert_eq!(x.1, 5); - let x = Foo(1i, 2i); + let x = Foo(1, 2); let a = &x.0; let b = &x.0; assert_eq!(*a, 1); assert_eq!(*b, 1); - let mut x = Foo(1i, 2i); + let mut x = Foo(1, 2); { let a = &x.0; let b = &mut x.1; diff --git a/src/test/run-pass/borrowck-closures-two-imm.rs b/src/test/run-pass/borrowck-closures-two-imm.rs index 33e4294366f..df8dbdd03c7 100644 --- a/src/test/run-pass/borrowck-closures-two-imm.rs +++ b/src/test/run-pass/borrowck-closures-two-imm.rs @@ -14,28 +14,28 @@ // that the main function can read the variable too while // the closures are in scope. Issue #6801. -fn a() -> int { - let mut x = 3i; +fn a() -> i32 { + let mut x = 3i32; x += 1; let c1 = |&:| x * 4; let c2 = |&:| x * 5; c1() * c2() * x } -fn get(x: &int) -> int { +fn get(x: &i32) -> i32 { *x * 4 } -fn b() -> int { - let mut x = 3; +fn b() -> i32 { + let mut x = 3i32; x += 1; let c1 = |&:| get(&x); let c2 = |&:| get(&x); c1() * c2() * x } -fn c() -> int { - let mut x = 3; +fn c() -> i32 { + let mut x = 3i32; x += 1; let c1 = |&:| x * 5; let c2 = |&:| get(&x); diff --git a/src/test/run-pass/borrowck-fixed-length-vecs.rs b/src/test/run-pass/borrowck-fixed-length-vecs.rs index 71c8936570a..ee561fdb0be 100644 --- a/src/test/run-pass/borrowck-fixed-length-vecs.rs +++ b/src/test/run-pass/borrowck-fixed-length-vecs.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - let x = [22i]; + let x = [22]; let y = &x[0]; assert_eq!(*y, 22); } diff --git a/src/test/run-pass/borrowck-freeze-frozen-mut.rs b/src/test/run-pass/borrowck-freeze-frozen-mut.rs index 21f5d0e6c14..30a921c9bd2 100644 --- a/src/test/run-pass/borrowck-freeze-frozen-mut.rs +++ b/src/test/run-pass/borrowck-freeze-frozen-mut.rs @@ -19,7 +19,7 @@ fn get<'a, T>(ms: &'a MutSlice<'a, T>, index: uint) -> &'a T { } pub fn main() { - let mut data = [1i, 2, 3]; + let mut data = [1, 2, 3]; { let slice = MutSlice { data: &mut data }; slice.data[0] += 4; diff --git a/src/test/run-pass/borrowck-pat-reassign-no-binding.rs b/src/test/run-pass/borrowck-pat-reassign-no-binding.rs index 6136bc90fd4..4ccbf6b5b0f 100644 --- a/src/test/run-pass/borrowck-pat-reassign-no-binding.rs +++ b/src/test/run-pass/borrowck-pat-reassign-no-binding.rs @@ -14,7 +14,7 @@ pub fn main() { None => { // It is ok to reassign x here, because there is in // fact no outstanding loan of x! - x = Some(0i); + x = Some(0); } Some(_) => { } } diff --git a/src/test/run-pass/borrowed-ptr-pattern-infallible.rs b/src/test/run-pass/borrowed-ptr-pattern-infallible.rs index 55ae6d3bebf..e57c001ea05 100644 --- a/src/test/run-pass/borrowed-ptr-pattern-infallible.rs +++ b/src/test/run-pass/borrowed-ptr-pattern-infallible.rs @@ -10,7 +10,7 @@ pub fn main() { - let (&x, &y) = (&3i, &'a'); + let (&x, &y) = (&3, &'a'); assert_eq!(x, 3); assert_eq!(y, 'a'); } diff --git a/src/test/run-pass/borrowed-ptr-pattern.rs b/src/test/run-pass/borrowed-ptr-pattern.rs index 3636d4d769d..7ccb40c8e7b 100644 --- a/src/test/run-pass/borrowed-ptr-pattern.rs +++ b/src/test/run-pass/borrowed-ptr-pattern.rs @@ -15,6 +15,6 @@ fn foo<T:Clone>(x: &T) -> T{ } pub fn main() { - assert_eq!(foo(&3i), 3i); + assert_eq!(foo(&3), 3); assert_eq!(foo(&'a'), 'a'); } diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs index 89745bd167c..bcfb8f6f914 100644 --- a/src/test/run-pass/break.rs +++ b/src/test/run-pass/break.rs @@ -9,12 +9,12 @@ // except according to those terms. pub fn main() { - let mut i = 0i; + let mut i = 0; while i < 20 { i += 1; if i == 10 { break; } } assert_eq!(i, 10); loop { i += 1; if i == 20 { break; } } assert_eq!(i, 20); - let xs = [1i, 2, 3, 4, 5, 6]; + let xs = [1, 2, 3, 4, 5, 6]; for x in xs.iter() { if *x == 3 { break; } assert!((*x <= 3)); } @@ -25,7 +25,7 @@ pub fn main() { i += 1; if i % 2 == 0 { continue; } assert!((i % 2 != 0)); if i >= 10 { break; } } - let ys = vec!(1i, 2, 3, 4, 5, 6); + let ys = vec!(1, 2, 3, 4, 5, 6); for x in ys.iter() { if *x % 2 == 0 { continue; } assert!((*x % 2 != 0)); diff --git a/src/test/run-pass/bug-7183-generics.rs b/src/test/run-pass/bug-7183-generics.rs index bf8d303f341..a3bb02d1d00 100644 --- a/src/test/run-pass/bug-7183-generics.rs +++ b/src/test/run-pass/bug-7183-generics.rs @@ -34,11 +34,11 @@ impl<T: Speak> Speak for Option<T> { pub fn main() { - assert_eq!(3i.hi(), "hello: 3".to_string()); - assert_eq!(Some(Some(3i)).hi(), + assert_eq!(3.hi(), "hello: 3".to_string()); + assert_eq!(Some(Some(3)).hi(), "something!something!hello: 3".to_string()); assert_eq!(None::<int>.hi(), "hello - none".to_string()); assert_eq!(Some(None::<int>).hi(), "something!hello - none".to_string()); - assert_eq!(Some(3i).hi(), "something!hello: 3".to_string()); + assert_eq!(Some(3).hi(), "something!hello: 3".to_string()); } diff --git a/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs b/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs index 365670db6f9..3df9dd25d86 100644 --- a/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs +++ b/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs @@ -28,6 +28,6 @@ fn foo<T: Foo>(val: T, chan: Sender<T>) { pub fn main() { let (tx, rx) = channel(); - foo(31337i, tx); - assert!(rx.recv().unwrap() == 31337i); + foo(31337, tx); + assert!(rx.recv().unwrap() == 31337); } diff --git a/src/test/run-pass/builtin-superkinds-capabilities-xc.rs b/src/test/run-pass/builtin-superkinds-capabilities-xc.rs index 126088d7f9d..52b826393e9 100644 --- a/src/test/run-pass/builtin-superkinds-capabilities-xc.rs +++ b/src/test/run-pass/builtin-superkinds-capabilities-xc.rs @@ -31,6 +31,6 @@ fn foo<T: RequiresRequiresShareAndSend>(val: T, chan: Sender<T>) { pub fn main() { let (tx, rx): (Sender<X<int>>, Receiver<X<int>>) = channel(); - foo(X(31337i), tx); - assert!(rx.recv().unwrap() == X(31337i)); + foo(X(31337), tx); + assert!(rx.recv().unwrap() == X(31337)); } diff --git a/src/test/run-pass/builtin-superkinds-capabilities.rs b/src/test/run-pass/builtin-superkinds-capabilities.rs index 7f4a2398f54..034e5ff2d3a 100644 --- a/src/test/run-pass/builtin-superkinds-capabilities.rs +++ b/src/test/run-pass/builtin-superkinds-capabilities.rs @@ -24,6 +24,6 @@ fn foo<T: Foo>(val: T, chan: Sender<T>) { pub fn main() { let (tx, rx): (Sender<int>, Receiver<int>) = channel(); - foo(31337i, tx); - assert!(rx.recv().unwrap() == 31337i); + foo(31337, tx); + assert!(rx.recv().unwrap() == 31337); } diff --git a/src/test/run-pass/builtin-superkinds-self-type.rs b/src/test/run-pass/builtin-superkinds-self-type.rs index d0db2542ccc..1b3070ba3b0 100644 --- a/src/test/run-pass/builtin-superkinds-self-type.rs +++ b/src/test/run-pass/builtin-superkinds-self-type.rs @@ -23,6 +23,6 @@ impl <T: Send> Foo for T { } pub fn main() { let (tx, rx) = channel(); - 1193182i.foo(tx); - assert!(rx.recv().unwrap() == 1193182i); + 1193182.foo(tx); + assert!(rx.recv().unwrap() == 1193182); } diff --git a/src/test/run-pass/cci_iter_exe.rs b/src/test/run-pass/cci_iter_exe.rs index 7191d5078b8..e4b26ba74be 100644 --- a/src/test/run-pass/cci_iter_exe.rs +++ b/src/test/run-pass/cci_iter_exe.rs @@ -15,7 +15,7 @@ extern crate cci_iter_lib; pub fn main() { //let bt0 = sys::rusti::frame_address(1u32); //println!("%?", bt0); - cci_iter_lib::iter(&[1i, 2, 3], |i| { + cci_iter_lib::iter(&[1, 2, 3], |i| { println!("{}", *i); //assert!(bt0 == sys::rusti::frame_address(2u32)); }) diff --git a/src/test/run-pass/class-poly-methods.rs b/src/test/run-pass/class-poly-methods.rs index d94547a4dda..4f94673a2c0 100644 --- a/src/test/run-pass/class-poly-methods.rs +++ b/src/test/run-pass/class-poly-methods.rs @@ -36,7 +36,7 @@ pub fn main() { let mut kitty = cat(1000u, 2, vec!("tabby".to_string())); assert_eq!(nyan.how_hungry, 99); assert_eq!(kitty.how_hungry, 2); - nyan.speak(vec!(1i,2,3)); + nyan.speak(vec!(1,2,3)); assert_eq!(nyan.meow_count(), 55u); kitty.speak(vec!("meow".to_string(), "mew".to_string(), "purr".to_string(), "chirp".to_string())); assert_eq!(kitty.meow_count(), 1004u); diff --git a/src/test/run-pass/cleanup-rvalue-scopes.rs b/src/test/run-pass/cleanup-rvalue-scopes.rs index bbfe0e6a18d..b39a4d7f685 100644 --- a/src/test/run-pass/cleanup-rvalue-scopes.rs +++ b/src/test/run-pass/cleanup-rvalue-scopes.rs @@ -110,7 +110,7 @@ pub fn main() { end_of_block!(ref _x, AddFlags(1)); end_of_block!(AddFlags { bits: ref _x }, AddFlags(1)); end_of_block!(&AddFlags { bits }, &AddFlags(1)); - end_of_block!((_, ref _y), (AddFlags(1), 22i)); + end_of_block!((_, ref _y), (AddFlags(1), 22)); end_of_block!(box ref _x, box AddFlags(1)); end_of_block!(box _x, box AddFlags(1)); end_of_block!(_, { { check_flags(0); &AddFlags(1) } }); @@ -120,7 +120,7 @@ pub fn main() { // LHS does not create a ref binding, so temporary lives as long // as statement, and we do not move the AddFlags out: end_of_stmt!(_, AddFlags(1)); - end_of_stmt!((_, _), (AddFlags(1), 22i)); + end_of_stmt!((_, _), (AddFlags(1), 22)); // `&` operator appears inside an arg to a function, // so it is not prolonged: diff --git a/src/test/run-pass/closure-inference2.rs b/src/test/run-pass/closure-inference2.rs index 03b10b881f7..c0877568b72 100644 --- a/src/test/run-pass/closure-inference2.rs +++ b/src/test/run-pass/closure-inference2.rs @@ -12,6 +12,6 @@ pub fn main() { let f = {|&: i| i}; - assert_eq!(f(2i), 2i); - assert_eq!(f(5i), 5i); + assert_eq!(f(2), 2); + assert_eq!(f(5), 5); } diff --git a/src/test/run-pass/coerce-match-calls.rs b/src/test/run-pass/coerce-match-calls.rs index 0ff28b471a3..34c9875f1de 100644 --- a/src/test/run-pass/coerce-match-calls.rs +++ b/src/test/run-pass/coerce-match-calls.rs @@ -13,9 +13,9 @@ use std::boxed::Box; pub fn main() { - let _: Box<[int]> = if true { Box::new([1i, 2, 3]) } else { Box::new([1i]) }; + let _: Box<[int]> = if true { Box::new([1, 2, 3]) } else { Box::new([1]) }; - let _: Box<[int]> = match true { true => Box::new([1i, 2, 3]), false => Box::new([1i]) }; + let _: Box<[int]> = match true { true => Box::new([1, 2, 3]), false => Box::new([1]) }; // Check we don't get over-keen at propagating coercions in the case of casts. let x = if true { 42 } else { 42u8 } as u16; diff --git a/src/test/run-pass/coerce-match.rs b/src/test/run-pass/coerce-match.rs index 0992ee97d06..098a08b0787 100644 --- a/src/test/run-pass/coerce-match.rs +++ b/src/test/run-pass/coerce-match.rs @@ -14,9 +14,9 @@ #![feature(box_syntax)] pub fn main() { - let _: Box<[int]> = if true { box [1i, 2, 3] } else { box [1i] }; + let _: Box<[int]> = if true { box [1, 2, 3] } else { box [1] }; - let _: Box<[int]> = match true { true => box [1i, 2, 3], false => box [1i] }; + let _: Box<[int]> = match true { true => box [1, 2, 3], false => box [1] }; // Check we don't get over-keen at propagating coercions in the case of casts. let x = if true { 42 } else { 42u8 } as u16; diff --git a/src/test/run-pass/complex.rs b/src/test/run-pass/complex.rs index 34292453ec4..f8c8ac20d72 100644 --- a/src/test/run-pass/complex.rs +++ b/src/test/run-pass/complex.rs @@ -35,8 +35,8 @@ fn foo(x: int) -> int { } pub fn main() { - let x: int = 2i + 2; + let x: int = 2 + 2; println!("{}", x); println!("hello, world"); - println!("{}", 10i); + println!("{}", 10); } diff --git a/src/test/run-pass/concat.rs b/src/test/run-pass/concat.rs index d78f948edc5..2a8443167d0 100644 --- a/src/test/run-pass/concat.rs +++ b/src/test/run-pass/concat.rs @@ -15,12 +15,12 @@ pub fn main() { assert_eq!(concat!("qux", "quux",).to_string(), "quxquux".to_string()); assert_eq!( - concat!(1, 2i, 3u, 4f32, 4.0, 'a', true), + concat!(1, 2, 3u, 4f32, 4.0, 'a', true), "12344.0atrue" ); assert!(match "12344.0atrue" { - concat!(1, 2i, 3u, 4f32, 4.0, 'a', true) => true, + concat!(1, 2, 3u, 4f32, 4.0, 'a', true) => true, _ => false }) } diff --git a/src/test/run-pass/const-binops.rs b/src/test/run-pass/const-binops.rs index 11590ceb19d..1268fc4e435 100644 --- a/src/test/run-pass/const-binops.rs +++ b/src/test/run-pass/const-binops.rs @@ -52,27 +52,27 @@ static V: int = 1 << 3; static W: int = 1024 >> 4; static X: uint = 1024 >> 4; -static Y: bool = 1i == 1; +static Y: bool = 1 == 1; static Z: bool = 1.0f64 == 1.0; -static AA: bool = 1i <= 2; -static AB: bool = -1i <= 2; +static AA: bool = 1 <= 2; +static AB: bool = -1 <= 2; static AC: bool = 1.0f64 <= 2.0; -static AD: bool = 1i < 2; -static AE: bool = -1i < 2; +static AD: bool = 1 < 2; +static AE: bool = -1 < 2; static AF: bool = 1.0f64 < 2.0; -static AG: bool = 1i != 2; -static AH: bool = -1i != 2; +static AG: bool = 1 != 2; +static AH: bool = -1 != 2; static AI: bool = 1.0f64 != 2.0; -static AJ: bool = 2i >= 1; -static AK: bool = 2i >= -2; +static AJ: bool = 2 >= 1; +static AK: bool = 2 >= -2; static AL: bool = 1.0f64 >= -2.0; -static AM: bool = 2i > 1; -static AN: bool = 2i > -2; +static AM: bool = 2 > 1; +static AN: bool = 2 > -2; static AO: bool = 1.0f64 > -2.0; pub fn main() { diff --git a/src/test/run-pass/const-bound.rs b/src/test/run-pass/const-bound.rs index 3a6973fe61c..e6a280a91d7 100644 --- a/src/test/run-pass/const-bound.rs +++ b/src/test/run-pass/const-bound.rs @@ -25,5 +25,5 @@ pub fn main() { foo(F{field: 42}); foo((1, 2u)); foo(@1);*/ - foo(box 1i); + foo(box 1); } diff --git a/src/test/run-pass/const-expr-in-vec-repeat.rs b/src/test/run-pass/const-expr-in-vec-repeat.rs index d692f3a87e4..0b097c0b060 100644 --- a/src/test/run-pass/const-expr-in-vec-repeat.rs +++ b/src/test/run-pass/const-expr-in-vec-repeat.rs @@ -13,6 +13,6 @@ pub fn main() { const FOO: uint = 2; - let _v = [0i; FOO*3*2/2]; + let _v = [0; FOO*3*2/2]; } diff --git a/src/test/run-pass/consts-in-patterns.rs b/src/test/run-pass/consts-in-patterns.rs index 87b7fcad385..e8f4948a165 100644 --- a/src/test/run-pass/consts-in-patterns.rs +++ b/src/test/run-pass/consts-in-patterns.rs @@ -12,11 +12,11 @@ const FOO: int = 10; const BAR: int = 3; pub fn main() { - let x: int = 3i; + let x: int = 3; let y = match x { - FOO => 1i, - BAR => 2i, - _ => 3i + FOO => 1, + BAR => 2, + _ => 3 }; assert_eq!(y, 2); } diff --git a/src/test/run-pass/deref-lval.rs b/src/test/run-pass/deref-lval.rs index ead0683b870..41c74250b3b 100644 --- a/src/test/run-pass/deref-lval.rs +++ b/src/test/run-pass/deref-lval.rs @@ -14,7 +14,7 @@ use std::cell::Cell; pub fn main() { - let x = box Cell::new(5i); - x.set(1000i); + let x = box Cell::new(5); + x.set(1000); println!("{}", x.get()); } diff --git a/src/test/run-pass/deref-rc.rs b/src/test/run-pass/deref-rc.rs index 03697875d56..fbb8a3a1720 100644 --- a/src/test/run-pass/deref-rc.rs +++ b/src/test/run-pass/deref-rc.rs @@ -11,6 +11,6 @@ use std::rc::Rc; fn main() { - let x = Rc::new([1i, 2, 3, 4]); + let x = Rc::new([1, 2, 3, 4]); assert!(*x == [1, 2, 3, 4]); } diff --git a/src/test/run-pass/deriving-clone-generic-enum.rs b/src/test/run-pass/deriving-clone-generic-enum.rs index e8e65dcb8a9..e174ffae75d 100644 --- a/src/test/run-pass/deriving-clone-generic-enum.rs +++ b/src/test/run-pass/deriving-clone-generic-enum.rs @@ -16,5 +16,5 @@ enum E<T,U> { } pub fn main() { - let _ = E::A::<int, int>(1i).clone(); + let _ = E::A::<int, int>(1).clone(); } diff --git a/src/test/run-pass/deriving-clone-generic-struct.rs b/src/test/run-pass/deriving-clone-generic-struct.rs index d340fe9d3fb..329c7dab3eb 100644 --- a/src/test/run-pass/deriving-clone-generic-struct.rs +++ b/src/test/run-pass/deriving-clone-generic-struct.rs @@ -16,5 +16,5 @@ struct S<T> { } pub fn main() { - let _ = S { foo: (), bar: (), baz: 1i }.clone(); + let _ = S { foo: (), bar: (), baz: 1 }.clone(); } diff --git a/src/test/run-pass/deriving-clone-generic-tuple-struct.rs b/src/test/run-pass/deriving-clone-generic-tuple-struct.rs index ecf1fdc6e5f..bb07b08859f 100644 --- a/src/test/run-pass/deriving-clone-generic-tuple-struct.rs +++ b/src/test/run-pass/deriving-clone-generic-tuple-struct.rs @@ -12,5 +12,5 @@ struct S<T>(T, ()); pub fn main() { - let _ = S(1i, ()).clone(); + let _ = S(1, ()).clone(); } diff --git a/src/test/run-pass/deriving-cmp-generic-enum.rs b/src/test/run-pass/deriving-cmp-generic-enum.rs index 04cb3b7c076..b3194d5820a 100644 --- a/src/test/run-pass/deriving-cmp-generic-enum.rs +++ b/src/test/run-pass/deriving-cmp-generic-enum.rs @@ -19,10 +19,10 @@ enum E<T> { pub fn main() { let e0 = E::E0; - let e11 = E::E1(1i); - let e12 = E::E1(2i); - let e21 = E::E2(1i, 1i); - let e22 = E::E2(1i, 2i); + let e11 = E::E1(1); + let e12 = E::E1(2); + let e21 = E::E2(1, 1); + let e22 = E::E2(1, 2); // in order for both PartialOrd and Ord let es = [e0, e11, e12, e21, e22]; diff --git a/src/test/run-pass/deriving-cmp-generic-struct-enum.rs b/src/test/run-pass/deriving-cmp-generic-struct-enum.rs index dbac7fa5bca..8b54536f3ab 100644 --- a/src/test/run-pass/deriving-cmp-generic-struct-enum.rs +++ b/src/test/run-pass/deriving-cmp-generic-struct-enum.rs @@ -19,15 +19,15 @@ enum ES<T> { pub fn main() { let (es11, es12, es21, es22) = (ES::ES1 { - x: 1i + x: 1 }, ES::ES1 { - x: 2i + x: 2 }, ES::ES2 { - x: 1i, - y: 1i + x: 1, + y: 1 }, ES::ES2 { - x: 1i, - y: 2i + x: 1, + y: 2 }); // in order for both PartialOrd and Ord diff --git a/src/test/run-pass/deriving-cmp-generic-struct.rs b/src/test/run-pass/deriving-cmp-generic-struct.rs index cd2cbb2d0a9..86887c3411f 100644 --- a/src/test/run-pass/deriving-cmp-generic-struct.rs +++ b/src/test/run-pass/deriving-cmp-generic-struct.rs @@ -17,8 +17,8 @@ struct S<T> { } pub fn main() { - let s1 = S {x: 1i, y: 1i}; - let s2 = S {x: 1i, y: 2i}; + let s1 = S {x: 1, y: 1}; + let s2 = S {x: 1, y: 2}; // in order for both PartialOrd and Ord let ss = [s1, s2]; diff --git a/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs b/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs index 0a45b73755e..c7d7f8ded83 100644 --- a/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs +++ b/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs @@ -15,8 +15,8 @@ struct TS<T>(T,T); pub fn main() { - let ts1 = TS(1i, 1i); - let ts2 = TS(1i, 2i); + let ts1 = TS(1, 1); + let ts2 = TS(1, 2); // in order for both PartialOrd and Ord let tss = [ts1, ts2]; diff --git a/src/test/run-pass/deriving-rand.rs b/src/test/run-pass/deriving-rand.rs index 36b6b3cbeea..d6e5fedf182 100644 --- a/src/test/run-pass/deriving-rand.rs +++ b/src/test/run-pass/deriving-rand.rs @@ -31,7 +31,7 @@ enum D { pub fn main() { // check there's no segfaults - for _ in 0i..20 { + for _ in 0..20 { rand::random::<A>(); rand::random::<B>(); rand::random::<C>(); diff --git a/src/test/run-pass/drop-trait-generic.rs b/src/test/run-pass/drop-trait-generic.rs index 9a93873f538..4ba3aa70dfc 100644 --- a/src/test/run-pass/drop-trait-generic.rs +++ b/src/test/run-pass/drop-trait-generic.rs @@ -22,5 +22,5 @@ impl<T> ::std::ops::Drop for S<T> { } pub fn main() { - let _x = S { x: 1i }; + let _x = S { x: 1 }; } diff --git a/src/test/run-pass/dst-raw.rs b/src/test/run-pass/dst-raw.rs index d3d2e3581aa..226025cd80e 100644 --- a/src/test/run-pass/dst-raw.rs +++ b/src/test/run-pass/dst-raw.rs @@ -45,7 +45,7 @@ pub fn main() { assert!(r == 42); // raw slice - let a: *const [_] = &[1i, 2, 3]; + let a: *const [_] = &[1, 2, 3]; unsafe { let b = (*a)[2]; assert!(b == 3); @@ -54,7 +54,7 @@ pub fn main() { } // raw slice with explicit cast - let a = &[1i, 2, 3] as *const [_]; + let a = &[1, 2, 3] as *const [_]; unsafe { let b = (*a)[2]; assert!(b == 3); @@ -63,7 +63,7 @@ pub fn main() { } // raw DST struct with slice - let c: *const Foo<[_]> = &Foo {f: [1i, 2, 3]}; + let c: *const Foo<[_]> = &Foo {f: [1, 2, 3]}; unsafe { let b = (&*c).f[0]; assert!(b == 1); @@ -86,7 +86,7 @@ pub fn main() { }; assert!(r == 42); - let a: *mut [_] = &mut [1i, 2, 3]; + let a: *mut [_] = &mut [1, 2, 3]; unsafe { let b = (*a)[2]; assert!(b == 3); @@ -94,7 +94,7 @@ pub fn main() { assert!(len == 3); } - let a = &mut [1i, 2, 3] as *mut [_]; + let a = &mut [1, 2, 3] as *mut [_]; unsafe { let b = (*a)[2]; assert!(b == 3); @@ -102,7 +102,7 @@ pub fn main() { assert!(len == 3); } - let c: *mut Foo<[_]> = &mut Foo {f: [1i, 2, 3]}; + let c: *mut Foo<[_]> = &mut Foo {f: [1, 2, 3]}; unsafe { let b = (&*c).f[0]; assert!(b == 1); diff --git a/src/test/run-pass/dst-struct.rs b/src/test/run-pass/dst-struct.rs index fa2af29431c..ee5193adbc6 100644 --- a/src/test/run-pass/dst-struct.rs +++ b/src/test/run-pass/dst-struct.rs @@ -115,7 +115,7 @@ pub fn main() { foo3(f5); // Box. - let f1 = box [1i, 2, 3]; + let f1 = box [1, 2, 3]; assert!((*f1)[1] == 2); let f2: Box<[int]> = f1; assert!((*f2)[1] == 2); diff --git a/src/test/run-pass/early-ret-binop-add.rs b/src/test/run-pass/early-ret-binop-add.rs index b9efdeb3bed..97e873e9aff 100644 --- a/src/test/run-pass/early-ret-binop-add.rs +++ b/src/test/run-pass/early-ret-binop-add.rs @@ -8,5 +8,5 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -fn wsucc(n: int) -> int { 0i + { return n + 1 } } +fn wsucc(n: int) -> int { 0 + { return n + 1 } } pub fn main() { } diff --git a/src/test/run-pass/early-vtbl-resolution.rs b/src/test/run-pass/early-vtbl-resolution.rs index 70030c66ca2..89fee7358a1 100644 --- a/src/test/run-pass/early-vtbl-resolution.rs +++ b/src/test/run-pass/early-vtbl-resolution.rs @@ -19,5 +19,5 @@ fn foo_func<A, B: thing<A>>(x: B) -> Option<A> { x.foo() } struct A { a: int } pub fn main() { - let _x: Option<f64> = foo_func(0i); + let _x: Option<f64> = foo_func(0); } diff --git a/src/test/run-pass/else-if.rs b/src/test/run-pass/else-if.rs index 63f32ae702b..476d3f42d6e 100644 --- a/src/test/run-pass/else-if.rs +++ b/src/test/run-pass/else-if.rs @@ -11,20 +11,20 @@ pub fn main() { - if 1i == 2 { + if 1 == 2 { assert!((false)); - } else if 2i == 3 { + } else if 2 == 3 { assert!((false)); - } else if 3i == 4 { assert!((false)); } else { assert!((true)); } - if 1i == 2 { assert!((false)); } else if 2i == 2 { assert!((true)); } - if 1i == 2 { + } else if 3 == 4 { assert!((false)); } else { assert!((true)); } + if 1 == 2 { assert!((false)); } else if 2 == 2 { assert!((true)); } + if 1 == 2 { assert!((false)); - } else if 2i == 2 { - if 1i == 1 { + } else if 2 == 2 { + if 1 == 1 { assert!((true)); - } else { if 2i == 1 { assert!((false)); } else { assert!((false)); } } + } else { if 2 == 1 { assert!((false)); } else { assert!((false)); } } } - if 1i == 2 { + if 1 == 2 { assert!((false)); - } else { if 1i == 2 { assert!((false)); } else { assert!((true)); } } + } else { if 1 == 2 { assert!((false)); } else { assert!((true)); } } } diff --git a/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs b/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs index 81713657202..468e5f5f4b3 100644 --- a/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs +++ b/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs @@ -19,8 +19,8 @@ enum List<X> { Nil, Cons(X, Box<List<X>>) } pub fn main() { - match List::Cons(10i, box List::Nil) { - List::Cons(10i, _) => {} + match List::Cons(10, box List::Nil) { + List::Cons(10, _) => {} List::Nil => {} _ => panic!() } diff --git a/src/test/run-pass/enum-vec-initializer.rs b/src/test/run-pass/enum-vec-initializer.rs index d436916c279..86a998100b0 100644 --- a/src/test/run-pass/enum-vec-initializer.rs +++ b/src/test/run-pass/enum-vec-initializer.rs @@ -16,9 +16,9 @@ const BAR:uint = Flopsy::Bunny as uint; const BAR2:uint = BAR; pub fn main() { - let _v = [0i; Flopsy::Bunny as uint]; - let _v = [0i; BAR]; - let _v = [0i; BAR2]; + let _v = [0; Flopsy::Bunny as uint]; + let _v = [0; BAR]; + let _v = [0; BAR2]; const BAR3:uint = BAR2; - let _v = [0i; BAR3]; + let _v = [0; BAR3]; } diff --git a/src/test/run-pass/explicit-i-suffix.rs b/src/test/run-pass/explicit-i-suffix.rs index 45cfee76fb8..96c58b106f3 100644 --- a/src/test/run-pass/explicit-i-suffix.rs +++ b/src/test/run-pass/explicit-i-suffix.rs @@ -9,11 +9,11 @@ // except according to those terms. pub fn main() { - let x: int = 8i; - let y = 9i; + let x: int = 8; + let y = 9; x + y; - let q: int = -8i; - let r = -9i; + let q: int = -8; + let r = -9; q + r; } diff --git a/src/test/run-pass/expr-block-unique.rs b/src/test/run-pass/expr-block-unique.rs index d934ce677d1..d10b209965f 100644 --- a/src/test/run-pass/expr-block-unique.rs +++ b/src/test/run-pass/expr-block-unique.rs @@ -12,4 +12,4 @@ #![allow(unknown_features)] #![feature(box_syntax)] -pub fn main() { let x = { box 100i }; assert!((*x == 100)); } +pub fn main() { let x = { box 100 }; assert!((*x == 100)); } diff --git a/src/test/run-pass/expr-block.rs b/src/test/run-pass/expr-block.rs index 7af9e790504..ee1d955b0d3 100644 --- a/src/test/run-pass/expr-block.rs +++ b/src/test/run-pass/expr-block.rs @@ -20,7 +20,7 @@ struct RS { v1: int, v2: int } fn test_rec() { let rs = { RS {v1: 10, v2: 20} }; assert!((rs.v2 == 20)); } fn test_filled_with_stuff() { - let rs = { let mut a = 0i; while a < 10 { a += 1; } a }; + let rs = { let mut a = 0; while a < 10 { a += 1; } a }; assert_eq!(rs, 10); } diff --git a/src/test/run-pass/expr-empty-ret.rs b/src/test/run-pass/expr-empty-ret.rs index 7b08251967e..afc7dfaf9b4 100644 --- a/src/test/run-pass/expr-empty-ret.rs +++ b/src/test/run-pass/expr-empty-ret.rs @@ -12,7 +12,7 @@ fn f() { let _x = match true { - true => { 10i } + true => { 10 } false => { return } }; } diff --git a/src/test/run-pass/expr-fn.rs b/src/test/run-pass/expr-fn.rs index 8172c16abf2..0ea1f3fcdaf 100644 --- a/src/test/run-pass/expr-fn.rs +++ b/src/test/run-pass/expr-fn.rs @@ -22,7 +22,7 @@ fn test_vec() { fn test_generic() { fn f<T>(t: T) -> T { t } - assert_eq!(f(10i), 10); + assert_eq!(f(10), 10); } fn test_alt() { diff --git a/src/test/run-pass/expr-if-panic-all.rs b/src/test/run-pass/expr-if-panic-all.rs index 0dd7ddc3f84..52ccee05817 100644 --- a/src/test/run-pass/expr-if-panic-all.rs +++ b/src/test/run-pass/expr-if-panic-all.rs @@ -12,7 +12,7 @@ // expression results in panic. pub fn main() { let _x = if true { - 10i + 10 } else { if true { panic!() } else { panic!() } }; diff --git a/src/test/run-pass/expr-if-panic.rs b/src/test/run-pass/expr-if-panic.rs index aa4240c60f1..87c7954fa49 100644 --- a/src/test/run-pass/expr-if-panic.rs +++ b/src/test/run-pass/expr-if-panic.rs @@ -9,18 +9,18 @@ // except according to those terms. fn test_if_panic() { - let x = if false { panic!() } else { 10i }; + let x = if false { panic!() } else { 10 }; assert!((x == 10)); } fn test_else_panic() { - let x = if true { 10i } else { panic!() }; - assert_eq!(x, 10i); + let x = if true { 10 } else { panic!() }; + assert_eq!(x, 10); } fn test_elseif_panic() { - let x = if false { 0i } else if false { panic!() } else { 10i }; - assert_eq!(x, 10i); + let x = if false { 0 } else if false { panic!() } else { 10 }; + assert_eq!(x, 10); } pub fn main() { test_if_panic(); test_else_panic(); test_elseif_panic(); } diff --git a/src/test/run-pass/expr-if-unique.rs b/src/test/run-pass/expr-if-unique.rs index 5294d05401c..317e5434930 100644 --- a/src/test/run-pass/expr-if-unique.rs +++ b/src/test/run-pass/expr-if-unique.rs @@ -15,8 +15,8 @@ // Tests for if as expressions returning boxed types fn test_box() { - let rs = if true { box 100i } else { box 101i }; - assert_eq!(*rs, 100i); + let rs = if true { box 100 } else { box 101 }; + assert_eq!(*rs, 100); } pub fn main() { test_box(); } diff --git a/src/test/run-pass/expr-match-panic-all.rs b/src/test/run-pass/expr-match-panic-all.rs index 3b33c18bbbd..3a8955917d6 100644 --- a/src/test/run-pass/expr-match-panic-all.rs +++ b/src/test/run-pass/expr-match-panic-all.rs @@ -16,7 +16,7 @@ pub fn main() { let _x = match true { - true => { 10i } + true => { 10 } false => { match true { true => { panic!() } false => { panic!() } } } }; } diff --git a/src/test/run-pass/expr-match-panic.rs b/src/test/run-pass/expr-match-panic.rs index d8ee21dfdc6..da24d4c57cc 100644 --- a/src/test/run-pass/expr-match-panic.rs +++ b/src/test/run-pass/expr-match-panic.rs @@ -15,8 +15,8 @@ fn test_simple() { } fn test_box() { - let r = match true { true => { vec!(10i) } false => { panic!() } }; - assert_eq!(r[0], 10i); + let r = match true { true => { vec!(10) } false => { panic!() } }; + assert_eq!(r[0], 10); } pub fn main() { test_simple(); test_box(); } diff --git a/src/test/run-pass/expr-match-unique.rs b/src/test/run-pass/expr-match-unique.rs index 7958f4927da..57ccfe1d5e0 100644 --- a/src/test/run-pass/expr-match-unique.rs +++ b/src/test/run-pass/expr-match-unique.rs @@ -13,8 +13,8 @@ // Tests for match as expressions resulting in boxed types fn test_box() { - let res = match true { true => { box 100i }, _ => panic!() }; - assert_eq!(*res, 100i); + let res = match true { true => { box 100 }, _ => panic!() }; + assert_eq!(*res, 100); } pub fn main() { test_box(); } diff --git a/src/test/run-pass/fat-arrow-match.rs b/src/test/run-pass/fat-arrow-match.rs index 929d1c8e63d..004e6d48e37 100644 --- a/src/test/run-pass/fat-arrow-match.rs +++ b/src/test/run-pass/fat-arrow-match.rs @@ -17,8 +17,8 @@ enum color { pub fn main() { println!("{}", match color::red { - color::red => { 1i } - color::green => { 2i } - color::blue => { 3i } + color::red => { 1 } + color::green => { 2 } + color::blue => { 3 } }); } diff --git a/src/test/run-pass/fixed_length_copy.rs b/src/test/run-pass/fixed_length_copy.rs index dc34cec7fa2..bbd7b9130e7 100644 --- a/src/test/run-pass/fixed_length_copy.rs +++ b/src/test/run-pass/fixed_length_copy.rs @@ -9,8 +9,8 @@ // except according to those terms. pub fn main() { - let arr = [1i,2i,3i]; + let arr = [1,2,3]; let arr2 = arr; - assert_eq!(arr[1], 2i); - assert_eq!(arr2[2], 3i); + assert_eq!(arr[1], 2); + assert_eq!(arr2[2], 3); } diff --git a/src/test/run-pass/fn-type-infer.rs b/src/test/run-pass/fn-type-infer.rs index ae22ff5cce0..785abbe449b 100644 --- a/src/test/run-pass/fn-type-infer.rs +++ b/src/test/run-pass/fn-type-infer.rs @@ -13,6 +13,6 @@ pub fn main() { // We should be able to type infer inside of ||s. let _f = |&:| { - let i = 10i; + let i = 10; }; } diff --git a/src/test/run-pass/for-loop-goofiness.rs b/src/test/run-pass/for-loop-goofiness.rs index 73f4cdd252e..ae509dc0862 100644 --- a/src/test/run-pass/for-loop-goofiness.rs +++ b/src/test/run-pass/for-loop-goofiness.rs @@ -16,7 +16,7 @@ enum BogusOption<T> { type Iterator = int; pub fn main() { - let x = [ 3i, 3, 3 ]; + let x = [ 3, 3, 3 ]; for i in x.iter() { assert_eq!(*i, 3); } diff --git a/src/test/run-pass/foreach-external-iterators-break.rs b/src/test/run-pass/foreach-external-iterators-break.rs index 5f7770e97a9..9cbb4f4107a 100644 --- a/src/test/run-pass/foreach-external-iterators-break.rs +++ b/src/test/run-pass/foreach-external-iterators-break.rs @@ -9,8 +9,8 @@ // except according to those terms. pub fn main() { - let x = [1i; 100]; - let mut y = 0i; + let x = [1; 100]; + let mut y = 0; for i in x.iter() { if y > 10 { break; diff --git a/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs b/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs index 4305ae95698..d16a964ea79 100644 --- a/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs +++ b/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs @@ -18,7 +18,7 @@ use std::collections::HashMap; pub fn main() { let mut h = HashMap::new(); - let kvs = [(1i, 10i), (2i, 20i), (3i, 30i)]; + let kvs = [(1, 10), (2, 20), (3, 30)]; for &(k,v) in kvs.iter() { h.insert(k,v); } diff --git a/src/test/run-pass/foreach-external-iterators-hashmap.rs b/src/test/run-pass/foreach-external-iterators-hashmap.rs index ab20f9f9778..1878997de5a 100644 --- a/src/test/run-pass/foreach-external-iterators-hashmap.rs +++ b/src/test/run-pass/foreach-external-iterators-hashmap.rs @@ -14,12 +14,12 @@ use std::collections::HashMap; pub fn main() { let mut h = HashMap::new(); - let kvs = [(1i, 10i), (2i, 20i), (3i, 30i)]; + let kvs = [(1, 10), (2, 20), (3, 30)]; for &(k,v) in kvs.iter() { h.insert(k,v); } - let mut x = 0i; - let mut y = 0i; + let mut x = 0; + let mut y = 0; for (&k,&v) in h.iter() { x += k; y += v; diff --git a/src/test/run-pass/foreach-external-iterators-loop.rs b/src/test/run-pass/foreach-external-iterators-loop.rs index d8c6dd6a93d..d9abed50123 100644 --- a/src/test/run-pass/foreach-external-iterators-loop.rs +++ b/src/test/run-pass/foreach-external-iterators-loop.rs @@ -9,8 +9,8 @@ // except according to those terms. pub fn main() { - let x = [1i; 100]; - let mut y = 0i; + let x = [1; 100]; + let mut y = 0; for (n,i) in x.iter().enumerate() { if n < 10 { continue; diff --git a/src/test/run-pass/foreach-external-iterators-nested.rs b/src/test/run-pass/foreach-external-iterators-nested.rs index 20ea9c440a1..75471991620 100644 --- a/src/test/run-pass/foreach-external-iterators-nested.rs +++ b/src/test/run-pass/foreach-external-iterators-nested.rs @@ -9,10 +9,10 @@ // except according to those terms. pub fn main() { - let x = [1i; 100]; - let y = [2i; 100]; - let mut p = 0i; - let mut q = 0i; + let x = [1; 100]; + let y = [2; 100]; + let mut p = 0; + let mut q = 0; for i in x.iter() { for j in y.iter() { p += *j; diff --git a/src/test/run-pass/foreach-external-iterators.rs b/src/test/run-pass/foreach-external-iterators.rs index 0ac642cc449..ef4692b2b51 100644 --- a/src/test/run-pass/foreach-external-iterators.rs +++ b/src/test/run-pass/foreach-external-iterators.rs @@ -9,8 +9,8 @@ // except according to those terms. pub fn main() { - let x = [1i; 100]; - let mut y = 0i; + let x = [1; 100]; + let mut y = 0; for i in x.iter() { y += *i } diff --git a/src/test/run-pass/foreign-call-no-runtime.rs b/src/test/run-pass/foreign-call-no-runtime.rs index c1df9d53ad4..f99d3eb1c7d 100644 --- a/src/test/run-pass/foreign-call-no-runtime.rs +++ b/src/test/run-pass/foreign-call-no-runtime.rs @@ -22,7 +22,7 @@ extern { pub fn main() { unsafe { Thread::scoped(move|| { - let i = &100i; + let i = &100; rust_dbg_call(callback, mem::transmute(i)); }).join(); } @@ -31,6 +31,6 @@ pub fn main() { extern fn callback(data: libc::uintptr_t) { unsafe { let data: *const int = mem::transmute(data); - assert_eq!(*data, 100i); + assert_eq!(*data, 100); } } diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs index 34b7f15e4c6..db468ba1802 100644 --- a/src/test/run-pass/generic-alias-unique.rs +++ b/src/test/run-pass/generic-alias-unique.rs @@ -14,7 +14,7 @@ fn id<T:Send>(t: T) -> T { return t; } pub fn main() { - let expected = box 100i; + let expected = box 100; let actual = id::<Box<int>>(expected.clone()); println!("{}", *actual); assert_eq!(*expected, *actual); diff --git a/src/test/run-pass/generic-fn-unique.rs b/src/test/run-pass/generic-fn-unique.rs index be83cb04f2c..6599aa74124 100644 --- a/src/test/run-pass/generic-fn-unique.rs +++ b/src/test/run-pass/generic-fn-unique.rs @@ -13,4 +13,4 @@ fn f<T>(x: Box<T>) -> Box<T> { return x; } -pub fn main() { let x = f(box 3i); println!("{}", *x); } +pub fn main() { let x = f(box 3); println!("{}", *x); } diff --git a/src/test/run-pass/generic-ivec-leak.rs b/src/test/run-pass/generic-ivec-leak.rs index 48b61bf745d..eb0546063f7 100644 --- a/src/test/run-pass/generic-ivec-leak.rs +++ b/src/test/run-pass/generic-ivec-leak.rs @@ -10,4 +10,4 @@ enum wrapper<T> { wrapped(T), } -pub fn main() { let _w = wrapper::wrapped(vec!(1i, 2, 3, 4, 5)); } +pub fn main() { let _w = wrapper::wrapped(vec!(1, 2, 3, 4, 5)); } diff --git a/src/test/run-pass/generic-newtype-struct.rs b/src/test/run-pass/generic-newtype-struct.rs index f87e11cbb61..4e3c8204052 100644 --- a/src/test/run-pass/generic-newtype-struct.rs +++ b/src/test/run-pass/generic-newtype-struct.rs @@ -11,5 +11,5 @@ struct S<T>(T); pub fn main() { - let _s = S(2i); + let _s = S(2); } diff --git a/src/test/run-pass/generic-static-methods.rs b/src/test/run-pass/generic-static-methods.rs index f992847e4e9..90a6349385d 100644 --- a/src/test/run-pass/generic-static-methods.rs +++ b/src/test/run-pass/generic-static-methods.rs @@ -24,5 +24,5 @@ impl<T> vec_utils<T> for Vec<T> { } pub fn main() { - assert_eq!(vec_utils::map_(&vec!(1i,2i,3i), |&x| x+1), vec!(2i,3i,4i)); + assert_eq!(vec_utils::map_(&vec!(1,2,3), |&x| x+1), vec!(2,3,4)); } diff --git a/src/test/run-pass/generic-tag-local.rs b/src/test/run-pass/generic-tag-local.rs index cd8b13421c4..24c31ab4ee6 100644 --- a/src/test/run-pass/generic-tag-local.rs +++ b/src/test/run-pass/generic-tag-local.rs @@ -12,4 +12,4 @@ enum clam<T> { a(T), } -pub fn main() { let _c = clam::a(3i); } +pub fn main() { let _c = clam::a(3); } diff --git a/src/test/run-pass/generic-tup.rs b/src/test/run-pass/generic-tup.rs index dc9a90f7025..cd0e344b89c 100644 --- a/src/test/run-pass/generic-tup.rs +++ b/src/test/run-pass/generic-tup.rs @@ -11,7 +11,7 @@ fn get_third<T>(t: (T, T, T)) -> T { let (_, _, x) = t; return x; } pub fn main() { - println!("{}", get_third((1i, 2i, 3i))); - assert_eq!(get_third((1i, 2i, 3i)), 3); + println!("{}", get_third((1, 2, 3))); + assert_eq!(get_third((1, 2, 3)), 3); assert_eq!(get_third((5u8, 6u8, 7u8)), 7u8); } diff --git a/src/test/run-pass/guards.rs b/src/test/run-pass/guards.rs index e7031ae147e..188106ec107 100644 --- a/src/test/run-pass/guards.rs +++ b/src/test/run-pass/guards.rs @@ -13,14 +13,14 @@ struct Pair { x: int, y: int } pub fn main() { let a: int = - match 10i { x if x < 7 => { 1i } x if x < 11 => { 2i } 10 => { 3i } _ => { 4i } }; + match 10 { x if x < 7 => { 1 } x if x < 11 => { 2 } 10 => { 3 } _ => { 4 } }; assert_eq!(a, 2); let b: int = match (Pair {x: 10, y: 20}) { - x if x.x < 5 && x.y < 5 => { 1i } - Pair {x: x, y: y} if x == 10 && y == 20 => { 2i } - Pair {x: _x, y: _y} => { 3i } + x if x.x < 5 && x.y < 5 => { 1 } + Pair {x: x, y: y} if x == 10 && y == 20 => { 2 } + Pair {x: _x, y: _y} => { 3 } }; assert_eq!(b, 2); } diff --git a/src/test/run-pass/hygiene-dodging-1.rs b/src/test/run-pass/hygiene-dodging-1.rs index eb81f82a146..3969394a26b 100644 --- a/src/test/run-pass/hygiene-dodging-1.rs +++ b/src/test/run-pass/hygiene-dodging-1.rs @@ -14,7 +14,7 @@ mod x { pub fn main(){ // should *not* shadow the module x: - let x = 9i; + let x = 9; // use it to avoid warnings: x+3; assert_eq!(x::g(),14); diff --git a/src/test/run-pass/hygienic-labels-in-let.rs b/src/test/run-pass/hygienic-labels-in-let.rs index d8c08a0e4ef..cca0e5b163c 100644 --- a/src/test/run-pass/hygienic-labels-in-let.rs +++ b/src/test/run-pass/hygienic-labels-in-let.rs @@ -20,19 +20,19 @@ macro_rules! loop_x { macro_rules! while_true { ($e: expr) => { // $e shouldn't be able to interact with this 'x - 'x: while 1i + 1 == 2 { $e } + 'x: while 1 + 1 == 2 { $e } } } macro_rules! run_once { ($e: expr) => { // ditto - 'x: for _ in 0i..1 { $e } + 'x: for _ in 0..1 { $e } } } pub fn main() { - let mut i = 0i; + let mut i = 0; let j: int = { 'x: loop { @@ -42,35 +42,35 @@ pub fn main() { } i + 1 }; - assert_eq!(j, 1i); + assert_eq!(j, 1); let k: int = { - 'x: for _ in 0i..1 { + 'x: for _ in 0..1 { // ditto loop_x!(break 'x); i += 1; } i + 1 }; - assert_eq!(k, 1i); + assert_eq!(k, 1); let l: int = { - 'x: for _ in 0i..1 { + 'x: for _ in 0..1 { // ditto while_true!(break 'x); i += 1; } i + 1 }; - assert_eq!(l, 1i); + assert_eq!(l, 1); let n: int = { - 'x: for _ in 0i..1 { + 'x: for _ in 0..1 { // ditto run_once!(continue 'x); i += 1; } i + 1 }; - assert_eq!(n, 1i); + assert_eq!(n, 1); } diff --git a/src/test/run-pass/hygienic-labels.rs b/src/test/run-pass/hygienic-labels.rs index ff8f248a082..0d8da2a9348 100644 --- a/src/test/run-pass/hygienic-labels.rs +++ b/src/test/run-pass/hygienic-labels.rs @@ -18,19 +18,19 @@ macro_rules! loop_x { macro_rules! run_once { ($e: expr) => { // ditto - 'x: for _ in 0i..1 { $e } + 'x: for _ in 0..1 { $e } } } macro_rules! while_x { ($e: expr) => { // ditto - 'x: while 1i + 1 == 2 { $e } + 'x: while 1 + 1 == 2 { $e } } } pub fn main() { - 'x: for _ in 0i..1 { + 'x: for _ in 0..1 { // this 'x should refer to the outer loop, lexically loop_x!(break 'x); panic!("break doesn't act hygienically inside for loop"); @@ -42,12 +42,12 @@ pub fn main() { panic!("break doesn't act hygienically inside infinite loop"); } - 'x: while 1i + 1 == 2 { + 'x: while 1 + 1 == 2 { while_x!(break 'x); panic!("break doesn't act hygienically inside infinite while loop"); } - 'x: for _ in 0i..1 { + 'x: for _ in 0..1 { // ditto run_once!(continue 'x); panic!("continue doesn't act hygienically inside for loop"); diff --git a/src/test/run-pass/if-let.rs b/src/test/run-pass/if-let.rs index 4dff2ea55f1..5d97b886e8e 100644 --- a/src/test/run-pass/if-let.rs +++ b/src/test/run-pass/if-let.rs @@ -9,9 +9,9 @@ // except according to those terms. pub fn main() { - let x = Some(3i); + let x = Some(3); if let Some(y) = x { - assert_eq!(y, 3i); + assert_eq!(y, 3); } else { panic!("if-let panicked"); } @@ -32,9 +32,9 @@ pub fn main() { } assert_eq!(clause, 4u); - if 3i > 4 { + if 3 > 4 { panic!("bad math"); - } else if let 1 = 2i { + } else if let 1 = 2 { panic!("bad pattern match"); } @@ -44,7 +44,7 @@ pub fn main() { Three(String, int) } - let foo = Foo::Three("three".to_string(), 42i); + let foo = Foo::Three("three".to_string(), 42); if let Foo::One = foo { panic!("bad pattern match"); } else if let Foo::Two(_x) = foo { diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs index 56de6726bfb..0acc70f6b5d 100644 --- a/src/test/run-pass/ifmt.rs +++ b/src/test/run-pass/ifmt.rs @@ -59,10 +59,10 @@ pub fn main() { // At least exercise all the formats t!(format!("{}", true), "true"); t!(format!("{}", '☃'), "☃"); - t!(format!("{}", 10i), "10"); + t!(format!("{}", 10), "10"); t!(format!("{}", 10u), "10"); t!(format!("{:?}", '☃'), "'\\u{2603}'"); - t!(format!("{:?}", 10i), "10"); + t!(format!("{:?}", 10), "10"); t!(format!("{:?}", 10u), "10"); t!(format!("{:?}", "true"), "\"true\""); t!(format!("{:?}", "foo\nbar"), "\"foo\\nbar\""); @@ -76,16 +76,16 @@ pub fn main() { t!(format!("{:x}", A), "aloha"); t!(format!("{:X}", B), "adios"); t!(format!("foo {} ☃☃☃☃☃☃", "bar"), "foo bar ☃☃☃☃☃☃"); - t!(format!("{1} {0}", 0i, 1i), "1 0"); - t!(format!("{foo} {bar}", foo=0i, bar=1is), "0 1"); + t!(format!("{1} {0}", 0, 1), "1 0"); + t!(format!("{foo} {bar}", foo=0, bar=1is), "0 1"); t!(format!("{foo} {1} {bar} {0}", 0is, 1is, foo=2is, bar=3is), "2 1 3 0"); t!(format!("{} {0}", "a"), "a a"); - t!(format!("{foo_bar}", foo_bar=1i), "1"); - t!(format!("{}", 5i + 5i), "10"); + t!(format!("{foo_bar}", foo_bar=1), "1"); + t!(format!("{}", 5 + 5), "10"); t!(format!("{:#4}", C), "☃123"); // FIXME(#20676) - // let a: &fmt::Debug = &1i; + // let a: &fmt::Debug = &1; // t!(format!("{:?}", a), "1"); @@ -146,7 +146,7 @@ pub fn main() { test_order(); // make sure that format! doesn't move out of local variables - let a = box 3i; + let a = box 3; format!("{}", a); format!("{}", a); @@ -169,10 +169,10 @@ pub fn main() { fn test_write() { use std::fmt::Writer; let mut buf = String::new(); - write!(&mut buf, "{}", 3i); + write!(&mut buf, "{}", 3); { let w = &mut buf; - write!(w, "{foo}", foo=4i); + write!(w, "{foo}", foo=4); write!(w, "{}", "hello"); writeln!(w, "{}", "line"); writeln!(w, "{foo}", foo="bar"); @@ -198,9 +198,9 @@ fn test_format_args() { let mut buf = String::new(); { let w = &mut buf; - write!(w, "{}", format_args!("{}", 1i)); + write!(w, "{}", format_args!("{}", 1)); write!(w, "{}", format_args!("test")); - write!(w, "{}", format_args!("{test}", test=3i)); + write!(w, "{}", format_args!("{test}", test=3)); } let s = buf; t!(s, "1test3"); diff --git a/src/test/run-pass/ignore-all-the-things.rs b/src/test/run-pass/ignore-all-the-things.rs index 1c87b6dad89..65fc24ae746 100644 --- a/src/test/run-pass/ignore-all-the-things.rs +++ b/src/test/run-pass/ignore-all-the-things.rs @@ -23,28 +23,28 @@ pub fn main() { //let (a, b, ..) = (5, 5, 5, 5); //let (.., c, d) = (5, 5, 5, 5); let Bar{b: b, ..} = Bar{a: 5, b: 5, c: 5, d: 5}; - match [5i, 5, 5, 5] { + match [5, 5, 5, 5] { [..] => { } } - match [5i, 5, 5, 5] { + match [5, 5, 5, 5] { [a, ..] => { } } - match [5i, 5, 5, 5] { + match [5, 5, 5, 5] { [.., b] => { } } - match [5i, 5, 5, 5] { + match [5, 5, 5, 5] { [a, .., b] => { } } - match [5i, 5, 5] { + match [5, 5, 5] { [..] => { } } - match [5i, 5, 5] { + match [5, 5, 5] { [a, ..] => { } } - match [5i, 5, 5] { + match [5, 5, 5] { [.., a] => { } } - match [5i, 5, 5] { + match [5, 5, 5] { [a, .., b] => { } } } diff --git a/src/test/run-pass/import-glob-crate.rs b/src/test/run-pass/import-glob-crate.rs index 24d90741bbc..f7874cc56fc 100644 --- a/src/test/run-pass/import-glob-crate.rs +++ b/src/test/run-pass/import-glob-crate.rs @@ -14,7 +14,7 @@ use std::mem::*; pub fn main() { assert_eq!(size_of::<u8>(), 1); - let (mut x, mut y) = (1i, 2i); + let (mut x, mut y) = (1, 2); swap(&mut x, &mut y); assert_eq!(x, 2); assert_eq!(y, 1); diff --git a/src/test/run-pass/import-in-block.rs b/src/test/run-pass/import-in-block.rs index 3c28354dedc..4567651e892 100644 --- a/src/test/run-pass/import-in-block.rs +++ b/src/test/run-pass/import-in-block.rs @@ -10,11 +10,11 @@ pub fn main() { use std::mem::replace; - let mut x = 5i; + let mut x = 5; replace(&mut x, 6); { use std::mem::*; - let mut y = 6i; + let mut y = 6; swap(&mut x, &mut y); } } diff --git a/src/test/run-pass/import4.rs b/src/test/run-pass/import4.rs index 0639d732089..44f6b6140fb 100644 --- a/src/test/run-pass/import4.rs +++ b/src/test/run-pass/import4.rs @@ -16,4 +16,4 @@ mod zed { pub fn bar() { println!("bar"); } } -pub fn main() { let _zed = 42i; bar(); } +pub fn main() { let _zed = 42; bar(); } diff --git a/src/test/run-pass/inferred-suffix-in-pattern-range.rs b/src/test/run-pass/inferred-suffix-in-pattern-range.rs index a104ee6baaa..be561dfffa6 100644 --- a/src/test/run-pass/inferred-suffix-in-pattern-range.rs +++ b/src/test/run-pass/inferred-suffix-in-pattern-range.rs @@ -9,14 +9,14 @@ // except according to those terms. pub fn main() { - let x = 2i; + let x = 2; let x_message = match x { 0 ... 1 => { "not many".to_string() } _ => { "lots".to_string() } }; assert_eq!(x_message, "lots".to_string()); - let y = 2i; + let y = 2; let y_message = match y { 0 ... 1 => { "not many".to_string() } _ => { "lots".to_string() } diff --git a/src/test/run-pass/init-res-into-things.rs b/src/test/run-pass/init-res-into-things.rs index eeae3f35cfc..ee793359fbc 100644 --- a/src/test/run-pass/init-res-into-things.rs +++ b/src/test/run-pass/init-res-into-things.rs @@ -37,7 +37,7 @@ fn r(i: &Cell<int>) -> r { } fn test_rec() { - let i = &Cell::new(0i); + let i = &Cell::new(0); { let _a = BoxR {x: r(i)}; } @@ -49,7 +49,7 @@ fn test_tag() { t0(r<'a>), } - let i = &Cell::new(0i); + let i = &Cell::new(0); { let _a = t::t0(r(i)); } @@ -57,15 +57,15 @@ fn test_tag() { } fn test_tup() { - let i = &Cell::new(0i); + let i = &Cell::new(0); { - let _a = (r(i), 0i); + let _a = (r(i), 0); } assert_eq!(i.get(), 1); } fn test_unique() { - let i = &Cell::new(0i); + let i = &Cell::new(0); { let _a = box r(i); } @@ -73,7 +73,7 @@ fn test_unique() { } fn test_unique_rec() { - let i = &Cell::new(0i); + let i = &Cell::new(0); { let _a = box BoxR { x: r(i) diff --git a/src/test/run-pass/intrinsic-atomics.rs b/src/test/run-pass/intrinsic-atomics.rs index 0644fbbc99f..d3f62f9d04a 100644 --- a/src/test/run-pass/intrinsic-atomics.rs +++ b/src/test/run-pass/intrinsic-atomics.rs @@ -40,7 +40,7 @@ mod rusti { pub fn main() { unsafe { - let mut x = box 1i; + let mut x = box 1; assert_eq!(rusti::atomic_load(&*x), 1); *x = 5; diff --git a/src/test/run-pass/intrinsic-move-val.rs b/src/test/run-pass/intrinsic-move-val.rs index fb04f67e380..0daf661c2f6 100644 --- a/src/test/run-pass/intrinsic-move-val.rs +++ b/src/test/run-pass/intrinsic-move-val.rs @@ -23,7 +23,7 @@ mod rusti { pub fn main() { unsafe { - let x = box 1i; + let x = box 1; let mut y = rusti::init(); let mut z: *const uint = transmute(&x); rusti::move_val_init(&mut y, x); diff --git a/src/test/run-pass/issue-10626.rs b/src/test/run-pass/issue-10626.rs index 880a8b4d2e0..79a0a54f834 100644 --- a/src/test/run-pass/issue-10626.rs +++ b/src/test/run-pass/issue-10626.rs @@ -19,10 +19,10 @@ pub fn main () { let args = os::args(); let args = args.as_slice(); if args.len() > 1 && args[1].as_slice() == "child" { - for _ in 0i..1000i { + for _ in 0..1000 { println!("hello?"); } - for _ in 0i..1000i { + for _ in 0..1000 { println!("hello?"); } return; diff --git a/src/test/run-pass/issue-10638.rs b/src/test/run-pass/issue-10638.rs index a4ef77df311..bc77b4c5343 100644 --- a/src/test/run-pass/issue-10638.rs +++ b/src/test/run-pass/issue-10638.rs @@ -13,6 +13,6 @@ pub fn main() { ////////////////// still not a doc comment /////**** nope, me neither */ /*** And neither am I! */ - 5i; + 5; /*****! certainly not I */ } diff --git a/src/test/run-pass/issue-11205.rs b/src/test/run-pass/issue-11205.rs index 194208620a8..d7c6c1b1bb2 100644 --- a/src/test/run-pass/issue-11205.rs +++ b/src/test/run-pass/issue-11205.rs @@ -22,45 +22,45 @@ fn bar(_: [Box<Foo>; 2]) {} fn bars(_: &[Box<Foo>]) {} fn main() { - let x: [&Foo; 2] = [&1i, &2i]; + let x: [&Foo; 2] = [&1, &2]; foo(x); - foo([&1i, &2i]); + foo([&1, &2]); - let r = &1i; + let r = &1; let x: [&Foo; 2] = [r; 2]; foo(x); - foo([&1i; 2]); + foo([&1; 2]); - let x: &[&Foo] = &[&1i, &2i]; + let x: &[&Foo] = &[&1, &2]; foos(x); - foos(&[&1i, &2i]); + foos(&[&1, &2]); - let x: &[&Foo] = &[&1i, &2i]; - let r = &1i; + let x: &[&Foo] = &[&1, &2]; + let r = &1; foog(x, &[r]); - let x: [Box<Foo>; 2] = [box 1i, box 2i]; + let x: [Box<Foo>; 2] = [box 1, box 2]; bar(x); - bar([box 1i, box 2i]); + bar([box 1, box 2]); - let x: &[Box<Foo>] = &[box 1i, box 2i]; + let x: &[Box<Foo>] = &[box 1, box 2]; bars(x); - bars(&[box 1i, box 2i]); + bars(&[box 1, box 2]); - let x: &[Box<Foo>] = &[box 1i, box 2i]; - foog(x, &[box 1i]); + let x: &[Box<Foo>] = &[box 1, box 2]; + foog(x, &[box 1]); struct T<'a> { t: [&'a (Foo+'a); 2] } let _n = T { - t: [&1i, &2i] + t: [&1, &2] }; - let r = &1i; + let r = &1; let _n = T { t: [r; 2] }; - let x: [&Foo; 2] = [&1i, &2i]; + let x: [&Foo; 2] = [&1, &2]; let _n = T { t: x }; @@ -69,14 +69,14 @@ fn main() { t: &'b [&'b (Foo+'b)] } let _n = F { - t: &[&1i, &2i] + t: &[&1, &2] }; - let r = &1i; + let r = &1; let r: [&Foo; 2] = [r; 2]; let _n = F { t: &r }; - let x: [&Foo; 2] = [&1i, &2i]; + let x: [&Foo; 2] = [&1, &2]; let _n = F { t: &x }; @@ -85,9 +85,9 @@ fn main() { t: &'a [Box<Foo+'static>] } let _n = M { - t: &[box 1i, box 2i] + t: &[box 1, box 2] }; - let x: [Box<Foo>; 2] = [box 1i, box 2i]; + let x: [Box<Foo>; 2] = [box 1, box 2]; let _n = M { t: &x }; diff --git a/src/test/run-pass/issue-11225-1.rs b/src/test/run-pass/issue-11225-1.rs index 7d1c93fe9a4..a45d129ade2 100644 --- a/src/test/run-pass/issue-11225-1.rs +++ b/src/test/run-pass/issue-11225-1.rs @@ -13,5 +13,5 @@ extern crate "issue-11225-1" as foo; pub fn main() { - foo::foo(1i); + foo::foo(1); } diff --git a/src/test/run-pass/issue-11225-2.rs b/src/test/run-pass/issue-11225-2.rs index 7f36c38283b..f07957b30ec 100644 --- a/src/test/run-pass/issue-11225-2.rs +++ b/src/test/run-pass/issue-11225-2.rs @@ -13,5 +13,5 @@ extern crate "issue-11225-2" as foo; pub fn main() { - foo::foo(1i); + foo::foo(1); } diff --git a/src/test/run-pass/issue-11958.rs b/src/test/run-pass/issue-11958.rs index 13177880c5a..00613f35f17 100644 --- a/src/test/run-pass/issue-11958.rs +++ b/src/test/run-pass/issue-11958.rs @@ -19,6 +19,6 @@ use std::thunk::Thunk; pub fn main() { - let mut x = 1i; + let mut x = 1i32; let _thunk = Thunk::new(move|| { x = 2; }); } diff --git a/src/test/run-pass/issue-1257.rs b/src/test/run-pass/issue-1257.rs index ad3a050dde9..7d5bd9d6a74 100644 --- a/src/test/run-pass/issue-1257.rs +++ b/src/test/run-pass/issue-1257.rs @@ -10,7 +10,7 @@ pub fn main () { let mut line = "".to_string(); - let mut i = 0i; + let mut i = 0; while line != "exit".to_string() { line = if i == 9 { "exit".to_string() } else { "notexit".to_string() }; i += 1; diff --git a/src/test/run-pass/issue-12582.rs b/src/test/run-pass/issue-12582.rs index ab2abc094f4..4009d17139d 100644 --- a/src/test/run-pass/issue-12582.rs +++ b/src/test/run-pass/issue-12582.rs @@ -11,10 +11,10 @@ // ignore-lexer-test FIXME #15877 pub fn main() { - let x = 1i; - let y = 2i; + let x = 1; + let y = 2; - assert_eq!(3i, match (x, y) { + assert_eq!(3, match (x, y) { (1, 1) => 1, (2, 2) => 2, (1...2, 2) => 3, @@ -22,7 +22,7 @@ pub fn main() { }); // nested tuple - assert_eq!(3i, match ((x, y),) { + assert_eq!(3, match ((x, y),) { ((1, 1),) => 1, ((2, 2),) => 2, ((1...2, 2),) => 3, diff --git a/src/test/run-pass/issue-12744.rs b/src/test/run-pass/issue-12744.rs index ec929a9c792..2f7ba315aa1 100644 --- a/src/test/run-pass/issue-12744.rs +++ b/src/test/run-pass/issue-12744.rs @@ -12,6 +12,6 @@ #![feature(box_syntax)] fn main() { - fn test() -> Box<std::any::Any + 'static> { box 1i } + fn test() -> Box<std::any::Any + 'static> { box 1 } println!("{:?}", test()) } diff --git a/src/test/run-pass/issue-12909.rs b/src/test/run-pass/issue-12909.rs index dfdf979fcec..3075bae44fe 100644 --- a/src/test/run-pass/issue-12909.rs +++ b/src/test/run-pass/issue-12909.rs @@ -15,7 +15,7 @@ fn copy<T: Copy>(&x: &T) -> T { } fn main() { - let arr = [(1i, 1u), (2, 2), (3, 3)]; + let arr = [(1, 1u), (2, 2), (3, 3)]; let v1: Vec<&_> = arr.iter().collect(); let v2: Vec<_> = arr.iter().map(copy).collect(); diff --git a/src/test/run-pass/issue-13027.rs b/src/test/run-pass/issue-13027.rs index 1f61da2f424..649cf63e84a 100644 --- a/src/test/run-pass/issue-13027.rs +++ b/src/test/run-pass/issue-13027.rs @@ -29,99 +29,99 @@ pub fn main() { } fn lit_shadow_range() { - assert_eq!(2i, match 1i { - 1 if false => 1i, + assert_eq!(2, match 1 { + 1 if false => 1, 1...2 => 2, _ => 3 }); - let x = 0i; - assert_eq!(2i, match x+1 { - 0 => 0i, + let x = 0; + assert_eq!(2, match x+1 { + 0 => 0, 1 if false => 1, 1...2 => 2, _ => 3 }); - assert_eq!(2i, match val() { - 1 if false => 1i, + assert_eq!(2, match val() { + 1 if false => 1, 1...2 => 2, _ => 3 }); - assert_eq!(2i, match CONST { - 0 => 0i, + assert_eq!(2, match CONST { + 0 => 0, 1 if false => 1, 1...2 => 2, _ => 3 }); // value is out of the range of second arm, should match wildcard pattern - assert_eq!(3i, match 3i { - 1 if false => 1i, + assert_eq!(3, match 3 { + 1 if false => 1, 1...2 => 2, _ => 3 }); } fn range_shadow_lit() { - assert_eq!(2i, match 1i { - 1...2 if false => 1i, + assert_eq!(2, match 1 { + 1...2 if false => 1, 1 => 2, _ => 3 }); - let x = 0i; - assert_eq!(2i, match x+1 { - 0 => 0i, + let x = 0; + assert_eq!(2, match x+1 { + 0 => 0, 1...2 if false => 1, 1 => 2, _ => 3 }); - assert_eq!(2i, match val() { - 1...2 if false => 1i, + assert_eq!(2, match val() { + 1...2 if false => 1, 1 => 2, _ => 3 }); - assert_eq!(2i, match CONST { - 0 => 0i, + assert_eq!(2, match CONST { + 0 => 0, 1...2 if false => 1, 1 => 2, _ => 3 }); // ditto - assert_eq!(3i, match 3i { - 1...2 if false => 1i, + assert_eq!(3, match 3 { + 1...2 if false => 1, 1 => 2, _ => 3 }); } fn range_shadow_range() { - assert_eq!(2i, match 1i { - 0...2 if false => 1i, + assert_eq!(2, match 1 { + 0...2 if false => 1, 1...3 => 2, _ => 3, }); - let x = 0i; - assert_eq!(2i, match x+1 { + let x = 0; + assert_eq!(2, match x+1 { 100 => 0, 0...2 if false => 1, 1...3 => 2, _ => 3, }); - assert_eq!(2i, match val() { + assert_eq!(2, match val() { 0...2 if false => 1, 1...3 => 2, _ => 3, }); - assert_eq!(2i, match CONST { + assert_eq!(2, match CONST { 100 => 0, 0...2 if false => 1, 1...3 => 2, @@ -129,16 +129,16 @@ fn range_shadow_range() { }); // ditto - assert_eq!(3i, match 5i { - 0...2 if false => 1i, + assert_eq!(3, match 5 { + 0...2 if false => 1, 1...3 => 2, _ => 3, }); } fn multi_pats_shadow_lit() { - assert_eq!(2i, match 1i { - 100 => 0i, + assert_eq!(2, match 1 { + 100 => 0, 0 | 1...10 if false => 1, 1 => 2, _ => 3, @@ -146,8 +146,8 @@ fn multi_pats_shadow_lit() { } fn multi_pats_shadow_range() { - assert_eq!(2i, match 1i { - 100 => 0i, + assert_eq!(2, match 1 { + 100 => 0, 0 | 1...10 if false => 1, 1...3 => 2, _ => 3, @@ -155,8 +155,8 @@ fn multi_pats_shadow_range() { } fn lit_shadow_multi_pats() { - assert_eq!(2i, match 1i { - 100 => 0i, + assert_eq!(2, match 1 { + 100 => 0, 1 if false => 1, 0 | 1...10 => 2, _ => 3, @@ -164,8 +164,8 @@ fn lit_shadow_multi_pats() { } fn range_shadow_multi_pats() { - assert_eq!(2i, match 1i { - 100 => 0i, + assert_eq!(2, match 1 { + 100 => 0, 1...3 if false => 1, 0 | 1...10 => 2, _ => 3, @@ -180,9 +180,9 @@ fn misc() { // which is a rare combination of vector patterns, multiple wild-card // patterns and guard functions. let r = match [Foo::Bar(0, false)].as_slice() { - [Foo::Bar(_, pred)] if pred => 1i, - [Foo::Bar(_, pred)] if !pred => 2i, - _ => 0i, + [Foo::Bar(_, pred)] if pred => 1, + [Foo::Bar(_, pred)] if !pred => 2, + _ => 0, }; - assert_eq!(2i, r); + assert_eq!(2, r); } diff --git a/src/test/run-pass/issue-13494.rs b/src/test/run-pass/issue-13494.rs index c10fd7328a1..5025d403468 100644 --- a/src/test/run-pass/issue-13494.rs +++ b/src/test/run-pass/issue-13494.rs @@ -24,7 +24,7 @@ fn main() { let (tx, rx) = channel(); let _t = Thread::spawn(move|| { helper(rx) }); let (snd, rcv) = channel::<int>(); - for _ in 1i..100000i { + for _ in 1..100000 { snd.send(1i).unwrap(); let (tx2, rx2) = channel(); tx.send(tx2).unwrap(); diff --git a/src/test/run-pass/issue-13867.rs b/src/test/run-pass/issue-13867.rs index 00ff837b981..960884c4aa5 100644 --- a/src/test/run-pass/issue-13867.rs +++ b/src/test/run-pass/issue-13867.rs @@ -18,39 +18,39 @@ enum Foo { fn main() { let r = match (Foo::FooNullary, 'a') { - (Foo::FooUint(..), 'a'...'z') => 1i, - (Foo::FooNullary, 'x') => 2i, + (Foo::FooUint(..), 'a'...'z') => 1, + (Foo::FooNullary, 'x') => 2, _ => 0 }; assert_eq!(r, 0); let r = match (Foo::FooUint(0), 'a') { - (Foo::FooUint(1), 'a'...'z') => 1i, - (Foo::FooUint(..), 'x') => 2i, - (Foo::FooNullary, 'a') => 3i, + (Foo::FooUint(1), 'a'...'z') => 1, + (Foo::FooUint(..), 'x') => 2, + (Foo::FooNullary, 'a') => 3, _ => 0 }; assert_eq!(r, 0); let r = match ('a', Foo::FooUint(0)) { - ('a'...'z', Foo::FooUint(1)) => 1i, - ('x', Foo::FooUint(..)) => 2i, - ('a', Foo::FooNullary) => 3i, + ('a'...'z', Foo::FooUint(1)) => 1, + ('x', Foo::FooUint(..)) => 2, + ('a', Foo::FooNullary) => 3, _ => 0 }; assert_eq!(r, 0); let r = match ('a', 'a') { - ('a'...'z', 'b') => 1i, - ('x', 'a'...'z') => 2i, + ('a'...'z', 'b') => 1, + ('x', 'a'...'z') => 2, _ => 0 }; assert_eq!(r, 0); let r = match ('a', 'a') { - ('a'...'z', 'b') => 1i, - ('x', 'a'...'z') => 2i, - ('a', 'a') => 3i, + ('a'...'z', 'b') => 1, + ('x', 'a'...'z') => 2, + ('a', 'a') => 3, _ => 0 }; assert_eq!(r, 3); diff --git a/src/test/run-pass/issue-14308.rs b/src/test/run-pass/issue-14308.rs index 82a1a16ba57..0e4b4a2c9cf 100644 --- a/src/test/run-pass/issue-14308.rs +++ b/src/test/run-pass/issue-14308.rs @@ -13,12 +13,12 @@ struct B; fn main() { let x = match A(3) { - A(..) => 1i + A(..) => 1 }; assert_eq!(x, 1); let x = match A(4) { - A(1) => 1i, - A(..) => 2i + A(1) => 1, + A(..) => 2 }; assert_eq!(x, 2); @@ -26,7 +26,7 @@ fn main() { // There's no particularly good reason to support this, but it's currently allowed, // and this makes sure it doesn't ICE or break LLVM. let x = match B { - B(..) => 3i + B(..) => 3 }; assert_eq!(x, 3); } diff --git a/src/test/run-pass/issue-1460.rs b/src/test/run-pass/issue-1460.rs index 2091a5437c2..e7516639db0 100644 --- a/src/test/run-pass/issue-1460.rs +++ b/src/test/run-pass/issue-1460.rs @@ -10,5 +10,5 @@ pub fn main() { - {|&: i| if 1i == i { }}; + {|&: i| if 1 == i { }}; } diff --git a/src/test/run-pass/issue-14865.rs b/src/test/run-pass/issue-14865.rs index 53af0c8635c..c322346c2a6 100644 --- a/src/test/run-pass/issue-14865.rs +++ b/src/test/run-pass/issue-14865.rs @@ -15,14 +15,14 @@ enum X { fn main() { let x = match X::Foo(42) { - X::Foo(..) => 1i, + X::Foo(..) => 1, _ if true => 0, X::Bar(..) => panic!("Oh dear") }; assert_eq!(x, 1); let x = match X::Foo(42) { - _ if true => 0i, + _ if true => 0, X::Foo(..) => 1, X::Bar(..) => panic!("Oh dear") }; diff --git a/src/test/run-pass/issue-15080.rs b/src/test/run-pass/issue-15080.rs index 76b8463a417..9752b01e52b 100644 --- a/src/test/run-pass/issue-15080.rs +++ b/src/test/run-pass/issue-15080.rs @@ -9,7 +9,7 @@ // except according to those terms. fn main() { - let mut x: &[_] = &[1i, 2, 3, 4]; + let mut x: &[_] = &[1, 2, 3, 4]; let mut result = vec!(); loop { diff --git a/src/test/run-pass/issue-15221.rs b/src/test/run-pass/issue-15221.rs index e3c102e01ec..49e5b14aff8 100644 --- a/src/test/run-pass/issue-15221.rs +++ b/src/test/run-pass/issue-15221.rs @@ -17,7 +17,7 @@ macro_rules! outer { } fn main() { - let outer!(g1) = 13i; + let outer!(g1) = 13; g1; } diff --git a/src/test/run-pass/issue-15571.rs b/src/test/run-pass/issue-15571.rs index 6b273b5786a..7d53b672951 100644 --- a/src/test/run-pass/issue-15571.rs +++ b/src/test/run-pass/issue-15571.rs @@ -12,7 +12,7 @@ #![feature(box_syntax)] fn match_on_local() { - let mut foo = Some(box 5i); + let mut foo = Some(box 5); match foo { None => {}, Some(x) => { @@ -22,7 +22,7 @@ fn match_on_local() { println!("'{}'", foo.unwrap()); } -fn match_on_arg(mut foo: Option<Box<int>>) { +fn match_on_arg(mut foo: Option<Box<i32>>) { match foo { None => {} Some(x) => { @@ -33,7 +33,7 @@ fn match_on_arg(mut foo: Option<Box<int>>) { } fn match_on_binding() { - match Some(box 7i) { + match Some(box 7) { mut foo => { match foo { None => {}, @@ -47,7 +47,7 @@ fn match_on_binding() { } fn match_on_upvar() { - let mut foo = Some(box 8i); + let mut foo = Some(box 8i32); let f = move|:| { match foo { None => {}, @@ -62,7 +62,7 @@ fn match_on_upvar() { fn main() { match_on_local(); - match_on_arg(Some(box 6i)); + match_on_arg(Some(box 6)); match_on_binding(); match_on_upvar(); } diff --git a/src/test/run-pass/issue-15763.rs b/src/test/run-pass/issue-15763.rs index f30991a1963..7bfd8e0ab71 100644 --- a/src/test/run-pass/issue-15763.rs +++ b/src/test/run-pass/issue-15763.rs @@ -87,12 +87,12 @@ fn main() { assert_eq!(cc().unwrap(), 3); assert_eq!(dd().unwrap(), 3); - let i = box 32i as Box<A>; + let i = box 32 as Box<A>; assert_eq!(i.aaa(), 3); - let i = box 32i as Box<A>; + let i = box 32 as Box<A>; assert_eq!(i.bbb(), 3); - let i = box 32i as Box<A>; + let i = box 32 as Box<A>; assert_eq!(i.ccc().unwrap(), 3); - let i = box 32i as Box<A>; + let i = box 32 as Box<A>; assert_eq!(i.ddd().unwrap(), 3); } diff --git a/src/test/run-pass/issue-15924.rs b/src/test/run-pass/issue-15924.rs index db9f1cc9df7..88b250af1c0 100644 --- a/src/test/run-pass/issue-15924.rs +++ b/src/test/run-pass/issue-15924.rs @@ -28,5 +28,5 @@ impl<T: Encodable> Drop for Foo<T> { } fn main() { - let _ = Foo { v: 10i }; + let _ = Foo { v: 10 }; } diff --git a/src/test/run-pass/issue-16648.rs b/src/test/run-pass/issue-16648.rs index 7ddb20811a3..0b58df56b6f 100644 --- a/src/test/run-pass/issue-16648.rs +++ b/src/test/run-pass/issue-16648.rs @@ -9,12 +9,12 @@ // except according to those terms. fn main() { - let x: (int, &[int]) = (2i, &[1i, 2i]); + let x: (int, &[int]) = (2, &[1, 2]); assert_eq!(match x { (0, [_, _]) => 0, (1, _) => 1, (2, [_, _]) => 2, (2, _) => 3, _ => 4 - }, 2i); + }, 2); } diff --git a/src/test/run-pass/issue-16774.rs b/src/test/run-pass/issue-16774.rs index 175e2188811..d426f82f89f 100644 --- a/src/test/run-pass/issue-16774.rs +++ b/src/test/run-pass/issue-16774.rs @@ -45,7 +45,7 @@ impl DerefMut for X { fn main() { { - let mut test = X(box 5i); + let mut test = X(box 5); { let mut change = |&mut:| { *test = 10 }; change(); diff --git a/src/test/run-pass/issue-17074.rs b/src/test/run-pass/issue-17074.rs index d35c3a587c5..d367e0e908e 100644 --- a/src/test/run-pass/issue-17074.rs +++ b/src/test/run-pass/issue-17074.rs @@ -17,6 +17,6 @@ fn main() { assert_eq!(match 1 { X => unreachable!(), Y => unreachable!(), - _ => 1i + _ => 1 }, 1); } diff --git a/src/test/run-pass/issue-19244.rs b/src/test/run-pass/issue-19244.rs index 3ee5ce9bff9..9af4d30c4f6 100644 --- a/src/test/run-pass/issue-19244.rs +++ b/src/test/run-pass/issue-19244.rs @@ -13,8 +13,8 @@ const STRUCT: MyStruct = MyStruct { field: 42 }; const TUP: (uint,) = (43,); fn main() { - let a = [0i; STRUCT.field]; - let b = [0i; TUP.0]; + let a = [0; STRUCT.field]; + let b = [0; TUP.0]; assert!(a.len() == 42); assert!(b.len() == 43); diff --git a/src/test/run-pass/issue-19358.rs b/src/test/run-pass/issue-19358.rs index 37d05453914..ff657376ecc 100644 --- a/src/test/run-pass/issue-19358.rs +++ b/src/test/run-pass/issue-19358.rs @@ -23,7 +23,7 @@ struct Bar<T> where T: Trait { impl Trait for int {} fn main() { - let a = Foo { foo: 12i }; - let b = Bar { bar: 12i }; + let a = Foo { foo: 12 }; + let b = Bar { bar: 12 }; println!("{:?} {:?}", a, b); } diff --git a/src/test/run-pass/issue-19367.rs b/src/test/run-pass/issue-19367.rs index 7db84d518ff..d5bb6ebb7de 100644 --- a/src/test/run-pass/issue-19367.rs +++ b/src/test/run-pass/issue-19367.rs @@ -16,7 +16,7 @@ struct S { // on field of struct or tuple which we reassign in the match body. fn main() { - let mut a = (0i, Some("right".to_string())); + let mut a = (0, Some("right".to_string())); let b = match a.1 { Some(v) => { a.1 = Some("wrong".to_string()); diff --git a/src/test/run-pass/issue-2216.rs b/src/test/run-pass/issue-2216.rs index 98e6e051343..c2f74a9d653 100644 --- a/src/test/run-pass/issue-2216.rs +++ b/src/test/run-pass/issue-2216.rs @@ -9,12 +9,12 @@ // except according to those terms. pub fn main() { - let mut x = 0i; + let mut x = 0; 'foo: loop { 'bar: loop { 'quux: loop { - if 1i == 2 { + if 1 == 2 { break 'foo; } else { diff --git a/src/test/run-pass/issue-2383.rs b/src/test/run-pass/issue-2383.rs index 94bff890820..b8136323df6 100644 --- a/src/test/run-pass/issue-2383.rs +++ b/src/test/run-pass/issue-2383.rs @@ -14,5 +14,5 @@ use std::collections::RingBuf; pub fn main() { let mut q = RingBuf::new(); - q.push_front(10i); + q.push_front(10); } diff --git a/src/test/run-pass/issue-2428.rs b/src/test/run-pass/issue-2428.rs index afa053de243..7ed26428be0 100644 --- a/src/test/run-pass/issue-2428.rs +++ b/src/test/run-pass/issue-2428.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - let _foo = 100i; + let _foo = 100; const quux: int = 5; enum Stuff { diff --git a/src/test/run-pass/issue-2633-2.rs b/src/test/run-pass/issue-2633-2.rs index c146f8a7a9a..80e9ca47025 100644 --- a/src/test/run-pass/issue-2633-2.rs +++ b/src/test/run-pass/issue-2633-2.rs @@ -17,6 +17,6 @@ fn a_val(x: Box<int>, y: Box<int>) -> int { } pub fn main() { - let z = box 22i; + let z = box 22; a_val(z.clone(), z.clone()); } diff --git a/src/test/run-pass/issue-2734.rs b/src/test/run-pass/issue-2734.rs index 3e4cffe5dfa..7ca439a1a19 100644 --- a/src/test/run-pass/issue-2734.rs +++ b/src/test/run-pass/issue-2734.rs @@ -23,5 +23,5 @@ fn deadcode() { } pub fn main() { - let _ = perform_hax(box 42i); + let _ = perform_hax(box 42); } diff --git a/src/test/run-pass/issue-2735.rs b/src/test/run-pass/issue-2735.rs index cb376d0e439..962359537bf 100644 --- a/src/test/run-pass/issue-2735.rs +++ b/src/test/run-pass/issue-2735.rs @@ -23,5 +23,5 @@ fn deadcode() { } pub fn main() { - perform_hax(box 42i); + perform_hax(box 42); } diff --git a/src/test/run-pass/issue-2935.rs b/src/test/run-pass/issue-2935.rs index 295fd538de6..31599d0caad 100644 --- a/src/test/run-pass/issue-2935.rs +++ b/src/test/run-pass/issue-2935.rs @@ -24,9 +24,9 @@ impl it for t { } pub fn main() { - // let x = ({a: 4i} as it); - // let y = box ({a: 4i}); - // let z = box ({a: 4i} as it); + // let x = ({a: 4} as it); + // let y = box ({a: 4}); + // let z = box ({a: 4} as it); // let z = box ({a: true} as it); let z = box() (box true as Box<it>); // x.f(); diff --git a/src/test/run-pass/issue-3091.rs b/src/test/run-pass/issue-3091.rs index 2e287e24e23..c4c2c2b7da8 100644 --- a/src/test/run-pass/issue-3091.rs +++ b/src/test/run-pass/issue-3091.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - let x = 1i; - let y = 1i; + let x = 1; + let y = 1; assert_eq!(&x, &y); } diff --git a/src/test/run-pass/issue-3211.rs b/src/test/run-pass/issue-3211.rs index c908c073d4f..28c9bf1e83a 100644 --- a/src/test/run-pass/issue-3211.rs +++ b/src/test/run-pass/issue-3211.rs @@ -9,8 +9,8 @@ // except according to those terms. pub fn main() { - let mut x = 0i; - for _ in 0i..4096 { x += 1; } + let mut x = 0; + for _ in 0..4096 { x += 1; } assert_eq!(x, 4096); println!("x = {}", x); } diff --git a/src/test/run-pass/issue-3290.rs b/src/test/run-pass/issue-3290.rs index a72b272abaa..c8d6e69801f 100644 --- a/src/test/run-pass/issue-3290.rs +++ b/src/test/run-pass/issue-3290.rs @@ -12,7 +12,7 @@ #![feature(box_syntax)] pub fn main() { - let mut x = box 3i; + let mut x = box 3; x = x; assert_eq!(*x, 3); } diff --git a/src/test/run-pass/issue-333.rs b/src/test/run-pass/issue-333.rs index ef49d0a170f..1217f32826f 100644 --- a/src/test/run-pass/issue-333.rs +++ b/src/test/run-pass/issue-333.rs @@ -12,4 +12,4 @@ fn quux<T>(x: T) -> T { let f = id::<T>; return f(x); } fn id<T>(x: T) -> T { return x; } -pub fn main() { assert!((quux(10i) == 10i)); } +pub fn main() { assert!((quux(10) == 10)); } diff --git a/src/test/run-pass/issue-3500.rs b/src/test/run-pass/issue-3500.rs index eb422c9a8b9..99def5476f9 100644 --- a/src/test/run-pass/issue-3500.rs +++ b/src/test/run-pass/issue-3500.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - let x = &Some(1i); + let x = &Some(1); match x { &Some(_) => (), &None => (), diff --git a/src/test/run-pass/issue-3559.rs b/src/test/run-pass/issue-3559.rs index 0118fce4ec3..69a148d4108 100644 --- a/src/test/run-pass/issue-3559.rs +++ b/src/test/run-pass/issue-3559.rs @@ -22,8 +22,8 @@ fn check_strs(actual: &str, expected: &str) -> bool { pub fn main() { let mut table = HashMap::new(); - table.insert("one".to_string(), 1i); - table.insert("two".to_string(), 2i); + table.insert("one".to_string(), 1); + table.insert("two".to_string(), 2); assert!(check_strs(format!("{:?}", table).as_slice(), "HashMap {\"one\": 1, \"two\": 2}") || check_strs(format!("{:?}", table).as_slice(), "HashMap {\"two\": 2, \"one\": 1}")); } diff --git a/src/test/run-pass/issue-3878.rs b/src/test/run-pass/issue-3878.rs index 5434e44c173..c1d19f228db 100644 --- a/src/test/run-pass/issue-3878.rs +++ b/src/test/run-pass/issue-3878.rs @@ -13,6 +13,6 @@ #![feature(box_syntax)] pub fn main() { - let y = box 1i; + let y = box 1; y; } diff --git a/src/test/run-pass/issue-4387.rs b/src/test/run-pass/issue-4387.rs index 43948ef4a45..02601ba2f2a 100644 --- a/src/test/run-pass/issue-4387.rs +++ b/src/test/run-pass/issue-4387.rs @@ -9,5 +9,5 @@ // except according to those terms. pub fn main() { - let _foo = [0i; 2*4]; + let _foo = [0; 2*4]; } diff --git a/src/test/run-pass/issue-4401.rs b/src/test/run-pass/issue-4401.rs index a03253b8efb..e4fea724c79 100644 --- a/src/test/run-pass/issue-4401.rs +++ b/src/test/run-pass/issue-4401.rs @@ -9,8 +9,8 @@ // except according to those terms. pub fn main() { - let mut count = 0i; - for _ in 0i..999_999 { count += 1; } + let mut count = 0; + for _ in 0..999_999 { count += 1; } assert_eq!(count, 999_999); println!("{}", count); } diff --git a/src/test/run-pass/issue-5708.rs b/src/test/run-pass/issue-5708.rs index 61ae273aef5..fd39bcc6b61 100644 --- a/src/test/run-pass/issue-5708.rs +++ b/src/test/run-pass/issue-5708.rs @@ -41,7 +41,7 @@ impl<'a> Outer<'a> { } pub fn main() { - let inner = 5i; + let inner = 5; let outer = Outer::new(&inner as &Inner); outer.inner.print(); } diff --git a/src/test/run-pass/issue-6117.rs b/src/test/run-pass/issue-6117.rs index 85de03dfe34..93edffdcb47 100644 --- a/src/test/run-pass/issue-6117.rs +++ b/src/test/run-pass/issue-6117.rs @@ -14,7 +14,7 @@ enum Either<T, U> { Left(T), Right(U) } pub fn main() { - match Either::Left(box 17i) { + match Either::Left(box 17) { Either::Right(()) => {} _ => {} } diff --git a/src/test/run-pass/issue-6318.rs b/src/test/run-pass/issue-6318.rs index b9f1a8bda7b..1d8fe8bfce8 100644 --- a/src/test/run-pass/issue-6318.rs +++ b/src/test/run-pass/issue-6318.rs @@ -23,7 +23,7 @@ impl Foo for Struct {} pub fn main() { match Thing::A(box Struct as Box<Foo+'static>) { - Thing::A(_a) => 0i, + Thing::A(_a) => 0, }; } diff --git a/src/test/run-pass/issue-7178.rs b/src/test/run-pass/issue-7178.rs index 4acb4959724..6ef740b2a50 100644 --- a/src/test/run-pass/issue-7178.rs +++ b/src/test/run-pass/issue-7178.rs @@ -13,5 +13,5 @@ extern crate "issue-7178" as cross_crate_self; pub fn main() { - let _ = cross_crate_self::Foo::new(&1i); + let _ = cross_crate_self::Foo::new(&1); } diff --git a/src/test/run-pass/issue-7575.rs b/src/test/run-pass/issue-7575.rs index d60e5caee68..225213db6a4 100644 --- a/src/test/run-pass/issue-7575.rs +++ b/src/test/run-pass/issue-7575.rs @@ -20,5 +20,5 @@ impl Bar for int {} impl Foo for int {} fn main() { - assert!(1i.new()); + assert!(1.new()); } diff --git a/src/test/run-pass/issue-7784.rs b/src/test/run-pass/issue-7784.rs index 882ca00f1df..a61ee8c2a0b 100644 --- a/src/test/run-pass/issue-7784.rs +++ b/src/test/run-pass/issue-7784.rs @@ -20,7 +20,7 @@ fn bar(a: &'static str, b: &'static str) -> [&'static str; 4] { } fn main() { - assert_eq!(foo([1i, 2i, 3i]), (1i, 3i, 6i)); + assert_eq!(foo([1, 2, 3]), (1, 3, 6)); let [a, b, c, d] = bar("foo", "bar"); assert_eq!(a, "foo"); diff --git a/src/test/run-pass/issue-8044.rs b/src/test/run-pass/issue-8044.rs index c50cf845d00..504441e3ba9 100644 --- a/src/test/run-pass/issue-8044.rs +++ b/src/test/run-pass/issue-8044.rs @@ -14,5 +14,5 @@ extern crate "issue-8044" as minimal; use minimal::{BTree, leaf}; pub fn main() { - BTree::<int> { node: leaf(1i) }; + BTree::<int> { node: leaf(1) }; } diff --git a/src/test/run-pass/issue-8391.rs b/src/test/run-pass/issue-8391.rs index 468e6563182..86c9b8c6964 100644 --- a/src/test/run-pass/issue-8391.rs +++ b/src/test/run-pass/issue-8391.rs @@ -9,9 +9,9 @@ // except according to those terms. fn main() { - let x = match Some(1i) { - ref _y @ Some(_) => 1i, - None => 2i, + let x = match Some(1) { + ref _y @ Some(_) => 1, + None => 2, }; assert_eq!(x, 1); } diff --git a/src/test/run-pass/issue-8460.rs b/src/test/run-pass/issue-8460.rs index 3ea6d5d4f2f..3944895460f 100644 --- a/src/test/run-pass/issue-8460.rs +++ b/src/test/run-pass/issue-8460.rs @@ -17,7 +17,7 @@ fn main() { assert!(Thread::scoped(move|| i16::MIN / -1).join().is_err()); assert!(Thread::scoped(move|| i32::MIN / -1).join().is_err()); assert!(Thread::scoped(move|| i64::MIN / -1).join().is_err()); - assert!(Thread::scoped(move|| 1i / 0).join().is_err()); + assert!(Thread::scoped(move|| 1 / 0).join().is_err()); assert!(Thread::scoped(move|| 1i8 / 0).join().is_err()); assert!(Thread::scoped(move|| 1i16 / 0).join().is_err()); assert!(Thread::scoped(move|| 1i32 / 0).join().is_err()); @@ -27,7 +27,7 @@ fn main() { assert!(Thread::scoped(move|| i16::MIN % -1).join().is_err()); assert!(Thread::scoped(move|| i32::MIN % -1).join().is_err()); assert!(Thread::scoped(move|| i64::MIN % -1).join().is_err()); - assert!(Thread::scoped(move|| 1i % 0).join().is_err()); + assert!(Thread::scoped(move|| 1 % 0).join().is_err()); assert!(Thread::scoped(move|| 1i8 % 0).join().is_err()); assert!(Thread::scoped(move|| 1i16 % 0).join().is_err()); assert!(Thread::scoped(move|| 1i32 % 0).join().is_err()); diff --git a/src/test/run-pass/issue-8498.rs b/src/test/run-pass/issue-8498.rs index 2a2ca4f0712..494b6217855 100644 --- a/src/test/run-pass/issue-8498.rs +++ b/src/test/run-pass/issue-8498.rs @@ -12,14 +12,14 @@ #![feature(box_syntax)] pub fn main() { - match &[(box 5i,box 7i)] { + match &[(box 5,box 7)] { ps => { let (ref y, _) = ps[0]; assert!(**y == 5); } } - match Some(&[(box 5i,)]) { + match Some(&[(box 5,)]) { Some(ps) => { let (ref y,) = ps[0]; assert!(**y == 5); @@ -27,7 +27,7 @@ pub fn main() { None => () } - match Some(&[(box 5i,box 7i)]) { + match Some(&[(box 5,box 7)]) { Some(ps) => { let (ref y, ref z) = ps[0]; assert!(**y == 5); diff --git a/src/test/run-pass/issue-868.rs b/src/test/run-pass/issue-868.rs index 72bdd1af746..b2ccc092358 100644 --- a/src/test/run-pass/issue-868.rs +++ b/src/test/run-pass/issue-868.rs @@ -11,7 +11,7 @@ fn f<T, F>(g: F) -> T where F: FnOnce() -> T { g() } pub fn main() { - let _x = f( | | { 10i }); + let _x = f( | | { 10 }); // used to be: cannot determine a type for this expression f(| | { }); // ditto diff --git a/src/test/run-pass/issue-8827.rs b/src/test/run-pass/issue-8827.rs index 80beeb7275c..d7a86749546 100644 --- a/src/test/run-pass/issue-8827.rs +++ b/src/test/run-pass/issue-8827.rs @@ -49,7 +49,7 @@ fn main() { let ints = integers(); let threes = periodical(3); let fives = periodical(5); - for _ in 1i..100i { + for _ in 1..100 { match (ints.recv().unwrap(), threes.recv().unwrap(), fives.recv().unwrap()) { (_, true, true) => println!("FizzBuzz"), (_, true, false) => println!("Fizz"), diff --git a/src/test/run-pass/issue-8860.rs b/src/test/run-pass/issue-8860.rs index 35f713c4c2c..72e2a33b43e 100644 --- a/src/test/run-pass/issue-8860.rs +++ b/src/test/run-pass/issue-8860.rs @@ -8,9 +8,9 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -static mut DROP: int = 0i; -static mut DROP_S: int = 0i; -static mut DROP_T: int = 0i; +static mut DROP: int = 0; +static mut DROP_S: int = 0; +static mut DROP_T: int = 0; struct S; impl Drop for S { diff --git a/src/test/run-pass/issue-9719.rs b/src/test/run-pass/issue-9719.rs index 4c6b9a3aaa0..8fc86eb49e7 100644 --- a/src/test/run-pass/issue-9719.rs +++ b/src/test/run-pass/issue-9719.rs @@ -17,7 +17,7 @@ mod a { impl X for int {} pub struct Z<'a>(Enum<&'a (X+'a)>); - fn foo() { let x = 42i; let z = Z(Enum::A(&x as &X)); let _ = z; } + fn foo() { let x = 42; let z = Z(Enum::A(&x as &X)); let _ = z; } } mod b { @@ -28,7 +28,7 @@ mod b { } fn bar() { - let x = 42i; + let x = 42; let _y = Y { x: Some(&x as &X) }; } } @@ -37,7 +37,7 @@ mod c { pub trait X { fn f(&self); } impl X for int { fn f(&self) {} } pub struct Z<'a>(Option<&'a (X+'a)>); - fn main() { let x = 42i; let z = Z(Some(&x as &X)); let _ = z; } + fn main() { let x = 42; let z = Z(Some(&x as &X)); let _ = z; } } pub fn main() {} diff --git a/src/test/run-pass/issue-9906.rs b/src/test/run-pass/issue-9906.rs index d8e28e449ee..921965b280b 100644 --- a/src/test/run-pass/issue-9906.rs +++ b/src/test/run-pass/issue-9906.rs @@ -14,5 +14,5 @@ extern crate "issue-9906" as testmod; pub fn main() { testmod::foo(); - testmod::FooBar::new(1i); + testmod::FooBar::new(1); } diff --git a/src/test/run-pass/issue-9942.rs b/src/test/run-pass/issue-9942.rs index 321e22cd19c..c7dea719986 100644 --- a/src/test/run-pass/issue-9942.rs +++ b/src/test/run-pass/issue-9942.rs @@ -9,5 +9,5 @@ // except according to those terms. pub fn main() { - const S: uint = 23 as uint; [0i; S]; () + const S: uint = 23 as uint; [0; S]; () } diff --git a/src/test/run-pass/keyword-changes-2012-07-31.rs b/src/test/run-pass/keyword-changes-2012-07-31.rs index 885f266ca3d..ff568b77f08 100644 --- a/src/test/run-pass/keyword-changes-2012-07-31.rs +++ b/src/test/run-pass/keyword-changes-2012-07-31.rs @@ -19,7 +19,7 @@ mod foo { } fn bar() -> int { - match 0i { - _ => { 0i } + match 0 { + _ => { 0 } } } diff --git a/src/test/run-pass/kindck-owned-trait-contains-1.rs b/src/test/run-pass/kindck-owned-trait-contains-1.rs index 999fb2c4b69..f05ac11d413 100644 --- a/src/test/run-pass/kindck-owned-trait-contains-1.rs +++ b/src/test/run-pass/kindck-owned-trait-contains-1.rs @@ -24,7 +24,7 @@ fn repeater<A:Clone + 'static>(v: Box<A>) -> Box<repeat<A>+'static> { } pub fn main() { - let x = 3i; + let x = 3; let y = repeater(box x); assert_eq!(x, y.get()); } diff --git a/src/test/run-pass/labeled-break.rs b/src/test/run-pass/labeled-break.rs index ebfe1e353d8..30c2495d590 100644 --- a/src/test/run-pass/labeled-break.rs +++ b/src/test/run-pass/labeled-break.rs @@ -15,13 +15,13 @@ pub fn main() { } } - 'bar: for _ in 0i..100i { + 'bar: for _ in 0..100 { loop { break 'bar; } } - 'foobar: while 1i + 1 == 2 { + 'foobar: while 1 + 1 == 2 { loop { break 'foobar; } diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs index 9be9f098264..0cdd4d3889c 100644 --- a/src/test/run-pass/last-use-in-cap-clause.rs +++ b/src/test/run-pass/last-use-in-cap-clause.rs @@ -17,7 +17,7 @@ struct A { a: Box<int> } fn foo() -> Box<FnMut() -> int + 'static> { - let k = box 22i; + let k = box 22; let _u = A {a: k.clone()}; let result = |&mut:| 22; box result diff --git a/src/test/run-pass/last-use-is-capture.rs b/src/test/run-pass/last-use-is-capture.rs index 4a7e844268f..19a780d180f 100644 --- a/src/test/run-pass/last-use-is-capture.rs +++ b/src/test/run-pass/last-use-is-capture.rs @@ -17,7 +17,7 @@ struct A { a: Box<int> } pub fn main() { fn invoke<F>(f: F) where F: FnOnce() { f(); } - let k = box 22i; + let k = box 22; let _u = A {a: k.clone()}; invoke(|| println!("{}", k.clone()) ) } diff --git a/src/test/run-pass/lazy-and-or.rs b/src/test/run-pass/lazy-and-or.rs index 043961ce599..559c9e78945 100644 --- a/src/test/run-pass/lazy-and-or.rs +++ b/src/test/run-pass/lazy-and-or.rs @@ -11,7 +11,7 @@ fn incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; } pub fn main() { - let x = 1i == 2 || 3i == 3; + let x = 1 == 2 || 3 == 3; assert!((x)); let mut y: int = 10; println!("{}", x || incr(&mut y)); diff --git a/src/test/run-pass/lazy-init.rs b/src/test/run-pass/lazy-init.rs index cd8be550d51..60f7689ecfa 100644 --- a/src/test/run-pass/lazy-init.rs +++ b/src/test/run-pass/lazy-init.rs @@ -12,4 +12,4 @@ fn foo(x: int) { println!("{}", x); } -pub fn main() { let mut x: int; if 1i > 2 { x = 12; } else { x = 10; } foo(x); } +pub fn main() { let mut x: int; if 1 > 2 { x = 12; } else { x = 10; } foo(x); } diff --git a/src/test/run-pass/let-var-hygiene.rs b/src/test/run-pass/let-var-hygiene.rs index 2287cc48b66..d6409267eb6 100644 --- a/src/test/run-pass/let-var-hygiene.rs +++ b/src/test/run-pass/let-var-hygiene.rs @@ -10,10 +10,10 @@ // shouldn't affect evaluation of $ex: macro_rules! bad_macro { - ($ex:expr) => ({let _x = 9i; $ex}) + ($ex:expr) => ({let _x = 9; $ex}) } pub fn main() { - let _x = 8i; - assert_eq!(bad_macro!(_x),8i) + let _x = 8; + assert_eq!(bad_macro!(_x),8) } diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs index 6a2140d49cd..eda14222e91 100644 --- a/src/test/run-pass/linear-for-loop.rs +++ b/src/test/run-pass/linear-for-loop.rs @@ -11,8 +11,8 @@ // no-pretty-expanded FIXME #15189 pub fn main() { - let x = vec!(1i, 2i, 3i); - let mut y = 0i; + let x = vec!(1, 2, 3); + let mut y = 0; for i in x.iter() { println!("{}", *i); y += *i; } println!("{}", y); assert_eq!(y, 6); diff --git a/src/test/run-pass/liveness-loop-break.rs b/src/test/run-pass/liveness-loop-break.rs index 6ad2be68e8f..0dba1830cbd 100644 --- a/src/test/run-pass/liveness-loop-break.rs +++ b/src/test/run-pass/liveness-loop-break.rs @@ -11,7 +11,7 @@ fn test() { let v; loop { - v = 3i; + v = 3; break; } println!("{}", v); diff --git a/src/test/run-pass/log-poly.rs b/src/test/run-pass/log-poly.rs index ce598c5d382..d8a69177caf 100644 --- a/src/test/run-pass/log-poly.rs +++ b/src/test/run-pass/log-poly.rs @@ -14,8 +14,8 @@ enum Numbers { } pub fn main() { - println!("{:?}", 1i); + println!("{:?}", 1); println!("{:?}", 2.0f64); println!("{:?}", Numbers::Three); - println!("{:?}", vec!(4i)); + println!("{:?}", vec!(4)); } diff --git a/src/test/run-pass/long-while.rs b/src/test/run-pass/long-while.rs index 7d30b22867c..cbe26844708 100644 --- a/src/test/run-pass/long-while.rs +++ b/src/test/run-pass/long-while.rs @@ -14,6 +14,6 @@ pub fn main() { let mut i: int = 0; while i < 1000000 { i += 1; - let x = 3i; + let x = 3; } } diff --git a/src/test/run-pass/loop-diverges.rs b/src/test/run-pass/loop-diverges.rs index 4fe73188b45..9c46ba2cb9b 100644 --- a/src/test/run-pass/loop-diverges.rs +++ b/src/test/run-pass/loop-diverges.rs @@ -16,5 +16,5 @@ fn forever() -> ! { } pub fn main() { - if (1i == 2) { forever(); } + if (1 == 2) { forever(); } } diff --git a/src/test/run-pass/loop-label-shadowing.rs b/src/test/run-pass/loop-label-shadowing.rs index 46d4fa460fe..cfe51fe7758 100644 --- a/src/test/run-pass/loop-label-shadowing.rs +++ b/src/test/run-pass/loop-label-shadowing.rs @@ -12,7 +12,7 @@ fn main() { let mut foo = Vec::new(); - 'foo: for i in [1i, 2, 3].iter() { + 'foo: for i in [1, 2, 3].iter() { foo.push(i); } } diff --git a/src/test/run-pass/loop-no-reinit-needed-post-bot.rs b/src/test/run-pass/loop-no-reinit-needed-post-bot.rs index 0f4dd881698..2582c2e6147 100644 --- a/src/test/run-pass/loop-no-reinit-needed-post-bot.rs +++ b/src/test/run-pass/loop-no-reinit-needed-post-bot.rs @@ -17,7 +17,7 @@ fn my_panic() -> ! { loop {} } pub fn step(f: bool) { let mut g = S; - let mut i = 0i; + let mut i = 0; loop { if i > 10 { break; } else { i += 1; } diff --git a/src/test/run-pass/loop-scope.rs b/src/test/run-pass/loop-scope.rs index 4b8ccad068c..1dc3700194c 100644 --- a/src/test/run-pass/loop-scope.rs +++ b/src/test/run-pass/loop-scope.rs @@ -9,8 +9,8 @@ // except according to those terms. pub fn main() { - let x = vec!(10i, 20i, 30i); - let mut sum = 0i; + let x = vec!(10, 20, 30); + let mut sum = 0; for x in x.iter() { sum += *x; } assert_eq!(sum, 60); } diff --git a/src/test/run-pass/macro-crate-def-only.rs b/src/test/run-pass/macro-crate-def-only.rs index 7505fa6e684..efee9ba963a 100644 --- a/src/test/run-pass/macro-crate-def-only.rs +++ b/src/test/run-pass/macro-crate-def-only.rs @@ -14,5 +14,5 @@ extern crate macro_crate_def_only; pub fn main() { - assert_eq!(5i, make_a_5!()); + assert_eq!(5, make_a_5!()); } diff --git a/src/test/run-pass/macro-export-inner-module.rs b/src/test/run-pass/macro-export-inner-module.rs index ef22410751c..1c7b2530b90 100644 --- a/src/test/run-pass/macro-export-inner-module.rs +++ b/src/test/run-pass/macro-export-inner-module.rs @@ -15,5 +15,5 @@ extern crate macro_export_inner_module; pub fn main() { - assert_eq!(1i, foo!()); + assert_eq!(1, foo!()); } diff --git a/src/test/run-pass/macro-pat.rs b/src/test/run-pass/macro-pat.rs index 07b75389cf4..30a74126b49 100644 --- a/src/test/run-pass/macro-pat.rs +++ b/src/test/run-pass/macro-pat.rs @@ -51,23 +51,23 @@ pub fn main() { assert_eq!(2u, f(Some('y'))); assert_eq!(3u, f(None)); - assert_eq!(1i, match Some('x') { - Some(char_x!()) => 1i, - _ => 2i, + assert_eq!(1, match Some('x') { + Some(char_x!()) => 1, + _ => 2, }); - assert_eq!(1i, match Some('x') { - some!(char_x!()) => 1i, - _ => 2i, + assert_eq!(1, match Some('x') { + some!(char_x!()) => 1, + _ => 2, }); - assert_eq!(1i, match Some('x') { - indirect!() => 1i, - _ => 2i, + assert_eq!(1, match Some('x') { + indirect!() => 1, + _ => 2, }); - assert_eq!(3i, { - let ident_pat!(x) = 2i; - x+1i + assert_eq!(3, { + let ident_pat!(x) = 2; + x+1 }); } diff --git a/src/test/run-pass/macro-stmt.rs b/src/test/run-pass/macro-stmt.rs index cb5370c8bcb..3aa02987098 100644 --- a/src/test/run-pass/macro-stmt.rs +++ b/src/test/run-pass/macro-stmt.rs @@ -26,17 +26,17 @@ pub fn main() { ) } - mylet!(y, 8i*2); - assert_eq!(y, 16i); + mylet!(y, 8*2); + assert_eq!(y, 16); myfn!(mult, (a,b), { a*b } ); assert_eq!(mult(2, add(4,4)), 16); macro_rules! actually_an_expr_macro { - () => ( 16i ) + () => ( 16 ) } - assert_eq!({ actually_an_expr_macro!() }, 16i); + assert_eq!({ actually_an_expr_macro!() }, 16); } diff --git a/src/test/run-pass/macro-with-attrs1.rs b/src/test/run-pass/macro-with-attrs1.rs index 3f9d07466cc..f180922a052 100644 --- a/src/test/run-pass/macro-with-attrs1.rs +++ b/src/test/run-pass/macro-with-attrs1.rs @@ -11,11 +11,11 @@ // compile-flags: --cfg foo #[cfg(foo)] -macro_rules! foo { () => (1i) } +macro_rules! foo { () => (1) } #[cfg(not(foo))] -macro_rules! foo { () => (2i) } +macro_rules! foo { () => (2) } pub fn main() { - assert_eq!(foo!(), 1i); + assert_eq!(foo!(), 1); } diff --git a/src/test/run-pass/macro-with-attrs2.rs b/src/test/run-pass/macro-with-attrs2.rs index f90a0dfa6b3..d683979462b 100644 --- a/src/test/run-pass/macro-with-attrs2.rs +++ b/src/test/run-pass/macro-with-attrs2.rs @@ -9,12 +9,12 @@ // except according to those terms. #[cfg(foo)] -macro_rules! foo { () => (1i) } +macro_rules! foo { () => (1) } #[cfg(not(foo))] -macro_rules! foo { () => (2i) } +macro_rules! foo { () => (2) } pub fn main() { - assert_eq!(foo!(), 2i); + assert_eq!(foo!(), 2); } diff --git a/src/test/run-pass/match-arm-statics.rs b/src/test/run-pass/match-arm-statics.rs index 1964bf4bd7d..dfefe84518c 100644 --- a/src/test/run-pass/match-arm-statics.rs +++ b/src/test/run-pass/match-arm-statics.rs @@ -84,7 +84,7 @@ fn issue_14576() { enum C { D = 3, E = 4 } const F : C = C::D; - assert_eq!(match C::D { F => 1i, _ => 2, }, 1); + assert_eq!(match C::D { F => 1, _ => 2, }, 1); } fn issue_13731() { @@ -113,14 +113,14 @@ fn issue_15393() { fn main() { assert_eq!(match (true, false) { - TRUE_TRUE => 1i, + TRUE_TRUE => 1, (false, false) => 2, (false, true) => 3, (true, false) => 4 }, 4); assert_eq!(match Some(Some(Direction::North)) { - Some(NONE) => 1i, + Some(NONE) => 1, Some(Some(Direction::North)) => 2, Some(Some(EAST)) => 3, Some(Some(Direction::South)) => 4, @@ -129,7 +129,7 @@ fn main() { }, 2); assert_eq!(match (Foo { bar: Some(Direction::West), baz: NewBool(true) }) { - Foo { bar: None, baz: NewBool(true) } => 1i, + Foo { bar: None, baz: NewBool(true) } => 1, Foo { bar: NONE, baz: NEW_FALSE } => 2, STATIC_FOO => 3, Foo { bar: _, baz: NEW_FALSE } => 4, @@ -140,7 +140,7 @@ fn main() { }, 5); assert_eq!(match (EnumWithStructVariants::Variant2 { dir: Direction::North }) { - EnumWithStructVariants::Variant1(true) => 1i, + EnumWithStructVariants::Variant1(true) => 1, EnumWithStructVariants::Variant1(false) => 2, EnumWithStructVariants::Variant2 { dir: Direction::West } => 3, VARIANT2_NORTH => 4, diff --git a/src/test/run-pass/match-bot-2.rs b/src/test/run-pass/match-bot-2.rs index 5b48d0ff508..949fad11344 100644 --- a/src/test/run-pass/match-bot-2.rs +++ b/src/test/run-pass/match-bot-2.rs @@ -9,5 +9,5 @@ // except according to those terms. // n.b. This was only ever failing with optimization disabled. -fn a() -> int { match return 1i { 2i => 3i, _ => panic!() } } +fn a() -> int { match return 1 { 2 => 3, _ => panic!() } } pub fn main() { a(); } diff --git a/src/test/run-pass/match-naked-record-expr.rs b/src/test/run-pass/match-naked-record-expr.rs index 170a3513a1a..433cf23626b 100644 --- a/src/test/run-pass/match-naked-record-expr.rs +++ b/src/test/run-pass/match-naked-record-expr.rs @@ -11,7 +11,7 @@ struct X { x: int } pub fn main() { - let _x = match 0i { + let _x = match 0 { _ => X { x: 0 }.x diff --git a/src/test/run-pass/match-naked-record.rs b/src/test/run-pass/match-naked-record.rs index 21c31b62183..fe12b7c1585 100644 --- a/src/test/run-pass/match-naked-record.rs +++ b/src/test/run-pass/match-naked-record.rs @@ -11,7 +11,7 @@ struct X { x: int } pub fn main() { - let _x = match 0i { + let _x = match 0 { _ => X { x: 0 } diff --git a/src/test/run-pass/match-pattern-bindings.rs b/src/test/run-pass/match-pattern-bindings.rs index e6ce94ec5d4..abb78fc8310 100644 --- a/src/test/run-pass/match-pattern-bindings.rs +++ b/src/test/run-pass/match-pattern-bindings.rs @@ -9,15 +9,15 @@ // except according to those terms. fn main() { - let value = Some(1i); + let value = Some(1); assert_eq!(match value { ref a @ Some(_) => a, ref b @ None => b - }, &Some(1i)); + }, &Some(1)); assert_eq!(match value { ref c @ Some(_) => c, ref b @ None => b - }, &Some(1i)); + }, &Some(1)); assert_eq!(match "foobarbaz" { b @ _ => b }, "foobarbaz"); diff --git a/src/test/run-pass/match-pipe-binding.rs b/src/test/run-pass/match-pipe-binding.rs index ed2f7c5cb47..bdf12d22edd 100644 --- a/src/test/run-pass/match-pipe-binding.rs +++ b/src/test/run-pass/match-pipe-binding.rs @@ -10,7 +10,7 @@ fn test1() { // from issue 6338 - match ((1i, "a".to_string()), (2i, "b".to_string())) { + match ((1, "a".to_string()), (2, "b".to_string())) { ((1, a), (2, b)) | ((2, b), (1, a)) => { assert_eq!(a, "a".to_string()); assert_eq!(b, "b".to_string()); @@ -20,7 +20,7 @@ fn test1() { } fn test2() { - match (1i, 2i, 3i) { + match (1, 2, 3) { (1, a, b) | (2, b, a) => { assert_eq!(a, 2); assert_eq!(b, 3); @@ -30,7 +30,7 @@ fn test2() { } fn test3() { - match (1i, 2i, 3i) { + match (1, 2, 3) { (1, ref a, ref b) | (2, ref b, ref a) => { assert_eq!(*a, 2); assert_eq!(*b, 3); @@ -40,7 +40,7 @@ fn test3() { } fn test4() { - match (1i, 2i, 3i) { + match (1, 2, 3) { (1, a, b) | (2, b, a) if a == 2 => { assert_eq!(a, 2); assert_eq!(b, 3); @@ -50,7 +50,7 @@ fn test4() { } fn test5() { - match (1i, 2i, 3i) { + match (1, 2, 3) { (1, ref a, ref b) | (2, ref b, ref a) if *a == 2 => { assert_eq!(*a, 2); assert_eq!(*b, 3); diff --git a/src/test/run-pass/match-range.rs b/src/test/run-pass/match-range.rs index 83066c126ce..b9ab0c85ec4 100644 --- a/src/test/run-pass/match-range.rs +++ b/src/test/run-pass/match-range.rs @@ -28,7 +28,7 @@ pub fn main() { 'a'...'z' => {} _ => panic!("should suppport char ranges") } - match -3i { + match -3 { -7...5 => {} _ => panic!("should match signed range") } diff --git a/src/test/run-pass/match-ref-binding-mut-option.rs b/src/test/run-pass/match-ref-binding-mut-option.rs index c983903ac18..8d1e483bcd8 100644 --- a/src/test/run-pass/match-ref-binding-mut-option.rs +++ b/src/test/run-pass/match-ref-binding-mut-option.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - let mut v = Some(22i); + let mut v = Some(22); match v { None => {} Some(ref mut p) => { *p += 1; } diff --git a/src/test/run-pass/match-str.rs b/src/test/run-pass/match-str.rs index 544751754c6..60a5904cff3 100644 --- a/src/test/run-pass/match-str.rs +++ b/src/test/run-pass/match-str.rs @@ -23,7 +23,7 @@ pub fn main() { _ => panic!() } - let x = match "a" { "a" => 1i, "b" => 2i, _ => panic!() }; + let x = match "a" { "a" => 1, "b" => 2, _ => panic!() }; assert_eq!(x, 1); match "a" { "a" => { } "b" => { }, _ => panic!() } diff --git a/src/test/run-pass/match-unique-bind.rs b/src/test/run-pass/match-unique-bind.rs index ebe01a1d1f2..63817d42ae8 100644 --- a/src/test/run-pass/match-unique-bind.rs +++ b/src/test/run-pass/match-unique-bind.rs @@ -12,7 +12,7 @@ #![feature(box_syntax)] pub fn main() { - match box 100i { + match box 100 { box x => { println!("{}", x); assert_eq!(x, 100); diff --git a/src/test/run-pass/match-vec-alternatives.rs b/src/test/run-pass/match-vec-alternatives.rs index ae4fd1f1993..98b9d11ecdd 100644 --- a/src/test/run-pass/match-vec-alternatives.rs +++ b/src/test/run-pass/match-vec-alternatives.rs @@ -55,28 +55,28 @@ fn match_nested_vecs_snoc<'a, T>(l1: Option<&'a [T]>, l2: Result<&'a [T], ()>) - } fn main() { - assert_eq!(match_vecs(&[1i, 2], &[2i, 3]), "both non-empty"); - assert_eq!(match_vecs(&[], &[1i, 2, 3, 4]), "one empty"); + assert_eq!(match_vecs(&[1, 2], &[2, 3]), "both non-empty"); + assert_eq!(match_vecs(&[], &[1, 2, 3, 4]), "one empty"); assert_eq!(match_vecs::<uint>(&[], &[]), "both empty"); - assert_eq!(match_vecs(&[1i, 2, 3], &[]), "one empty"); + assert_eq!(match_vecs(&[1, 2, 3], &[]), "one empty"); - assert_eq!(match_vecs_cons(&[1i, 2], &[2i, 3]), "both non-empty"); - assert_eq!(match_vecs_cons(&[], &[1i, 2, 3, 4]), "one empty"); + assert_eq!(match_vecs_cons(&[1, 2], &[2, 3]), "both non-empty"); + assert_eq!(match_vecs_cons(&[], &[1, 2, 3, 4]), "one empty"); assert_eq!(match_vecs_cons::<uint>(&[], &[]), "both empty"); - assert_eq!(match_vecs_cons(&[1i, 2, 3], &[]), "one empty"); + assert_eq!(match_vecs_cons(&[1, 2, 3], &[]), "one empty"); - assert_eq!(match_vecs_snoc(&[1i, 2], &[2i, 3]), "both non-empty"); - assert_eq!(match_vecs_snoc(&[], &[1i, 2, 3, 4]), "one empty"); + assert_eq!(match_vecs_snoc(&[1, 2], &[2, 3]), "both non-empty"); + assert_eq!(match_vecs_snoc(&[], &[1, 2, 3, 4]), "one empty"); assert_eq!(match_vecs_snoc::<uint>(&[], &[]), "both empty"); - assert_eq!(match_vecs_snoc(&[1i, 2, 3], &[]), "one empty"); + assert_eq!(match_vecs_snoc(&[1, 2, 3], &[]), "one empty"); assert_eq!(match_nested_vecs_cons(None, Ok::<&[_], ()>(&[4u, 2u])), "None, Ok(at least two elements)"); assert_eq!(match_nested_vecs_cons::<uint>(None, Err(())), "None, Ok(less than one element)"); assert_eq!(match_nested_vecs_cons::<bool>(Some::<&[_]>(&[]), Ok::<&[_], ()>(&[])), "Some(empty), Ok(empty)"); - assert_eq!(match_nested_vecs_cons(Some::<&[_]>(&[1i]), Err(())), "Some(non-empty), any"); - assert_eq!(match_nested_vecs_cons(Some::<&[_]>(&[(42i, ())]), Ok::<&[_], ()>(&[(1i, ())])), + assert_eq!(match_nested_vecs_cons(Some::<&[_]>(&[1]), Err(())), "Some(non-empty), any"); + assert_eq!(match_nested_vecs_cons(Some::<&[_]>(&[(42, ())]), Ok::<&[_], ()>(&[(1, ())])), "Some(non-empty), any"); assert_eq!(match_nested_vecs_snoc(None, Ok::<&[_], ()>(&[4u, 2u])), @@ -84,7 +84,7 @@ fn main() { assert_eq!(match_nested_vecs_snoc::<uint>(None, Err(())), "None, Ok(less than one element)"); assert_eq!(match_nested_vecs_snoc::<bool>(Some::<&[_]>(&[]), Ok::<&[_], ()>(&[])), "Some(empty), Ok(empty)"); - assert_eq!(match_nested_vecs_snoc(Some::<&[_]>(&[1i]), Err(())), "Some(non-empty), any"); - assert_eq!(match_nested_vecs_snoc(Some::<&[_]>(&[(42i, ())]), Ok::<&[_], ()>(&[(1i, ())])), + assert_eq!(match_nested_vecs_snoc(Some::<&[_]>(&[1]), Err(())), "Some(non-empty), any"); + assert_eq!(match_nested_vecs_snoc(Some::<&[_]>(&[(42, ())]), Ok::<&[_], ()>(&[(1, ())])), "Some(non-empty), any"); } diff --git a/src/test/run-pass/match-vec-rvalue.rs b/src/test/run-pass/match-vec-rvalue.rs index 0f058086add..04a0204d206 100644 --- a/src/test/run-pass/match-vec-rvalue.rs +++ b/src/test/run-pass/match-vec-rvalue.rs @@ -12,7 +12,7 @@ pub fn main() { - match vec!(1i, 2i, 3i) { + match vec!(1, 2, 3) { x => { assert_eq!(x.len(), 3); assert_eq!(x[0], 1); diff --git a/src/test/run-pass/method-two-trait-defer-resolution-1.rs b/src/test/run-pass/method-two-trait-defer-resolution-1.rs index e4ae33c1c50..414b08b4335 100644 --- a/src/test/run-pass/method-two-trait-defer-resolution-1.rs +++ b/src/test/run-pass/method-two-trait-defer-resolution-1.rs @@ -12,28 +12,28 @@ // type that is (ultimately) inferred for `x`. trait foo { - fn foo(&self) -> int; + fn foo(&self) -> i32; } -impl foo for Vec<uint> { - fn foo(&self) -> int {1} +impl foo for Vec<u32> { + fn foo(&self) -> i32 {1} } -impl foo for Vec<int> { - fn foo(&self) -> int {2} +impl foo for Vec<i32> { + fn foo(&self) -> i32 {2} } -fn call_foo_uint() -> int { +fn call_foo_uint() -> i32 { let mut x = Vec::new(); let y = x.foo(); - x.push(0u); + x.push(0u32); y } -fn call_foo_int() -> int { +fn call_foo_int() -> i32 { let mut x = Vec::new(); let y = x.foo(); - x.push(0i); + x.push(0i32); y } diff --git a/src/test/run-pass/method-two-trait-defer-resolution-2.rs b/src/test/run-pass/method-two-trait-defer-resolution-2.rs index b18c29dc3c1..7f498b2b578 100644 --- a/src/test/run-pass/method-two-trait-defer-resolution-2.rs +++ b/src/test/run-pass/method-two-trait-defer-resolution-2.rs @@ -41,7 +41,7 @@ fn call_foo_copy() -> int { fn call_foo_other() -> int { let mut x = Vec::new(); let y = x.foo(); - x.push(box 0i); + x.push(box 0); y } diff --git a/src/test/run-pass/method-where-clause.rs b/src/test/run-pass/method-where-clause.rs index 4361c22f55a..6337538a332 100644 --- a/src/test/run-pass/method-where-clause.rs +++ b/src/test/run-pass/method-where-clause.rs @@ -12,24 +12,24 @@ // where clause type, and not only type parameters. trait Foo { - fn foo(&self) -> int; + fn foo(&self) -> i32; } -impl Foo for Option<int> +impl Foo for Option<i32> { - fn foo(&self) -> int { + fn foo(&self) -> i32 { self.unwrap_or(22) } } -impl Foo for Option<uint> +impl Foo for Option<u32> { - fn foo(&self) -> int { - self.unwrap_or(22) as int + fn foo(&self) -> i32 { + self.unwrap_or(22) as i32 } } -fn check<T>(x: Option<T>) -> (int, int) +fn check<T>(x: Option<T>) -> (i32, i32) where Option<T> : Foo { let y: Option<T> = None; @@ -37,6 +37,6 @@ fn check<T>(x: Option<T>) -> (int, int) } fn main() { - assert_eq!(check(Some(23u)), (23i, 22i)); - assert_eq!(check(Some(23i)), (23i, 22i)); + assert_eq!(check(Some(23u32)), (23, 22)); + assert_eq!(check(Some(23)), (23, 22)); } diff --git a/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs b/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs index 4ebebc46018..eb17aa78bd9 100644 --- a/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs +++ b/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs @@ -32,9 +32,9 @@ impl Serializer for int { } pub fn main() { - let foo = F { a: 1i }; - foo.serialize(1i); + let foo = F { a: 1 }; + foo.serialize(1); - let bar = F { a: F {a: 1i } }; - bar.serialize(2i); + let bar = F { a: F {a: 1 } }; + bar.serialize(2); } diff --git a/src/test/run-pass/multi-let.rs b/src/test/run-pass/multi-let.rs index 201abeba073..eb1444be378 100644 --- a/src/test/run-pass/multi-let.rs +++ b/src/test/run-pass/multi-let.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - let x = 10i; + let x = 10; let y = x; assert!((y == 10)); } diff --git a/src/test/run-pass/multiple-trait-bounds.rs b/src/test/run-pass/multiple-trait-bounds.rs index 10abe4ce710..7ce1afb52a2 100644 --- a/src/test/run-pass/multiple-trait-bounds.rs +++ b/src/test/run-pass/multiple-trait-bounds.rs @@ -12,5 +12,5 @@ fn f<T:PartialEq + PartialOrd>(_: T) { } pub fn main() { - f(3i); + f(3); } diff --git a/src/test/run-pass/mut-in-ident-patterns.rs b/src/test/run-pass/mut-in-ident-patterns.rs index ad9161f9bd4..8be200d3bf3 100644 --- a/src/test/run-pass/mut-in-ident-patterns.rs +++ b/src/test/run-pass/mut-in-ident-patterns.rs @@ -20,7 +20,7 @@ struct X; impl Foo for X {} pub fn main() { - let (a, mut b) = (23i, 4i); + let (a, mut b) = (23, 4); assert_eq!(a, 23); assert_eq!(b, 4); b = a + b; @@ -34,7 +34,7 @@ pub fn main() { Baz(f32, u8) } - let (x, mut y) = (32i, Bar::Foo(21)); + let (x, mut y) = (32, Bar::Foo(21)); match x { mut z @ 32 => { diff --git a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs index bf926a6c48a..7d6bbbe4240 100644 --- a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs +++ b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs @@ -9,13 +9,13 @@ // except according to those terms. fn test1() { - let mut ints = [0i; 32]; + let mut ints = [0; 32]; ints[0] += 1; assert_eq!(ints[0], 1); } fn test2() { - let mut ints = [0i; 32]; + let mut ints = [0; 32]; for i in ints.iter_mut() { *i += 22; } for i in ints.iter() { assert!(*i == 22); } } diff --git a/src/test/run-pass/negative.rs b/src/test/run-pass/negative.rs index 4bf91bf7035..435382666f1 100644 --- a/src/test/run-pass/negative.rs +++ b/src/test/run-pass/negative.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - match -5i { + match -5 { -5 => {} _ => { panic!() } } diff --git a/src/test/run-pass/nested-matchs.rs b/src/test/run-pass/nested-matchs.rs index 55c1de2700f..b0ac9fb597a 100644 --- a/src/test/run-pass/nested-matchs.rs +++ b/src/test/run-pass/nested-matchs.rs @@ -14,7 +14,7 @@ fn foo() { match Some::<int>(5) { Some::<int>(_x) => { let mut bar; - match None::<int> { None::<int> => { bar = 5i; } _ => { baz(); } } + match None::<int> { None::<int> => { bar = 5; } _ => { baz(); } } println!("{}", bar); } None::<int> => { println!("hello"); } diff --git a/src/test/run-pass/new-box-syntax.rs b/src/test/run-pass/new-box-syntax.rs index 4ea51b3b409..3d4847a119a 100644 --- a/src/test/run-pass/new-box-syntax.rs +++ b/src/test/run-pass/new-box-syntax.rs @@ -24,8 +24,8 @@ struct Structure { } pub fn main() { - let x: Box<int> = box(HEAP) 2i; - let y: Box<int> = box 2i; - let b: Box<int> = box()(1i + 2); - let c = box()(3i + 4); + let x: Box<int> = box(HEAP) 2; + let y: Box<int> = box 2; + let b: Box<int> = box()(1 + 2); + let c = box()(3 + 4); } diff --git a/src/test/run-pass/newtype-polymorphic.rs b/src/test/run-pass/newtype-polymorphic.rs index 74487f5b57d..4b7dbdc9e5b 100644 --- a/src/test/run-pass/newtype-polymorphic.rs +++ b/src/test/run-pass/newtype-polymorphic.rs @@ -23,7 +23,7 @@ fn myvec_elt<X>(mv: myvec<X>) -> X { } pub fn main() { - let mv = myvec(vec!(1i, 2, 3)); + let mv = myvec(vec!(1, 2, 3)); let mv_clone = mv.clone(); let mv_clone = myvec_deref(mv_clone); assert_eq!(mv_clone[1], 2); diff --git a/src/test/run-pass/numeric-method-autoexport.rs b/src/test/run-pass/numeric-method-autoexport.rs index b4d079d79d6..140cf33cd1d 100644 --- a/src/test/run-pass/numeric-method-autoexport.rs +++ b/src/test/run-pass/numeric-method-autoexport.rs @@ -21,7 +21,7 @@ use std::num::ToPrimitive; pub fn main() { // ints // num - assert_eq!(15i.add(6), 21); + assert_eq!(15is.add(6is), 21is); assert_eq!(15i8.add(6i8), 21i8); assert_eq!(15i16.add(6i16), 21i16); assert_eq!(15i32.add(6i32), 21i32); @@ -29,7 +29,7 @@ pub fn main() { // uints // num - assert_eq!(15u.add(6u), 21u); + assert_eq!(15u.add(6us), 21us); assert_eq!(15u8.add(6u8), 21u8); assert_eq!(15u16.add(6u16), 21u16); assert_eq!(15u32.add(6u32), 21u32); diff --git a/src/test/run-pass/object-one-type-two-traits.rs b/src/test/run-pass/object-one-type-two-traits.rs index ebdf3c08a22..f8a3ce7cda0 100644 --- a/src/test/run-pass/object-one-type-two-traits.rs +++ b/src/test/run-pass/object-one-type-two-traits.rs @@ -35,7 +35,7 @@ fn is<T:'static>(x: &Any) -> bool { } fn main() { - let x = box 22i as Box<Wrap>; + let x = box 22 as Box<Wrap>; println!("x={}", x.get()); let y = x.wrap(); } diff --git a/src/test/run-pass/operator-associativity.rs b/src/test/run-pass/operator-associativity.rs index 8d45b8ecb08..bee6d23a27d 100644 --- a/src/test/run-pass/operator-associativity.rs +++ b/src/test/run-pass/operator-associativity.rs @@ -12,4 +12,4 @@ // Testcase for issue #130, operator associativity. -pub fn main() { assert!((3i * 5i / 2i == 7i)); } +pub fn main() { assert!((3 * 5 / 2 == 7)); } diff --git a/src/test/run-pass/out-of-stack-new-thread-no-split.rs b/src/test/run-pass/out-of-stack-new-thread-no-split.rs index 1ede5f546d7..c9e2f893c0f 100644 --- a/src/test/run-pass/out-of-stack-new-thread-no-split.rs +++ b/src/test/run-pass/out-of-stack-new-thread-no-split.rs @@ -28,7 +28,7 @@ pub fn black_box<T>(dummy: T) { unsafe { asm!("" : : "r"(&dummy)) } } #[no_stack_check] fn recurse() { - let buf = [0i; 10]; + let buf = [0; 10]; black_box(buf); recurse(); } diff --git a/src/test/run-pass/out-of-stack-no-split.rs b/src/test/run-pass/out-of-stack-no-split.rs index adaa472c760..846fbd477e0 100644 --- a/src/test/run-pass/out-of-stack-no-split.rs +++ b/src/test/run-pass/out-of-stack-no-split.rs @@ -28,7 +28,7 @@ pub fn black_box<T>(dummy: T) { unsafe { asm!("" : : "r"(&dummy)) } } #[no_stack_check] fn recurse() { - let buf = [0i; 10]; + let buf = [0; 10]; black_box(buf); recurse(); } diff --git a/src/test/run-pass/out-of-stack.rs b/src/test/run-pass/out-of-stack.rs index 9615cfab5c1..97539a076ff 100644 --- a/src/test/run-pass/out-of-stack.rs +++ b/src/test/run-pass/out-of-stack.rs @@ -22,7 +22,7 @@ use std::os; pub fn black_box<T>(dummy: T) { unsafe { asm!("" : : "r"(&dummy)) } } fn silent_recurse() { - let buf = [0i; 1000]; + let buf = [0; 1000]; black_box(buf); silent_recurse(); } diff --git a/src/test/run-pass/overloaded-autoderef-indexing.rs b/src/test/run-pass/overloaded-autoderef-indexing.rs index de37173810f..4cb7ece4ab8 100644 --- a/src/test/run-pass/overloaded-autoderef-indexing.rs +++ b/src/test/run-pass/overloaded-autoderef-indexing.rs @@ -23,6 +23,6 @@ impl<'a, T> Deref for DerefArray<'a, T> { } pub fn main() { - let a = &[1i, 2i, 3i]; + let a = &[1, 2, 3]; assert_eq!(DerefArray {inner: a}[1], 2); } diff --git a/src/test/run-pass/overloaded-autoderef-order.rs b/src/test/run-pass/overloaded-autoderef-order.rs index 4c48b0ba710..d023a01f4b1 100644 --- a/src/test/run-pass/overloaded-autoderef-order.rs +++ b/src/test/run-pass/overloaded-autoderef-order.rs @@ -59,7 +59,7 @@ mod priv_test { } pub fn main() { - let nested = DerefWrapper {x: true, y: DerefWrapper {x: 0i, y: 1i}}; + let nested = DerefWrapper {x: true, y: DerefWrapper {x: 0, y: 1}}; // Use the first field that you can find. assert_eq!(nested.x, true); @@ -73,7 +73,7 @@ pub fn main() { // Also go through multiple levels of indirection. assert_eq!(Rc::new(nested).x, true); - let nested_priv = priv_test::DerefWrapperHideX::new(true, DerefWrapper {x: 0i, y: 1i}); + let nested_priv = priv_test::DerefWrapperHideX::new(true, DerefWrapper {x: 0, y: 1}); // FIXME(eddyb) #12808 should skip private fields. // assert_eq!(nested_priv.x, 0); assert_eq!((*nested_priv).x, 0); diff --git a/src/test/run-pass/overloaded-autoderef-xcrate.rs b/src/test/run-pass/overloaded-autoderef-xcrate.rs index 4f449b344e3..f8dd729ec67 100644 --- a/src/test/run-pass/overloaded-autoderef-xcrate.rs +++ b/src/test/run-pass/overloaded-autoderef-xcrate.rs @@ -13,5 +13,5 @@ extern crate overloaded_autoderef_xc; fn main() { - assert!(overloaded_autoderef_xc::check(5i, 5i)); + assert!(overloaded_autoderef_xc::check(5, 5)); } diff --git a/src/test/run-pass/overloaded-autoderef.rs b/src/test/run-pass/overloaded-autoderef.rs index 59e3a807d5a..baa9709eb76 100644 --- a/src/test/run-pass/overloaded-autoderef.rs +++ b/src/test/run-pass/overloaded-autoderef.rs @@ -28,7 +28,7 @@ pub fn main() { assert_eq!(point.x, 2); assert_eq!(point.y, 4); - let i = Rc::new(RefCell::new(2i)); + let i = Rc::new(RefCell::new(2)); let i_value = *i.borrow(); *i.borrow_mut() = 5; assert_eq!((i_value, *i.borrow()), (2, 5)); @@ -47,7 +47,7 @@ pub fn main() { p.borrow_mut().y += 3; assert_eq!(*p.borrow(), Point {x: 3, y: 5}); - let v = Rc::new(RefCell::new([1i, 2, 3])); + let v = Rc::new(RefCell::new([1, 2, 3])); v.borrow_mut()[0] = 3; v.borrow_mut()[1] += 3; assert_eq!((v.borrow()[0], v.borrow()[1], v.borrow()[2]), (3, 5, 3)); diff --git a/src/test/run-pass/overloaded-deref-count.rs b/src/test/run-pass/overloaded-deref-count.rs index 5cd76879798..03fa64fb87f 100644 --- a/src/test/run-pass/overloaded-deref-count.rs +++ b/src/test/run-pass/overloaded-deref-count.rs @@ -49,7 +49,7 @@ impl<T> DerefMut for DerefCounter<T> { } pub fn main() { - let mut n = DerefCounter::new(0i); + let mut n = DerefCounter::new(0); let mut v = DerefCounter::new(Vec::new()); let _ = *n; // Immutable deref + copy a POD. @@ -62,7 +62,7 @@ pub fn main() { assert_eq!(n.counts(), (2, 1)); assert_eq!(v.counts(), (1, 1)); let mut v2 = Vec::new(); - v2.push(1i); + v2.push(1); *n = 5; *v = v2; // Mutable deref + assignment. assert_eq!(n.counts(), (2, 2)); assert_eq!(v.counts(), (1, 2)); diff --git a/src/test/run-pass/overloaded-deref.rs b/src/test/run-pass/overloaded-deref.rs index d02951e981e..fdaddca091f 100644 --- a/src/test/run-pass/overloaded-deref.rs +++ b/src/test/run-pass/overloaded-deref.rs @@ -22,11 +22,11 @@ struct Point { } pub fn main() { - assert_eq!(*Rc::new(5i), 5); - assert_eq!(***Rc::new(box box 5i), 5); + assert_eq!(*Rc::new(5), 5); + assert_eq!(***Rc::new(box box 5), 5); assert_eq!(*Rc::new(Point {x: 2, y: 4}), Point {x: 2, y: 4}); - let i = Rc::new(RefCell::new(2i)); + let i = Rc::new(RefCell::new(2)); let i_value = *(*i).borrow(); *(*i).borrow_mut() = 5; assert_eq!((i_value, *(*i).borrow()), (2, 5)); @@ -46,7 +46,7 @@ pub fn main() { (*(*p).borrow_mut()).y += 3; assert_eq!(*(*p).borrow(), Point {x: 3, y: 5}); - let v = Rc::new(RefCell::new(vec!(1i, 2, 3))); + let v = Rc::new(RefCell::new(vec!(1, 2, 3))); (*(*v).borrow_mut())[0] = 3; (*(*v).borrow_mut())[1] += 3; assert_eq!(((*(*v).borrow())[0], diff --git a/src/test/run-pass/overloaded-index-assoc-list.rs b/src/test/run-pass/overloaded-index-assoc-list.rs index 5e0523d7041..7e3ff198c43 100644 --- a/src/test/run-pass/overloaded-index-assoc-list.rs +++ b/src/test/run-pass/overloaded-index-assoc-list.rs @@ -46,8 +46,8 @@ pub fn main() { let bar = "bar".to_string(); let mut list = AssociationList {pairs: Vec::new()}; - list.push(foo.clone(), 22i); - list.push(bar.clone(), 44i); + list.push(foo.clone(), 22); + list.push(bar.clone(), 44); assert!(list[foo] == 22); assert!(list[bar] == 44); diff --git a/src/test/run-pass/owned-implies-static.rs b/src/test/run-pass/owned-implies-static.rs index e784318fc76..2db6f7ffaaa 100644 --- a/src/test/run-pass/owned-implies-static.rs +++ b/src/test/run-pass/owned-implies-static.rs @@ -14,5 +14,5 @@ fn f<T: 'static>(_x: T) {} pub fn main() { - f(box 5i); + f(box 5); } diff --git a/src/test/run-pass/paren-free.rs b/src/test/run-pass/paren-free.rs index 569023c4439..d9669812d2a 100644 --- a/src/test/run-pass/paren-free.rs +++ b/src/test/run-pass/paren-free.rs @@ -10,6 +10,6 @@ pub fn main() { let x = true; - if x { let mut i = 10i; while i > 0 { i -= 1; } } + if x { let mut i = 10; while i > 0 { i -= 1; } } match x { true => { println!("right"); } false => { println!("wrong"); } } } diff --git a/src/test/run-pass/parse-complex-macro-invoc-op.rs b/src/test/run-pass/parse-complex-macro-invoc-op.rs index e9ec624c13e..0995910fd4c 100644 --- a/src/test/run-pass/parse-complex-macro-invoc-op.rs +++ b/src/test/run-pass/parse-complex-macro-invoc-op.rs @@ -17,24 +17,24 @@ macro_rules! id { } fn foo() { - id!(1i) + 1; - id![1i] - 1; - id!(1i) * 1; - id![1i] / 1; - id!(1i) % 1; + id!(1) + 1; + id![1] - 1; + id!(1) * 1; + id![1] / 1; + id!(1) % 1; - id!(1i) & 1; - id![1i] | 1; - id!(1i) ^ 1; + id!(1) & 1; + id![1] | 1; + id!(1) ^ 1; - let mut x = 1i; + let mut x = 1; id![x] = 2; id!(x) += 1; id!(1f64).clone(); - id!([1i, 2, 3])[1]; - id; + id!([1, 2, 3])[1]; + id; id!(true) && true; id![true] || true; diff --git a/src/test/run-pass/parse-panic.rs b/src/test/run-pass/parse-panic.rs index 0dbba3654b6..22b24ebb3b5 100644 --- a/src/test/run-pass/parse-panic.rs +++ b/src/test/run-pass/parse-panic.rs @@ -10,6 +10,6 @@ #![allow(unreachable_code)] -fn dont_call_me() { panic!(); println!("{}", 1i); } +fn dont_call_me() { panic!(); println!("{}", 1); } pub fn main() { } diff --git a/src/test/run-pass/priv-impl-prim-ty.rs b/src/test/run-pass/priv-impl-prim-ty.rs index a8cd5e789b1..679aa3d668f 100644 --- a/src/test/run-pass/priv-impl-prim-ty.rs +++ b/src/test/run-pass/priv-impl-prim-ty.rs @@ -13,6 +13,6 @@ extern crate "priv-impl-prim-ty" as bar; pub fn main() { - bar::frob(1i); + bar::frob(1); } diff --git a/src/test/run-pass/ptr-coercion.rs b/src/test/run-pass/ptr-coercion.rs index 1b77c1316ed..a6a8890101c 100644 --- a/src/test/run-pass/ptr-coercion.rs +++ b/src/test/run-pass/ptr-coercion.rs @@ -12,24 +12,24 @@ pub fn main() { // &mut -> & - let x: &mut int = &mut 42i; + let x: &mut int = &mut 42; let x: &int = x; - let x: &int = &mut 42i; + let x: &int = &mut 42; // & -> *const - let x: &int = &42i; + let x: &int = &42; let x: *const int = x; - let x: *const int = &42i; + let x: *const int = &42; // &mut -> *const - let x: &mut int = &mut 42i; + let x: &mut int = &mut 42; let x: *const int = x; - let x: *const int = &mut 42i; + let x: *const int = &mut 42; // *mut -> *const - let x: *mut int = &mut 42i; + let x: *mut int = &mut 42; let x: *const int = x; } diff --git a/src/test/run-pass/range.rs b/src/test/run-pass/range.rs index bfd3e43768f..11e8bfa48f6 100644 --- a/src/test/run-pass/range.rs +++ b/src/test/run-pass/range.rs @@ -45,9 +45,9 @@ pub fn main() { let _ = ..42u; // Test we can use two different types with a common supertype. - let x = &42i; + let x = &42; { - let y = 42i; + let y = 42; let _ = x..&y; } } diff --git a/src/test/run-pass/reexported-static-methods-cross-crate.rs b/src/test/run-pass/reexported-static-methods-cross-crate.rs index 0d0fdb13db3..5399f3cfd35 100644 --- a/src/test/run-pass/reexported-static-methods-cross-crate.rs +++ b/src/test/run-pass/reexported-static-methods-cross-crate.rs @@ -17,8 +17,8 @@ use reexported_static_methods::Boz; use reexported_static_methods::Bort; pub fn main() { - assert_eq!(42i, Foo::foo()); - assert_eq!(84i, Baz::bar()); - assert!(Boz::boz(1i)); + assert_eq!(42, Foo::foo()); + assert_eq!(84, Baz::bar()); + assert!(Boz::boz(1)); assert_eq!("bort()".to_string(), Bort::bort()); } diff --git a/src/test/run-pass/regions-copy-closure.rs b/src/test/run-pass/regions-copy-closure.rs index 0152793d96c..dc6f377e9b2 100644 --- a/src/test/run-pass/regions-copy-closure.rs +++ b/src/test/run-pass/regions-copy-closure.rs @@ -21,7 +21,7 @@ fn box_it<'a>(x: Box<FnMut() + 'a>) -> closure_box<'a> { } pub fn main() { - let mut i = 3i; + let mut i = 3i32; assert_eq!(i, 3); { let cl = |&mut:| i += 1; diff --git a/src/test/run-pass/regions-early-bound-trait-param.rs b/src/test/run-pass/regions-early-bound-trait-param.rs index 3267ff2c7e0..6fcfaf58a02 100644 --- a/src/test/run-pass/regions-early-bound-trait-param.rs +++ b/src/test/run-pass/regions-early-bound-trait-param.rs @@ -81,7 +81,7 @@ impl<'s> Trait<'s> for (int,int) { } impl<'t> MakerTrait<'t> for Box<Trait<'t>+'static> { - fn mk() -> Box<Trait<'t>+'static> { box() (4i,5i) as Box<Trait> } + fn mk() -> Box<Trait<'t>+'static> { box() (4,5) as Box<Trait> } } enum List<'l> { @@ -111,7 +111,7 @@ impl<'t> RefMakerTrait<'t> for List<'t> { } pub fn main() { - let t = (2i,3i); + let t = (2,3); let o = &t as &Trait; let s1 = Struct1 { f: o }; let s2 = Struct2 { f: o }; diff --git a/src/test/run-pass/regions-early-bound-used-in-bound.rs b/src/test/run-pass/regions-early-bound-used-in-bound.rs index 73eb7ca7188..a3602c5fbec 100644 --- a/src/test/run-pass/regions-early-bound-used-in-bound.rs +++ b/src/test/run-pass/regions-early-bound-used-in-bound.rs @@ -32,6 +32,6 @@ fn add<'a,G:GetRef<'a, int>>(g1: G, g2: G) -> int { } pub fn main() { - let b1 = Box { t: &3i }; - assert_eq!(add(b1, b1), 6i); + let b1 = Box { t: &3 }; + assert_eq!(add(b1, b1), 6); } diff --git a/src/test/run-pass/regions-early-bound-used-in-type-param.rs b/src/test/run-pass/regions-early-bound-used-in-type-param.rs index e0d5e0a1c78..caef4e3fa9c 100644 --- a/src/test/run-pass/regions-early-bound-used-in-type-param.rs +++ b/src/test/run-pass/regions-early-bound-used-in-type-param.rs @@ -31,6 +31,6 @@ fn add<'a,G:Get<&'a int>>(g1: G, g2: G) -> int { } pub fn main() { - let b1 = Box { t: &3i }; - assert_eq!(add(b1, b1), 6i); + let b1 = Box { t: &3 }; + assert_eq!(add(b1, b1), 6); } diff --git a/src/test/run-pass/regions-infer-borrow-scope-view.rs b/src/test/run-pass/regions-infer-borrow-scope-view.rs index ce9edb5678a..d247f864571 100644 --- a/src/test/run-pass/regions-infer-borrow-scope-view.rs +++ b/src/test/run-pass/regions-infer-borrow-scope-view.rs @@ -12,7 +12,7 @@ fn view<T>(x: &[T]) -> &[T] {x} pub fn main() { - let v = vec!(1i, 2, 3); + let v = vec!(1, 2, 3); let x = view(v.as_slice()); let y = view(x.as_slice()); assert!((v[0] == x[0]) && (v[0] == y[0])); diff --git a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs index f397b5124ca..d07110fd721 100644 --- a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs +++ b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs @@ -14,7 +14,7 @@ fn borrow<T>(x: &T) -> &T {x} pub fn main() { - let x = box 3i; + let x = box 3; loop { let y = borrow(&*x); assert_eq!(*x, *y); diff --git a/src/test/run-pass/regions-return-interior-of-option.rs b/src/test/run-pass/regions-return-interior-of-option.rs index 54458f0d0df..ee1d6687307 100644 --- a/src/test/run-pass/regions-return-interior-of-option.rs +++ b/src/test/run-pass/regions-return-interior-of-option.rs @@ -16,14 +16,14 @@ fn get<T>(opt: &Option<T>) -> &T { } pub fn main() { - let mut x = Some(23i); + let mut x = Some(23); { let y = get(&x); assert_eq!(*y, 23); } - x = Some(24i); + x = Some(24); { let y = get(&x); diff --git a/src/test/run-pass/regions-scope-chain-example.rs b/src/test/run-pass/regions-scope-chain-example.rs index 0388ffb7894..e5ef88006c7 100644 --- a/src/test/run-pass/regions-scope-chain-example.rs +++ b/src/test/run-pass/regions-scope-chain-example.rs @@ -31,7 +31,7 @@ struct Context<'a> { impl<'a> Context<'a> { fn foo(&mut self, scope: Scope) { - let link = if 1i < 2 { + let link = if 1 < 2 { let l = ScopeChain::Link(scope); self.take_scope(&l); l diff --git a/src/test/run-pass/repeated-vector-syntax.rs b/src/test/run-pass/repeated-vector-syntax.rs index d1d37ea5bb0..6048e0d8673 100644 --- a/src/test/run-pass/repeated-vector-syntax.rs +++ b/src/test/run-pass/repeated-vector-syntax.rs @@ -10,7 +10,7 @@ pub fn main() { let x = [ [true]; 512 ]; - let y = [ 0i; 1 ]; + let y = [ 0; 1 ]; print!("["); for xi in x.iter() { diff --git a/src/test/run-pass/resource-assign-is-not-copy.rs b/src/test/run-pass/resource-assign-is-not-copy.rs index ff38b02ae76..abc33e9f2e6 100644 --- a/src/test/run-pass/resource-assign-is-not-copy.rs +++ b/src/test/run-pass/resource-assign-is-not-copy.rs @@ -31,11 +31,11 @@ fn r(i: &Cell<int>) -> r { } pub fn main() { - let i = &Cell::new(0i); + let i = &Cell::new(0); // Even though these look like copies, they are guaranteed not to be { let a = r(i); - let b = (a, 10i); + let b = (a, 10); let (c, _d) = b; println!("{:?}", c); } diff --git a/src/test/run-pass/self-re-assign.rs b/src/test/run-pass/self-re-assign.rs index 3092898d986..cf09737e32e 100644 --- a/src/test/run-pass/self-re-assign.rs +++ b/src/test/run-pass/self-re-assign.rs @@ -17,11 +17,11 @@ use std::rc::Rc; pub fn main() { - let mut x = box 3i; + let mut x = box 3; x = x; assert!(*x == 3); - let mut x = Rc::new(3i); + let mut x = Rc::new(3); x = x; assert!(*x == 3); } diff --git a/src/test/run-pass/seq-compare.rs b/src/test/run-pass/seq-compare.rs index 29729b15aa8..ef14e0ba931 100644 --- a/src/test/run-pass/seq-compare.rs +++ b/src/test/run-pass/seq-compare.rs @@ -13,13 +13,13 @@ pub fn main() { assert!(("hello".to_string() < "hellr".to_string())); assert!(("hello ".to_string() > "hello".to_string())); assert!(("hello".to_string() != "there".to_string())); - assert!((vec!(1i, 2, 3, 4) > vec!(1, 2, 3))); - assert!((vec!(1i, 2, 3) < vec!(1, 2, 3, 4))); - assert!((vec!(1i, 2, 4, 4) > vec!(1, 2, 3, 4))); - assert!((vec!(1i, 2, 3, 4) < vec!(1, 2, 4, 4))); - assert!((vec!(1i, 2, 3) <= vec!(1, 2, 3))); - assert!((vec!(1i, 2, 3) <= vec!(1, 2, 3, 3))); - assert!((vec!(1i, 2, 3, 4) > vec!(1, 2, 3))); - assert_eq!(vec!(1i, 2, 3), vec!(1, 2, 3)); - assert!((vec!(1i, 2, 3) != vec!(1, 1, 3))); + assert!((vec!(1, 2, 3, 4) > vec!(1, 2, 3))); + assert!((vec!(1, 2, 3) < vec!(1, 2, 3, 4))); + assert!((vec!(1, 2, 4, 4) > vec!(1, 2, 3, 4))); + assert!((vec!(1, 2, 3, 4) < vec!(1, 2, 4, 4))); + assert!((vec!(1, 2, 3) <= vec!(1, 2, 3))); + assert!((vec!(1, 2, 3) <= vec!(1, 2, 3, 3))); + assert!((vec!(1, 2, 3, 4) > vec!(1, 2, 3))); + assert_eq!(vec!(1, 2, 3), vec!(1, 2, 3)); + assert!((vec!(1, 2, 3) != vec!(1, 1, 3))); } diff --git a/src/test/run-pass/shadow.rs b/src/test/run-pass/shadow.rs index 06d707d3ab0..dbe73d1b94a 100644 --- a/src/test/run-pass/shadow.rs +++ b/src/test/run-pass/shadow.rs @@ -17,7 +17,7 @@ fn foo(c: Vec<int> ) { t::some::<int>(_) => { for _i in c.iter() { println!("{}", a); - let a = 17i; + let a = 17; b.push(a); } } @@ -27,4 +27,4 @@ fn foo(c: Vec<int> ) { enum t<T> { none, some(T), } -pub fn main() { let x = 10i; let x = x + 20; assert!((x == 30)); foo(Vec::new()); } +pub fn main() { let x = 10; let x = x + 20; assert!((x == 30)); foo(Vec::new()); } diff --git a/src/test/run-pass/shift.rs b/src/test/run-pass/shift.rs index d8a67eef3f6..2dbedc3a573 100644 --- a/src/test/run-pass/shift.rs +++ b/src/test/run-pass/shift.rs @@ -18,7 +18,7 @@ pub fn main() { } fn test_misc() { - assert_eq!(1i << 1 << 1 << 1 << 1 << 1, 32); + assert_eq!(1 << 1 << 1 << 1 << 1 << 1, 32); } fn test_expr() { diff --git a/src/test/run-pass/simple-infer.rs b/src/test/run-pass/simple-infer.rs index 4f6feb544f4..04c1af4326b 100644 --- a/src/test/run-pass/simple-infer.rs +++ b/src/test/run-pass/simple-infer.rs @@ -10,4 +10,4 @@ -pub fn main() { let mut n; n = 1i; println!("{}", n); } +pub fn main() { let mut n; n = 1; println!("{}", n); } diff --git a/src/test/run-pass/static-assert.rs b/src/test/run-pass/static-assert.rs index c695fa2b72e..f8fd81b9365 100644 --- a/src/test/run-pass/static-assert.rs +++ b/src/test/run-pass/static-assert.rs @@ -12,13 +12,13 @@ static b: bool = true; #[static_assert] -static c: bool = 1i == 1; +static c: bool = 1 == 1; #[static_assert] -static d: bool = 1i != 2; +static d: bool = 1 != 2; #[static_assert] -static f: bool = (4i/2) == 2; +static f: bool = (4/2) == 2; pub fn main() { } diff --git a/src/test/run-pass/static-fn-inline-xc.rs b/src/test/run-pass/static-fn-inline-xc.rs index dbe9221066f..efc374e25bb 100644 --- a/src/test/run-pass/static-fn-inline-xc.rs +++ b/src/test/run-pass/static-fn-inline-xc.rs @@ -15,5 +15,5 @@ extern crate "static_fn_inline_xc_aux" as mycore; use mycore::num; pub fn main() { - let _1: f64 = num::Num2::from_int2(1i); + let _1: f64 = num::Num2::from_int2(1); } diff --git a/src/test/run-pass/static-fn-trait-xc.rs b/src/test/run-pass/static-fn-trait-xc.rs index 5dd6b6dbc53..cb9f7c3da02 100644 --- a/src/test/run-pass/static-fn-trait-xc.rs +++ b/src/test/run-pass/static-fn-trait-xc.rs @@ -15,5 +15,5 @@ extern crate "static_fn_trait_xc_aux" as mycore; use mycore::num; pub fn main() { - let _1: f64 = num::Num2::from_int2(1i); + let _1: f64 = num::Num2::from_int2(1); } diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs index 74c0663971e..44d77e440d1 100644 --- a/src/test/run-pass/static-impl.rs +++ b/src/test/run-pass/static-impl.rs @@ -61,10 +61,10 @@ pub fn main() { assert_eq!(10u.plus(), 30); assert_eq!(("hi".to_string()).plus(), 200); - assert_eq!((vec!(1i)).length_().str(), "1".to_string()); - let vect = vec!(3i, 4).map_(|a| *a + 4); + assert_eq!((vec!(1)).length_().str(), "1".to_string()); + let vect = vec!(3, 4).map_(|a| *a + 4); assert_eq!(vect[0], 7); - let vect = (vec!(3i, 4)).map_::<uint, _>(|a| *a as uint + 4u); + let vect = (vec!(3, 4)).map_::<uint, _>(|a| *a as uint + 4u); assert_eq!(vect[0], 7u); let mut x = 0u; 10u.multi(|_n| x += 2u ); diff --git a/src/test/run-pass/string-self-append.rs b/src/test/run-pass/string-self-append.rs index dc1e23ca09c..612483f6909 100644 --- a/src/test/run-pass/string-self-append.rs +++ b/src/test/run-pass/string-self-append.rs @@ -11,7 +11,7 @@ pub fn main() { // Make sure we properly handle repeated self-appends. let mut a: String = "A".to_string(); - let mut i = 20i; + let mut i = 20; let mut expected_len = 1u; while i > 0 { println!("{}", a.len()); diff --git a/src/test/run-pass/struct-lit-functional-no-fields.rs b/src/test/run-pass/struct-lit-functional-no-fields.rs index ebf2fbbe53c..c3b1ff0f057 100644 --- a/src/test/run-pass/struct-lit-functional-no-fields.rs +++ b/src/test/run-pass/struct-lit-functional-no-fields.rs @@ -16,8 +16,8 @@ struct Foo<T> { pub fn main() { let foo = Foo { - bar: 0i, - baz: 1i + bar: 0, + baz: 1 }; let foo_ = foo.clone(); diff --git a/src/test/run-pass/structured-compare.rs b/src/test/run-pass/structured-compare.rs index d87ff64ebd9..12d8fe8f4c8 100644 --- a/src/test/run-pass/structured-compare.rs +++ b/src/test/run-pass/structured-compare.rs @@ -21,14 +21,14 @@ impl PartialEq for foo { } pub fn main() { - let a = (1i, 2i, 3i); - let b = (1i, 2i, 3i); + let a = (1, 2, 3); + let b = (1, 2, 3); assert_eq!(a, b); assert!((a != (1, 2, 4))); assert!((a < (1, 2, 4))); assert!((a <= (1, 2, 4))); - assert!(((1i, 2i, 4i) > a)); - assert!(((1i, 2i, 4i) >= a)); + assert!(((1, 2, 4) > a)); + assert!(((1, 2, 4) >= a)); let x = foo::large; let y = foo::small; assert!((x != y)); diff --git a/src/test/run-pass/supertrait-default-generics.rs b/src/test/run-pass/supertrait-default-generics.rs index f31d9ca186f..e158ae672aa 100644 --- a/src/test/run-pass/supertrait-default-generics.rs +++ b/src/test/run-pass/supertrait-default-generics.rs @@ -38,7 +38,7 @@ impl<S: Clone> Positioned<S> for Point<S> { impl<S: Clone + Add<Output=S>> Movable<S> for Point<S> {} pub fn main() { - let mut p = Point{ x: 1i, y: 2i}; + let mut p = Point{ x: 1, y: 2}; p.translate(3); assert_eq!(p.X(), 4); } diff --git a/src/test/run-pass/supported-cast.rs b/src/test/run-pass/supported-cast.rs index 7cba4533c7f..60431fbedd0 100644 --- a/src/test/run-pass/supported-cast.rs +++ b/src/test/run-pass/supported-cast.rs @@ -34,8 +34,8 @@ pub fn main() { println!("{:?}", 1 as u16); println!("{:?}", 1 as u32); println!("{:?}", 1 as u64); - println!("{:?}", 1i as f32); - println!("{:?}", 1i as f64); + println!("{:?}", 1 as f32); + println!("{:?}", 1 as f64); println!("{:?}", 1u as int); println!("{:?}", 1u as uint); diff --git a/src/test/run-pass/swap-1.rs b/src/test/run-pass/swap-1.rs index 9a77356d7eb..82a76512e08 100644 --- a/src/test/run-pass/swap-1.rs +++ b/src/test/run-pass/swap-1.rs @@ -11,7 +11,7 @@ use std::mem::swap; pub fn main() { - let mut x = 3i; let mut y = 7i; + let mut x = 3; let mut y = 7; swap(&mut x, &mut y); assert!((x == 7)); assert!((y == 3)); } diff --git a/src/test/run-pass/tag-variant-disr-type-mismatch.rs b/src/test/run-pass/tag-variant-disr-type-mismatch.rs index c04751d51b4..7e4bd9ab273 100644 --- a/src/test/run-pass/tag-variant-disr-type-mismatch.rs +++ b/src/test/run-pass/tag-variant-disr-type-mismatch.rs @@ -9,7 +9,7 @@ // except according to those terms. enum color { - red = 1i, + red = 1, blue = 2, } diff --git a/src/test/run-pass/terminate-in-initializer.rs b/src/test/run-pass/terminate-in-initializer.rs index bfd1f5f4a74..185edb02cca 100644 --- a/src/test/run-pass/terminate-in-initializer.rs +++ b/src/test/run-pass/terminate-in-initializer.rs @@ -16,7 +16,7 @@ use std::thread::Thread; fn test_break() { loop { let _x: Box<int> = break; } } -fn test_cont() { let mut i = 0i; while i < 1 { i += 1; let _x: Box<int> = continue; } } +fn test_cont() { let mut i = 0; while i < 1 { i += 1; let _x: Box<int> = continue; } } fn test_ret() { let _x: Box<int> = return; } diff --git a/src/test/run-pass/trailing-comma.rs b/src/test/run-pass/trailing-comma.rs index 00e05064080..b5ae259bc63 100644 --- a/src/test/run-pass/trailing-comma.rs +++ b/src/test/run-pass/trailing-comma.rs @@ -28,16 +28,16 @@ enum Baz { #[allow(unused,)] pub fn main() { - f::<int,>(0i,); - let (_, _,) = (1i, 1i,); - let [_, _,] = [1i, 1,]; - let [_, _, .., _,] = [1i, 1, 1, 1,]; - let [_, _, _.., _,] = [1i, 1, 1, 1,]; + f::<int,>(0,); + let (_, _,) = (1, 1,); + let [_, _,] = [1, 1,]; + let [_, _, .., _,] = [1, 1, 1, 1,]; + let [_, _, _.., _,] = [1, 1, 1, 1,]; let x: Foo<int,> = Foo::<int,>; - Bar::f(0i,); - Bar.g(0i,); + Bar::f(0,); + Bar.g(0,); Bar.h(); let x = Baz::Qux(1,); diff --git a/src/test/run-pass/trait-default-method-bound-subst.rs b/src/test/run-pass/trait-default-method-bound-subst.rs index 6b0ab8910de..5f0e149eb28 100644 --- a/src/test/run-pass/trait-default-method-bound-subst.rs +++ b/src/test/run-pass/trait-default-method-bound-subst.rs @@ -13,14 +13,14 @@ trait A<T> { fn g<U>(&self, x: T, y: U) -> (T, U) { (x, y) } } -impl A<int> for int { } -impl<T> A<T> for uint { } +impl A<i32> for i32 { } +impl<T> A<T> for u32 { } fn f<T, U, V: A<T>>(i: V, j: T, k: U) -> (T, U) { i.g(j, k) } pub fn main () { - assert_eq!(f(0i, 1i, 2i), (1, 2)); - assert_eq!(f(0u, 1i, 2i), (1, 2)); + assert_eq!(f(0, 1, 2), (1, 2)); + assert_eq!(f(0, 1, 2), (1, 2)); } diff --git a/src/test/run-pass/trait-default-method-bound-subst2.rs b/src/test/run-pass/trait-default-method-bound-subst2.rs index d9ba9ca9220..1ea3879e7fa 100644 --- a/src/test/run-pass/trait-default-method-bound-subst2.rs +++ b/src/test/run-pass/trait-default-method-bound-subst2.rs @@ -20,5 +20,5 @@ fn f<T, V: A<T>>(i: V, j: T) -> T { } pub fn main () { - assert_eq!(f(0i, 2i), 2); + assert_eq!(f(0, 2), 2); } diff --git a/src/test/run-pass/trait-default-method-bound-subst3.rs b/src/test/run-pass/trait-default-method-bound-subst3.rs index 43fb19a58ed..aff20ffe962 100644 --- a/src/test/run-pass/trait-default-method-bound-subst3.rs +++ b/src/test/run-pass/trait-default-method-bound-subst3.rs @@ -20,6 +20,6 @@ fn f<T, V: A>(i: V, j: T, k: T) -> (T, T) { } pub fn main () { - assert_eq!(f(0i, 1i, 2i), (1, 2)); - assert_eq!(f(0i, 1u8, 2u8), (1u8, 2u8)); + assert_eq!(f(0, 1, 2), (1, 2)); + assert_eq!(f(0, 1u8, 2u8), (1u8, 2u8)); } diff --git a/src/test/run-pass/trait-default-method-bound.rs b/src/test/run-pass/trait-default-method-bound.rs index 1505d48839e..8a2f1b1743b 100644 --- a/src/test/run-pass/trait-default-method-bound.rs +++ b/src/test/run-pass/trait-default-method-bound.rs @@ -20,5 +20,5 @@ fn f<T:A>(i: T) { } pub fn main () { - f(0i); + f(0); } diff --git a/src/test/run-pass/trait-default-method-xc-2.rs b/src/test/run-pass/trait-default-method-xc-2.rs index 1aa958dafc7..b28e8bd24aa 100644 --- a/src/test/run-pass/trait-default-method-xc-2.rs +++ b/src/test/run-pass/trait-default-method-xc-2.rs @@ -20,15 +20,15 @@ use aux2::{a_struct, welp}; pub fn main () { - let a = a_struct { x: 0i }; - let b = a_struct { x: 1i }; + let a = a_struct { x: 0 }; + let b = a_struct { x: 1 }; - assert_eq!(0i.g(), 10); + assert_eq!(0.g(), 10); assert_eq!(a.g(), 10); assert_eq!(a.h(), 11); assert_eq!(b.g(), 10); assert_eq!(b.h(), 11); assert_eq!(A::lurr(&a, &b), 21); - welp(&0i); + welp(&0); } diff --git a/src/test/run-pass/trait-default-method-xc.rs b/src/test/run-pass/trait-default-method-xc.rs index c4880e97c45..4745d057952 100644 --- a/src/test/run-pass/trait-default-method-xc.rs +++ b/src/test/run-pass/trait-default-method-xc.rs @@ -52,35 +52,35 @@ impl TestEquality for stuff::thing { pub fn main() { // Some tests of random things - f(0i); + f(0); - assert_eq!(A::lurr(&0i, &1i), 21); + assert_eq!(A::lurr(&0, &1), 21); let a = stuff::thing { x: 0 }; let b = stuff::thing { x: 1 }; let c = Something { x: 1 }; - assert_eq!(0i.g(), 10); + assert_eq!(0.g(), 10); assert_eq!(a.g(), 10); assert_eq!(a.h(), 11); assert_eq!(c.h(), 11); - assert_eq!(0i.thing(3.14f64, 1i), (3.14f64, 1i)); - assert_eq!(B::staticthing(&0i, 3.14f64, 1i), (3.14f64, 1i)); - assert_eq!(B::<f64>::staticthing::<int>(&0i, 3.14, 1), (3.14, 1)); + assert_eq!(0.thing(3.14f64, 1), (3.14f64, 1)); + assert_eq!(B::staticthing(&0, 3.14f64, 1), (3.14f64, 1)); + assert_eq!(B::<f64>::staticthing::<int>(&0, 3.14, 1), (3.14, 1)); - assert_eq!(g(0i, 3.14f64, 1i), (3.14f64, 1i)); - assert_eq!(g(false, 3.14f64, 1i), (3.14, 1)); + assert_eq!(g(0, 3.14f64, 1), (3.14f64, 1)); + assert_eq!(g(false, 3.14f64, 1), (3.14, 1)); // Trying out a real one - assert!(12i.test_neq(&10i)); - assert!(!10i.test_neq(&10i)); + assert!(12.test_neq(&10)); + assert!(!10.test_neq(&10)); assert!(a.test_neq(&b)); assert!(!a.test_neq(&a)); - assert!(neq(&12i, &10i)); - assert!(!neq(&10i, &10i)); + assert!(neq(&12, &10)); + assert!(!neq(&10, &10)); assert!(neq(&a, &b)); assert!(!neq(&a, &a)); } diff --git a/src/test/run-pass/trait-generic.rs b/src/test/run-pass/trait-generic.rs index d4c1b688b47..e79b22f70cf 100644 --- a/src/test/run-pass/trait-generic.rs +++ b/src/test/run-pass/trait-generic.rs @@ -44,7 +44,7 @@ fn bar<U:to_str,T:map<U>>(x: T) -> Vec<String> { } pub fn main() { - assert_eq!(foo(vec!(1i)), vec!("hi".to_string())); + assert_eq!(foo(vec!(1)), vec!("hi".to_string())); assert_eq!(bar::<int, Vec<int> >(vec!(4, 5)), vec!("4".to_string(), "5".to_string())); assert_eq!(bar::<String, Vec<String> >(vec!("x".to_string(), "y".to_string())), vec!("x".to_string(), "y".to_string())); diff --git a/src/test/run-pass/trait-impl.rs b/src/test/run-pass/trait-impl.rs index 003686c0bbe..16ef315c206 100644 --- a/src/test/run-pass/trait-impl.rs +++ b/src/test/run-pass/trait-impl.rs @@ -33,7 +33,7 @@ struct Foo; impl<'a> Bar<'a> for Foo {} fn main() { - let x: &T = &42i; + let x: &T = &42; x.foo(); T::foo(x); diff --git a/src/test/run-pass/trait-inheritance-num.rs b/src/test/run-pass/trait-inheritance-num.rs index e606018feb9..9a30d51f4c5 100644 --- a/src/test/run-pass/trait-inheritance-num.rs +++ b/src/test/run-pass/trait-inheritance-num.rs @@ -16,7 +16,7 @@ pub trait NumExt: NumCast + PartialEq + PartialOrd {} pub trait FloatExt: NumExt {} -fn greater_than_one<T: NumExt>(n: &T) -> bool { *n > NumCast::from(1i).unwrap() } -fn greater_than_one_float<T: FloatExt>(n: &T) -> bool { *n > NumCast::from(1i).unwrap() } +fn greater_than_one<T: NumExt>(n: &T) -> bool { *n > NumCast::from(1).unwrap() } +fn greater_than_one_float<T: FloatExt>(n: &T) -> bool { *n > NumCast::from(1).unwrap() } pub fn main() {} diff --git a/src/test/run-pass/trait-inheritance-num0.rs b/src/test/run-pass/trait-inheritance-num0.rs index 42eaaa09fcd..d68b6a54f71 100644 --- a/src/test/run-pass/trait-inheritance-num0.rs +++ b/src/test/run-pass/trait-inheritance-num0.rs @@ -22,7 +22,7 @@ pub trait Num { pub trait NumExt: NumCast + PartialOrd { } fn greater_than_one<T:NumExt>(n: &T) -> bool { - n.gt(&NumCast::from(1i).unwrap()) + n.gt(&NumCast::from(1).unwrap()) } pub fn main() {} diff --git a/src/test/run-pass/trait-inheritance-num1.rs b/src/test/run-pass/trait-inheritance-num1.rs index 9407afbdd6b..15fb5df4626 100644 --- a/src/test/run-pass/trait-inheritance-num1.rs +++ b/src/test/run-pass/trait-inheritance-num1.rs @@ -14,7 +14,7 @@ use std::num::NumCast; pub trait NumExt: NumCast + PartialOrd { } fn greater_than_one<T:NumExt>(n: &T) -> bool { - *n > NumCast::from(1i).unwrap() + *n > NumCast::from(1).unwrap() } pub fn main() {} diff --git a/src/test/run-pass/trait-inheritance-num3.rs b/src/test/run-pass/trait-inheritance-num3.rs index bd93223093a..09015d983ea 100644 --- a/src/test/run-pass/trait-inheritance-num3.rs +++ b/src/test/run-pass/trait-inheritance-num3.rs @@ -16,7 +16,7 @@ pub trait NumExt: PartialEq + PartialOrd + NumCast {} impl NumExt for f32 {} fn num_eq_one<T: NumExt>(n: T) { - println!("{}", n == NumCast::from(1i).unwrap()) + println!("{}", n == NumCast::from(1).unwrap()) } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-num5.rs b/src/test/run-pass/trait-inheritance-num5.rs index 4c79600e2e9..a21026839a7 100644 --- a/src/test/run-pass/trait-inheritance-num5.rs +++ b/src/test/run-pass/trait-inheritance-num5.rs @@ -17,7 +17,7 @@ impl NumExt for f32 {} impl NumExt for int {} fn num_eq_one<T:NumExt>() -> T { - NumCast::from(1i).unwrap() + NumCast::from(1).unwrap() } pub fn main() { diff --git a/src/test/run-pass/trait-inheritance-visibility.rs b/src/test/run-pass/trait-inheritance-visibility.rs index dc84cbfb09a..3cdedd884a4 100644 --- a/src/test/run-pass/trait-inheritance-visibility.rs +++ b/src/test/run-pass/trait-inheritance-visibility.rs @@ -24,5 +24,5 @@ fn f<T:Quux>(x: &T) { } pub fn main() { - f(&0i) + f(&0) } diff --git a/src/test/run-pass/trait-to-str.rs b/src/test/run-pass/trait-to-str.rs index 9b910d24bdc..ea8a5a28c34 100644 --- a/src/test/run-pass/trait-to-str.rs +++ b/src/test/run-pass/trait-to-str.rs @@ -31,15 +31,15 @@ impl<T:to_str> to_str for Vec<T> { pub fn main() { assert!(1.to_string_() == "1".to_string()); - assert!((vec!(2i, 3, 4)).to_string_() == "[2, 3, 4]".to_string()); + assert!((vec!(2, 3, 4)).to_string_() == "[2, 3, 4]".to_string()); fn indirect<T:to_str>(x: T) -> String { format!("{}!", x.to_string_()) } - assert!(indirect(vec!(10i, 20)) == "[10, 20]!".to_string()); + assert!(indirect(vec!(10, 20)) == "[10, 20]!".to_string()); fn indirect2<T:to_str>(x: T) -> String { indirect(x) } - assert!(indirect2(vec!(1i)) == "[1]!".to_string()); + assert!(indirect2(vec!(1)) == "[1]!".to_string()); } diff --git a/src/test/run-pass/traits-conditional-dispatch.rs b/src/test/run-pass/traits-conditional-dispatch.rs index 7e2b7ae0663..5af2d4ee806 100644 --- a/src/test/run-pass/traits-conditional-dispatch.rs +++ b/src/test/run-pass/traits-conditional-dispatch.rs @@ -35,5 +35,5 @@ fn main() { assert_eq!(get_it(&1_u32), 1_u32); assert_eq!(get_it(&1_u16), 1_u16); assert_eq!(get_it(&Some(1_u16)), Some(1_u16)); - assert_eq!(get_it(&box 1i), box 1i); + assert_eq!(get_it(&box 1), box 1); } diff --git a/src/test/run-pass/trivial-message.rs b/src/test/run-pass/trivial-message.rs index df8efb42e30..fd60c614638 100644 --- a/src/test/run-pass/trivial-message.rs +++ b/src/test/run-pass/trivial-message.rs @@ -17,7 +17,7 @@ use std::sync::mpsc::channel; pub fn main() { let (tx, rx) = channel(); - tx.send(42i); + tx.send(42); let r = rx.recv(); println!("{:?}", r); } diff --git a/src/test/run-pass/tuple-index-fat-types.rs b/src/test/run-pass/tuple-index-fat-types.rs index eccd841e357..924b861a911 100644 --- a/src/test/run-pass/tuple-index-fat-types.rs +++ b/src/test/run-pass/tuple-index-fat-types.rs @@ -11,11 +11,11 @@ struct Foo<'a>(&'a [int]); fn main() { - let x: &[int] = &[1i, 2, 3]; + let x: &[int] = &[1, 2, 3]; let y = (x,); assert_eq!(y.0, x); - let x: &[int] = &[1i, 2, 3]; + let x: &[int] = &[1, 2, 3]; let y = Foo(x); assert_eq!(y.0, x); } diff --git a/src/test/run-pass/tuple-index.rs b/src/test/run-pass/tuple-index.rs index 78e0cad4712..abdf6172779 100644 --- a/src/test/run-pass/tuple-index.rs +++ b/src/test/run-pass/tuple-index.rs @@ -24,7 +24,7 @@ fn main() { } assert_eq!(x.1, 0); - let mut x = (3i, 2i); + let mut x = (3, 2); assert_eq!(x.0, 3); assert_eq!(x.1, 2); x.0 += 5; diff --git a/src/test/run-pass/type-param-constraints.rs b/src/test/run-pass/type-param-constraints.rs index 3fcb04d6848..7d1fad5d281 100644 --- a/src/test/run-pass/type-param-constraints.rs +++ b/src/test/run-pass/type-param-constraints.rs @@ -33,12 +33,12 @@ pub fn main() { p_foo(r(10)); p_foo(box r(10)); - p_foo(box 10i); - p_foo(10i); + p_foo(box 10); + p_foo(10); - s_foo(box 10i); - s_foo(10i); + s_foo(box 10); + s_foo(10); - u_foo(box 10i); - u_foo(10i); + u_foo(box 10); + u_foo(10); } diff --git a/src/test/run-pass/typestate-cfg-nesting.rs b/src/test/run-pass/typestate-cfg-nesting.rs index f1e40cc3e58..37d06bf4f83 100644 --- a/src/test/run-pass/typestate-cfg-nesting.rs +++ b/src/test/run-pass/typestate-cfg-nesting.rs @@ -12,12 +12,12 @@ #![allow(unused_variable)] fn f() { - let x = 10i; let mut y = 11i; + let x = 10; let mut y = 11; if true { match x { _ => { y = x; } } } else { } } pub fn main() { - let x = 10i; - let mut y = 11i; + let x = 10; + let mut y = 11; if true { while false { y = x; } } else { } } diff --git a/src/test/run-pass/typestate-multi-decl.rs b/src/test/run-pass/typestate-multi-decl.rs index cbb0dcc8f2b..42910c47005 100644 --- a/src/test/run-pass/typestate-multi-decl.rs +++ b/src/test/run-pass/typestate-multi-decl.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - let (x, y) = (10i, 20i); + let (x, y) = (10, 20); let z = x + y; assert!((z == 30)); } diff --git a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs index fdd85b71cd2..5bebc70ca54 100644 --- a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs +++ b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs @@ -22,5 +22,5 @@ fn doit<T,F>(val: T, f: &F) } pub fn main() { - doit(0i, &|&: x /*: int*/ | { x.to_int(); }); + doit(0, &|&: x /*: int*/ | { x.to_int(); }); } diff --git a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs index cce8cd64a14..a678c7a852f 100644 --- a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs +++ b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs @@ -18,5 +18,5 @@ use std::num::ToPrimitive; fn doit<T>(val: T, f: &Fn(T)) { f.call((val,)) } pub fn main() { - doit(0i, &|&: x /*: int*/ | { x.to_int(); }); + doit(0, &|&: x /*: int*/ | { x.to_int(); }); } diff --git a/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs b/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs index 8497bf7f987..6e0b3625a2e 100644 --- a/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs +++ b/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs @@ -22,5 +22,5 @@ fn doit<T,F>(val: T, f: &F) } pub fn main() { - doit(0i, &|&: x /*: int*/ | { x.to_int(); }); + doit(0, &|&: x /*: int*/ | { x.to_int(); }); } diff --git a/src/test/run-pass/unboxed-closures-prelude.rs b/src/test/run-pass/unboxed-closures-prelude.rs index 915715727e8..f9fc5770a38 100644 --- a/src/test/run-pass/unboxed-closures-prelude.rs +++ b/src/test/run-pass/unboxed-closures-prelude.rs @@ -16,10 +16,10 @@ fn main() { let task: Box<Fn(int) -> int> = box |&: x| x; - task.call((0i, )); + task.call((0, )); let mut task: Box<FnMut(int) -> int> = box |&mut: x| x; - task(0i); + task(0); call(|:x| x, 22); } diff --git a/src/test/run-pass/unboxed-closures-static-call-fn-once.rs b/src/test/run-pass/unboxed-closures-static-call-fn-once.rs index 780a1e6cdf0..e4b35aada9f 100644 --- a/src/test/run-pass/unboxed-closures-static-call-fn-once.rs +++ b/src/test/run-pass/unboxed-closures-static-call-fn-once.rs @@ -12,6 +12,6 @@ fn main() { let onetime = |: x| x; - onetime(0i); + onetime(0); } diff --git a/src/test/run-pass/unique-assign-copy.rs b/src/test/run-pass/unique-assign-copy.rs index 9e3d9544d42..c19063fe464 100644 --- a/src/test/run-pass/unique-assign-copy.rs +++ b/src/test/run-pass/unique-assign-copy.rs @@ -12,7 +12,7 @@ #![feature(box_syntax)] pub fn main() { - let mut i = box 1i; + let mut i = box 1; // Should be a copy let mut j; j = i.clone(); diff --git a/src/test/run-pass/unique-assign-drop.rs b/src/test/run-pass/unique-assign-drop.rs index 81c4b6ab7e5..241258f089c 100644 --- a/src/test/run-pass/unique-assign-drop.rs +++ b/src/test/run-pass/unique-assign-drop.rs @@ -13,8 +13,8 @@ #![feature(box_syntax)] pub fn main() { - let i = box 1i; - let mut j = box 2i; + let i = box 1; + let mut j = box 2; // Should drop the previous value of j j = i; assert_eq!(*j, 1); diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs index 7c9bbd64171..c8abb080848 100644 --- a/src/test/run-pass/unique-assign-generic.rs +++ b/src/test/run-pass/unique-assign-generic.rs @@ -18,6 +18,6 @@ fn f<T>(t: T) -> T { } pub fn main() { - let t = f(box 100i); - assert_eq!(t, box 100i); + let t = f(box 100); + assert_eq!(t, box 100); } diff --git a/src/test/run-pass/unique-assign.rs b/src/test/run-pass/unique-assign.rs index 199657fd995..cbcb6afb4c8 100644 --- a/src/test/run-pass/unique-assign.rs +++ b/src/test/run-pass/unique-assign.rs @@ -13,6 +13,6 @@ pub fn main() { let mut i; - i = box 1i; + i = box 1; assert_eq!(*i, 1); } diff --git a/src/test/run-pass/unique-autoderef-index.rs b/src/test/run-pass/unique-autoderef-index.rs index 1c7b4c534ed..30c4b2d7b56 100644 --- a/src/test/run-pass/unique-autoderef-index.rs +++ b/src/test/run-pass/unique-autoderef-index.rs @@ -12,6 +12,6 @@ #![feature(box_syntax)] pub fn main() { - let i = box vec!(100i); - assert_eq!((*i)[0], 100i); + let i = box vec!(100); + assert_eq!((*i)[0], 100); } diff --git a/src/test/run-pass/unique-cmp.rs b/src/test/run-pass/unique-cmp.rs index dba4d8db849..a2962dc00d5 100644 --- a/src/test/run-pass/unique-cmp.rs +++ b/src/test/run-pass/unique-cmp.rs @@ -12,10 +12,10 @@ #![feature(box_syntax)] pub fn main() { - let i = box 100i; - assert!(i == box 100i); - assert!(i < box 101i); - assert!(i <= box 100i); - assert!(i > box 99i); - assert!(i >= box 99i); + let i = box 100; + assert!(i == box 100); + assert!(i < box 101); + assert!(i <= box 100); + assert!(i > box 99); + assert!(i >= box 99); } diff --git a/src/test/run-pass/unique-create.rs b/src/test/run-pass/unique-create.rs index cec74d251b3..975f1e9da82 100644 --- a/src/test/run-pass/unique-create.rs +++ b/src/test/run-pass/unique-create.rs @@ -12,9 +12,9 @@ #![feature(box_syntax)] pub fn main() { - box 100i; + box 100; } fn vec() { - vec!(0i); + vec!(0); } diff --git a/src/test/run-pass/unique-decl-init-copy.rs b/src/test/run-pass/unique-decl-init-copy.rs index d0ad03b773c..3af38784add 100644 --- a/src/test/run-pass/unique-decl-init-copy.rs +++ b/src/test/run-pass/unique-decl-init-copy.rs @@ -12,11 +12,11 @@ #![feature(box_syntax)] pub fn main() { - let mut i = box 1i; + let mut i = box 1; // Should be a copy let mut j = i.clone(); - *i = 2i; - *j = 3i; - assert_eq!(*i, 2i); - assert_eq!(*j, 3i); + *i = 2; + *j = 3; + assert_eq!(*i, 2); + assert_eq!(*j, 3); } diff --git a/src/test/run-pass/unique-decl-init.rs b/src/test/run-pass/unique-decl-init.rs index d7c19eb6358..c9192748809 100644 --- a/src/test/run-pass/unique-decl-init.rs +++ b/src/test/run-pass/unique-decl-init.rs @@ -12,7 +12,7 @@ #![feature(box_syntax)] pub fn main() { - let i = box 1i; + let i = box 1; let j = i; assert_eq!(*j, 1); } diff --git a/src/test/run-pass/unique-decl-move.rs b/src/test/run-pass/unique-decl-move.rs index 0acdc8f3b80..96dd9f51fbe 100644 --- a/src/test/run-pass/unique-decl-move.rs +++ b/src/test/run-pass/unique-decl-move.rs @@ -12,7 +12,7 @@ #![feature(box_syntax)] pub fn main() { - let i = box 100i; + let i = box 100; let j = i; assert_eq!(*j, 100); } diff --git a/src/test/run-pass/unique-deref.rs b/src/test/run-pass/unique-deref.rs index 752ea830aa5..41d3b87a003 100644 --- a/src/test/run-pass/unique-deref.rs +++ b/src/test/run-pass/unique-deref.rs @@ -12,6 +12,6 @@ #![feature(box_syntax)] pub fn main() { - let i = box 100i; + let i = box 100; assert_eq!(*i, 100); } diff --git a/src/test/run-pass/unique-drop-complex.rs b/src/test/run-pass/unique-drop-complex.rs index ec2c9f8c666..c5a0a4df275 100644 --- a/src/test/run-pass/unique-drop-complex.rs +++ b/src/test/run-pass/unique-drop-complex.rs @@ -12,5 +12,5 @@ #![feature(box_syntax)] pub fn main() { - let _x = box vec!(0i,0,0,0,0); + let _x = box vec!(0,0,0,0,0); } diff --git a/src/test/run-pass/unique-fn-arg-move.rs b/src/test/run-pass/unique-fn-arg-move.rs index 0e47d39e55f..1b3f7e72a4d 100644 --- a/src/test/run-pass/unique-fn-arg-move.rs +++ b/src/test/run-pass/unique-fn-arg-move.rs @@ -16,6 +16,6 @@ fn f(i: Box<int>) { } pub fn main() { - let i = box 100i; + let i = box 100; f(i); } diff --git a/src/test/run-pass/unique-in-vec-copy.rs b/src/test/run-pass/unique-in-vec-copy.rs index 4620815e74e..3bde79fdce0 100644 --- a/src/test/run-pass/unique-in-vec-copy.rs +++ b/src/test/run-pass/unique-in-vec-copy.rs @@ -12,7 +12,7 @@ #![feature(box_syntax)] pub fn main() { - let mut a = vec!(box 10i); + let mut a = vec!(box 10); let b = a.clone(); assert_eq!(*a[0], 10); diff --git a/src/test/run-pass/unique-in-vec.rs b/src/test/run-pass/unique-in-vec.rs index 389ca2c18b1..05b0c7244de 100644 --- a/src/test/run-pass/unique-in-vec.rs +++ b/src/test/run-pass/unique-in-vec.rs @@ -12,6 +12,6 @@ #![feature(box_syntax)] pub fn main() { - let vect = vec!(box 100i); + let vect = vec!(box 100); assert!(vect[0] == box 100); } diff --git a/src/test/run-pass/unique-init.rs b/src/test/run-pass/unique-init.rs index b36d08364a2..d3f13f1609f 100644 --- a/src/test/run-pass/unique-init.rs +++ b/src/test/run-pass/unique-init.rs @@ -12,5 +12,5 @@ #![feature(box_syntax)] pub fn main() { - let _i = box 100i; + let _i = box 100; } diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs index 56f7a3f7990..4c93c379b48 100644 --- a/src/test/run-pass/unique-kinds.rs +++ b/src/test/run-pass/unique-kinds.rs @@ -23,11 +23,11 @@ fn sendable() { assert!(i != j); } - let i = box 100i; - let j = box 100i; + let i = box 100; + let j = box 100; f(i, j); - let i = box 100i; - let j = box 101i; + let i = box 100; + let j = box 101; g(i, j); } @@ -41,11 +41,11 @@ fn copyable() { assert!(i != j); } - let i = box 100i; - let j = box 100i; + let i = box 100; + let j = box 100; f(i, j); - let i = box 100i; - let j = box 101i; + let i = box 100; + let j = box 101; g(i, j); } @@ -59,11 +59,11 @@ fn noncopyable() { assert!(i != j); } - let i = box 100i; - let j = box 100i; + let i = box 100; + let j = box 100; f(i, j); - let i = box 100i; - let j = box 101i; + let i = box 100; + let j = box 101; g(i, j); } diff --git a/src/test/run-pass/unique-log.rs b/src/test/run-pass/unique-log.rs index 05579796dab..4b21b949f88 100644 --- a/src/test/run-pass/unique-log.rs +++ b/src/test/run-pass/unique-log.rs @@ -12,6 +12,6 @@ #![feature(box_syntax)] pub fn main() { - let i = box 100i; + let i = box 100; println!("{}", i); } diff --git a/src/test/run-pass/unique-move-drop.rs b/src/test/run-pass/unique-move-drop.rs index 1388c6c5d2b..705b9d6e92c 100644 --- a/src/test/run-pass/unique-move-drop.rs +++ b/src/test/run-pass/unique-move-drop.rs @@ -13,8 +13,8 @@ #![feature(box_syntax)] pub fn main() { - let i = box 100i; - let j = box 200i; + let i = box 100; + let j = box 200; let j = i; assert_eq!(*j, 100); } diff --git a/src/test/run-pass/unique-move-temp.rs b/src/test/run-pass/unique-move-temp.rs index af82d3e14ea..b6c24f5be28 100644 --- a/src/test/run-pass/unique-move-temp.rs +++ b/src/test/run-pass/unique-move-temp.rs @@ -13,6 +13,6 @@ pub fn main() { let mut i; - i = box 100i; + i = box 100; assert_eq!(*i, 100); } diff --git a/src/test/run-pass/unique-move.rs b/src/test/run-pass/unique-move.rs index 791c4799bf0..ed13bf6a5c4 100644 --- a/src/test/run-pass/unique-move.rs +++ b/src/test/run-pass/unique-move.rs @@ -12,7 +12,7 @@ #![feature(box_syntax)] pub fn main() { - let i = box 100i; + let i = box 100; let mut j; j = i; assert_eq!(*j, 100); diff --git a/src/test/run-pass/unique-mutable.rs b/src/test/run-pass/unique-mutable.rs index c4f860d930b..403b8bf18b8 100644 --- a/src/test/run-pass/unique-mutable.rs +++ b/src/test/run-pass/unique-mutable.rs @@ -12,7 +12,7 @@ #![feature(box_syntax)] pub fn main() { - let mut i = box 0i; + let mut i = box 0; *i = 1; assert_eq!(*i, 1); } diff --git a/src/test/run-pass/unique-send.rs b/src/test/run-pass/unique-send.rs index 13728585455..2a462e9cdd8 100644 --- a/src/test/run-pass/unique-send.rs +++ b/src/test/run-pass/unique-send.rs @@ -15,7 +15,7 @@ use std::sync::mpsc::channel; pub fn main() { let (tx, rx) = channel(); - tx.send(box 100i).unwrap(); + tx.send(box 100).unwrap(); let v = rx.recv().unwrap(); - assert_eq!(v, box 100i); + assert_eq!(v, box 100); } diff --git a/src/test/run-pass/unique-swap.rs b/src/test/run-pass/unique-swap.rs index cd3b59a69ba..2adb9c22f60 100644 --- a/src/test/run-pass/unique-swap.rs +++ b/src/test/run-pass/unique-swap.rs @@ -14,9 +14,9 @@ use std::mem::swap; pub fn main() { - let mut i = box 100i; - let mut j = box 200i; + let mut i = box 100; + let mut j = box 200; swap(&mut i, &mut j); - assert_eq!(i, box 200i); - assert_eq!(j, box 100i); + assert_eq!(i, box 200); + assert_eq!(j, box 100); } diff --git a/src/test/run-pass/unreachable-code.rs b/src/test/run-pass/unreachable-code.rs index a9ac78c5d76..a28dc2c1f15 100644 --- a/src/test/run-pass/unreachable-code.rs +++ b/src/test/run-pass/unreachable-code.rs @@ -24,7 +24,7 @@ fn call_id_2() { id(true) && id(return); } fn call_id_3() { id(return) && id(return); } fn ret_guard() { - match 2i { + match 2 { x if (return) => { x; } _ => {} } diff --git a/src/test/run-pass/unused-move-capture.rs b/src/test/run-pass/unused-move-capture.rs index 27945f46920..a2d1b8780aa 100644 --- a/src/test/run-pass/unused-move-capture.rs +++ b/src/test/run-pass/unused-move-capture.rs @@ -12,7 +12,7 @@ #![feature(box_syntax)] pub fn main() { - let _x = box 1i; + let _x = box 1; let lam_move = |&:| {}; lam_move(); } diff --git a/src/test/run-pass/unused-move.rs b/src/test/run-pass/unused-move.rs index 22201c7d83f..d053b03a2ca 100644 --- a/src/test/run-pass/unused-move.rs +++ b/src/test/run-pass/unused-move.rs @@ -18,6 +18,6 @@ pub fn main() { - let y = box 1i; + let y = box 1; y; } diff --git a/src/test/run-pass/unwind-unique.rs b/src/test/run-pass/unwind-unique.rs index 74802c156a2..ea52802d245 100644 --- a/src/test/run-pass/unwind-unique.rs +++ b/src/test/run-pass/unwind-unique.rs @@ -14,7 +14,7 @@ use std::thread::Thread; fn f() { - let _a = box 0i; + let _a = box 0; panic!(); } diff --git a/src/test/run-pass/use-uninit-match.rs b/src/test/run-pass/use-uninit-match.rs index 3f23d714c0f..efa6a2c5834 100644 --- a/src/test/run-pass/use-uninit-match.rs +++ b/src/test/run-pass/use-uninit-match.rs @@ -21,4 +21,4 @@ fn foo<T>(o: myoption<T>) -> int { enum myoption<T> { none, some(T), } -pub fn main() { println!("{}", 5i); } +pub fn main() { println!("{}", 5); } diff --git a/src/test/run-pass/use-uninit-match2.rs b/src/test/run-pass/use-uninit-match2.rs index de5b32dd176..f2b487b7034 100644 --- a/src/test/run-pass/use-uninit-match2.rs +++ b/src/test/run-pass/use-uninit-match2.rs @@ -21,4 +21,4 @@ fn foo<T>(o: myoption<T>) -> int { enum myoption<T> { none, some(T), } -pub fn main() { println!("{}", 5i); } +pub fn main() { println!("{}", 5); } diff --git a/src/test/run-pass/utf8_idents.rs b/src/test/run-pass/utf8_idents.rs index c99c394969c..0e6f20358aa 100644 --- a/src/test/run-pass/utf8_idents.rs +++ b/src/test/run-pass/utf8_idents.rs @@ -26,25 +26,25 @@ fn საჭმელად_გემრიელი_სადილი() -> int // Lunch in several languages. - let ランチ = 10i; - let 午餐 = 10i; + let ランチ = 10; + let 午餐 = 10; - let ארוחת_צהריי = 10i; + let ארוחת_צהריי = 10; let غداء = 10u; - let լանչ = 10i; - let обед = 10i; - let абед = 10i; - let μεσημεριανό = 10i; - let hádegismatur = 10i; - let ручек = 10i; + let լանչ = 10; + let обед = 10; + let абед = 10; + let μεσημεριανό = 10; + let hádegismatur = 10; + let ручек = 10; - let ăn_trưa = 10i; - let อาหารกลางวัน = 10i; + let ăn_trưa = 10; + let อาหารกลางวัน = 10; // Lunchy arithmetic, mm. assert_eq!(hádegismatur * ручек * обед, 1000); - assert_eq!(10i, ארוחת_צהריי); + assert_eq!(10, ארוחת_צהריי); assert_eq!(ランチ + 午餐 + μεσημεριανό, 30); assert_eq!(ăn_trưa + อาหารกลางวัน, 20); return (абед + լանչ) >> غداء; diff --git a/src/test/run-pass/variadic-ffi.rs b/src/test/run-pass/variadic-ffi.rs index 9600a242ca1..a729fedb271 100644 --- a/src/test/run-pass/variadic-ffi.rs +++ b/src/test/run-pass/variadic-ffi.rs @@ -35,7 +35,7 @@ pub fn main() { // Call with variable number of arguments let c = CString::from_slice(b"%d %f %c %s\n"); check("42 42.500000 a %d %f %c %s\n\n", |s| { - sprintf(s, c.as_ptr(), 42i, 42.5f64, 'a' as c_int, c.as_ptr()); + sprintf(s, c.as_ptr(), 42, 42.5f64, 'a' as c_int, c.as_ptr()); }); // Make a function pointer @@ -50,7 +50,7 @@ pub fn main() { // Call with variable number of arguments let c = CString::from_slice(b"%d %f %c %s\n"); check("42 42.500000 a %d %f %c %s\n\n", |s| { - sprintf(s, c.as_ptr(), 42i, 42.5f64, 'a' as c_int, c.as_ptr()); + sprintf(s, c.as_ptr(), 42, 42.5f64, 'a' as c_int, c.as_ptr()); }); } diff --git a/src/test/run-pass/vec-growth.rs b/src/test/run-pass/vec-growth.rs index d5e5f94d261..b8626b9c8a9 100644 --- a/src/test/run-pass/vec-growth.rs +++ b/src/test/run-pass/vec-growth.rs @@ -10,11 +10,11 @@ pub fn main() { - let mut v = vec!(1i); - v.push(2i); - v.push(3i); - v.push(4i); - v.push(5i); + let mut v = vec!(1); + v.push(2); + v.push(3); + v.push(4); + v.push(5); assert_eq!(v[0], 1); assert_eq!(v[1], 2); assert_eq!(v[2], 3); diff --git a/src/test/run-pass/vec-macro-with-brackets.rs b/src/test/run-pass/vec-macro-with-brackets.rs index a263501f8fe..5d1f43fb230 100644 --- a/src/test/run-pass/vec-macro-with-brackets.rs +++ b/src/test/run-pass/vec-macro-with-brackets.rs @@ -17,5 +17,5 @@ macro_rules! vec [ ]; pub fn main() { - let my_vec = vec![1i, 2, 3, 4, 5]; + let my_vec = vec![1, 2, 3, 4, 5]; } diff --git a/src/test/run-pass/vec-macro-with-trailing-comma.rs b/src/test/run-pass/vec-macro-with-trailing-comma.rs index 80c2a5fe83e..07033d60497 100644 --- a/src/test/run-pass/vec-macro-with-trailing-comma.rs +++ b/src/test/run-pass/vec-macro-with-trailing-comma.rs @@ -10,6 +10,6 @@ pub fn main() { - assert_eq!(vec!(1i), vec!(1i,)); - assert_eq!(vec!(1i, 2, 3), vec!(1i, 2, 3,)); + assert_eq!(vec!(1), vec!(1,)); + assert_eq!(vec!(1, 2, 3), vec!(1, 2, 3,)); } diff --git a/src/test/run-pass/vec-matching-autoslice.rs b/src/test/run-pass/vec-matching-autoslice.rs index 6476f734ae6..4ed73dc2301 100644 --- a/src/test/run-pass/vec-matching-autoslice.rs +++ b/src/test/run-pass/vec-matching-autoslice.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - let x = [1i, 2, 3]; + let x = [1, 2, 3]; match x { [2, _, _] => panic!(), [1, a, b] => { @@ -18,7 +18,7 @@ pub fn main() { [_, _, _] => panic!(), } - let y = ([(1i, true), (2i, false)], 0.5f64); + let y = ([(1, true), (2, false)], 0.5f64); match y { ([(1, a), (b, false)], _) => { assert_eq!(a, true); diff --git a/src/test/run-pass/vec-matching-fixed.rs b/src/test/run-pass/vec-matching-fixed.rs index a1a14823ff5..6ef1dc4ea26 100644 --- a/src/test/run-pass/vec-matching-fixed.rs +++ b/src/test/run-pass/vec-matching-fixed.rs @@ -11,7 +11,7 @@ #![feature(advanced_slice_patterns)] fn a() { - let x = [1i, 2, 3]; + let x = [1, 2, 3]; match x { [1, 2, 4] => unreachable!(), [0, 2, 3, ..] => unreachable!(), diff --git a/src/test/run-pass/vec-matching-fold.rs b/src/test/run-pass/vec-matching-fold.rs index 57660183333..e72170cb730 100644 --- a/src/test/run-pass/vec-matching-fold.rs +++ b/src/test/run-pass/vec-matching-fold.rs @@ -39,11 +39,11 @@ fn foldr<T, U, F>(values: &[T], } pub fn main() { - let x = &[1i, 2, 3, 4, 5]; + let x = &[1, 2, 3, 4, 5]; - let product = foldl(x, 1i, |a, b| a * *b); + let product = foldl(x, 1, |a, b| a * *b); assert_eq!(product, 120); - let sum = foldr(x, 0i, |a, b| *a + b); + let sum = foldr(x, 0, |a, b| *a + b); assert_eq!(sum, 15); } diff --git a/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs b/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs index a140399447b..64309906156 100644 --- a/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs +++ b/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - let x = &[1i, 2, 3, 4, 5]; + let x = &[1, 2, 3, 4, 5]; let x: &[int] = &[1, 2, 3, 4, 5]; if !x.is_empty() { let el = match x { diff --git a/src/test/run-pass/vec-matching.rs b/src/test/run-pass/vec-matching.rs index 77226df7fa2..8dcf4612f47 100644 --- a/src/test/run-pass/vec-matching.rs +++ b/src/test/run-pass/vec-matching.rs @@ -11,7 +11,7 @@ #![feature(advanced_slice_patterns)] fn a() { - let x = [1i]; + let x = [1]; match x { [a] => { assert_eq!(a, 1); @@ -20,7 +20,7 @@ fn a() { } fn b() { - let x = [1i, 2, 3]; + let x = [1, 2, 3]; match x { [a, b, c..] => { assert_eq!(a, 1); @@ -55,7 +55,7 @@ fn b() { } fn c() { - let x = [1i]; + let x = [1]; match x { [2, ..] => panic!(), [..] => () @@ -63,18 +63,18 @@ fn c() { } fn d() { - let x = [1i, 2, 3]; + let x = [1, 2, 3]; let branch = match x { - [1, 1, ..] => 0i, - [1, 2, 3, ..] => 1i, - [1, 2, ..] => 2i, + [1, 1, ..] => 0, + [1, 2, 3, ..] => 1, + [1, 2, ..] => 2, _ => 3 }; assert_eq!(branch, 1); } fn e() { - let x: &[int] = &[1i, 2, 3]; + let x: &[int] = &[1, 2, 3]; match x { [1, 2] => (), [..] => () diff --git a/src/test/run-pass/vec-push.rs b/src/test/run-pass/vec-push.rs index fe0f92a0c11..33f01c5bd41 100644 --- a/src/test/run-pass/vec-push.rs +++ b/src/test/run-pass/vec-push.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pub fn main() { let mut v = vec!(1i, 2, 3); v.push(1); } +pub fn main() { let mut v = vec!(1, 2, 3); v.push(1); } diff --git a/src/test/run-pass/vec-repeat-with-cast.rs b/src/test/run-pass/vec-repeat-with-cast.rs index 97a443cb3b8..22ca6c37a8e 100644 --- a/src/test/run-pass/vec-repeat-with-cast.rs +++ b/src/test/run-pass/vec-repeat-with-cast.rs @@ -8,4 +8,4 @@ // option. This file may not be copied, modified, or distributed // except according to those terms. -pub fn main() { let _a = [0i; 1 as uint]; } +pub fn main() { let _a = [0; 1 as uint]; } diff --git a/src/test/run-pass/vec-slice.rs b/src/test/run-pass/vec-slice.rs index 374913e3cfd..5375e54e27f 100644 --- a/src/test/run-pass/vec-slice.rs +++ b/src/test/run-pass/vec-slice.rs @@ -9,7 +9,7 @@ // except according to those terms. pub fn main() { - let v = vec!(1i,2,3,4,5); + let v = vec![1,2,3,4,5]; let v2 = &v[1..3]; assert_eq!(v2[0], 2); assert_eq!(v2[1], 3); diff --git a/src/test/run-pass/vec-to_str.rs b/src/test/run-pass/vec-to_str.rs index 31f26126242..5d132b2a749 100644 --- a/src/test/run-pass/vec-to_str.rs +++ b/src/test/run-pass/vec-to_str.rs @@ -9,9 +9,9 @@ // except according to those terms. pub fn main() { - assert_eq!(format!("{:?}", vec!(0i, 1)), "[0, 1]".to_string()); + assert_eq!(format!("{:?}", vec!(0, 1)), "[0, 1]".to_string()); - let foo = vec!(3i, 4); + let foo = vec!(3, 4); let bar: &[int] = &[4, 5]; assert_eq!(format!("{:?}", foo), "[3, 4]"); diff --git a/src/test/run-pass/vector-sort-panic-safe.rs b/src/test/run-pass/vector-sort-panic-safe.rs index 250bafc712d..aaefbc42d70 100644 --- a/src/test/run-pass/vector-sort-panic-safe.rs +++ b/src/test/run-pass/vector-sort-panic-safe.rs @@ -12,8 +12,8 @@ use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering}; use std::rand::{thread_rng, Rng, Rand}; use std::thread::Thread; -const REPEATS: uint = 5; -const MAX_LEN: uint = 32; +const REPEATS: usize = 5; +const MAX_LEN: usize = 32; static drop_counts: [AtomicUsize; MAX_LEN] = // FIXME #5244: AtomicUsize is not Copy. [ @@ -33,7 +33,7 @@ static drop_counts: [AtomicUsize; MAX_LEN] = static creation_count: AtomicUsize = ATOMIC_USIZE_INIT; #[derive(Clone, PartialEq, PartialOrd, Eq, Ord)] -struct DropCounter { x: uint, creation_id: uint } +struct DropCounter { x: usize, creation_id: usize } impl Rand for DropCounter { fn rand<R: Rng>(rng: &mut R) -> DropCounter { @@ -53,7 +53,7 @@ impl Drop for DropCounter { } pub fn main() { - assert!(MAX_LEN <= std::uint::BITS); + assert!(MAX_LEN <= std::usize::BITS); // len can't go above 64. for len in 2..MAX_LEN { for _ in 0..REPEATS { @@ -67,11 +67,11 @@ pub fn main() { // work out the total number of comparisons required to sort // this array... - let mut count = 0; + let mut count = 0us; main.clone().as_mut_slice().sort_by(|a, b| { count += 1; a.cmp(b) }); // ... and then panic on each and every single one. - for panic_countdown in 0i..count { + for panic_countdown in 0..count { // refresh the counters. for c in drop_counts.iter() { c.store(0, Ordering::Relaxed); diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs index c8ed1a26105..4080796b7a7 100644 --- a/src/test/run-pass/weird-exprs.rs +++ b/src/test/run-pass/weird-exprs.rs @@ -36,7 +36,7 @@ fn zombiejesus() { while (return) { if (return) { match (return) { - 1i => { + 1 => { if (return) { return } else { @@ -65,13 +65,13 @@ fn canttouchthis() -> uint { fn p() -> bool { true } let _a = (assert!((true)) == (assert!(p()))); let _c = (assert!((p())) == ()); - let _b: bool = (println!("{}", 0i) == (return 0u)); + let _b: bool = (println!("{}", 0) == (return 0u)); } fn angrydome() { loop { if break { } } - let mut i = 0i; - loop { i += 1; if i == 1 { match (continue) { 1i => { }, _ => panic!("wat") } } + let mut i = 0; + loop { i += 1; if i == 1 { match (continue) { 1 => { }, _ => panic!("wat") } } break; } } diff --git a/src/test/run-pass/where-clause-region-outlives.rs b/src/test/run-pass/where-clause-region-outlives.rs index 1ecb4b6c2dc..aa39325277e 100644 --- a/src/test/run-pass/where-clause-region-outlives.rs +++ b/src/test/run-pass/where-clause-region-outlives.rs @@ -11,7 +11,7 @@ struct A<'a, 'b> where 'a : 'b { x: &'a int, y: &'b int } fn main() { - let x = 1i; - let y = 1i; + let x = 1; + let y = 1; let a = A { x: &x, y: &y }; } diff --git a/src/test/run-pass/where-clauses-cross-crate.rs b/src/test/run-pass/where-clauses-cross-crate.rs index 648f646b637..b822abd6732 100644 --- a/src/test/run-pass/where-clauses-cross-crate.rs +++ b/src/test/run-pass/where-clauses-cross-crate.rs @@ -15,9 +15,9 @@ extern crate where_clauses_xc; use where_clauses_xc::{Equal, equal}; fn main() { - println!("{}", equal(&1i, &2i)); - println!("{}", equal(&1i, &1i)); + println!("{}", equal(&1, &2)); + println!("{}", equal(&1, &1)); println!("{}", "hello".equal(&"hello")); - println!("{}", "hello".equals::<int,&str>(&1i, &1i, &"foo", &"bar")); + println!("{}", "hello".equals::<int,&str>(&1, &1, &"foo", &"bar")); } diff --git a/src/test/run-pass/where-clauses-lifetimes.rs b/src/test/run-pass/where-clauses-lifetimes.rs index 237c83c8aa2..e3ea7cd80e7 100644 --- a/src/test/run-pass/where-clauses-lifetimes.rs +++ b/src/test/run-pass/where-clauses-lifetimes.rs @@ -11,5 +11,5 @@ fn foo<'a, I>(mut it: I) where I: Iterator<Item=&'a int> {} fn main() { - foo([1i, 2].iter()); + foo([1, 2].iter()); } diff --git a/src/test/run-pass/where-clauses-method.rs b/src/test/run-pass/where-clauses-method.rs index 2b87bcd4b39..29efe727276 100644 --- a/src/test/run-pass/where-clauses-method.rs +++ b/src/test/run-pass/where-clauses-method.rs @@ -22,8 +22,8 @@ impl<T> Foo<T> { } fn main() { - let x = Foo { value: 1i }; - let y = Foo { value: 2i }; + let x = Foo { value: 1 }; + let y = Foo { value: 2 }; println!("{}", x.equals(&x)); println!("{}", x.equals(&y)); } diff --git a/src/test/run-pass/where-clauses.rs b/src/test/run-pass/where-clauses.rs index 807d95691f4..92bc7edf285 100644 --- a/src/test/run-pass/where-clauses.rs +++ b/src/test/run-pass/where-clauses.rs @@ -29,9 +29,9 @@ fn equal<T>(x: &T, y: &T) -> bool where T: Eq { } fn main() { - println!("{}", equal(&1i, &2i)); - println!("{}", equal(&1i, &1i)); + println!("{}", equal(&1, &2)); + println!("{}", equal(&1, &1)); println!("{}", "hello".equal(&"hello")); - println!("{}", "hello".equals::<int,&str>(&1i, &1i, &"foo", &"bar")); + println!("{}", "hello".equals::<int,&str>(&1, &1, &"foo", &"bar")); } diff --git a/src/test/run-pass/while-cont.rs b/src/test/run-pass/while-cont.rs index 50feb3ef4e1..3e1a232115f 100644 --- a/src/test/run-pass/while-cont.rs +++ b/src/test/run-pass/while-cont.rs @@ -10,7 +10,7 @@ // Issue #825: Should recheck the loop condition after continuing pub fn main() { - let mut i = 1i; + let mut i = 1; while i > 0 { assert!((i > 0)); println!("{}", i); diff --git a/src/test/run-pass/while-label.rs b/src/test/run-pass/while-label.rs index 41712f7c64d..4a3cd115d20 100644 --- a/src/test/run-pass/while-label.rs +++ b/src/test/run-pass/while-label.rs @@ -10,8 +10,8 @@ pub fn main() { - let mut i = 100i; - 'w: while 1i + 1 == 2 { + let mut i = 100; + 'w: while 1 + 1 == 2 { i -= 1; if i == 95 { break 'w; diff --git a/src/test/run-pass/while-let.rs b/src/test/run-pass/while-let.rs index 94a45817ee5..1780445fb3b 100644 --- a/src/test/run-pass/while-let.rs +++ b/src/test/run-pass/while-let.rs @@ -11,16 +11,16 @@ use std::collections::BinaryHeap; fn make_pq() -> BinaryHeap<int> { - BinaryHeap::from_vec(vec![1i,2,3]) + BinaryHeap::from_vec(vec![1,2,3]) } pub fn main() { let mut pq = make_pq(); - let mut sum = 0i; + let mut sum = 0; while let Some(x) = pq.pop() { sum += x; } - assert_eq!(sum, 6i); + assert_eq!(sum, 6); pq = make_pq(); sum = 0; @@ -30,7 +30,7 @@ pub fn main() { break 'a; } } - assert_eq!(sum, 5i); + assert_eq!(sum, 5); pq = make_pq(); sum = 0; @@ -40,7 +40,7 @@ pub fn main() { } sum += x; } - assert_eq!(sum, 3i); + assert_eq!(sum, 3); let mut pq1 = make_pq(); sum = 0; @@ -50,5 +50,5 @@ pub fn main() { sum += x * y; } } - assert_eq!(sum, 6i + 12 + 18); + assert_eq!(sum, 6 + 12 + 18); } |